@orchid-labs/pluxx 0.1.6 → 0.1.7

package/dist/cli/index.js

@@ -85,7 +85,7 @@ var require_src = __commonJS({
 });
 
 // src/cli/index.ts
-import { readFileSync as readFileSync16 } from "fs";
+import { readFileSync as readFileSync17 } from "fs";
 
 // src/config/load.ts
 import { resolve, extname, dirname } from "path";
@@ -7084,14 +7084,14 @@ async function build(config, rootDir, options = {}) {
 }
 
 // src/cli/agent.ts
-import { existsSync as existsSync21, readdirSync as readdirSync7, readFileSync as readFileSync9, statSync as statSync4 } from "fs";
+import { existsSync as existsSync22, readdirSync as readdirSync7, readFileSync as readFileSync9, statSync as statSync4 } from "fs";
 import { chmod, copyFile, mkdir as mkdir3, mkdtemp, readFile as readFile3, rm as rm2 } from "fs/promises";
 import { homedir, tmpdir as tmpdir2 } from "os";
-import { relative as relative8, resolve as resolve14 } from "path";
+import { relative as relative9, resolve as resolve14 } from "path";
 import { spawn as spawn2 } from "child_process";
 
 // src/cli/lint.ts
-import { existsSync as existsSync17, readdirSync as readdirSync5, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync17, lstatSync, readdirSync as readdirSync5, readFileSync as readFileSync6 } from "fs";
 import { resolve as resolve9, relative as relative6, basename as basename4, dirname as dirname3 } from "path";
 
 // src/validation/platform-rules.ts
@@ -8452,10 +8452,11 @@ function lintMcpUrls(config, issues) {
     }
   }
 }
-function lintMcpRuntimeState(config, issues) {
+function lintMcpRuntimeState(rootDir, config, issues) {
   if (!config.mcp) return;
   const claudeUsesPlatformAuth = config.targets.includes("claude-code") && config.platforms?.["claude-code"]?.mcpAuth === "platform";
   const cursorUsesPlatformAuth = config.targets.includes("cursor") && config.platforms?.cursor?.mcpAuth === "platform";
+  const passthroughDirs = (config.passthrough ?? []).map((entry) => resolveBundledPassthroughDir(rootDir, entry)).filter((entry) => Boolean(entry));
   for (const [serverName, server] of Object.entries(config.mcp)) {
     if (server.transport === "stdio") {
       pushIssue(issues, {
@@ -8465,6 +8466,17 @@ function lintMcpRuntimeState(config, issues) {
         file: "pluxx.config.ts",
         platform: "MCP"
       });
+      for (const runtimePath of findLocalStdioRuntimePaths(rootDir, server)) {
+        if (passthroughDirs.some((dir) => runtimePath === dir || runtimePath.startsWith(`${dir}/`))) continue;
+        const relativeDir = `./${relative6(rootDir, runtimePath).replace(/\\/g, "/")}/`;
+        pushIssue(issues, {
+          level: "warning",
+          code: "mcp-stdio-runtime-unbundled",
+          message: `MCP server "${serverName}" references a project-local stdio runtime under ${relativeDir}, but that directory is not included in passthrough. Installed bundles may ship the MCP config without the executable payload.`,
+          file: "pluxx.config.ts",
+          platform: "MCP"
+        });
+      }
     }
     const runtimeAuthTargets = [];
     if (server.auth?.type === "platform") {
@@ -8488,6 +8500,37 @@ function lintMcpRuntimeState(config, issues) {
     }
   }
 }
+function resolveBundledPassthroughDir(rootDir, entry) {
+  const resolvedPath = resolve9(rootDir, entry);
+  if (!existsSync17(resolvedPath)) return null;
+  try {
+    const stats = lstatSync(resolvedPath);
+    if (!stats.isDirectory()) return null;
+    return resolvedPath.replace(/\/+$/, "");
+  } catch {
+    return null;
+  }
+}
+function findLocalStdioRuntimePaths(rootDir, server) {
+  if (server.transport !== "stdio") return [];
+  const runtimeDirs = /* @__PURE__ */ new Set();
+  const candidates = [server.command, ...server.args ?? []];
+  for (const candidate of candidates) {
+    if (!isLikelyLocalRuntimePath(candidate)) continue;
+    const resolvedPath = resolve9(rootDir, candidate);
+    if (!existsSync17(resolvedPath)) continue;
+    try {
+      const stats = lstatSync(resolvedPath);
+      const runtimeDir = stats.isDirectory() ? resolvedPath : dirname3(resolvedPath);
+      runtimeDirs.add(runtimeDir.replace(/\/+$/, ""));
+    } catch {
+    }
+  }
+  return [...runtimeDirs].sort();
+}
+function isLikelyLocalRuntimePath(value) {
+  return value.startsWith("./") || value.startsWith("../") || value.startsWith(".\\") || value.startsWith("..\\");
+}
 function lintCodexHookCompatibility(config, issues) {
   if (!isCodexTargetEnabled(config) || !config.hooks) return;
   for (const hookEvent of Object.keys(config.hooks)) {
@@ -8721,15 +8764,19 @@ function lintOpenCodeAgentFrontmatter(dir, config, issues) {
   const agents = readCanonicalAgentFiles(resolve9(dir, config.agents));
   for (const agent of agents) {
     if (!("tools" in agent.frontmatter)) continue;
+    if (hasCanonicalAgentPermission(agent.frontmatter.permission)) continue;
     pushIssue(issues, {
       level: "warning",
       code: "opencode-agent-tools-deprecated",
-      message: "OpenCode agent `tools` is deprecated. Pluxx will translate legacy agent tools into permission-first OpenCode output where possible, but canonical agents should prefer `permission`.",
+      message: "OpenCode agent `tools` is deprecated. Add canonical `permission` frontmatter so Pluxx can keep the emitted OpenCode agent permission-first even when shared cross-host authoring still carries legacy tool hints.",
       file: relative6(dir, agent.filePath).replace(/\\/g, "/"),
       platform: "OpenCode"
     });
   }
 }
+function hasCanonicalAgentPermission(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
 function lintAbsolutePaths(config, issues) {
   const absolutePathPattern = /^\/[a-zA-Z]|^[A-Z]:\\/;
   if (config.hooks) {
@@ -9172,7 +9219,7 @@ async function lintProject(dir = process.cwd(), options = {}) {
   lintAgentIsolation(agentFiles, issues, frontmatterCache);
   lintOpenCodeAgentFrontmatter(dir, { ...lintConfig, agents: lintConfig.agents ?? "./agents/" }, issues);
   lintMcpUrls(lintConfig, issues);
-  lintMcpRuntimeState(lintConfig, issues);
+  lintMcpRuntimeState(dir, lintConfig, issues);
   lintBrandMetadata(lintConfig, issues);
   lintCodexOverrides(lintConfig, issues);
   lintCodexHookCompatibility(lintConfig, issues);
@@ -9256,16 +9303,17 @@ async function runLint(dir = process.cwd()) {
 }
 
 // src/cli/test.ts
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { resolve as resolve12 } from "path";
 
 // src/cli/eval.ts
-import { existsSync as existsSync18, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync7 } from "fs";
 import { resolve as resolve11 } from "path";
 
 // src/cli/init-from-mcp.ts
+import { existsSync as existsSync18, lstatSync as lstatSync2 } from "fs";
 import { mkdir as mkdir2 } from "fs/promises";
-import { basename as basename5, resolve as resolve10 } from "path";
+import { basename as basename5, dirname as dirname4, relative as relative7, resolve as resolve10 } from "path";
 
 // src/user-config.ts
 var ENV_VAR_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -9548,6 +9596,7 @@ async function planMcpScaffold(options) {
   });
   const serverName = options.serverName ?? toKebabCase(options.introspection.serverInfo.name) ?? pluginName;
   const permissions = options.permissions ?? (options.approveMcpTools ? { allow: [`MCP(${serverName}.*)`] } : void 0);
+  const passthroughPaths = inferLocalRuntimePassthroughPaths(options.rootDir, options.source);
   const runtimeAuthMode = options.runtimeAuthMode ?? (options.source.transport !== "stdio" && options.source.auth?.type === "platform" ? "platform" : "inline");
   const instructionsPath = resolve10(options.rootDir, "INSTRUCTIONS.md");
   const skillRoot = resolve10(options.rootDir, "skills");
@@ -9589,6 +9638,7 @@ async function planMcpScaffold(options) {
       userConfig,
       hooks: generatedHooks.hookEntries,
       scriptsPath: generatedHooks.scriptsPath,
+      passthroughPaths,
       runtimeAuthMode,
       permissions,
       commandsPath: "./commands/"
@@ -9986,6 +10036,8 @@ function buildConfigTemplate(input) {
   userConfig: ${serializeUserConfig(input.userConfig)},
 ` : "";
   const scriptsBlock = input.scriptsPath ? `  scripts: ${JSON.stringify(input.scriptsPath)},
+` : "";
+  const passthroughBlock = input.passthroughPaths && input.passthroughPaths.length > 0 ? `  passthrough: ${JSON.stringify(input.passthroughPaths)},
 ` : "";
   const commandsBlock = input.commandsPath ? `  commands: ${JSON.stringify(input.commandsPath)},
 ` : "";
@@ -10021,6 +10073,7 @@ ${commandsBlock}
   instructions: './INSTRUCTIONS.md',
 ${userConfigBlock}
 ${scriptsBlock}
+${passthroughBlock}
 
   mcp: {
 ${mcpBlock}
@@ -10037,6 +10090,29 @@ ${platformsBlock}
 })
 `;
 }
+function inferLocalRuntimePassthroughPaths(rootDir, source) {
+  if (source.transport !== "stdio") return [];
+  const passthrough = /* @__PURE__ */ new Set();
+  const candidates = [source.command, ...source.args ?? []];
+  for (const candidate of candidates) {
+    if (!isLikelyLocalRuntimePath2(candidate)) continue;
+    const resolvedPath = resolve10(rootDir, candidate);
+    if (!existsSync18(resolvedPath)) continue;
+    const stats = lstatSync2(resolvedPath);
+    const runtimeDir = stats.isDirectory() ? resolvedPath : dirname4(resolvedPath);
+    const normalized = normalizePassthroughDir(rootDir, runtimeDir);
+    if (normalized) passthrough.add(normalized);
+  }
+  return [...passthrough].sort();
+}
+function isLikelyLocalRuntimePath2(value) {
+  return value.startsWith("./") || value.startsWith("../") || value.startsWith(".\\") || value.startsWith("..\\");
+}
+function normalizePassthroughDir(rootDir, dirPath) {
+  const relativePath = relative7(rootDir, dirPath).replace(/\\/g, "/").replace(/\/+$/, "");
+  if (!relativePath || relativePath === ".") return null;
+  return `./${relativePath}/`;
+}
 function buildMcpBlock(serverName, source) {
   if (source.transport === "stdio") {
     const argsLine = source.args && source.args.length > 0 ? `,
@@ -11076,7 +11152,7 @@ function summarizeChecks(checks) {
 }
 async function loadMcpScaffoldMetadata(rootDir) {
   const metadataPath = resolve11(rootDir, MCP_SCAFFOLD_METADATA_PATH);
-  if (!existsSync18(metadataPath)) {
+  if (!existsSync19(metadataPath)) {
     return null;
   }
   const parsed = JSON.parse(readFileSync7(metadataPath, "utf-8"));
@@ -11107,7 +11183,7 @@ function collectSkillPromptLabels(skill) {
 function evaluateInstructions(rootDir, metadata, checks) {
   const relativePath = "INSTRUCTIONS.md";
   const filePath = resolve11(rootDir, relativePath);
-  if (!existsSync18(filePath)) {
+  if (!existsSync19(filePath)) {
     addCheck(checks, {
       level: "error",
       code: "instructions-missing",
@@ -11153,7 +11229,7 @@ function evaluateSkills(rootDir, metadata, checks) {
   for (const skill of metadata.skills) {
     const relativePath = `skills/${skill.dirName}/SKILL.md`;
     const filePath = resolve11(rootDir, relativePath);
-    if (!existsSync18(filePath)) {
+    if (!existsSync19(filePath)) {
       failures.push({ path: relativePath, missing: ["skill file"] });
       continue;
     }
@@ -11211,7 +11287,7 @@ function evaluateCommands(rootDir, metadata, checks) {
   for (const skill of metadata.skills) {
     const relativePath = `commands/${skill.dirName}.md`;
     const filePath = resolve11(rootDir, relativePath);
-    if (!existsSync18(filePath)) {
+    if (!existsSync19(filePath)) {
       failures.push({ path: relativePath, missing: ["command file"] });
       continue;
     }
@@ -11463,7 +11539,7 @@ async function runTestSuite(options = {}) {
     const evalReport = await runEvalSuite({ rootDir });
     const checks = targets.map((platform) => {
       const requiredPath = SMOKE_PATHS[platform];
-      const ok = existsSync19(resolve12(rootDir, config.outDir, platform, requiredPath));
+      const ok = existsSync20(resolve12(rootDir, config.outDir, platform, requiredPath));
       return { platform, requiredPath, ok };
     });
     return {
@@ -11520,8 +11596,8 @@ function printTestResult(result) {
 }
 
 // src/cli/sync-from-mcp.ts
-import { cpSync as cpSync2, existsSync as existsSync20, mkdtempSync, readFileSync as readFileSync8, rmSync as rmSync2, readdirSync as readdirSync6, rmdirSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname4, isAbsolute, relative as relative7, resolve as resolve13 } from "path";
+import { cpSync as cpSync2, existsSync as existsSync21, mkdtempSync, readFileSync as readFileSync8, rmSync as rmSync2, readdirSync as readdirSync6, rmdirSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname5, isAbsolute, relative as relative8, resolve as resolve13 } from "path";
 import { tmpdir } from "os";
 
 // src/mcp/introspect.ts
@@ -11803,10 +11879,10 @@ async function createSseClient(server) {
   let resolveEndpoint;
   let rejectEndpoint;
   let endpointSettled = false;
-  const endpointReady = new Promise((resolve24, reject) => {
+  const endpointReady = new Promise((resolve25, reject) => {
     resolveEndpoint = (value) => {
       endpointSettled = true;
-      resolve24(value);
+      resolve25(value);
     };
     rejectEndpoint = (error) => {
       endpointSettled = true;
@@ -11943,7 +12019,7 @@ async function createSseClient(server) {
     async request(method, params) {
       const requestId = nextRequestId();
       const endpoint = endpointUrl ?? await endpointReady;
-      const resultPromise = new Promise((resolve24, reject) => {
+      const resultPromise = new Promise((resolve25, reject) => {
         const timeout = setTimeout(() => {
           pending.delete(requestId);
           reject(new McpIntrospectionError(`Timed out waiting for MCP SSE response to ${method}.`));
@@ -11951,7 +12027,7 @@ async function createSseClient(server) {
         pending.set(requestId, {
           resolve: (value) => {
             clearTimeout(timeout);
-            resolve24(value);
+            resolve25(value);
           },
           reject: (error) => {
             clearTimeout(timeout);
@@ -12104,7 +12180,7 @@ async function createStdioClient(server) {
         method,
         ...params ? { params } : {}
       });
-      return new Promise((resolve24, reject) => {
+      return new Promise((resolve25, reject) => {
         const timeout = setTimeout(() => {
           pending.delete(id);
           reject(new McpIntrospectionError(`Timed out waiting for MCP stdio response to ${method}.`));
@@ -12112,7 +12188,7 @@ async function createStdioClient(server) {
         pending.set(id, {
           resolve: (value) => {
             clearTimeout(timeout);
-            resolve24(value);
+            resolve25(value);
           },
           reject: (error) => {
             clearTimeout(timeout);
@@ -12290,7 +12366,7 @@ function nextRequestId() {
 // src/cli/sync-from-mcp.ts
 async function readMcpScaffoldMetadata(rootDir) {
   const filepath = resolveWithinRoot(rootDir, MCP_SCAFFOLD_METADATA_PATH);
-  if (!existsSync20(filepath)) {
+  if (!existsSync21(filepath)) {
     throw new Error(
       `No MCP scaffold metadata found at ${MCP_SCAFFOLD_METADATA_PATH}. Run "pluxx init --from-mcp" first.`
     );
@@ -12325,14 +12401,14 @@ async function syncFromMcp(options) {
   const skillRenames = detectSkillRenames(metadata.skills, newMetadata.skills, toolRenames);
   for (const [oldSkillDir, newSkillDir] of skillRenames) {
     const oldSkillPath = resolveWithinRoot(options.rootDir, `skills/${oldSkillDir}/SKILL.md`);
-    if (!existsSync20(oldSkillPath)) continue;
+    if (!existsSync21(oldSkillPath)) continue;
     const oldContent = readFileSync8(oldSkillPath, "utf-8");
     const extracted = extractMixedMarkdownContent(oldContent, "");
     if (!hasMeaningfulCustomContent(oldContent)) continue;
     const newSkill = newMetadata.skills.find((s) => s.dirName === newSkillDir);
     if (!newSkill) continue;
     const newSkillPath = resolveWithinRoot(options.rootDir, `skills/${newSkill.dirName}/SKILL.md`);
-    if (!existsSync20(newSkillPath)) continue;
+    if (!existsSync21(newSkillPath)) continue;
     const currentContent = readFileSync8(newSkillPath, "utf-8");
     const updatedContent = injectCustomContent(currentContent, extracted.customContent);
     writeFileSync3(newSkillPath, updatedContent, "utf-8");
@@ -12375,7 +12451,7 @@ async function syncFromMcp(options) {
     if (!beforeManaged.has(file)) return false;
     const before = beforeContents.get(file);
     const currentPath = resolveWithinRoot(options.rootDir, file);
-    if (!existsSync20(currentPath)) return false;
+    if (!existsSync21(currentPath)) return false;
     const after = readFileSync8(currentPath, "utf-8");
     return before !== after;
   });
@@ -12464,7 +12540,7 @@ async function planSyncFromMcp(options) {
 }
 function readPersistedSkills(rootDir, metadata) {
   const taxonomyPath = resolveWithinRoot(rootDir, MCP_TAXONOMY_PATH);
-  if (existsSync20(taxonomyPath)) {
+  if (existsSync21(taxonomyPath)) {
     return JSON.parse(readFileSync8(taxonomyPath, "utf-8"));
   }
   return metadata.skills.map((skill) => ({
@@ -12477,12 +12553,12 @@ function readPersistedSkills(rootDir, metadata) {
 function preserveCustomContentForRenames(rootDir, renames, pathForName) {
   for (const [oldName, newName] of renames) {
     const oldPath = resolveWithinRoot(rootDir, pathForName(oldName));
-    if (!existsSync20(oldPath)) continue;
+    if (!existsSync21(oldPath)) continue;
     const oldContent = readFileSync8(oldPath, "utf-8");
     const extracted = extractMixedMarkdownContent(oldContent, "");
     if (!hasMeaningfulCustomContent(oldContent)) continue;
     const newPath = resolveWithinRoot(rootDir, pathForName(newName));
-    if (!existsSync20(newPath)) continue;
+    if (!existsSync21(newPath)) continue;
     const currentContent = readFileSync8(newPath, "utf-8");
     const updatedContent = injectCustomContent(currentContent, extracted.customContent);
     writeFileSync3(newPath, updatedContent, "utf-8");
@@ -12492,21 +12568,21 @@ function snapshotManagedFiles(rootDir, files) {
   const contents = /* @__PURE__ */ new Map();
   for (const file of files) {
     const filepath = resolveWithinRoot(rootDir, file);
-    if (!existsSync20(filepath)) continue;
+    if (!existsSync21(filepath)) continue;
     contents.set(file, readFileSync8(filepath, "utf-8"));
   }
   return contents;
 }
 function removeManagedFile(rootDir, relativePath) {
   const filepath = resolveWithinRoot(rootDir, relativePath);
-  if (!existsSync20(filepath)) return;
+  if (!existsSync21(filepath)) return;
   rmSync2(filepath, { force: true });
-  pruneEmptyDirectories(rootDir, dirname4(filepath));
+  pruneEmptyDirectories(rootDir, dirname5(filepath));
 }
 function shouldPreserveManagedFile(rootDir, relativePath) {
   if (!relativePath.endsWith(".md")) return false;
   const filepath = resolveWithinRoot(rootDir, relativePath);
-  if (!existsSync20(filepath)) return false;
+  if (!existsSync21(filepath)) return false;
   return hasMeaningfulCustomContent(readFileSync8(filepath, "utf-8"));
 }
 function pruneEmptyDirectories(rootDir, startDir) {
@@ -12516,7 +12592,7 @@ function pruneEmptyDirectories(rootDir, startDir) {
     const entries = readdirSync6(current);
     if (entries.length > 0) return;
     rmdirSync(current);
-    current = dirname4(current);
+    current = dirname5(current);
   }
 }
 var AGENT_PACK_FILES = [
@@ -12680,7 +12756,7 @@ function computeSkillRenameScore(oldSkill, newSkill, toolRenames) {
 function resolveWithinRoot(rootDir, relativePath) {
   const rootPath = resolve13(rootDir);
   const filepath = resolve13(rootPath, relativePath);
-  const relativePathFromRoot = relative7(rootPath, filepath);
+  const relativePathFromRoot = relative8(rootPath, filepath);
   if (relativePathFromRoot === "" || !relativePathFromRoot.startsWith("..") && !isAbsolute(relativePathFromRoot)) {
     return filepath;
   }
@@ -12696,13 +12772,13 @@ function formatSyncSummary(result, rootDir) {
     result.renamedFiles.forEach((rename) => lines.push(`  \u2192 ${rename.from} \u2192 ${rename.to}`));
   }
   lines.push(`Added: ${result.addedFiles.length}`);
-  result.addedFiles.forEach((file) => lines.push(`  + ${relative7(rootDir, resolve13(rootDir, file))}`));
+  result.addedFiles.forEach((file) => lines.push(`  + ${relative8(rootDir, resolve13(rootDir, file))}`));
   lines.push(`Updated: ${result.updatedFiles.length}`);
-  result.updatedFiles.forEach((file) => lines.push(`  ~ ${relative7(rootDir, resolve13(rootDir, file))}`));
+  result.updatedFiles.forEach((file) => lines.push(`  ~ ${relative8(rootDir, resolve13(rootDir, file))}`));
   lines.push(`Removed: ${result.removedFiles.length}`);
-  result.removedFiles.forEach((file) => lines.push(`  - ${relative7(rootDir, resolve13(rootDir, file))}`));
+  result.removedFiles.forEach((file) => lines.push(`  - ${relative8(rootDir, resolve13(rootDir, file))}`));
   lines.push(`Preserved: ${result.preservedFiles.length}`);
-  result.preservedFiles.forEach((file) => lines.push(`  ! ${relative7(rootDir, resolve13(rootDir, file))}`));
+  result.preservedFiles.forEach((file) => lines.push(`  ! ${relative8(rootDir, resolve13(rootDir, file))}`));
   return lines;
 }
 
@@ -12791,7 +12867,7 @@ async function planAgentPrompt(rootDir, kind, options = {}) {
   const project = await loadAgentProjectModel(rootDir, config);
   const overrides = await loadAgentOverrides(rootDir);
   const contextPath = resolve14(rootDir, AGENT_CONTEXT_PATH);
-  if (!options.allowMissingContext && !existsSync21(contextPath)) {
+  if (!options.allowMissingContext && !existsSync22(contextPath)) {
     throw new Error(`No agent context found at ${AGENT_CONTEXT_PATH}. Run "pluxx agent prepare" first.`);
   }
   if (project.sourceKind !== "mcp-derived" && kind !== "review") {
@@ -12803,7 +12879,7 @@ async function planAgentPrompt(rootDir, kind, options = {}) {
     displayName: project.displayName,
     skillPaths: project.skills.map((skill) => skill.path),
     commandPaths: project.commands.map((command2) => command2.path),
-    extraContextPaths: [AGENT_SOURCES_PATH, AGENT_DOCS_CONTEXT_PATH].filter((path) => existsSync21(resolve14(rootDir, path))),
+    extraContextPaths: [AGENT_SOURCES_PATH, AGENT_DOCS_CONTEXT_PATH].filter((path) => existsSync22(resolve14(rootDir, path))),
     sourceKind: project.sourceKind,
     taxonomyPath: project.taxonomyPath,
     overrides
@@ -12971,7 +13047,7 @@ function buildProtectedFiles() {
 }
 async function loadMcpScaffoldMetadata2(rootDir) {
   const metadataPath = resolve14(rootDir, MCP_SCAFFOLD_METADATA_PATH);
-  if (!existsSync21(metadataPath)) {
+  if (!existsSync22(metadataPath)) {
     throw new Error(`No MCP scaffold metadata found at ${MCP_SCAFFOLD_METADATA_PATH}. Run "pluxx init --from-mcp" first.`);
   }
   try {
@@ -12985,7 +13061,7 @@ async function loadMcpScaffoldMetadata2(rootDir) {
 }
 async function loadAgentProjectModel(rootDir, config) {
   const metadataPath = resolve14(rootDir, MCP_SCAFFOLD_METADATA_PATH);
-  if (existsSync21(metadataPath)) {
+  if (existsSync22(metadataPath)) {
     const metadata = await loadMcpScaffoldMetadata2(rootDir);
     const serverEntry = Object.entries(config.mcp ?? {})[0];
     const [serverName, server] = serverEntry ?? ["unknown", metadata.source];
@@ -13023,7 +13099,7 @@ function loadManualAgentProjectModel(rootDir, config) {
   const commandsDir = config.commands ? resolve14(rootDir, config.commands) : void 0;
   const skills = readCanonicalSkillFiles(rootDir, skillsDir);
   const commands = readCanonicalCommandFiles(commandsDir).map((command2) => ({
-    path: normalizeRelativePath(relative8(rootDir, command2.filePath)),
+    path: normalizeRelativePath(relative9(rootDir, command2.filePath)),
     title: command2.title,
     description: command2.description
   }));
@@ -13354,7 +13430,7 @@ async function collectAgentContextPackInternal(rootDir, options, overrides) {
     if (seenFilePaths.has(relativePath)) continue;
     seenFilePaths.add(relativePath);
     const filePath = resolve14(rootDir, relativePath);
-    if (!existsSync21(filePath)) {
+    if (!existsSync22(filePath)) {
       const source2 = {
         label: relativePath,
         kind: "file",
@@ -14524,18 +14600,18 @@ function normalizeRelativePath(path) {
   return path.replace(/\\/g, "/").replace(/^\.\//, "");
 }
 function readCanonicalSkillFiles(rootDir, skillsDir) {
-  if (!skillsDir || !existsSync21(skillsDir)) return [];
+  if (!skillsDir || !existsSync22(skillsDir)) return [];
   return walkSkillMarkdownFiles(skillsDir).sort((a, b) => a.localeCompare(b)).map((filePath) => {
     const content = readFileSync9(filePath, "utf-8");
     const { frontmatterLines, body } = splitSkillMarkdownFrontmatter(content);
-    const dirName = normalizeRelativePath(relative8(skillsDir, filePath).replace(/\/SKILL\.md$/i, ""));
+    const dirName = normalizeRelativePath(relative9(skillsDir, filePath).replace(/\/SKILL\.md$/i, ""));
     const title = firstMarkdownHeading(body) ?? dirName;
     return {
       dirName,
       title,
       description: parseYamlDescription(frontmatterLines),
       toolNames: [],
-      path: normalizeRelativePath(relative8(rootDir, filePath))
+      path: normalizeRelativePath(relative9(rootDir, filePath))
     };
   });
 }
@@ -14845,7 +14921,7 @@ async function executeCommand(command2, cwd, options = {}) {
     let claudeTurnCompleted = false;
     let claudeTurnFailed = false;
     const sentinelInterval = codexLastMessagePath || isClaudeStreamJson ? setInterval(() => {
-      const sawCompletionSignal = codexTurnCompleted || codexTurnFailed || claudeTurnCompleted || claudeTurnFailed || (codexLastMessagePath ? existsSync21(codexLastMessagePath) : false);
+      const sawCompletionSignal = codexTurnCompleted || codexTurnFailed || claudeTurnCompleted || claudeTurnFailed || (codexLastMessagePath ? existsSync22(codexLastMessagePath) : false);
       if (!sawCompletionSignal) return;
       if (sawFinalMessageAt == null) {
         sawFinalMessageAt = Date.now();
@@ -14971,15 +15047,15 @@ exec ${shellQuote(cursorBinary)} "$@"
   await mkdir3(resolve14(isolatedCodexHome, "memories"), { recursive: true });
   for (const relativePath of ["auth.json", "config.toml", "hooks.json", "installation_id"]) {
     const sourcePath = resolve14(currentCodexHome, relativePath);
-    if (!existsSync21(sourcePath)) continue;
+    if (!existsSync22(sourcePath)) continue;
     await copyFile(sourcePath, resolve14(isolatedCodexHome, relativePath));
   }
   const rulesSourceDir = resolve14(currentCodexHome, "rules");
-  if (existsSync21(rulesSourceDir)) {
+  if (existsSync22(rulesSourceDir)) {
     const rulesTargetDir = resolve14(isolatedCodexHome, "rules");
     await mkdir3(rulesTargetDir, { recursive: true });
     const defaultRulesPath = resolve14(rulesSourceDir, "default.rules");
-    if (existsSync21(defaultRulesPath)) {
+    if (existsSync22(defaultRulesPath)) {
       await copyFile(defaultRulesPath, resolve14(rulesTargetDir, "default.rules"));
     }
   }
@@ -15017,7 +15093,7 @@ function titleCase(value) {
 }
 async function loadAgentOverrides(rootDir) {
   const overridesPath = resolve14(rootDir, AGENT_OVERRIDES_PATH);
-  if (!existsSync21(overridesPath)) {
+  if (!existsSync22(overridesPath)) {
     return null;
   }
   const content = await readTextFile(overridesPath);
@@ -15119,12 +15195,12 @@ ${additions.map((block) => `- ${block.replace(/\n/g, "\n  ")}`).join("\n")}
 }
 
 // src/cli/doctor.ts
-import { accessSync, constants, existsSync as existsSync23, lstatSync, readFileSync as readFileSync11, readdirSync as readdirSync9 } from "fs";
-import { basename as basename6, dirname as dirname6, resolve as resolve16 } from "path";
+import { accessSync, constants, existsSync as existsSync24, lstatSync as lstatSync3, readFileSync as readFileSync11, readdirSync as readdirSync9 } from "fs";
+import { basename as basename6, dirname as dirname7, resolve as resolve16 } from "path";
 
 // src/cli/install.ts
-import { resolve as resolve15, dirname as dirname5 } from "path";
-import { existsSync as existsSync22, symlinkSync, mkdirSync as mkdirSync4, rmSync as rmSync3, readFileSync as readFileSync10, writeFileSync as writeFileSync4, cpSync as cpSync3, readdirSync as readdirSync8 } from "fs";
+import { resolve as resolve15, dirname as dirname6 } from "path";
+import { existsSync as existsSync23, symlinkSync, mkdirSync as mkdirSync4, rmSync as rmSync3, readFileSync as readFileSync10, writeFileSync as writeFileSync4, cpSync as cpSync3, readdirSync as readdirSync8 } from "fs";
 import { spawnSync } from "child_process";
 import * as readline2 from "readline";
 function listHookCommands(hooks) {
@@ -15393,12 +15469,12 @@ ${content.slice(frontmatterMatch[0].length)}`;
 }
 function syncOpenCodeSkills(pluginDir, pluginName) {
   const sourceSkillsDir = resolve15(pluginDir, "skills");
-  if (!existsSync22(sourceSkillsDir)) return;
+  if (!existsSync23(sourceSkillsDir)) return;
   mkdirSync4(getOpenCodeSkillRoot(), { recursive: true });
   for (const entry of readdirSync8(sourceSkillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     const skillSourceDir = resolve15(sourceSkillsDir, entry.name);
-    if (!existsSync22(resolve15(skillSourceDir, "SKILL.md"))) continue;
+    if (!existsSync23(resolve15(skillSourceDir, "SKILL.md"))) continue;
     const installedSkillDir = getOpenCodeInstalledSkillDir(pluginName, entry.name);
     rmSync3(installedSkillDir, { recursive: true, force: true });
     cpSync3(skillSourceDir, installedSkillDir, { recursive: true });
@@ -15411,7 +15487,7 @@ function syncOpenCodeSkills(pluginDir, pluginName) {
 }
 function verifyOpenCodeInstall(pluginDir, pluginName) {
   const entryPath = getOpenCodeEntryPath(pluginDir);
-  if (!existsSync22(entryPath)) {
+  if (!existsSync23(entryPath)) {
     throw new Error(`OpenCode install is incomplete: missing host entry file at ${entryPath}`);
   }
   const entryContent = readFileSync10(entryPath, "utf-8");
@@ -15424,13 +15500,13 @@ function verifyOpenCodeInstall(pluginDir, pluginName) {
     throw new Error(`OpenCode install is incomplete: ${entryPath} does not preserve the plugin root bridge`);
   }
   const sourceSkillsDir = resolve15(pluginDir, "skills");
-  if (!existsSync22(sourceSkillsDir)) return;
+  if (!existsSync23(sourceSkillsDir)) return;
   for (const entry of readdirSync8(sourceSkillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     const sourceSkillPath = resolve15(sourceSkillsDir, entry.name, "SKILL.md");
-    if (!existsSync22(sourceSkillPath)) continue;
+    if (!existsSync23(sourceSkillPath)) continue;
     const installedSkillPath = resolve15(getOpenCodeInstalledSkillDir(pluginName, entry.name), "SKILL.md");
-    if (!existsSync22(installedSkillPath)) {
+    if (!existsSync23(installedSkillPath)) {
       throw new Error(`OpenCode install is incomplete: missing synced skill at ${installedSkillPath}`);
     }
     const installedSkillContent = readFileSync10(installedSkillPath, "utf-8");
@@ -15441,7 +15517,7 @@ function verifyOpenCodeInstall(pluginDir, pluginName) {
 }
 function removeOpenCodeSkills(pluginName) {
   const root = getOpenCodeSkillRoot();
-  if (!existsSync22(root)) return false;
+  if (!existsSync23(root)) return false;
   let removed = false;
   for (const entry of readdirSync8(root, { withFileTypes: true })) {
     if (!entry.name.startsWith(`${pluginName}-`)) continue;
@@ -15477,7 +15553,7 @@ function runCommandDefault(command2, args2) {
 function createSymlinkInstall(target) {
   const parentDir = resolve15(target.pluginDir, "..");
   mkdirSync4(parentDir, { recursive: true });
-  if (existsSync22(target.pluginDir)) {
+  if (existsSync23(target.pluginDir)) {
     rmSync3(target.pluginDir, { recursive: true, force: true });
   }
   symlinkSync(target.sourceDir, target.pluginDir);
@@ -15495,7 +15571,7 @@ function getCodexMarketplacePluginPath(pluginName) {
   return `./.codex/plugins/${pluginName}`;
 }
 function readCodexMarketplace(filepath) {
-  if (!existsSync22(filepath)) {
+  if (!existsSync23(filepath)) {
     return {
       name: "pluxx-local",
       interface: {
@@ -15514,7 +15590,7 @@ function readCodexMarketplace(filepath) {
 }
 function ensureCodexMarketplace(pluginName) {
   const filepath = getCodexMarketplacePath();
-  mkdirSync4(dirname5(filepath), { recursive: true });
+  mkdirSync4(dirname6(filepath), { recursive: true });
   const marketplace = readCodexMarketplace(filepath);
   const nextPlugins = (marketplace.plugins ?? []).filter((plugin) => plugin.name !== pluginName);
   nextPlugins.push({
@@ -15540,7 +15616,7 @@ function ensureCodexMarketplace(pluginName) {
 }
 function removeCodexMarketplacePlugin(pluginName) {
   const filepath = getCodexMarketplacePath();
-  if (!existsSync22(filepath)) return;
+  if (!existsSync23(filepath)) return;
   const marketplace = readCodexMarketplace(filepath);
   const nextPlugins = (marketplace.plugins ?? []).filter((plugin) => plugin.name !== pluginName);
   if (nextPlugins.length === (marketplace.plugins ?? []).length) {
@@ -15562,7 +15638,7 @@ function removeCodexMarketplacePlugin(pluginName) {
 function createCopiedInstall(target) {
   const parentDir = resolve15(target.pluginDir, "..");
   mkdirSync4(parentDir, { recursive: true });
-  if (existsSync22(target.pluginDir)) {
+  if (existsSync23(target.pluginDir)) {
     rmSync3(target.pluginDir, { recursive: true, force: true });
   }
   cpSync3(target.sourceDir, target.pluginDir, { recursive: true });
@@ -15587,7 +15663,7 @@ function patchInstalledMcpConfig(pluginDir, platform, config, entries) {
   const env = buildUserConfigEnvMap(entries);
   if (platform === "claude-code" || platform === "cursor") {
     const filepath = resolve15(pluginDir, platform === "claude-code" ? ".mcp.json" : "mcp.json");
-    if (!existsSync22(filepath)) return;
+    if (!existsSync23(filepath)) return;
     const mcpServers = {};
     const usesPlatformManagedAuth = platform === "claude-code" ? config.platforms?.["claude-code"]?.mcpAuth === "platform" : config.platforms?.cursor?.mcpAuth === "platform";
     for (const [name, server] of Object.entries(config.mcp)) {
@@ -15619,7 +15695,7 @@ function patchInstalledMcpConfig(pluginDir, platform, config, entries) {
   }
   if (platform === "codex") {
     const filepath = resolve15(pluginDir, ".mcp.json");
-    if (!existsSync22(filepath)) return;
+    if (!existsSync23(filepath)) return;
     const mcpServers = {};
     for (const [name, server] of Object.entries(config.mcp)) {
       if (server.transport === "stdio") {
@@ -15659,7 +15735,7 @@ function writeInstalledUserConfig(pluginDir, entries) {
 function disableInstalledEnvValidation(pluginDir, entries) {
   if (entries.length === 0) return;
   const filepath = resolve15(pluginDir, "scripts/check-env.sh");
-  if (!existsSync22(filepath)) return;
+  if (!existsSync23(filepath)) return;
   writeFileSync4(
     filepath,
     "#!/usr/bin/env bash\nset -euo pipefail\n# pluxx install materialized required config for this local plugin install.\nexit 0\n"
@@ -15741,7 +15817,7 @@ function ensureClaudeMarketplaceRegistered(pluginName, sourceDir, runCommand, ma
 }
 function installClaudePlugin(target, pluginName, runCommand, materialized) {
   const marketplaceName = ensureClaudeMarketplaceRegistered(pluginName, target.sourceDir, runCommand, materialized);
-  if (existsSync22(target.pluginDir)) {
+  if (existsSync23(target.pluginDir)) {
     rmSync3(target.pluginDir, { recursive: true, force: true });
   }
   runCommand("claude", ["plugin", "uninstall", `${pluginName}@${marketplaceName}`]);
@@ -15760,9 +15836,9 @@ function uninstallClaudePlugin(target, pluginName, runCommand, options = {}) {
     }
   }
   const marketplaceRoot = getClaudeMarketplaceRoot(pluginName);
-  const hadMarketplaceRoot = existsSync22(marketplaceRoot);
+  const hadMarketplaceRoot = existsSync23(marketplaceRoot);
   rmSync3(marketplaceRoot, { recursive: true, force: true });
-  const hadLegacyPluginDir = existsSync22(target.pluginDir);
+  const hadLegacyPluginDir = existsSync23(target.pluginDir);
   if (hadLegacyPluginDir) {
     rmSync3(target.pluginDir, { recursive: true, force: true });
   }
@@ -15776,8 +15852,8 @@ function planInstallPlugin(distDir, pluginName, platforms) {
     return {
       ...target,
       sourceDir,
-      built: existsSync22(sourceDir),
-      existing: existsSync22(target.pluginDir)
+      built: existsSync23(sourceDir),
+      existing: existsSync23(target.pluginDir)
     };
   });
 }
@@ -15853,13 +15929,13 @@ async function uninstallPlugin(pluginName, platforms, options = {}) {
       continue;
     }
     let removedTarget = false;
-    if (existsSync22(target.pluginDir)) {
+    if (existsSync23(target.pluginDir)) {
       rmSync3(target.pluginDir, { recursive: true, force: true });
       removedTarget = true;
     }
     if (target.platform === "opencode") {
       const entryPath = getOpenCodeEntryPath(target.pluginDir);
-      if (existsSync22(entryPath)) {
+      if (existsSync23(entryPath)) {
         rmSync3(entryPath, { force: true });
         removedTarget = true;
       }
@@ -15969,7 +16045,7 @@ function checkReadablePath(checks, rootDir, label, configuredPath, required) {
     return;
   }
   const resolvedPath = resolve16(rootDir, configuredPath);
-  if (!existsSync23(resolvedPath)) {
+  if (!existsSync24(resolvedPath)) {
     addCheck2(checks, {
       level: "error",
       code: "path-not-found",
@@ -16335,7 +16411,7 @@ function checkCompilerIntent(checks, rootDir) {
 }
 function checkScaffoldMetadata(checks, rootDir, config) {
   const metadataPath = resolve16(rootDir, MCP_SCAFFOLD_METADATA_PATH);
-  if (!existsSync23(metadataPath)) {
+  if (!existsSync24(metadataPath)) {
     addCheck2(checks, {
       level: "info",
       code: "mcp-metadata-missing",
@@ -16400,7 +16476,7 @@ function checkScaffoldMetadata(checks, rootDir, config) {
   }
 }
 function detectConsumerLayout(rootDir) {
-  if (existsSync23(resolve16(rootDir, ".claude-plugin/plugin.json"))) {
+  if (existsSync24(resolve16(rootDir, ".claude-plugin/plugin.json"))) {
     return {
       kind: "installed-platform",
       platform: "claude-code",
@@ -16408,7 +16484,7 @@ function detectConsumerLayout(rootDir) {
       mcpConfigPath: ".mcp.json"
     };
   }
-  if (existsSync23(resolve16(rootDir, ".cursor-plugin/plugin.json"))) {
+  if (existsSync24(resolve16(rootDir, ".cursor-plugin/plugin.json"))) {
     return {
       kind: "installed-platform",
       platform: "cursor",
@@ -16416,7 +16492,7 @@ function detectConsumerLayout(rootDir) {
       mcpConfigPath: "mcp.json"
     };
   }
-  if (existsSync23(resolve16(rootDir, ".codex-plugin/plugin.json"))) {
+  if (existsSync24(resolve16(rootDir, ".codex-plugin/plugin.json"))) {
     return {
       kind: "installed-platform",
       platform: "codex",
@@ -16426,7 +16502,7 @@ function detectConsumerLayout(rootDir) {
   }
   const packagePath = resolve16(rootDir, "package.json");
   const indexPath = resolve16(rootDir, "index.ts");
-  if (existsSync23(packagePath) && existsSync23(indexPath)) {
+  if (existsSync24(packagePath) && existsSync24(indexPath)) {
     try {
       const pkg = JSON.parse(readFileSync11(packagePath, "utf-8"));
       if (pkg.peerDependencies?.["@opencode-ai/plugin"] || pkg.keywords?.includes("opencode-plugin")) {
@@ -16444,10 +16520,10 @@ function detectConsumerLayout(rootDir) {
       };
     }
   }
-  if (CONFIG_FILES.some((filename) => existsSync23(resolve16(rootDir, filename)))) {
+  if (CONFIG_FILES.some((filename) => existsSync24(resolve16(rootDir, filename)))) {
     return { kind: "source-project" };
   }
-  if (["claude-code", "cursor", "codex", "opencode"].some((dir) => existsSync23(resolve16(rootDir, dir)))) {
+  if (["claude-code", "cursor", "codex", "opencode"].some((dir) => existsSync24(resolve16(rootDir, dir)))) {
     return { kind: "multi-target-dist" };
   }
   return { kind: "unknown" };
@@ -16458,7 +16534,7 @@ function readJsonFile2(rootDir, relativePath) {
 function checkConsumerBundlePath(checks, rootDir) {
   try {
     accessSync(rootDir, constants.R_OK);
-    const details = lstatSync(rootDir);
+    const details = lstatSync3(rootDir);
     addCheck2(checks, {
       level: "success",
       code: "consumer-path-readable",
@@ -16505,7 +16581,7 @@ function checkConsumerManifest(checks, rootDir, layout) {
 function checkInstalledUserConfig(checks, rootDir) {
   const userConfigPath = ".pluxx-user.json";
   const resolvedPath = resolve16(rootDir, userConfigPath);
-  if (!existsSync23(resolvedPath)) {
+  if (!existsSync24(resolvedPath)) {
     addCheck2(checks, {
       level: "info",
       code: "consumer-user-config-missing",
@@ -16542,7 +16618,7 @@ function checkInstalledUserConfig(checks, rootDir) {
 function checkInstalledEnvValidation(checks, rootDir) {
   const envScriptPath = "scripts/check-env.sh";
   const resolvedPath = resolve16(rootDir, envScriptPath);
-  if (!existsSync23(resolvedPath)) {
+  if (!existsSync24(resolvedPath)) {
     addCheck2(checks, {
       level: "info",
       code: "consumer-env-script-missing",
@@ -16587,7 +16663,7 @@ function checkInstalledMcpConfig(checks, rootDir, layout) {
     return;
   }
   const resolvedPath = resolve16(rootDir, layout.mcpConfigPath);
-  if (!existsSync23(resolvedPath)) {
+  if (!existsSync24(resolvedPath)) {
     addCheck2(checks, {
       level: "info",
       code: "consumer-mcp-config-missing",
@@ -16628,6 +16704,17 @@ function checkInstalledMcpConfig(checks, rootDir, layout) {
         fix: "If tools fail, verify the bundled command or its runtime dependencies on this machine.",
         path: layout.mcpConfigPath
       });
+      const missingRuntimePaths = findMissingInstalledStdioRuntimePaths(rootDir, stdioEntries);
+      if (missingRuntimePaths.length > 0) {
+        addCheck2(checks, {
+          level: "warning",
+          code: "consumer-mcp-stdio-runtime-missing",
+          title: "Bundled stdio MCP runtime files are missing",
+          detail: `This installed MCP config references local runtime path${missingRuntimePaths.length === 1 ? "" : "s"} that do not exist in the bundle: ${missingRuntimePaths.join(", ")}.`,
+          fix: "Rebuild the plugin with the MCP runtime directory included in passthrough, then reinstall the host bundle.",
+          path: layout.mcpConfigPath
+        });
+      }
     }
     if (remoteEntries.length > 0 && inlineHeaderEntries.length > 0) {
       addCheck2(checks, {
@@ -16662,9 +16749,27 @@ function checkInstalledMcpConfig(checks, rootDir, layout) {
     });
   }
 }
+function findMissingInstalledStdioRuntimePaths(rootDir, stdioEntries) {
+  const missing = /* @__PURE__ */ new Set();
+  for (const server of stdioEntries) {
+    const command2 = typeof server.command === "string" ? server.command : void 0;
+    const args2 = Array.isArray(server.args) ? server.args.filter((value) => typeof value === "string") : [];
+    for (const candidate of [command2, ...args2]) {
+      if (!candidate || !isLikelyLocalRuntimePath3(candidate)) continue;
+      const resolvedPath = resolve16(rootDir, candidate);
+      if (!existsSync24(resolvedPath)) {
+        missing.add(candidate);
+      }
+    }
+  }
+  return [...missing].sort();
+}
+function isLikelyLocalRuntimePath3(value) {
+  return value.startsWith("./") || value.startsWith("../") || value.startsWith(".\\") || value.startsWith("..\\");
+}
 function isLikelyOpenCodeInstallPath(rootDir) {
-  const parent = dirname6(rootDir);
-  const grandparent = dirname6(parent);
+  const parent = dirname7(rootDir);
+  const grandparent = dirname7(parent);
   return basename6(parent) === "plugins" && basename6(grandparent) === "opencode";
 }
 function checkInstalledOpenCodeHostBridge(checks, rootDir) {
@@ -16682,7 +16787,7 @@ function checkInstalledOpenCodeHostBridge(checks, rootDir) {
   const pluginName = basename6(rootDir);
   const entryPath = `${rootDir}.ts`;
   const entryRelativePath = `${pluginName}.ts`;
-  if (!existsSync23(entryPath)) {
+  if (!existsSync24(entryPath)) {
     addCheck2(checks, {
       level: "error",
       code: "consumer-opencode-entry-missing",
@@ -16722,7 +16827,7 @@ function checkInstalledOpenCodeSkills(checks, rootDir) {
   }
   const pluginName = basename6(rootDir);
   const sourceSkillsDir = resolve16(rootDir, "skills");
-  if (!existsSync23(sourceSkillsDir)) {
+  if (!existsSync24(sourceSkillsDir)) {
     addCheck2(checks, {
       level: "info",
       code: "consumer-opencode-skill-sync-not-applicable",
@@ -16733,17 +16838,17 @@ function checkInstalledOpenCodeSkills(checks, rootDir) {
     });
     return;
   }
-  const skillRoot = resolve16(dirname6(dirname6(rootDir)), "skills");
+  const skillRoot = resolve16(dirname7(dirname7(rootDir)), "skills");
   const missingSkills = [];
   const malformedSkills = [];
   let expectedSkillCount = 0;
   for (const entry of readdirSync9(sourceSkillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     const sourceSkillPath = resolve16(sourceSkillsDir, entry.name, "SKILL.md");
-    if (!existsSync23(sourceSkillPath)) continue;
+    if (!existsSync24(sourceSkillPath)) continue;
     expectedSkillCount++;
     const installedSkillPath = resolve16(skillRoot, `${pluginName}-${entry.name}`, "SKILL.md");
-    if (!existsSync23(installedSkillPath)) {
+    if (!existsSync24(installedSkillPath)) {
       missingSkills.push(`${pluginName}-${entry.name}`);
       continue;
     }
@@ -16840,7 +16945,7 @@ async function doctorConsumer(rootDir = process.cwd()) {
 }
 async function doctorProject(rootDir = process.cwd()) {
   const checks = [];
-  const configPath = CONFIG_FILES.find((filename) => existsSync23(resolve16(rootDir, filename)));
+  const configPath = CONFIG_FILES.find((filename) => existsSync24(resolve16(rootDir, filename)));
   addRuntimeChecks(checks, "project");
   if (!configPath) {
     addCheck2(checks, {
@@ -16939,7 +17044,7 @@ function printDoctorReport(report) {
 
 // src/cli/dev.ts
 import { watch } from "fs";
-import { relative as relative9, resolve as resolve17 } from "path";
+import { relative as relative10, resolve as resolve17 } from "path";
 var WATCH_PATTERNS = [
   /^pluxx\.config\.(ts|js|json)$/,
   /^skills\//,
@@ -16965,7 +17070,7 @@ async function runDev(args2) {
   let pendingFile = null;
   const watcher = watch(rootDir, { recursive: true }, (_event, filename) => {
     if (!filename) return;
-    const rel = relative9(rootDir, resolve17(rootDir, filename));
+    const rel = relative10(rootDir, resolve17(rootDir, filename));
     if (rel.startsWith("dist/") || rel.startsWith(".") || rel.includes("node_modules")) {
       return;
     }
@@ -17020,8 +17125,8 @@ async function runBuild(rootDir, targets) {
 }
 
 // src/cli/migrate.ts
-import { basename as basename7, relative as relative10, resolve as resolve18 } from "path";
-import { existsSync as existsSync24, readdirSync as readdirSync10, mkdirSync as mkdirSync5, cpSync as cpSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
+import { basename as basename7, relative as relative11, resolve as resolve18 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync10, mkdirSync as mkdirSync5, cpSync as cpSync4, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
 function detectPlatform(pluginDir) {
   const checks = [
     { dir: ".claude-plugin", platform: "claude-code" },
@@ -17030,12 +17135,12 @@ function detectPlatform(pluginDir) {
   ];
   for (const check of checks) {
     const manifestPath = resolve18(pluginDir, check.dir, "plugin.json");
-    if (existsSync24(manifestPath)) {
+    if (existsSync25(manifestPath)) {
       return { platform: check.platform, manifestPath };
     }
   }
   const pkgPath = resolve18(pluginDir, "package.json");
-  if (existsSync24(pkgPath)) {
+  if (existsSync25(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       const deps = {
@@ -17088,7 +17193,7 @@ function parseMcp(pluginDir, detection) {
   } catch {
   }
   for (const mcpPath of mcpPaths) {
-    if (!existsSync24(mcpPath)) continue;
+    if (!existsSync25(mcpPath)) continue;
     try {
       const raw = JSON.parse(readFileSync12(mcpPath, "utf-8"));
       const servers = raw.mcpServers ?? raw;
@@ -17182,7 +17287,7 @@ function parseHooks(pluginDir, detection) {
   } catch {
   }
   for (const hooksPath of hooksPaths) {
-    if (!existsSync24(hooksPath)) continue;
+    if (!existsSync25(hooksPath)) continue;
     try {
       const raw = JSON.parse(readFileSync12(hooksPath, "utf-8"));
       const hooksObj = raw.hooks ?? raw;
@@ -17231,7 +17336,7 @@ function findInstructions(pluginDir) {
   ];
   for (const candidate of candidates) {
     const filePath = resolve18(pluginDir, candidate);
-    if (existsSync24(filePath)) {
+    if (existsSync25(filePath)) {
       return `./${candidate}`;
     }
   }
@@ -17256,7 +17361,7 @@ function detectCanonicalSourcePaths(pluginDir) {
   for (const bucket of Object.keys(CANONICAL_SOURCE_CANDIDATES)) {
     for (const candidate of CANONICAL_SOURCE_CANDIDATES[bucket]) {
       const normalized = stripRelativePrefix(candidate);
-      if (!existsSync24(resolve18(pluginDir, normalized))) continue;
+      if (!existsSync25(resolve18(pluginDir, normalized))) continue;
       result[bucket] = normalizeRelativeDir(normalized);
       break;
     }
@@ -17272,7 +17377,7 @@ function detectPassthroughDirs(pluginDir, mcp) {
       if (!match?.[1]) continue;
       const dirName = match[1];
       const dirPath = resolve18(pluginDir, dirName);
-      if (existsSync24(dirPath)) {
+      if (existsSync25(dirPath)) {
         passthrough.add(`./${dirName}/`);
       }
     }
@@ -17373,7 +17478,7 @@ function inferPermissionsFromMigratedSkills(pluginDir, sourcePaths) {
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const skillPath = resolve18(skillsDir, entry.name, "SKILL.md");
-    if (!existsSync24(skillPath)) continue;
+    if (!existsSync25(skillPath)) continue;
     const content = readFileSync12(skillPath, "utf-8");
     const inferredRules = extractAllowedTools(content).map(normalizeMigratedAllowedTool).filter((rule) => Boolean(rule));
     if (inferredRules.length === 0) continue;
@@ -17418,7 +17523,7 @@ function readMigratedSkills(pluginDir, sourcePaths) {
       const skillPath = resolve18(skillsDir, dirName, "SKILL.md");
       let title = titleCaseFromDirName(dirName);
       let description;
-      if (existsSync24(skillPath)) {
+      if (existsSync25(skillPath)) {
         const content = readFileSync12(skillPath, "utf-8");
         title = extractFrontmatterField(content, "name") ?? firstHeading3(content) ?? title;
         description = extractFrontmatterField(content, "description");
@@ -17452,13 +17557,13 @@ var HOST_NATIVE_SKILL_FRONTMATTER_KEYS = /* @__PURE__ */ new Set([
   "allowed-tools"
 ]);
 function sanitizeMigratedSkillFrontmatter(outputDir) {
-  if (!existsSync24(resolve18(outputDir, "skills"))) return;
+  if (!existsSync25(resolve18(outputDir, "skills"))) return;
   const skillsDir = resolve18(outputDir, "skills");
   const entries = readdirSync10(skillsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const skillPath = resolve18(skillsDir, entry.name, "SKILL.md");
-    if (!existsSync24(skillPath)) continue;
+    if (!existsSync25(skillPath)) continue;
     const content = readFileSync12(skillPath, "utf-8");
     const lines = content.split(/\r?\n/);
     if (lines[0]?.trim() !== "---") continue;
@@ -17621,11 +17726,11 @@ function walkMarkdownFiles3(dir) {
   return files;
 }
 function normalizeMigratedOpenCodeAgents(destDir) {
-  if (!existsSync24(destDir)) return [];
+  if (!existsSync25(destDir)) return [];
   const normalized = [];
   for (const filePath of walkMarkdownFiles3(destDir)) {
     if (normalizeMigratedOpenCodeAgentFile(filePath)) {
-      normalized.push(relative10(destDir, filePath).replace(/\\/g, "/"));
+      normalized.push(relative11(destDir, filePath).replace(/\\/g, "/"));
     }
   }
   return normalized.sort();
@@ -17710,7 +17815,7 @@ function buildMigratedScaffoldMetadata(result, outputDir) {
       if (!result.sourcePaths[dir]) return [];
       const baseDir = dir;
       const dirPath = resolve18(outputDir, baseDir);
-      if (!existsSync24(dirPath)) return [];
+      if (!existsSync25(dirPath)) return [];
       const entries = readdirSync10(dirPath, { withFileTypes: true });
       const files = [];
       for (const entry of entries) {
@@ -17777,7 +17882,7 @@ function copyDirectories(pluginDir, outputDir, sourcePaths, passthrough) {
     const normalizedSource = stripRelativePrefix(sourcePath);
     const src = resolve18(pluginDir, normalizedSource);
     const dest = resolve18(outputDir, dir);
-    if (existsSync24(dest)) {
+    if (existsSync25(dest)) {
       console.log(`  skip ./${dir}/ (already exists)`);
       continue;
     }
@@ -17794,7 +17899,7 @@ function copyDirectories(pluginDir, outputDir, sourcePaths, passthrough) {
     const normalized = entry.replace(/^\.\//, "").replace(/\/$/, "");
     const src = resolve18(pluginDir, normalized);
     const dest = resolve18(outputDir, normalized);
-    if (existsSync24(dest)) {
+    if (existsSync25(dest)) {
       console.log(`  skip ./${normalized}/ (already exists)`);
       continue;
     }
@@ -17940,7 +18045,7 @@ function quote(s) {
 async function migrate(inputPath) {
   const pluginDir = resolve18(inputPath);
   const outputDir = process.cwd();
-  if (!existsSync24(pluginDir)) {
+  if (!existsSync25(pluginDir)) {
     console.error(`Error: Path does not exist: ${pluginDir}`);
     process.exit(1);
   }
@@ -18007,7 +18112,7 @@ async function migrate(inputPath) {
   };
   const configContent = generateConfigTs(result);
   const configPath = resolve18(outputDir, "pluxx.config.ts");
-  if (existsSync24(configPath)) {
+  if (existsSync25(configPath)) {
     console.error(`
 Error: pluxx.config.ts already exists in ${outputDir}`);
     console.error("Remove it first or run from a different directory.");
@@ -18024,7 +18129,7 @@ Generated pluxx.config.ts`);
   if (instructions) {
     const srcInstr = resolve18(pluginDir, instructions);
     const destInstr = resolve18(outputDir, instructions);
-    if (!existsSync24(destInstr)) {
+    if (!existsSync25(destInstr)) {
       const content = readFileSync12(srcInstr, "utf-8");
       await writeTextFile(destInstr, content);
       console.log(`Copied: ${instructions}`);
@@ -18060,7 +18165,7 @@ Generated pluxx.config.ts`);
 
 // src/cli/mcp-proxy.ts
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync13 } from "fs";
-import { dirname as dirname7, resolve as resolve19 } from "path";
+import { dirname as dirname8, resolve as resolve19 } from "path";
 import * as readline3 from "readline";
 function usage() {
   return [
@@ -18137,7 +18242,7 @@ async function loadReplayTape(filepath) {
 }
 async function writeTape(filepath, tape) {
   const absolutePath = resolve19(process.cwd(), filepath);
-  mkdirSync6(dirname7(absolutePath), { recursive: true });
+  mkdirSync6(dirname8(absolutePath), { recursive: true });
   await writeTextFile(absolutePath, `${JSON.stringify(tape, null, 2)}
 `);
 }
@@ -18308,7 +18413,7 @@ var PromptCancelledError = class extends Error {
   }
 };
 function ask(question) {
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     const rl = readline4.createInterface({
       input: process.stdin,
       output: process.stdout
@@ -18336,7 +18441,7 @@ function ask(question) {
     rl.once("close", onClose);
     rl.question(question, (answer) => {
       settle(() => {
-        resolve24(answer);
+        resolve25(answer);
         rl.close();
       });
     });
@@ -19311,13 +19416,13 @@ ${c2}
 } }).prompt();
 
 // src/cli/index.ts
-import { basename as basename8, resolve as resolve23 } from "path";
+import { basename as basename8, resolve as resolve24 } from "path";
 import { mkdir as mkdir4, mkdtemp as mkdtemp3, rm as rm4 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
 import { spawn as spawn4, spawnSync as spawnSync3 } from "child_process";
 
 // src/cli/publish.ts
-import { chmodSync, existsSync as existsSync25, mkdtempSync as mkdtempSync2, readFileSync as readFileSync14, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
+import { chmodSync, existsSync as existsSync26, mkdtempSync as mkdtempSync2, readFileSync as readFileSync14, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
 import { createHash } from "crypto";
 import { resolve as resolve20 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
@@ -19352,7 +19457,7 @@ function resolveRequestedChannels(options) {
 }
 function getBuiltTargets(rootDir, config) {
   return config.targets.filter(
-    (platform) => existsSync25(resolve20(rootDir, config.outDir, platform))
+    (platform) => existsSync26(resolve20(rootDir, config.outDir, platform))
   );
 }
 function getArchiveAssetName(pluginName, platform, version, variant) {
@@ -19411,7 +19516,7 @@ function buildReleaseAssets(rootDir, config, version, targets) {
 function readNpmPackageName(rootDir, config) {
   const packageDir = resolve20(rootDir, config.outDir, "opencode");
   const packageJsonPath = resolve20(packageDir, "package.json");
-  if (!existsSync25(packageJsonPath)) {
+  if (!existsSync26(packageJsonPath)) {
     return {};
   }
   try {
@@ -19464,7 +19569,7 @@ function collectChecks(args2) {
   if (args2.npmEnabled) {
     checks.push({
       name: "npm-package-ready",
-      ok: Boolean(args2.packageDir && existsSync25(resolve20(args2.packageDir, "package.json")) && args2.packageName),
+      ok: Boolean(args2.packageDir && existsSync26(resolve20(args2.packageDir, "package.json")) && args2.packageName),
       code: "npm-package-ready",
       detail: args2.packageDir ? `OpenCode package dir: ${args2.packageDir}` : "No npm-backed target package found."
     });
@@ -20271,7 +20376,7 @@ function printJson(value) {
 }
 
 // src/cli/verify-install.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 import { resolve as resolve21 } from "path";
 function buildCheckFromReport(target, pluginName, report) {
   const consumerPath = resolveInstalledConsumerPath(target, pluginName);
@@ -20280,7 +20385,7 @@ function buildCheckFromReport(target, pluginName, report) {
     installPath: target.pluginDir,
     consumerPath,
     built: target.built,
-    installed: existsSync26(consumerPath),
+    installed: existsSync27(consumerPath),
     ok: report.errors === 0,
     errors: report.errors,
     warnings: report.warnings,
@@ -20319,7 +20424,7 @@ function printVerifyInstallResult(result) {
 }
 
 // src/cli/behavioral.ts
-import { existsSync as existsSync27, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync15 } from "fs";
 import { mkdtemp as mkdtemp2, rm as rm3 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
 import { resolve as resolve22 } from "path";
@@ -20356,7 +20461,7 @@ function loadBehavioralCases(rootDir, targets, promptOverride) {
     }];
   }
   const filePath = resolve22(rootDir, BEHAVIORAL_CONFIG_PATH);
-  if (!existsSync27(filePath)) {
+  if (!existsSync28(filePath)) {
     throw new Error(
       `No behavioral smoke config found at ${BEHAVIORAL_CONFIG_PATH}. Add that file or pass --behavioral-prompt to define a real example query.`
     );
@@ -20471,7 +20576,7 @@ async function executeBehavioralCommand(platform, command2, cwd) {
       child.on("close", (code) => {
         const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
         const stderr = Buffer.concat(stderrChunks).toString("utf-8");
-        const codexMessage = codexLastMessagePath && existsSync27(codexLastMessagePath) ? readFileSync15(codexLastMessagePath, "utf-8") : "";
+        const codexMessage = codexLastMessagePath && existsSync28(codexLastMessagePath) ? readFileSync15(codexLastMessagePath, "utf-8") : "";
         resolvePromise({
           exitCode: code ?? 1,
           response: codexMessage.trim() || stdout.trim() || stderr.trim()
@@ -20533,6 +20638,396 @@ function shellQuote2(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 
+// src/cli/discover-installed-mcp.ts
+import { existsSync as existsSync29, readFileSync as readFileSync16 } from "fs";
+import { homedir as homedir2 } from "os";
+import { resolve as resolve23 } from "path";
+var INSTALLED_MCP_HOSTS = ["claude-code", "cursor", "codex", "opencode"];
+function discoverInstalledMcpServers(options = {}) {
+  const rootDir = options.rootDir ?? process.cwd();
+  const homeDir = options.homeDir ?? homedir2();
+  const hostSet = new Set(options.hosts ?? INSTALLED_MCP_HOSTS);
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of installedMcpFileCandidates(rootDir, homeDir)) {
+    if (!hostSet.has(candidate.host) || !existsSync29(candidate.path)) continue;
+    const parsed = candidate.parser === "json" ? parseJsonMcpFile(candidate.path, candidate.host) : parseCodexTomlMcpFile(candidate.path);
+    for (const discovered of parsed) {
+      const key = `${discovered.host}:${discovered.serverName}:${discovered.sourcePath}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      results.push(discovered);
+    }
+  }
+  return results.sort((a, b) => {
+    const hostOrder = INSTALLED_MCP_HOSTS.indexOf(a.host) - INSTALLED_MCP_HOSTS.indexOf(b.host);
+    if (hostOrder !== 0) return hostOrder;
+    return a.serverName.localeCompare(b.serverName);
+  });
+}
+function resolveInstalledMcpSelector(selector, candidates) {
+  const trimmed = selector.trim();
+  if (!trimmed) {
+    throw new Error("Provide an installed MCP selector such as `exa` or `codex:exa`.");
+  }
+  const exactId = candidates.filter((candidate) => candidate.id === trimmed);
+  if (exactId.length === 1) return exactId[0];
+  const hostMatch = trimmed.match(/^([^:]+):(.+)$/);
+  if (hostMatch) {
+    const host = normalizeInstalledMcpHost(hostMatch[1]);
+    const serverName = hostMatch[2];
+    const matches = candidates.filter((candidate) => candidate.host === host && candidate.serverName === serverName);
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) {
+      throw new Error(`Installed MCP selector "${trimmed}" matched multiple config files. Use one of: ${matches.map((match) => match.id).join(", ")}`);
+    }
+  }
+  const nameMatches = candidates.filter((candidate) => candidate.serverName === trimmed);
+  if (nameMatches.length === 1) return nameMatches[0];
+  if (nameMatches.length > 1) {
+    throw new Error(`Installed MCP selector "${trimmed}" is ambiguous. Use one of: ${nameMatches.map((match) => match.id).join(", ")}`);
+  }
+  const available = candidates.map((candidate) => candidate.id).join(", ") || "none";
+  throw new Error(`No installed MCP named "${trimmed}" was found. Available installed MCPs: ${available}`);
+}
+function normalizeInstalledMcpHost(value) {
+  const normalized = value.trim().toLowerCase();
+  const aliases = {
+    claude: "claude-code",
+    "claude-code": "claude-code",
+    cursor: "cursor",
+    codex: "codex",
+    open: "opencode",
+    opencode: "opencode"
+  };
+  const host = aliases[normalized];
+  if (!host) {
+    throw new Error(`Installed MCP host must be one of: ${INSTALLED_MCP_HOSTS.join(", ")}`);
+  }
+  return host;
+}
+function formatInstalledMcpSource(discovered) {
+  const transport = discovered.server.transport;
+  const endpoint = transport === "stdio" ? [discovered.server.command, ...discovered.server.args ?? []].join(" ") : discovered.server.url;
+  return `${discovered.id} (${transport}: ${endpoint})`;
+}
+function installedMcpFileCandidates(rootDir, homeDir) {
+  return [
+    { host: "claude-code", path: resolve23(rootDir, ".mcp.json"), parser: "json" },
+    { host: "claude-code", path: resolve23(rootDir, ".claude-plugin/plugin.json"), parser: "json" },
+    { host: "claude-code", path: resolve23(rootDir, ".claude/settings.json"), parser: "json" },
+    { host: "claude-code", path: resolve23(rootDir, ".claude/settings.local.json"), parser: "json" },
+    { host: "claude-code", path: resolve23(homeDir, ".claude/settings.json"), parser: "json" },
+    { host: "claude-code", path: resolve23(homeDir, ".claude/settings.local.json"), parser: "json" },
+    { host: "claude-code", path: resolve23(homeDir, ".claude.json"), parser: "json" },
+    { host: "cursor", path: resolve23(rootDir, "mcp.json"), parser: "json" },
+    { host: "cursor", path: resolve23(rootDir, ".cursor/mcp.json"), parser: "json" },
+    { host: "cursor", path: resolve23(homeDir, ".cursor/mcp.json"), parser: "json" },
+    { host: "codex", path: resolve23(rootDir, ".mcp.json"), parser: "json" },
+    { host: "codex", path: resolve23(rootDir, ".codex/config.toml"), parser: "toml" },
+    { host: "codex", path: resolve23(homeDir, ".codex/config.toml"), parser: "toml" },
+    { host: "opencode", path: resolve23(rootDir, "opencode.json"), parser: "json" },
+    { host: "opencode", path: resolve23(rootDir, ".opencode.json"), parser: "json" },
+    { host: "opencode", path: resolve23(homeDir, ".config/opencode/opencode.json"), parser: "json" }
+  ];
+}
+function parseJsonMcpFile(path, host) {
+  try {
+    const raw = JSON.parse(readFileSync16(path, "utf-8"));
+    const servers = extractJsonMcpServers(raw, path, host);
+    return Object.entries(servers).flatMap(([serverName, config]) => {
+      const normalized = normalizeCommonMcpServer(config, host);
+      if (!normalized) return [];
+      return [toDiscovered(host, serverName, path, normalized.server, normalized.warnings)];
+    });
+  } catch {
+    return [];
+  }
+}
+function extractJsonMcpServers(raw, path, host) {
+  if (host === "opencode" && raw.mcp && typeof raw.mcp === "object") {
+    return raw.mcp;
+  }
+  if (raw.mcpServers && typeof raw.mcpServers === "object") {
+    return raw.mcpServers;
+  }
+  if (host === "claude-code" && raw.projects && typeof raw.projects === "object") {
+    const projectServers = {};
+    for (const projectConfig of Object.values(raw.projects)) {
+      if (!projectConfig || typeof projectConfig !== "object") continue;
+      const mcpServers = projectConfig.mcpServers;
+      if (!mcpServers || typeof mcpServers !== "object") continue;
+      Object.assign(projectServers, mcpServers);
+    }
+    return projectServers;
+  }
+  if (typeof raw.mcpServers === "string") return {};
+  if (path.endsWith("mcp.json") || path.endsWith(".mcp.json")) {
+    return raw;
+  }
+  return {};
+}
+function parseCodexTomlMcpFile(path) {
+  const text = readFileSync16(path, "utf-8");
+  const servers = {};
+  let currentServer;
+  let currentSubtable;
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = stripTomlComment(rawLine).trim();
+    if (!line) continue;
+    const section = line.match(/^\[mcp_servers\.([A-Za-z0-9_.-]+)(?:\.([A-Za-z0-9_.-]+))?\]$/);
+    if (section) {
+      currentServer = section[1];
+      currentSubtable = section[2];
+      servers[currentServer] ??= {};
+      if (currentSubtable) {
+        const existing = servers[currentServer][currentSubtable];
+        if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+          servers[currentServer][currentSubtable] = {};
+        }
+      }
+      continue;
+    }
+    if (!currentServer) continue;
+    const assignment = line.match(/^([A-Za-z0-9_-]+)\s*=\s*(.+)$/);
+    if (!assignment) continue;
+    const key = assignment[1];
+    const value = parseTomlValue(assignment[2].trim());
+    if (currentSubtable) {
+      const table = servers[currentServer][currentSubtable];
+      table[key] = value;
+    } else {
+      servers[currentServer][key] = value;
+    }
+  }
+  return Object.entries(servers).flatMap(([serverName, config]) => {
+    const normalized = normalizeCommonMcpServer(config, "codex");
+    if (!normalized) return [];
+    return [toDiscovered("codex", serverName, path, normalized.server, normalized.warnings)];
+  });
+}
+function normalizeCommonMcpServer(config, host) {
+  if (!config || typeof config !== "object") return null;
+  const cfg = config;
+  const warnings = [];
+  const auth = inferAuth(cfg, warnings);
+  const remoteUrl = firstString(cfg.url, cfg.endpoint);
+  if (remoteUrl) {
+    const server = cfg.type === "sse" || cfg.transport === "sse" ? {
+      transport: "sse",
+      url: remoteUrl,
+      ...auth ? { auth } : {}
+    } : {
+      transport: "http",
+      url: remoteUrl,
+      ...auth ? { auth } : {}
+    };
+    return { server, warnings };
+  }
+  const command2 = normalizeCommand(cfg.command, host);
+  if (!command2) return null;
+  const args2 = normalizeArgs(cfg.command, cfg.args, host);
+  const env = normalizeEnv(cfg.env, warnings);
+  return {
+    server: {
+      transport: "stdio",
+      command: command2,
+      ...args2.length > 0 ? { args: args2 } : {},
+      ...Object.keys(env).length > 0 ? { env } : {},
+      ...auth ? { auth } : {}
+    },
+    warnings
+  };
+}
+function normalizeCommand(value, host) {
+  if (typeof value === "string") return value;
+  if (host === "opencode" && Array.isArray(value) && typeof value[0] === "string") {
+    return value[0];
+  }
+  return void 0;
+}
+function normalizeArgs(command2, args2, host) {
+  if (host === "opencode" && Array.isArray(command2)) {
+    return command2.slice(1).map(String);
+  }
+  return normalizeStringArray(args2);
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map(String);
+}
+function normalizeEnv(value, warnings) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const env = {};
+  for (const [key, rawValue] of Object.entries(value)) {
+    if (typeof rawValue !== "string") continue;
+    const placeholder = envPlaceholder(rawValue);
+    if (placeholder) {
+      env[key] = placeholder;
+      continue;
+    }
+    if (looksSecretKey(key)) {
+      env[key] = `\${${key}}`;
+      warnings.push(`Literal secret-like env value for ${key} was replaced with \${${key}}.`);
+      continue;
+    }
+    env[key] = rawValue;
+  }
+  return env;
+}
+function inferAuth(cfg, warnings) {
+  const bearerTokenEnv = firstString(cfg.bearer_token_env_var, cfg.bearerTokenEnvVar);
+  if (bearerTokenEnv) {
+    return {
+      type: "bearer",
+      envVar: bearerTokenEnv,
+      headerName: "Authorization",
+      headerTemplate: "Bearer ${value}"
+    };
+  }
+  const envHttpHeaders = cfg.env_http_headers ?? cfg.envHttpHeaders;
+  if (envHttpHeaders && typeof envHttpHeaders === "object" && !Array.isArray(envHttpHeaders)) {
+    const [headerName, envVar] = Object.entries(envHttpHeaders).find(([, value]) => typeof value === "string") ?? [];
+    if (typeof headerName === "string" && typeof envVar === "string") {
+      return {
+        type: headerName.toLowerCase() === "authorization" ? "bearer" : "header",
+        envVar,
+        headerName,
+        headerTemplate: headerName.toLowerCase() === "authorization" ? "Bearer ${value}" : "${value}"
+      };
+    }
+  }
+  const headers = cfg.headers ?? cfg.http_headers ?? cfg.httpHeaders;
+  if (!headers || typeof headers !== "object" || Array.isArray(headers)) return void 0;
+  const headerEntries = Object.entries(headers);
+  for (const [headerName, rawValue] of headerEntries) {
+    if (typeof rawValue !== "string") continue;
+    const envVar = extractEnvVar(rawValue);
+    if (envVar) {
+      return {
+        type: headerName.toLowerCase() === "authorization" ? "bearer" : "header",
+        envVar,
+        headerName,
+        headerTemplate: rawValue.replace(envReferencePattern(envVar), "${value}")
+      };
+    }
+    if (looksSecretValue(rawValue)) {
+      warnings.push(`Literal ${headerName} header value was not copied. Re-run init with --auth-env if this server needs auth.`);
+    }
+  }
+  return void 0;
+}
+function toDiscovered(host, serverName, sourcePath, server, warnings) {
+  return {
+    id: `${host}:${serverName}`,
+    host,
+    serverName,
+    sourcePath,
+    server,
+    warnings
+  };
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return void 0;
+}
+function envPlaceholder(value) {
+  const envVar = extractEnvVar(value);
+  return envVar ? `\${${envVar}}` : void 0;
+}
+function extractEnvVar(value) {
+  const match = value.match(/\$\{(?:env:)?([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/);
+  return match?.[1] ?? match?.[2];
+}
+function envReferencePattern(envVar) {
+  return new RegExp(`\\$\\{(?:env:)?${escapeRegExp2(envVar)}\\}|\\$${escapeRegExp2(envVar)}`);
+}
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function looksSecretKey(value) {
+  return /(api|auth|secret|token|key|password|credential)/i.test(value);
+}
+function looksSecretValue(value) {
+  return value.length >= 16 && !extractEnvVar(value);
+}
+function stripTomlComment(line) {
+  let inString = false;
+  let quote2 = "";
+  for (let i = 0; i < line.length; i += 1) {
+    const char = line[i];
+    if ((char === '"' || char === "'") && line[i - 1] !== "\\") {
+      if (!inString) {
+        inString = true;
+        quote2 = char;
+      } else if (quote2 === char) {
+        inString = false;
+        quote2 = "";
+      }
+      continue;
+    }
+    if (char === "#" && !inString) return line.slice(0, i);
+  }
+  return line;
+}
+function parseTomlValue(value) {
+  if (value.startsWith('"') && value.endsWith('"')) return unquoteTomlString(value);
+  if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner) return [];
+    return splitTomlList(inner).map((part) => parseTomlValue(part.trim()));
+  }
+  if (value.startsWith("{") && value.endsWith("}")) {
+    const inner = value.slice(1, -1).trim();
+    const result = {};
+    if (!inner) return result;
+    for (const part of splitTomlList(inner)) {
+      const assignment = part.match(/^([A-Za-z0-9_-]+)\s*=\s*(.+)$/);
+      if (!assignment) continue;
+      result[assignment[1]] = parseTomlValue(assignment[2].trim());
+    }
+    return result;
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return value;
+}
+function splitTomlList(value) {
+  const parts = [];
+  let current = "";
+  let inString = false;
+  let quote2 = "";
+  let braceDepth = 0;
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    if ((char === '"' || char === "'") && value[i - 1] !== "\\") {
+      if (!inString) {
+        inString = true;
+        quote2 = char;
+      } else if (quote2 === char) {
+        inString = false;
+        quote2 = "";
+      }
+    }
+    if (!inString && char === "{") braceDepth += 1;
+    if (!inString && char === "}") braceDepth -= 1;
+    if (!inString && braceDepth === 0 && char === ",") {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) parts.push(current);
+  return parts;
+}
+function unquoteTomlString(value) {
+  return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\\\/g, "\\");
+}
+
 // src/cli/index.ts
 var CLI_PACKAGE_NAME = "@orchid-labs/pluxx";
 var rawArgs = process.argv.slice(2);
@@ -20583,6 +21078,9 @@ async function main() {
     case "mcp":
       await runMcp();
       break;
+    case "discover-mcp":
+      await runDiscoverMcp();
+      break;
     case "autopilot":
       await runAutopilot();
       break;
@@ -20596,6 +21094,10 @@ async function main() {
       await runVerifyInstall();
       break;
     case "publish":
+      if (isHelpRequested(args.slice(1))) {
+        printPublishHelp();
+        break;
+      }
       await runPublishCommand();
       break;
     case "uninstall":
@@ -20634,9 +21136,12 @@ function normalizeTopLevelArgs(input) {
   }
   return input;
 }
+function isHelpRequested(input) {
+  return input.includes("--help") || input.includes("-h");
+}
 function getCliPackageVersion() {
   const packageJsonPath = new URL("../../package.json", import.meta.url);
-  const raw = JSON.parse(readFileSync16(packageJsonPath, "utf-8"));
+  const raw = JSON.parse(readFileSync17(packageJsonPath, "utf-8"));
   if (typeof raw.version !== "string" || raw.version.trim() === "") {
     throw new Error("Unable to determine the installed pluxx version from package.json.");
   }
@@ -21296,7 +21801,7 @@ async function planInitContextArtifactFiles(rootDir, contextPack) {
   return plannedFiles;
 }
 async function planAuxiliaryFile(rootDir, relativePath, content) {
-  const filePath = resolve23(rootDir, relativePath);
+  const filePath = resolve24(rootDir, relativePath);
   const action = await planTextFileAction(filePath, content);
   return {
     relativePath,
@@ -21326,6 +21831,7 @@ function formatMcpDiscoverySummary(introspection) {
 function parseInitFromMcpOptions(rawArgs2, initialName, initialSource) {
   return {
     source: initialSource ?? readOption2(rawArgs2, "--from-mcp"),
+    installedMcp: readOption2(rawArgs2, "--from-installed-mcp"),
     assumeDefaults: rawArgs2.includes("--yes"),
     name: readOption2(rawArgs2, "--name") ?? initialName,
     author: readOption2(rawArgs2, "--author"),
@@ -21354,11 +21860,49 @@ function toKebabCase3(value) {
 function toTsString(value) {
   return JSON.stringify(value);
 }
+function parseInstalledMcpHosts(rawArgs2) {
+  const hostValues = readMultiValueOption(rawArgs2, "--host") ?? readMultiValueOption(rawArgs2, "--hosts");
+  if (!hostValues) return void 0;
+  return hostValues.flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean).map(normalizeInstalledMcpHost);
+}
+function resolveInstalledMcpForInit(selector, hosts) {
+  const discovered = discoverInstalledMcpServers({ hosts });
+  return resolveInstalledMcpSelector(selector, discovered);
+}
+async function runDiscoverMcp() {
+  const hosts = parseInstalledMcpHosts(args);
+  const discovered = discoverInstalledMcpServers({ hosts });
+  if (runtime.jsonOutput) {
+    printJson({
+      count: discovered.length,
+      servers: discovered
+    });
+    return;
+  }
+  if (discovered.length === 0) {
+    console.log("No installed MCP servers found.");
+    console.log(`Searched hosts: ${(hosts ?? INSTALLED_MCP_HOSTS).join(", ")}`);
+    return;
+  }
+  console.log("Installed MCP servers:");
+  for (const server of discovered) {
+    console.log(`  ${server.id}`);
+    console.log(`    source: ${server.sourcePath}`);
+    console.log(`    server: ${formatInstalledMcpSource(server)}`);
+    for (const warning of server.warnings) {
+      console.log(`    warning: ${warning}`);
+    }
+  }
+  console.log("");
+  console.log("Import one:");
+  console.log(`  pluxx init --from-installed-mcp ${discovered[0].id} --yes`);
+}
 async function runInit() {
   const positionalName = args[1] && !args[1].startsWith("-") ? args[1] : void 0;
   const fromMcpFlag = args.indexOf("--from-mcp");
+  const fromInstalledMcpFlag = args.indexOf("--from-installed-mcp");
   const fromMcpInput = fromMcpFlag !== -1 && args[fromMcpFlag + 1] && !args[fromMcpFlag + 1].startsWith("-") ? args[fromMcpFlag + 1] : void 0;
-  if (fromMcpFlag !== -1) {
+  if (fromMcpFlag !== -1 || fromInstalledMcpFlag !== -1) {
     await runInitFromMcp(positionalName, fromMcpInput);
     return;
   }
@@ -21442,7 +21986,7 @@ ${mcpBlock}${brandBlock}
   targets: [${targetsList}],
 })
 `;
-    await writeTextFile(resolve23(process.cwd(), "pluxx.config.ts"), template);
+    await writeTextFile(resolve24(process.cwd(), "pluxx.config.ts"), template);
     const skillDir = `skills/${skillName}`;
     await mkdir4(skillDir, { recursive: true });
     const skillContent = `---
@@ -21464,7 +22008,7 @@ Describe how agents should use this skill.
 Example prompt or command here
 \`\`\`
 `;
-    await writeTextFile(resolve23(process.cwd(), `${skillDir}/SKILL.md`), skillContent);
+    await writeTextFile(resolve24(process.cwd(), `${skillDir}/SKILL.md`), skillContent);
     console.log("");
     console.log("  Created:");
     console.log("    pluxx.config.ts");
@@ -21493,14 +22037,15 @@ async function runInitFromMcp(initialName, initialSource) {
   const contextPaths = options.contextPaths ?? [];
   const ingestProvider = options.ingestProvider ? parseChoiceOption(options.ingestProvider, AGENT_INGEST_PROVIDERS, "Ingestion provider") : void 0;
   if (!options.jsonOutput && !runtime.quiet) {
-    mt("pluxx init --from-mcp");
+    mt(options.installedMcp ? "pluxx init --from-installed-mcp" : "pluxx init --from-mcp");
   }
   try {
-    const rawSource = options.source ?? (interactive ? await clackText("MCP server URL or local command") : "");
+    const installedMcpSource = options.installedMcp ? resolveInstalledMcpForInit(options.installedMcp, parseInstalledMcpHosts(args)) : void 0;
+    const rawSource = installedMcpSource ? formatInstalledMcpSource(installedMcpSource) : options.source ?? (interactive ? await clackText("MCP server URL or local command") : "");
     if (!rawSource) {
-      throw new Error("Provide an MCP server URL or local command. Example: pluxx init --from-mcp https://example.com/mcp");
+      throw new Error("Provide an MCP server URL/local command or an installed MCP selector. Example: pluxx init --from-mcp https://example.com/mcp");
     }
-    let source = parseMcpSourceInput(rawSource, options.transport);
+    let source = installedMcpSource?.server ?? parseMcpSourceInput(rawSource, options.transport);
     let introspectionSource = source;
     const configuredRemoteAuth = source.transport === "stdio" ? void 0 : buildRemoteAuthConfig(options);
     if (configuredRemoteAuth && !source.auth) {
@@ -21653,7 +22198,7 @@ ${formatAuthRequiredMessage("init", retryError, source)}`);
     if (!options.jsonOutput && !runtime.quiet) {
       O2.step("Step 2/4 \xB7 Plugin identity");
     }
-    const defaultPluginName = options.name ? toKebabCase3(options.name) : derivePluginName(introspection, source);
+    const defaultPluginName = options.name ? toKebabCase3(options.name) : installedMcpSource?.serverName ? toKebabCase3(installedMcpSource.serverName) : derivePluginName(introspection, source);
     const pluginName = toKebabCase3(
       options.name ?? (interactive ? await clackText("Plugin name", defaultPluginName) : defaultPluginName)
     );
@@ -21687,6 +22232,7 @@ ${formatAuthRequiredMessage("init", retryError, source)}`);
       source,
       runtimeAuthMode,
       introspection,
+      serverName: installedMcpSource?.serverName,
       displayName,
       description: sourcedContextPack?.docsContext?.shortDescription,
       websiteUrl,
@@ -21708,7 +22254,7 @@ ${formatAuthRequiredMessage("init", retryError, source)}`);
     if (!runtime.dryRun) {
       await applyMcpScaffoldPlan(process.cwd(), plan);
       for (const file of contextArtifactFiles) {
-        await writeTextFile(resolve23(process.cwd(), file.relativePath), file.content);
+        await writeTextFile(resolve24(process.cwd(), file.relativePath), file.content);
       }
     }
     const lintResult = runtime.dryRun ? { errors: 0, warnings: 0, issues: [] } : await lintProject(process.cwd());
@@ -21778,6 +22324,11 @@ ${formatAuthRequiredMessage("init", retryError, source)}`);
         O2.info(n);
       }
     }
+    if (installedMcpSource && installedMcpSource.warnings.length > 0) {
+      for (const warning of installedMcpSource.warnings) {
+        O2.warn(`Installed MCP import: ${warning}`);
+      }
+    }
     if (summary.quality.issues.length > 0) {
       for (const line of formatMcpQualityLines(summary.quality)) {
         O2.info(line);
@@ -21871,7 +22422,7 @@ async function runSync() {
 async function runDoctor() {
   const consumerMode = readFlag(args, "--consumer");
   const doctorPath = args.slice(1).find((value) => !value.startsWith("-"));
-  const rootDir = doctorPath ? resolve23(process.cwd(), doctorPath) : process.cwd();
+  const rootDir = doctorPath ? resolve24(process.cwd(), doctorPath) : process.cwd();
   const report = consumerMode ? await doctorConsumer(rootDir) : await doctorProject(rootDir);
   if (runtime.jsonOutput) {
     printJson(report);
@@ -22828,7 +23379,7 @@ async function runVerifyInstall() {
   const targets = parseTargetFlagValues(args);
   const config = await loadConfig();
   if (runtime.dryRun) {
-    const distDir = resolve23(process.cwd(), config.outDir);
+    const distDir = resolve24(process.cwd(), config.outDir);
     const plan = planInstallPlugin(distDir, config.name, targets ?? config.targets);
     const summary = {
       dryRun: true,
@@ -22915,9 +23466,10 @@ Usage:
   pluxx agent prepare                     Generate agent context + boundary files for host agents
   pluxx agent prompt <kind>               Generate a prompt pack (taxonomy, instructions, review)
   pluxx agent run <kind> --runner <id>    Execute a prompt pack via Claude, Cursor, Codex, or OpenCode headlessly
+  pluxx discover-mcp [--host <hosts...>] List installed MCP servers from local host configs
   pluxx mcp proxy ...                     Run a local MCP proxy with optional record/replay tapes
   pluxx autopilot --from-mcp ...          Run import + agent refinement + verification in one command
-  pluxx init [name] [--from-mcp <source>] Create a new pluxx.config.ts
+  pluxx init [name] [--from-mcp <source>|--from-installed-mcp <selector>] Create a new pluxx.config.ts
   pluxx sync [--from-mcp <source>]        Refresh MCP-derived scaffold files
   pluxx migrate <path>                    Import an existing plugin into pluxx
   pluxx test [--target <platforms...>] [--install] [--behavioral]    Run config, lint, eval, build, and smoke checks
@@ -22952,6 +23504,9 @@ Examples:
   pluxx init my-plugin                    Scaffold a new plugin config
   pluxx init --from-mcp https://example.com/mcp  Scaffold from a remote MCP server
   pluxx init --from-mcp "npx -y -p @acme/mcp acme-mcp"  Scaffold from a local MCP command
+  pluxx discover-mcp                      List installed MCP servers in Claude, Cursor, Codex, and OpenCode config
+  pluxx discover-mcp --host codex opencode --json
+  pluxx init --from-installed-mcp codex:acme --yes  Scaffold from an already installed MCP config
   pluxx init --from-mcp https://example.com/mcp --yes --name acme --display-name "Acme" --author "Acme" --targets claude-code,codex --grouping workflow --hooks safe --json
   pluxx init --from-mcp https://example.com/mcp --yes --auth-env API_KEY --auth-type header --auth-header X-API-Key --auth-template "\${value}"
   pluxx init --from-mcp https://example.com/mcp --yes --auth-type platform --runtime-auth platform
@@ -22992,6 +23547,39 @@ Examples:
   pluxx verify-install --target codex     Verify the installed Codex bundle in its native local path
   pluxx install --dry-run                 Preview local install paths and trust implications
   pluxx install --trust                   Install without hook trust confirmation
+  pluxx publish --dry-run                 Preview npm/GitHub release publish checks
+  pluxx publish --github-release --version 1.0.0  Create release installers and a GitHub release
+  pluxx publish --npm --tag next          Publish the npm package under a non-latest dist-tag
+`);
+}
+function printPublishHelp() {
+  console.log(`
+pluxx publish \u2014 package and release a built plugin or CLI
+
+Usage:
+  pluxx publish [--npm] [--github-release] [--allow-dirty] [--dry-run] [--json] [--tag latest] [--version x.y.z]
+
+Behavior:
+  - loads the current pluxx.config.* project
+  - plans npm publish and/or GitHub release work
+  - runs clean-working-tree checks unless --allow-dirty is passed
+  - writes release assets such as install scripts and release-manifest.json when applicable
+
+Flags:
+  --npm              Publish to npm using the configured package metadata
+  --github-release   Create or update GitHub release assets for the requested version
+  --version x.y.z    Override the release version for the publish plan
+  --tag <name>       Set the npm dist-tag (default: latest)
+  --allow-dirty      Skip the clean-working-tree check
+  --dry-run          Show the publish plan without writing or uploading
+  --json             Print the publish plan or result as JSON
+  --help, -h         Show this command help
+
+Examples:
+  pluxx publish --dry-run
+  pluxx publish --github-release --version 1.0.0
+  pluxx publish --npm --version 0.1.7
+  pluxx publish --npm --github-release --version 1.0.0
 `);
 }
 if (import.meta.main) {