@modootoday/pmcp 0.16.1 → 0.17.1

package/dist/index.js

@@ -1548,7 +1548,8 @@ function nativeOptions(path, where, value) {
     codex: ["startup_timeout_sec", "tool_timeout_sec"],
     gemini: ["timeout"],
     grok: ["startup_timeout_sec", "tool_timeout_sec"],
-    antigravity: []
+    antigravity: [],
+    opencode: ["timeout"]
   };
   const result = {};
   for (const [tool, raw] of Object.entries(
@@ -1980,7 +1981,8 @@ var TOOLS = [
   "codex",
   "gemini",
   "grok",
-  "antigravity"
+  "antigravity",
+  "opencode"
 ];
 var NAME = /^[a-z0-9][a-z0-9-]*$/u;
 function table(path, where, value) {
@@ -2079,8 +2081,8 @@ function readSpec(config) {
 }
 
 // src/project/plan.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, readdirSync as readdirSync4 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync7, readdirSync as readdirSync4 } from "fs";
+import { join as join8 } from "path";
 
 // src/project/frontmatter.ts
 import { parse as parse3 } from "yaml";
@@ -2228,6 +2230,56 @@ function packageRuleOutputs(root, spec, owned) {
 
 // src/project/mcp.ts
 import { isAbsolute as isAbsolute4, relative as relative4 } from "path";
+
+// src/project/adapters/opencode.ts
+import { existsSync as existsSync8 } from "fs";
+import { join as join6 } from "path";
+var OPENCODE_CONFIG = "opencode.json";
+function checkOpenCodeConfig(root) {
+  if (existsSync8(join6(root, "opencode.jsonc"))) {
+    throw new ProjectError(
+      "OpenCode JSONC projection is not supported; reconcile opencode.jsonc before projecting opencode.json"
+    );
+  }
+}
+function opencodeMcpEntry(server, started) {
+  if (server.tools !== void 0) {
+    throw new ProjectError(
+      "OpenCode per-server tool filtering is not qualified; limit this server's targets"
+    );
+  }
+  const timeout = server.native?.opencode;
+  if (server.url !== void 0) {
+    const headers = { ...server.headers };
+    for (const [key, name] of Object.entries(server.headerEnv ?? {})) {
+      headers[key] = `{env:${name}}`;
+    }
+    if (server.bearerTokenEnvVar) {
+      headers["Authorization"] = `Bearer {env:${server.bearerTokenEnvVar}}`;
+    }
+    return {
+      type: "remote",
+      url: server.url,
+      enabled: true,
+      ...Object.keys(headers).length > 0 ? { headers } : {},
+      ...timeout
+    };
+  }
+  if (!started) {
+    throw new ProjectError(
+      "OpenCode local MCP projection requires a launch specification"
+    );
+  }
+  return {
+    type: "local",
+    command: [started.command, ...started.args],
+    enabled: true,
+    ...Object.keys(started.env).length > 0 ? { environment: { ...started.env } } : {},
+    ...timeout
+  };
+}
+
+// src/project/mcp.ts
 var runtimeByTool = {
   claude: "claude-code",
   codex: "codex-cli",
@@ -2235,6 +2287,15 @@ var runtimeByTool = {
   grok: "grok-cli",
   antigravity: "antigravity"
 };
+function mailboxRuntime(tool) {
+  const runtime = runtimeByTool[tool];
+  if (!runtime) {
+    throw new ProjectError(
+      "OpenCode mailbox runtime binding is not qualified; limit this server's targets"
+    );
+  }
+  return runtime;
+}
 var ROOT_VAR = "${PROJECT_ROOT}";
 var ANTIGRAVITY_MCP_PLUGIN = ".agents/plugins/pmcp-mcp";
 var VARIABLE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/gu;
@@ -2370,18 +2431,19 @@ function httpEntry(server, tool) {
 function nativeEntry(spec, alias, server, tool) {
   let result;
   if (server.url !== void 0) {
+    if (tool === "opencode") return opencodeMcpEntry(server);
     result = httpEntry(server, tool);
   } else {
     const env = { ...server.env };
     if (server.mailbox) {
-      env["PMCP_MAILBOX_RUNTIME"] = runtimeByTool[tool];
+      env["PMCP_MAILBOX_RUNTIME"] = mailboxRuntime(tool);
     }
     let started;
     if (Object.keys(server.envFrom ?? {}).length > 0) {
       const entry = relative4(spec.root, process.argv[1] ?? "");
       const driverEnv = {};
       if (server.mailbox) {
-        driverEnv["PMCP_MAILBOX_RUNTIME"] = runtimeByTool[tool];
+        driverEnv["PMCP_MAILBOX_RUNTIME"] = mailboxRuntime(tool);
       }
       if (!isAbsolute4(entry) && !entry.startsWith("..")) {
         started = launch({
@@ -2399,6 +2461,7 @@ function nativeEntry(spec, alias, server, tool) {
     } else {
       started = launch({ ...server, env });
     }
+    if (tool === "opencode") return opencodeMcpEntry(server, started);
     result = { command: started.command, args: [...started.args] };
     if (Object.keys(started.env).length > 0) {
       result["env"] = { ...started.env };
@@ -2455,9 +2518,11 @@ function mcpOutputs(spec) {
   const jsonFiles = {
     claude: ".mcp.json",
     gemini: ".gemini/settings.json",
-    antigravity: `${ANTIGRAVITY_MCP_PLUGIN}/mcp_config.json`
+    antigravity: `${ANTIGRAVITY_MCP_PLUGIN}/mcp_config.json`,
+    opencode: OPENCODE_CONFIG
   };
   for (const tool of spec.tools) {
+    if (tool === "opencode") checkOpenCodeConfig(spec.root);
     const servers = serversForTool(spec, tool);
     if (servers.length === 0) {
       continue;
@@ -2476,7 +2541,7 @@ function mcpOutputs(spec) {
         outputs.push(
           jsonOutput(
             file,
-            ["mcpServers", alias],
+            [tool === "opencode" ? "mcp" : "mcpServers", alias],
             nativeEntry(spec, alias, server, tool)
           )
         );
@@ -2492,8 +2557,8 @@ function mcpOutputs(spec) {
 
 // src/project/hooks.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
 import { fileURLToPath } from "url";
 var HOOK_DIRECTORY = ".agents/pmcp-hooks";
 var ADAPTER = `${HOOK_DIRECTORY}/adapter.mjs`;
@@ -2523,8 +2588,8 @@ function object4(value) {
   return value;
 }
 function groups(root, file, key) {
-  const absolute = join6(root, file);
-  if (!existsSync8(absolute)) {
+  const absolute = join7(root, file);
+  if (!existsSync9(absolute)) {
     return [];
   }
   let value;
@@ -2553,15 +2618,15 @@ function adapterSource() {
   const sourceBuild = fileURLToPath(
     new URL("../../dist/project/hook-adapter.js", import.meta.url)
   );
-  const file = existsSync8(published) ? published : sourceBuild;
-  if (!existsSync8(file)) {
+  const file = existsSync9(published) ? published : sourceBuild;
+  if (!existsSync9(file)) {
     throw new ProjectError("Build pmcp before projecting shell hook adapters");
   }
   return readFileSync6(file, "utf8");
 }
 function hookOutputs(spec) {
-  const lockFile = join6(spec.root, "pmcp.lock");
-  const lock = existsSync8(lockFile) ? JSON.parse(readFileSync6(lockFile, "utf8")) : {};
+  const lockFile = join7(spec.root, "pmcp.lock");
+  const lock = existsSync9(lockFile) ? JSON.parse(readFileSync6(lockFile, "utf8")) : {};
   const previous = new Map(
     (lock.outputs ?? []).filter((entry) => entry.managed !== void 0).map((entry) => [entry.path, entry.managed])
   );
@@ -2641,6 +2706,14 @@ function hookOutputs(spec) {
   return outputs;
 }
 
+// src/project/adapters/opencode-skills.ts
+function opencodeSkillOutputs(spec, names) {
+  if (!spec.tools.has("opencode")) return [];
+  return names.filter((name) => spec.skills[name]?.invocation === "user").map(
+    (name) => jsonOutput(OPENCODE_CONFIG, ["permission", "skill", name], "deny")
+  );
+}
+
 // src/project/plan.ts
 var AGENT_FIELDS = {
   claude: ["name", "description", "tools", "model", "effort"],
@@ -2648,25 +2721,26 @@ var AGENT_FIELDS = {
 };
 var SETTINGS = ".claude/settings.json";
 function listDirs(dir) {
-  if (!existsSync9(dir)) return [];
+  if (!existsSync10(dir)) return [];
   return readdirSync4(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
 }
 var tomlString = (value) => JSON.stringify(typeof value === "string" ? value : String(value ?? ""));
 function skillNames(root) {
-  const dir = join7(root, ".agents/skills");
+  const dir = join8(root, ".agents/skills");
   return listDirs(dir).filter(
-    (name) => existsSync9(join7(dir, name, "SKILL.md"))
+    (name) => existsSync10(join8(dir, name, "SKILL.md"))
   );
 }
 function agentNames(root) {
-  const dir = join7(root, ".agents/agents");
+  const dir = join8(root, ".agents/agents");
   return listDirs(dir).filter(
-    (name) => existsSync9(join7(dir, name, "agent.md"))
+    (name) => existsSync10(join8(dir, name, "agent.md"))
   );
 }
 function skillOutputs(spec) {
-  const outputs = [];
-  for (const name of skillNames(spec.root)) {
+  const names = skillNames(spec.root);
+  const outputs = opencodeSkillOutputs(spec, names);
+  for (const name of names) {
     const target = `../../.agents/skills/${name}`;
     if (spec.tools.has("claude")) {
       outputs.push({ kind: "link", path: `.claude/skills/${name}`, target });
@@ -2695,13 +2769,13 @@ policy:
 }
 function ruleOutputs(spec) {
   if (!spec.tools.has("claude")) return [];
-  const dir = join7(spec.root, ".agents/rules");
-  if (!existsSync9(dir)) return [];
+  const dir = join8(spec.root, ".agents/rules");
+  if (!existsSync10(dir)) return [];
   const outputs = [];
   for (const file of readdirSync4(dir).filter((f) => f.endsWith(".md")).sort()) {
     const rel = `.agents/rules/${file}`;
     const { meta, body } = splitFrontmatter(
-      readFileSync7(join7(spec.root, rel), "utf8")
+      readFileSync7(join8(spec.root, rel), "utf8")
     );
     const globs = [meta["globs"] ?? []].flat().filter((g) => typeof g === "string" && g !== "");
     const head = globs.length > 0 ? renderFrontmatter({ paths: globs }) : "";
@@ -2720,7 +2794,7 @@ function agentOutputs(spec) {
   for (const name of agentNames(spec.root)) {
     const rel = `.agents/agents/${name}/agent.md`;
     const { meta, body } = splitFrontmatter(
-      readFileSync7(join7(spec.root, rel), "utf8")
+      readFileSync7(join8(spec.root, rel), "utf8")
     );
     const overrides = spec.agents[name] ?? {};
     const note = `<!-- ${MARK} from ${rel} -->
@@ -2792,7 +2866,7 @@ function censusDirs(spec) {
 // src/project/apply.ts
 import { createHash as createHash6 } from "crypto";
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   lstatSync as lstatSync4,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync9,
@@ -2800,13 +2874,13 @@ import {
   readlinkSync as readlinkSync2,
   rmSync as rmSync2
 } from "fs";
-import { dirname as dirname8, join as join9, posix as posix2 } from "path";
+import { dirname as dirname8, join as join10, posix as posix2 } from "path";
 import { parse as parse4 } from "smol-toml";
 
 // src/project/backup.ts
 import { createHash as createHash5 } from "crypto";
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   lstatSync as lstatSync2,
   mkdirSync,
   mkdtempSync,
@@ -2814,9 +2888,9 @@ import {
   writeFileSync
 } from "fs";
 import { homedir } from "os";
-import { dirname as dirname6, isAbsolute as isAbsolute5, join as join8, relative as relative5, resolve as resolve6 } from "path";
+import { dirname as dirname6, isAbsolute as isAbsolute5, join as join9, relative as relative5, resolve as resolve6 } from "path";
 function backupFiles(root, paths) {
-  const base = join8(homedir(), ".cache/pmcp/project-backups");
+  const base = join9(homedir(), ".cache/pmcp/project-backups");
   const inside = relative5(resolve6(root), resolve6(base));
   if (!isAbsolute5(inside) && inside !== ".." && !inside.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`)) {
     throw new ProjectError("Project backups must be outside the project");
@@ -2837,7 +2911,7 @@ function backupFiles(root, paths) {
     if (isAbsolute5(within) || within === ".." || within.startsWith("../") || within.startsWith("..\\")) {
       throw new ProjectError("Backup paths must stay inside the project");
     }
-    if (!existsSync10(absolute)) {
+    if (!existsSync11(absolute)) {
       return { path, contents: null };
     }
     const stat = lstatSync2(absolute);
@@ -2848,12 +2922,12 @@ function backupFiles(root, paths) {
     }
     return { path, contents: readFileSync8(absolute) };
   });
-  const destination = mkdtempSync(join8(base, "project-"));
+  const destination = mkdtempSync(join9(base, "project-"));
   const entries = snapshots.map(({ path, contents }) => {
     if (contents === null) {
       return { path, present: false };
     }
-    const output = join8(destination, "files", path);
+    const output = join9(destination, "files", path);
     mkdirSync(dirname6(output), { recursive: true, mode: 448 });
     writeFileSync(output, contents, { mode: 384 });
     return {
@@ -2863,7 +2937,7 @@ function backupFiles(root, paths) {
     };
   });
   writeFileSync(
-    join8(destination, "receipt.json"),
+    join9(destination, "receipt.json"),
     JSON.stringify(
       {
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2949,8 +3023,8 @@ var PREDECESSORS = [
 ];
 var sha = (text) => createHash6("sha256").update(text).digest("hex");
 function readLock(root) {
-  const path = join9(root, LOCK_FILE);
-  if (!existsSync11(path)) return [];
+  const path = join10(root, LOCK_FILE);
+  if (!existsSync12(path)) return [];
   const lock = JSON.parse(readFileSync9(path, "utf8"));
   return lock.outputs ?? [];
 }
@@ -2961,9 +3035,9 @@ function linkOf(abs) {
     return null;
   }
 }
-var exists = (abs) => existsSync11(abs) || linkOf(abs) !== null;
+var exists = (abs) => existsSync12(abs) || linkOf(abs) !== null;
 function readJson2(abs) {
-  if (!existsSync11(abs)) return {};
+  if (!existsSync12(abs)) return {};
   let value;
   try {
     value = JSON.parse(readFileSync9(abs, "utf8"));
@@ -3018,32 +3092,44 @@ function withoutBlock(text) {
   return `${text.slice(0, start).replace(/\n+$/u, "\n")}${after}`;
 }
 function present(root, output) {
-  const abs = join9(root, "file" in output ? output.file : output.path);
+  const abs = join10(root, "file" in output ? output.file : output.path);
   switch (output.kind) {
     case "link":
       return linkOf(abs) === output.target;
     case "file":
-      return existsSync11(abs) && linkOf(abs) === null && readFileSync9(abs, "utf8") === output.content;
+      return existsSync12(abs) && linkOf(abs) === null && readFileSync9(abs, "utf8") === output.content;
     case "json":
       if (output.managed && Array.isArray(output.value) && output.value.length === 0) {
         return getKey(readJson2(abs), output.key) === void 0;
       }
       return same(getKey(readJson2(abs), output.key), output.value);
     case "block":
-      return existsSync11(abs) && readFileSync9(abs, "utf8").includes(block(output.content));
+      return existsSync12(abs) && readFileSync9(abs, "utf8").includes(block(output.content));
   }
 }
 function replaceable(root, output, owned) {
   if (output.kind === "json") {
-    if (output.key[0] !== "mcpServers" || owned.has(output.path)) {
+    if (output.file === "opencode.json") {
+      let parent = readJson2(join10(root, output.file));
+      for (const part of output.key.slice(0, -1)) {
+        if (parent === void 0) break;
+        if (parent === null || typeof parent !== "object" || Array.isArray(parent))
+          return false;
+        parent = parent[part];
+      }
+      if (parent !== void 0 && (parent === null || typeof parent !== "object" || Array.isArray(parent)))
+        return false;
+    }
+    const guarded = output.key[0] === "mcpServers" || output.file === "opencode.json";
+    if (!guarded || owned.has(output.path)) {
       return true;
     }
-    const existing = getKey(readJson2(join9(root, output.file)), output.key);
+    const existing = getKey(readJson2(join10(root, output.file)), output.key);
     return existing === void 0 || same(existing, output.value);
   }
   if (output.kind === "block") {
-    const absolute = join9(root, output.file);
-    const text2 = existsSync11(absolute) ? readFileSync9(absolute, "utf8") : "";
+    const absolute = join10(root, output.file);
+    const text2 = existsSync12(absolute) ? readFileSync9(absolute, "utf8") : "";
     const outside = parse4(withoutBlock(text2));
     const proposed = parse4(output.content);
     const existing = objectKeys(outside["mcp_servers"]);
@@ -3052,7 +3138,7 @@ function replaceable(root, output, owned) {
     );
   }
   if (owned.has(output.path)) return true;
-  const abs = join9(root, output.path);
+  const abs = join10(root, output.path);
   if (!exists(abs)) return true;
   const target = linkOf(abs);
   if (target !== null) {
@@ -3073,15 +3159,15 @@ function undeclared(spec, outputs) {
   const declared = new Set(outputs.map((o) => o.path));
   const found = [];
   for (const dir of censusDirs(spec)) {
-    const abs = join9(spec.root, dir);
-    if (!existsSync11(abs)) continue;
+    const abs = join10(spec.root, dir);
+    if (!existsSync12(abs)) continue;
     for (const entry of readdirSync5(abs)) {
       const path = `${dir}/${entry}`;
       if (!declared.has(path)) found.push(path);
     }
   }
-  const rules = join9(spec.root, RULES_DIR);
-  if (spec.tools.has("grok") && existsSync11(rules)) {
+  const rules = join10(spec.root, RULES_DIR);
+  if (spec.tools.has("grok") && existsSync12(rules)) {
     for (const entry of readdirSync5(rules, { withFileTypes: true })) {
       if (entry.isDirectory()) continue;
       found.push(`${RULES_DIR}/${entry.name}`);
@@ -3108,8 +3194,8 @@ function deadGlobs(root, outputs) {
     if (rule.kind === "file") {
       text = rule.content;
     } else if (rule.kind === "link") {
-      const abs = join9(root, posix2.join(posix2.dirname(rule.path), rule.target));
-      if (!existsSync11(abs)) continue;
+      const abs = join10(root, posix2.join(posix2.dirname(rule.path), rule.target));
+      if (!existsSync12(abs)) continue;
       text = readFileSync9(abs, "utf8");
     } else {
       continue;
@@ -3160,7 +3246,7 @@ function project(spec, options) {
     }
   }
   for (const path of jsonPaths) {
-    readJson2(join9(spec.root, path));
+    readJson2(join10(spec.root, path));
   }
   if (options.check) {
     const problems = [
@@ -3181,6 +3267,7 @@ function project(spec, options) {
     return { code: 3, problems: refused, outputs: outputs.length, pruned: 0 };
   }
   const mcpPaths = [
+    "opencode.json",
     ".mcp.json",
     ".gemini/settings.json",
     ".agents/mcp_config.json",
@@ -3222,7 +3309,7 @@ function project(spec, options) {
   for (const output of outputs) {
     if (output.kind !== "link" && output.kind !== "file") continue;
     if (present(spec.root, output)) continue;
-    const abs = join9(spec.root, output.path);
+    const abs = join10(spec.root, output.path);
     mkdirSync2(dirname8(abs), { recursive: true });
     if (output.kind === "link") {
       replaceLink(abs, output.target);
@@ -3250,12 +3337,12 @@ function project(spec, options) {
       group.drops.push(keyed.key);
       jsonFiles.set(keyed.file, group);
     } else {
-      rmSync2(join9(spec.root, entry.path), { force: true, recursive: true });
+      rmSync2(join10(spec.root, entry.path), { force: true, recursive: true });
     }
     pruned += 1;
   }
   for (const [file, { sets, drops }] of jsonFiles) {
-    const abs = join9(spec.root, file);
+    const abs = join10(spec.root, file);
     const before = readJson2(abs);
     const after = structuredClone(before);
     for (const key of drops) deleteKey(after, key);
@@ -3270,14 +3357,14 @@ function project(spec, options) {
       }
     }
     if (same(before, after)) continue;
-    if (!existsSync11(abs) && Object.keys(after).length === 0) continue;
+    if (!existsSync12(abs) && Object.keys(after).length === 0) continue;
     mkdirSync2(dirname8(abs), { recursive: true });
     replaceFile(abs, `${JSON.stringify(after, null, 2)}
 `);
   }
   for (const [file, content] of blockFiles) {
-    const abs = join9(spec.root, file);
-    const before = existsSync11(abs) ? readFileSync9(abs, "utf8") : "";
+    const abs = join10(spec.root, file);
+    const before = existsSync12(abs) ? readFileSync9(abs, "utf8") : "";
     let after = withoutBlock(before);
     if (content !== null) {
       const sep5 = after === "" || after.endsWith("\n\n") ? "" : after.endsWith("\n") ? "\n" : "\n\n";
@@ -3296,15 +3383,15 @@ function project(spec, options) {
       )
     );
     for (const [name, target] of legacyLinks(spec.root)) {
-      const abs = join9(spec.root, RULES_DIR, `${name}.md`);
-      const broken = !existsSync11(abs);
+      const abs = join10(spec.root, RULES_DIR, `${name}.md`);
+      const broken = !existsSync12(abs);
       if (!broken && !linkedDirs.has(posix2.dirname(target))) continue;
       rmSync2(abs, { force: true });
       pruned += 1;
     }
   }
   replaceFile(
-    join9(spec.root, LOCK_FILE),
+    join10(spec.root, LOCK_FILE),
     `${JSON.stringify({ version: 1, outputs: outputs.filter((output) => output.kind !== "json" || output.managed === void 0 || output.managed.length > 0).map(lockEntry) }, null, 2)}
 `
   );
@@ -3318,10 +3405,83 @@ function project(spec, options) {
 }
 
 // src/project/doctor.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
-import { join as join10 } from "path";
+import { spawnSync as spawnSync3 } from "child_process";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
+import { join as join13 } from "path";
 import { parse as parse5 } from "smol-toml";
+
+// src/project/adapters/opencode-doctor.ts
+import { realpathSync as realpathSync3 } from "fs";
+import { join as join11 } from "path";
+function connected(out, alias) {
+  const ansi = new RegExp(
+    `${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`,
+    "gu"
+  );
+  const pattern = new RegExp(
+    `^[^a-zA-Z0-9]*${alias}\\s+connected(?:\\s|$)`,
+    "u"
+  );
+  return out.replace(ansi, "").split("\n").some((line) => pattern.test(line.trim()));
+}
+function projectSkill(out, root, name) {
+  try {
+    const entries = JSON.parse(out);
+    if (!Array.isArray(entries)) return false;
+    const expected = realpathSync3(
+      join11(root, ".agents/skills", name, "SKILL.md")
+    );
+    return entries.some(
+      (entry) => entry?.name === name && typeof entry.location === "string" && realpathSync3(entry.location) === expected
+    );
+  } catch {
+    return false;
+  }
+}
+function opencodeDoctor(spec, options, listed2) {
+  const findings = [];
+  const names = skillNames(spec.root);
+  if (names.length > 0) {
+    findings.push(
+      listed2(
+        "opencode",
+        "project skills discovered",
+        options.run("opencode", ["debug", "skill"], spec.root, options.env),
+        names,
+        (out, name) => projectSkill(out, spec.root, name)
+      )
+    );
+  }
+  const aliases = serversForTool(spec, "opencode").map(([alias]) => alias);
+  if (aliases.length > 0) {
+    findings.push(
+      listed2(
+        "opencode",
+        "mcp servers connected",
+        options.run("opencode", ["mcp", "list"], spec.root, options.env),
+        aliases,
+        connected
+      )
+    );
+  }
+  return findings;
+}
+
+// src/project/diagnostics/native-json.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import {
+  closeSync as closeSync2,
+  mkdtempSync as mkdtempSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync10,
+  rmSync as rmSync3,
+  statSync as statSync3
+} from "fs";
+import { tmpdir } from "os";
+import { join as join12 } from "path";
+var MAX_OUTPUT = 1 << 26;
+
+// src/project/doctor.ts
 var missingFrom = (names, present2) => names.filter((name) => !present2(name));
 function verdict(tool, check, missing) {
   if (missing.length === 0) return { tool, check, status: "ok" };
@@ -3382,10 +3542,10 @@ function claude(spec, o) {
 }
 function codex(spec, o) {
   const findings = [];
-  const config = join10(o.home, ".codex/config.toml");
+  const config = join13(o.home, ".codex/config.toml");
   let trusted = false;
-  if (existsSync12(config)) {
-    const projects = parse5(readFileSync10(config, "utf8")).projects ?? {};
+  if (existsSync13(config)) {
+    const projects = parse5(readFileSync11(config, "utf8")).projects ?? {};
     const root = spec.root.replace(/\/$/u, "");
     trusted = projects[root]?.trust_level === "trusted" || projects[`${root}/`]?.trust_level === "trusted";
   }
@@ -3511,8 +3671,8 @@ function grok(spec, o) {
 }
 function antigravity(spec, options) {
   const foreign = agentNames(spec.root).filter((name) => {
-    const text = readFileSync10(
-      join10(spec.root, ".agents/agents", name, "agent.md"),
+    const text = readFileSync11(
+      join13(spec.root, ".agents/agents", name, "agent.md"),
       "utf8"
     );
     return splitFrontmatter(text).meta["tools"] !== void 0;
@@ -3532,7 +3692,7 @@ function antigravity(spec, options) {
   if (serversForTool(spec, "antigravity").length > 0) {
     const result = options.run(
       "agy",
-      ["plugin", "validate", join10(spec.root, ANTIGRAVITY_MCP_PLUGIN)],
+      ["plugin", "validate", join13(spec.root, ANTIGRAVITY_MCP_PLUGIN)],
       spec.root
     );
     findings.push(
@@ -3556,6 +3716,8 @@ function doctor(spec, options) {
   if (wanted("codex")) findings.push(...codex(spec, options));
   if (wanted("gemini")) findings.push(...gemini(spec, options));
   if (wanted("grok")) findings.push(...grok(spec, options));
+  if (wanted("opencode"))
+    findings.push(...opencodeDoctor(spec, options, listed));
   if (wanted("antigravity")) {
     findings.push(...antigravity(spec, options));
   }
@@ -3563,11 +3725,11 @@ function doctor(spec, options) {
 }
 
 // src/server.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 
 // src/files/bundle.ts
-import { readFileSync as readFileSync12, statSync as statSync4 } from "fs";
-import { dirname as dirname9, join as join12 } from "path";
+import { readFileSync as readFileSync13, statSync as statSync5 } from "fs";
+import { dirname as dirname9, join as join15 } from "path";
 
 // src/mime.ts
 var TYPES = {
@@ -3674,8 +3836,8 @@ function classify(path, bytes) {
 
 // src/files/list.ts
 import { createHash as createHash7 } from "crypto";
-import { readFileSync as readFileSync11, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
-import { basename as basename4, join as join11, relative as relative6, sep as sep2 } from "path";
+import { readFileSync as readFileSync12, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
+import { basename as basename4, join as join14, relative as relative6, sep as sep2 } from "path";
 
 // src/files/redact.ts
 import { basename as basename3 } from "path";
@@ -3712,11 +3874,11 @@ function servedBytes(path, raw) {
 var FILE_LIST_LIMIT = 200;
 var sha256 = (bytes) => createHash7("sha256").update(bytes).digest("hex");
 function describe(path, full) {
-  const bytes = servedBytes(full, readFileSync11(full));
+  const bytes = servedBytes(full, readFileSync12(full));
   return { path, bytes: bytes.length, sha256: sha256(bytes) };
 }
 function listSkillFiles(root, limit = FILE_LIST_LIMIT) {
-  if (statSync3(root).isFile()) {
+  if (statSync4(root).isFile()) {
     return { files: [describe(basename4(root), root)], truncated: false };
   }
   const files = [];
@@ -3725,7 +3887,7 @@ function listSkillFiles(root, limit = FILE_LIST_LIMIT) {
     const dir = stack.pop();
     for (const entry of readdirSync6(dir, { withFileTypes: true })) {
       if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const full = join11(dir, entry.name);
+      const full = join14(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(full);
         continue;
@@ -3759,7 +3921,7 @@ function resolveSkillFileUri(uri, entries) {
 // src/files/bundle.ts
 function bundleSkill(entry) {
   const root = assetRoot(entry);
-  const base = statSync4(root).isFile() ? dirname9(root) : root;
+  const base = statSync5(root).isFile() ? dirname9(root) : root;
   const listing2 = listSkillFiles(root);
   return {
     name: entry.name,
@@ -3767,28 +3929,28 @@ function bundleSkill(entry) {
     files: listing2.files.map((file) => ({
       ...file,
       uri: skillFileUri(entry, file.path),
-      mimeType: classify(file.path, readFileSync12(join12(base, file.path))).mimeType
+      mimeType: classify(file.path, readFileSync13(join15(base, file.path))).mimeType
     }))
   };
 }
 
 // src/files/read.ts
-import { readFileSync as readFileSync13, statSync as statSync6 } from "fs";
+import { readFileSync as readFileSync14, statSync as statSync7 } from "fs";
 
 // src/files/resolve.ts
-import { realpathSync as realpathSync3, statSync as statSync5 } from "fs";
+import { realpathSync as realpathSync4, statSync as statSync6 } from "fs";
 import { dirname as dirname10, isAbsolute as isAbsolute6, relative as relative7, resolve as resolve7, sep as sep3 } from "path";
 var ownFile = (entry) => relative7(assetRoot(entry), entry.path).split(sep3).join("/");
 function resolveSkillFile(entry, wanted = ownFile(entry)) {
   if (isAbsolute6(wanted) || wanted.split(/[\\/]/u).includes("..")) {
     return { ok: false, error: "path_outside_skill", detail: wanted };
   }
-  const scope = realpathSync3(assetRoot(entry));
-  const single = statSync5(scope).isFile();
+  const scope = realpathSync4(assetRoot(entry));
+  const single = statSync6(scope).isFile();
   const root = single ? dirname10(scope) : scope;
   let target;
   try {
-    target = realpathSync3(
+    target = realpathSync4(
       single && wanted === "" ? scope : resolve7(root, wanted)
     );
   } catch {
@@ -3809,7 +3971,7 @@ var READ_BUDGET_BYTES = 256 * 1024;
 function readSkillFile(entry, wanted, budget = READ_BUDGET_BYTES) {
   const resolved = resolveSkillFile(entry, wanted);
   if (!resolved.ok) return resolved;
-  const size = statSync6(resolved.target).size;
+  const size = statSync7(resolved.target).size;
   if (size > budget) {
     return {
       ok: false,
@@ -3817,7 +3979,7 @@ function readSkillFile(entry, wanted, budget = READ_BUDGET_BYTES) {
       detail: `${size} bytes > ${budget}`
     };
   }
-  const bytes = servedBytes(resolved.target, readFileSync13(resolved.target));
+  const bytes = servedBytes(resolved.target, readFileSync14(resolved.target));
   const { kind: kind2, mimeType } = classify(resolved.path, bytes);
   return {
     ok: true,
@@ -3993,7 +4155,7 @@ function createSkillTools(options) {
     describe(name) {
       const entry = byName(name);
       if (!entry) return null;
-      const source = readFileSync14(entry.path, "utf8");
+      const source = readFileSync15(entry.path, "utf8");
       const listing2 = listSkillFiles(assetRoot(entry));
       return {
         name: entry.name,
@@ -4030,7 +4192,7 @@ function createSkillTools(options) {
       return {
         name: entry.name,
         body: readBody(
-          servedBytes(entry.path, readFileSync14(entry.path)).toString("utf8")
+          servedBytes(entry.path, readFileSync15(entry.path)).toString("utf8")
         ),
         files: bundle.files.filter((file) => file.path !== own),
         filesTruncated: bundle.truncated
@@ -4099,7 +4261,7 @@ function registerSkillPrompts(server, tools) {
 }
 
 // src/resources.ts
-import { statSync as statSync7 } from "fs";
+import { statSync as statSync8 } from "fs";
 import {
   ResourceNotFoundError,
   ResourceTemplate
@@ -4112,7 +4274,7 @@ function listing(entries) {
     name: entry.name,
     description: entry.description,
     mimeType: "text/markdown",
-    size: statSync7(entry.path).size
+    size: statSync8(entry.path).size
   }));
 }
 function complete(value, entries) {
@@ -4150,17 +4312,17 @@ function registerSkillResources(server, skills) {
 
 // src/extension/entry.ts
 import { createHash as createHash8 } from "crypto";
-import { readFileSync as readFileSync15, readdirSync as readdirSync7, statSync as statSync8 } from "fs";
-import { basename as basename5, dirname as dirname11, join as join13, relative as relative8, sep as sep4 } from "path";
+import { readFileSync as readFileSync16, readdirSync as readdirSync7, statSync as statSync9 } from "fs";
+import { basename as basename5, dirname as dirname11, join as join16, relative as relative8, sep as sep4 } from "path";
 var MAX_RESOURCES = 512;
 var MAX_SKILL_BYTES = 16 * 1024 * 1024;
 var digests = /* @__PURE__ */ new Map();
 function facts(path) {
-  const stat = statSync8(path);
+  const stat = statSync9(path);
   const key = `${stat.mtimeMs}:${stat.size}`;
   const cached = digests.get(path);
   if (cached?.key === key) return cached;
-  const bytes = servedBytes(path, readFileSync15(path));
+  const bytes = servedBytes(path, readFileSync16(path));
   const digest = `sha256:${createHash8("sha256").update(bytes).digest("hex")}`;
   const fresh = { key, digest, size: bytes.length };
   digests.set(path, fresh);
@@ -4173,7 +4335,7 @@ function filesUnder(root) {
     const dir = stack.pop();
     for (const entry of readdirSync7(dir, { withFileTypes: true })) {
       if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const full = join13(dir, entry.name);
+      const full = join16(dir, entry.name);
       if (entry.isDirectory()) stack.push(full);
       else if (entry.isFile()) found.push(full);
       if (found.length > MAX_RESOURCES) return null;
@@ -4184,7 +4346,7 @@ function filesUnder(root) {
 function extensionEntry(entry) {
   if (kindOf(entry) !== "skill" || basename5(entry.path) !== "SKILL.md")
     return null;
-  const frontmatter = frontmatterObject(readFileSync15(entry.path, "utf8"));
+  const frontmatter = frontmatterObject(readFileSync16(entry.path, "utf8"));
   const root = dirname11(entry.path);
   if (specProblems(frontmatter, basename5(root)).length > 0) return null;
   if (frontmatter?.["name"] !== entry.slug) return null;
@@ -4679,7 +4841,7 @@ function registerMailboxTools(server, service) {
 
 // src/mcp.ts
 var SERVER_NAME = "pmcp";
-var SERVER_VERSION = "0.16.1";
+var SERVER_VERSION = "0.17.1";
 function registerSkillTools(server, tools) {
   registerCatalogTool(server, tools);
   registerFindTool(server, tools);
@@ -4700,16 +4862,16 @@ function createSkillServer(options) {
 }
 
 // src/validate.ts
-import { existsSync as existsSync13, readFileSync as readFileSync16, statSync as statSync9 } from "fs";
-import { basename as basename6, join as join14, resolve as resolve8 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync17, statSync as statSync10 } from "fs";
+import { basename as basename6, join as join17, resolve as resolve8 } from "path";
 function validateSkillDir(dir) {
   const root = resolve8(dir);
-  const skillMd = basename6(root) === "SKILL.md" ? root : join14(root, "SKILL.md");
-  if (!existsSync13(skillMd) || !statSync9(skillMd).isFile()) {
+  const skillMd = basename6(root) === "SKILL.md" ? root : join17(root, "SKILL.md");
+  if (!existsSync14(skillMd) || !statSync10(skillMd).isFile()) {
     return [{ path: root, reason: "no SKILL.md", level: "error" }];
   }
-  const front = frontmatterObject(readFileSync16(skillMd, "utf8"));
-  const directory = basename6(skillMd === root ? join14(root, "..") : root);
+  const front = frontmatterObject(readFileSync17(skillMd, "utf8"));
+  const directory = basename6(skillMd === root ? join17(root, "..") : root);
   return specProblems(front, directory).map((reason) => ({
     path: skillMd,
     reason,