@stablekernel/opencode-cursor 0.7.1 → 0.9.0-next.0

package/dist/plugin/index.js

@@ -4,6 +4,7 @@ import {
   clearLogBridge,
   clearSubagentBridge,
   fingerprintApiKey,
+  linkDelegateSession,
   loadCursorSdk,
   pluginLog,
   removeSystemRule,
@@ -11,11 +12,14 @@ import {
   resolveCursorApiKey,
   setLogBridge,
   setSubagentBridge,
-  streamAgentTurn
-} from "../chunk-RDY3H2LE.js";
+  stampTaskPartSessionId,
+  streamAgentTurn,
+  subagentCallChildId
+} from "../chunk-YIEC27VB.js";
 
 // src/plugin/index.ts
-import { rmSync as rmSync3 } from "fs";
+import { rmSync as rmSync4 } from "fs";
+import { homedir as homedir5 } from "os";
 import semver2 from "semver";
 
 // src/model-limits.ts
@@ -585,6 +589,7 @@ async function runDelegate(params) {
           break;
         case "reasoning-complete":
         case "compaction":
+        case "subagent-event":
           break;
         case "finish":
           if (event.text && text.length === 0) text.push(event.text);
@@ -726,6 +731,21 @@ function buildCursorTools(deps) {
         const toolNote = result.toolActivity.length > 0 ? `
 
 (${result.toolActivity.length} tool call(s)${result.toolActivity.some((t) => t.isError) ? ", some failed" : ""})` : "";
+        if (context.sessionID) {
+          const transcript = [
+            result.text || "(no text output)",
+            ...result.reasoning ? [`
+> ${result.reasoning}`] : [],
+            ...result.toolActivity.length > 0 ? [`
+(${result.toolActivity.length} tool call(s))`] : []
+          ].join("\n");
+          await linkDelegateSession({
+            parentSessionID: context.sessionID,
+            title: `Cursor delegate (${args.model})`,
+            prompt: args.prompt,
+            transcript
+          });
+        }
         return {
           title: `Cursor delegate (${args.model})`,
           output: (result.text || "(no text output)") + toolNote,
@@ -794,7 +814,7 @@ function clearVersionCache() {
   }
 }
 function getLocalVersion() {
-  if (true) return "0.7.1";
+  if (true) return "0.9.0-next.0";
   try {
     const require2 = createRequire(import.meta.url);
     const pkg = require2("../package.json");
@@ -850,11 +870,11 @@ async function getLatestVersion() {
 
 // src/provider/skill-mirror.ts
 import {
-  mkdirSync as mkdirSync3,
-  writeFileSync as writeFileSync3,
+  mkdirSync as mkdirSync4,
+  writeFileSync as writeFileSync4,
   readFileSync as readFileSync4,
   existsSync as existsSync2,
-  rmSync as rmSync2,
+  rmSync as rmSync3,
   readdirSync as readdirSync2,
   statSync as statSync2,
   copyFileSync,
@@ -868,10 +888,20 @@ import {
   readFileSync as readFileSync3,
   statSync,
   existsSync,
-  realpathSync
+  realpathSync,
+  mkdtempSync,
+  mkdirSync as mkdirSync3,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync3
 } from "fs";
-import { join as join3, relative, dirname, resolve as resolvePath, isAbsolute } from "path";
-import { homedir as homedir3 } from "os";
+import {
+  join as join3,
+  relative,
+  dirname,
+  resolve as resolvePath,
+  isAbsolute
+} from "path";
+import { homedir as homedir3, tmpdir as tmpdir3 } from "os";
 import { execSync } from "child_process";
 function parseFrontmatter(content) {
   if (!content.startsWith("---")) return {};
@@ -896,6 +926,112 @@ function parseFrontmatter(content) {
 }
 var SKILL_DIR_NAMES = ["skill", "skills"];
 var EXTERNAL_DIR_NAMES = [".claude", ".agents"];
+var FILE_PLUGIN_DIR_NAMES = ["plugin", "plugins"];
+var PLUGIN_SKILL_DIR_NAMES = ["skills", "skill"];
+function opencodePackagesRoot(home = homedir3()) {
+  if (process.platform === "win32") {
+    return join3(
+      process.env.LocalAppData ?? join3(home, "AppData", "Local"),
+      "opencode",
+      "cache",
+      "packages"
+    );
+  }
+  return join3(
+    process.env.XDG_CACHE_HOME ?? join3(home, ".cache"),
+    "opencode",
+    "packages"
+  );
+}
+function pluginCacheSkillDirs(entry) {
+  const dirs = [];
+  const visited = /* @__PURE__ */ new Set();
+  function scanNodeModules(nodeModules) {
+    let entries;
+    try {
+      entries = readdirSync(nodeModules, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      if (ent.name === ".bin") continue;
+      const fullPath = join3(nodeModules, ent.name);
+      if (entryKind(ent, fullPath) !== "dir") continue;
+      if (ent.name.startsWith("@")) {
+        scanNodeModules(fullPath);
+        continue;
+      }
+      for (const skillName of SKILL_DIR_NAMES) {
+        const candidate = join3(fullPath, skillName);
+        if (existsSync(candidate)) dirs.push(candidate);
+      }
+    }
+  }
+  function findNodeModules(dir, depth) {
+    if (depth > 5) return;
+    let realDir;
+    try {
+      realDir = realpathSync(dir);
+    } catch {
+      return;
+    }
+    if (visited.has(realDir)) return;
+    visited.add(realDir);
+    const nm = join3(dir, "node_modules");
+    if (existsSync(nm)) {
+      scanNodeModules(nm);
+      return;
+    }
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const fullPath = join3(dir, ent.name);
+      if (entryKind(ent, fullPath) === "dir") {
+        findNodeModules(fullPath, depth + 1);
+      }
+    }
+  }
+  findNodeModules(entry, 0);
+  return dirs;
+}
+function pluginCacheEntries(root) {
+  let entries;
+  try {
+    entries = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const skip = /* @__PURE__ */ new Set([
+    "node_modules",
+    "package.json",
+    "package-lock.json",
+    "bun.lock",
+    "bun.lockb"
+  ]);
+  const out = [];
+  for (const ent of entries) {
+    if (skip.has(ent.name)) continue;
+    const full = join3(root, ent.name);
+    if (entryKind(ent, full) !== "dir") continue;
+    out.push(full);
+  }
+  return out;
+}
+function discoverPluginSkillDirs(cacheRoot, home) {
+  const root = cacheRoot ?? opencodePackagesRoot(home);
+  if (!existsSync(root)) return [];
+  const dirs = [];
+  for (const entry of pluginCacheEntries(root)) {
+    for (const skillDir of pluginCacheSkillDirs(entry)) {
+      dirs.push(skillDir);
+    }
+  }
+  return dirs;
+}
 function worktreeRoot(cwd) {
   try {
     const root = execSync("git rev-parse --show-toplevel", {
@@ -1006,7 +1142,39 @@ function expandSkillPath(raw, cwd, home) {
   if (isAbsolute(trimmed)) return trimmed;
   return resolvePath(cwd, trimmed);
 }
-function discoverSkills(cwd, extraPaths) {
+function discoverFilePluginSkillDirs(roots) {
+  const dirs = [];
+  for (const root of roots) {
+    for (const sub of FILE_PLUGIN_DIR_NAMES) {
+      const pluginDir = join3(root, sub);
+      if (!existsSync(pluginDir)) continue;
+      for (const skillName of PLUGIN_SKILL_DIR_NAMES) {
+        const skillDir = join3(pluginDir, skillName);
+        if (existsSync(skillDir)) dirs.push(skillDir);
+      }
+    }
+  }
+  return dirs;
+}
+function resolvePluginSkillSources(cwd) {
+  const home = homedir3();
+  const cacheRoot = opencodePackagesRoot(home);
+  let filePluginRoots = [];
+  try {
+    const candidates = [];
+    const start = cwd ?? process.cwd();
+    const stop = worktreeRoot(start);
+    for (const ancestor of walkUp(start, stop)) {
+      candidates.push(join3(ancestor, ".opencode"));
+    }
+    const xdgConfig = process.env["XDG_CONFIG_HOME"] || join3(home, ".config");
+    candidates.push(join3(xdgConfig, "opencode"), home);
+    filePluginRoots = discoverFilePluginSkillDirs(candidates).map((dir) => dirname(dirname(dir))).filter((v, i, arr) => arr.indexOf(v) === i);
+  } catch {
+  }
+  return { cacheRoot, filePluginRoots };
+}
+function discoverSkills(cwd, extraPaths, options) {
   const home = homedir3();
   const xdgConfig = process.env["XDG_CONFIG_HOME"] || join3(home, ".config");
   const stop = worktreeRoot(cwd);
@@ -1041,6 +1209,29 @@ function discoverSkills(cwd, extraPaths) {
       scanRoots.push(expanded);
     }
   }
+  for (const dir of discoverPluginSkillDirs(options?.cacheRoot, home)) {
+    scanRoots.push(dir);
+  }
+  const filePluginRoots = options?.filePluginRoots;
+  if (filePluginRoots) {
+    for (const dir of discoverFilePluginSkillDirs(filePluginRoots)) {
+      scanRoots.push(dir);
+    }
+  } else {
+    for (const ancestor of walkUp(cwd, stop)) {
+      for (const dir of discoverFilePluginSkillDirs([
+        join3(ancestor, ".opencode")
+      ])) {
+        scanRoots.push(dir);
+      }
+    }
+    for (const dir of discoverFilePluginSkillDirs([
+      join3(xdgConfig, "opencode"),
+      home
+    ])) {
+      scanRoots.push(dir);
+    }
+  }
   const byId = /* @__PURE__ */ new Map();
   for (const dir of scanRoots) {
     const found = scanSkillDir(dir);
@@ -1131,15 +1322,82 @@ function filterSkills(skills, config, options) {
   }
   return { skills: permitted, withheld };
 }
-function resolveSkills(cwd, config, options) {
+var liveScratchRoot;
+var liveScratchCleanupRegistered = false;
+function liveScratchDir() {
+  if (!liveScratchRoot) {
+    liveScratchRoot = mkdtempSync(join3(tmpdir3(), "opencode-cursor-skills-"));
+    if (!liveScratchCleanupRegistered) {
+      liveScratchCleanupRegistered = true;
+      const rootAtExit = liveScratchRoot;
+      process.once("exit", () => {
+        rmSync2(rootAtExit, { recursive: true, force: true });
+      });
+    }
+  }
+  return liveScratchRoot;
+}
+function liveSkillsToDiscovered(live) {
+  const out = [];
+  for (const skill of live) {
+    if (!skill.location || !skill.name) continue;
+    const sourceDir = skill.location.endsWith("SKILL.md") ? dirname(skill.location) : skill.location;
+    if (existsSync(join3(sourceDir, "SKILL.md"))) {
+      const loaded2 = loadSkill(skill.name, sourceDir);
+      if (loaded2) out.push(loaded2);
+      continue;
+    }
+    if (!skill.content) continue;
+    const scratchDir = join3(liveScratchDir(), skill.name);
+    const scratchMd = join3(scratchDir, "SKILL.md");
+    let needsWrite = true;
+    if (existsSync(scratchMd)) {
+      try {
+        const existing = readFileSync3(scratchMd, "utf8");
+        if (existing === renderLiveSkillMd(skill)) needsWrite = false;
+      } catch {
+      }
+    }
+    if (needsWrite) {
+      try {
+        mkdirSync3(scratchDir, { recursive: true });
+        writeFileSync3(scratchMd, renderLiveSkillMd(skill), "utf8");
+      } catch {
+        continue;
+      }
+    }
+    const loaded = loadSkill(skill.name, scratchDir);
+    if (loaded) out.push(loaded);
+  }
+  return out;
+}
+function renderLiveSkillMd(skill) {
+  const escaped = (skill.description ?? "").replace(/"/g, '\\"');
+  const body = skill.content ?? "";
+  const separator = body.startsWith("\n") ? "" : "\n";
+  return `---
+name: ${skill.name}
+description: "${escaped}"
+---
+${separator}${body}`;
+}
+function resolveSkills(cwd, config, options, discoveryOptions) {
   const skillsConfig = config;
   const extraPaths = skillsConfig?.skills?.paths;
   let discovered;
   try {
-    discovered = discoverSkills(cwd, extraPaths);
+    discovered = discoverSkills(cwd, extraPaths, discoveryOptions);
   } catch {
     discovered = [];
   }
+  if (discoveryOptions?.liveSkills?.length) {
+    const seen = new Set(discovered.map((s2) => s2.id));
+    for (const skill of liveSkillsToDiscovered(discoveryOptions.liveSkills)) {
+      if (seen.has(skill.id)) continue;
+      seen.add(skill.id);
+      discovered.push(skill);
+    }
+  }
   return filterSkills(discovered, config, options);
 }
 function skillSetHash(skills) {
@@ -1234,7 +1492,7 @@ function copyTree(srcDir, destDir, skillId, maxBytes, warn) {
             );
             continue;
           }
-          mkdirSync3(dirname2(destPath), { recursive: true });
+          mkdirSync4(dirname2(destPath), { recursive: true });
           copyFileSync(srcPath, destPath);
           bytes += size;
         } catch {
@@ -1248,8 +1506,8 @@ function copyTree(srcDir, destDir, skillId, maxBytes, warn) {
 function writeIfChanged(path, content) {
   const existing = existsSync2(path) ? readFileSync4(path, "utf8") : void 0;
   if (existing === content) return false;
-  mkdirSync3(dirname2(path), { recursive: true });
-  writeFileSync3(path, content, "utf8");
+  mkdirSync4(dirname2(path), { recursive: true });
+  writeFileSync4(path, content, "utf8");
   return true;
 }
 function ensureGitIgnored(dir, skillIds) {
@@ -1262,7 +1520,7 @@ function ensureGitIgnored(dir, skillIds) {
   if (missing.length === 0) return;
   const prefix = existing && !existing.endsWith("\n") ? `${existing}
 ` : existing;
-  writeFileSync3(path, `${prefix}${missing.join("\n")}
+  writeFileSync4(path, `${prefix}${missing.join("\n")}
 `, "utf8");
 }
 function writeSkillMirror(cwd, skills, warn) {
@@ -1370,7 +1628,7 @@ function pruneStale(cwd, currentIds, warn) {
     try {
       const content = readFileSync4(skillMdPath, "utf8");
       if (isGenerated(content)) {
-        rmSync2(join4(dir, entry.name), { recursive: true, force: true });
+        rmSync3(join4(dir, entry.name), { recursive: true, force: true });
         removed = true;
       }
     } catch {
@@ -1389,7 +1647,7 @@ function removeSkillMirror(cwd) {
       if (!existsSync2(skillMdPath)) continue;
       try {
         if (isGenerated(readFileSync4(skillMdPath, "utf8"))) {
-          rmSync2(join4(dir, entry.name), { recursive: true, force: true });
+          rmSync3(join4(dir, entry.name), { recursive: true, force: true });
         }
       } catch {
       }
@@ -1409,7 +1667,7 @@ function removeSkillMirror(cwd) {
       const ignorePath = join4(dir, IGNORE_FILE);
       if (existsSync2(ignorePath)) {
         try {
-          rmSync2(ignorePath);
+          rmSync3(ignorePath);
         } catch {
         }
       }
@@ -1431,10 +1689,449 @@ function buildSkillsCatalogue(skills) {
   ].join("\n");
 }
 
+// src/plugin/plugin-tool-registry.ts
+import { existsSync as existsSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { join as join5 } from "path";
+import { createRequire as createRequire2 } from "module";
+import { pathToFileURL } from "url";
+import { homedir as homedir4 } from "os";
+import { tool as tool2 } from "@opencode-ai/plugin";
+var SELF_SPECS = /* @__PURE__ */ new Set([
+  "@stablekernel/opencode-cursor",
+  "@stablekernel/opencode-cursor@latest"
+]);
+function parsePluginSpec(spec) {
+  const trimmed = spec.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("~/") || /\.[cm]?[jt]sx?$/.test(trimmed)) {
+    const expanded = trimmed.startsWith("~/") ? join5(homedir4(), trimmed.slice(2)) : trimmed;
+    return { kind: "path", path: expanded };
+  }
+  const at = trimmed.lastIndexOf("@");
+  if (at > 0) {
+    const name = trimmed.slice(0, at);
+    const version = trimmed.slice(at + 1);
+    if (version.startsWith("git+")) {
+      return { kind: "git", name, raw: trimmed };
+    }
+    if (version.includes("://")) {
+      return { kind: "unsupported", raw: trimmed };
+    }
+    return { kind: "npm", name, version };
+  }
+  return { kind: "npm", name: trimmed };
+}
+function resolveCacheEntry(cacheRoot, parsed) {
+  if (parsed.kind === "unsupported") return void 0;
+  if (parsed.kind === "git") {
+    const parts = parsed.raw.split("/");
+    let current = cacheRoot;
+    for (const part of parts) {
+      const candidate = join5(current, part);
+      if (!existsSync3(candidate)) return void 0;
+      current = candidate;
+    }
+    return current;
+  }
+  const { name, version } = parsed;
+  const candidates = [
+    version ? join5(cacheRoot, `${name}@${version}`) : void 0,
+    join5(cacheRoot, `${name}@latest`),
+    join5(cacheRoot, name)
+  ].filter((c) => Boolean(c));
+  for (const candidate of candidates) {
+    if (existsSync3(candidate)) return candidate;
+  }
+  return void 0;
+}
+function resolvePackageMain(cacheEntry, pkgDir, name) {
+  const tryRequire = (baseDir) => {
+    try {
+      const req = createRequire2(join5(baseDir, "noop.js"));
+      return req.resolve(name);
+    } catch {
+      return void 0;
+    }
+  };
+  return tryRequire(pkgDir) ?? tryRequire(cacheEntry);
+}
+function packageRoot(cacheEntry, name) {
+  const direct = join5(cacheEntry, "node_modules", name);
+  if (existsSync3(direct)) return direct;
+  const nm = join5(cacheEntry, "node_modules");
+  if (!existsSync3(nm)) return void 0;
+  let entries;
+  try {
+    entries = readdirSync3(nm, { withFileTypes: true });
+  } catch {
+    return void 0;
+  }
+  for (const ent of entries) {
+    if (ent.name === ".bin") continue;
+    const full = join5(nm, ent.name);
+    let isDir = ent.isDirectory();
+    if (!isDir && ent.isSymbolicLink()) {
+      try {
+        isDir = statSync3(full).isDirectory();
+      } catch {
+        isDir = false;
+      }
+    }
+    if (isDir) return full;
+  }
+  return void 0;
+}
+function argsToJsonSchema(args) {
+  if (args == null || typeof args !== "object")
+    return { type: "object", properties: {}, required: [] };
+  const entries = Object.entries(args);
+  const allZod = entries.length > 0 && entries.every(([, v]) => isZodType(v));
+  if (allZod) {
+    try {
+      const zodLike = tool2.schema;
+      if (typeof zodLike.toJSONSchema === "function") {
+        const schema = zodLike.toJSONSchema(zodLike.object(args), {
+          io: "input"
+        });
+        return normalizeZodSchema(schema);
+      }
+    } catch {
+    }
+  }
+  const properties = {};
+  for (const [key, value] of entries) {
+    if (typeof value === "boolean" || typeof value === "object" && value !== null && !Array.isArray(value)) {
+      properties[key] = value;
+    }
+  }
+  return { type: "object", properties, required: Object.keys(properties) };
+}
+function isZodType(value) {
+  return typeof value === "object" && value !== null && "_zod" in value;
+}
+function normalizeZodSchema(schema) {
+  const out = { ...schema };
+  delete out["$schema"];
+  return out;
+}
+function extractToolMap(hooks) {
+  if (!hooks || typeof hooks !== "object") return void 0;
+  const tool3 = hooks.tool;
+  if (!tool3 || typeof tool3 !== "object") return void 0;
+  const out = {};
+  for (const [id, def] of Object.entries(tool3)) {
+    if (isPluginTool(def)) out[id] = def;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function isPluginTool(value) {
+  return typeof value === "object" && value !== null && "args" in value && "description" in value && "execute" in value;
+}
+async function loadToolMap(modulePath, input) {
+  const mod = await import(pathToFileURL(modulePath).href);
+  const candidates = [mod["server"], mod["default"]];
+  for (const value of Object.values(mod)) {
+    if (typeof value === "function" && !candidates.includes(value)) {
+      candidates.push(value);
+    }
+  }
+  for (const candidate of candidates) {
+    if (typeof candidate !== "function") continue;
+    let hooks;
+    try {
+      hooks = await candidate(input);
+    } catch {
+      continue;
+    }
+    const tools = extractToolMap(hooks);
+    if (tools) return tools;
+  }
+  return void 0;
+}
+async function mirrorPluginTools(config, input, options) {
+  const failed = {};
+  const tools = [];
+  const seen = /* @__PURE__ */ new Set();
+  const specs = (config?.plugin ?? []).map(
+    (entry) => typeof entry === "string" ? entry : Array.isArray(entry) ? entry[0] : void 0
+  ).filter((s2) => typeof s2 === "string" && s2.length > 0);
+  const cacheRoot = options?.cacheRoot ?? opencodePackagesRoot(homedir4());
+  for (const spec of specs) {
+    if (SELF_SPECS.has(spec)) continue;
+    const parsed = parsePluginSpec(spec);
+    if (!parsed) {
+      failed[spec] = "unsupported spec format";
+      continue;
+    }
+    if (parsed.kind === "unsupported") {
+      failed[spec] = "unsupported spec format (URL tarball specs are not mirrored)";
+      continue;
+    }
+    let modulePath;
+    if (parsed.kind === "path") {
+      modulePath = parsed.path.startsWith("/") ? parsed.path : void 0;
+      if (!modulePath || !existsSync3(modulePath)) {
+        failed[spec] = "plugin file not found";
+        continue;
+      }
+    } else {
+      const entry = resolveCacheEntry(cacheRoot, parsed);
+      if (!entry) {
+        failed[spec] = "not found in opencode package cache";
+        continue;
+      }
+      const pkg = packageRoot(entry, parsed.name);
+      if (!pkg) {
+        failed[spec] = "package root not found in cache entry";
+        continue;
+      }
+      const resolved = resolvePackageMain(entry, pkg, parsed.name);
+      if (!resolved) {
+        failed[spec] = "package entry point not found";
+        continue;
+      }
+      modulePath = resolved;
+    }
+    if (!modulePath) {
+      failed[spec] = "plugin module path not resolved";
+      continue;
+    }
+    let toolMap;
+    try {
+      toolMap = await loadToolMap(modulePath, input);
+    } catch (error) {
+      failed[spec] = error instanceof Error ? error.message : String(error);
+      continue;
+    }
+    if (!toolMap) {
+      failed[spec] = "no tool map exported";
+      continue;
+    }
+    for (const [id, def] of Object.entries(toolMap)) {
+      if (seen.has(id)) continue;
+      if (options?.exclude?.some((p) => matchPattern(p, id))) continue;
+      if (options?.include && options.include.length > 0 && !options.include.some((p) => matchPattern(p, id))) {
+        continue;
+      }
+      seen.add(id);
+      tools.push({
+        id,
+        description: def.description,
+        parameters: argsToJsonSchema(def.args),
+        execute: def.execute,
+        sourcePlugin: spec
+      });
+    }
+  }
+  return { tools, failed };
+}
+function matchPattern(pattern, value) {
+  if (pattern === "*") return true;
+  if (!pattern.includes("*")) return pattern === value;
+  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${regex}$`).test(value);
+}
+
+// src/plugin/plugin-tools-bridge.ts
+import { createServer } from "http";
+import { randomBytes } from "crypto";
+import { existsSync as existsSync4 } from "fs";
+import { fileURLToPath } from "url";
+import { execSync as execSync2 } from "child_process";
+function buildToolContext(args, askGate) {
+  const controller = new AbortController();
+  return {
+    sessionID: args.sessionID,
+    messageID: "cursor-plugin-tools",
+    agent: args.agent,
+    directory: args.directory,
+    worktree: args.directory,
+    abort: controller.signal,
+    metadata: () => {
+    },
+    ask: async (input) => {
+      if (!askGate) {
+        throw new Error(
+          "permission gate unavailable \u2014 refusing to run plugin tool without approval"
+        );
+      }
+      await askGate(input);
+    }
+  };
+}
+function resolvePluginToolsScript() {
+  const candidates = [
+    "./plugin-tools-mcp.js",
+    // importer is a chunk at dist root
+    "../sidecar/plugin-tools-mcp.js",
+    // importer is dist/plugin/index.js
+    "../sidecar/plugin-tools-mcp.mjs"
+    // importer is src/plugin/*.ts (dev/tests)
+  ];
+  for (const candidate of candidates) {
+    const path = fileURLToPath(new URL(candidate, import.meta.url));
+    if (existsSync4(path)) return path;
+  }
+  return void 0;
+}
+function execBasename(execPath) {
+  const base = execPath.split(/[/\\]/).pop() ?? "";
+  return base.replace(/\.exe$/i, "").toLowerCase();
+}
+function resolvePluginToolsNodeCommand(execPath = process.execPath, lookupNode) {
+  const name = execBasename(execPath);
+  if (name === "node" || name === "bun") return execPath;
+  if (lookupNode) return lookupNode() || void 0;
+  try {
+    const out = execSync2(
+      process.platform === "win32" ? "where node" : "command -v node",
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    ).trim();
+    return out.split("\n")[0] || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function startPluginToolsBridge(options) {
+  const scriptPath = resolvePluginToolsScript();
+  if (!scriptPath) {
+    pluginLog("warn", "plugin-tools MCP script not found; bridge disabled");
+    return { close: async () => {
+    } };
+  }
+  const nodePath = resolvePluginToolsNodeCommand();
+  if (!nodePath) {
+    pluginLog("warn", "plugin-tools MCP needs node on PATH; bridge disabled");
+    return { close: async () => {
+    } };
+  }
+  const token = randomBytes(24).toString("hex");
+  const toolById = new Map(options.tools.map((t) => [t.id, t]));
+  const server = createServer((req, res) => {
+    const send = (status, body) => {
+      res.writeHead(status, { "content-type": "application/json" });
+      res.end(JSON.stringify(body));
+    };
+    const auth = req.headers["authorization"];
+    if (auth !== `Bearer ${token}`) {
+      send(401, { error: "unauthorized" });
+      return;
+    }
+    if (req.method === "GET" && req.url === "/tools") {
+      send(200, {
+        tools: options.tools.map((t) => ({
+          id: t.id,
+          description: t.description,
+          parameters: t.parameters
+        }))
+      });
+      return;
+    }
+    if (req.method === "POST" && req.url === "/call") {
+      const MAX_BODY = 10 * 1024 * 1024;
+      let raw = "";
+      let size = 0;
+      req.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > MAX_BODY) {
+          req.destroy();
+          return;
+        }
+        raw += chunk;
+      });
+      req.on("end", async () => {
+        if (size > MAX_BODY) return;
+        let body;
+        try {
+          body = JSON.parse(raw);
+        } catch {
+          send(400, { ok: false, error: "invalid JSON body" });
+          return;
+        }
+        const tool3 = body.id ? toolById.get(body.id) : void 0;
+        if (!tool3) {
+          send(404, { ok: false, error: `unknown tool: ${body.id}` });
+          return;
+        }
+        try {
+          const ctx = buildToolContext(
+            {
+              sessionID: options.sessionID ?? "cursor-plugin-tools",
+              agent: options.agent ?? "cursor",
+              directory: options.directory
+            },
+            options.askGate
+          );
+          const result = await tool3.execute(body.args ?? {}, ctx);
+          if (typeof result === "string") {
+            send(200, { ok: true, output: result });
+          } else {
+            send(200, {
+              ok: true,
+              title: result.title,
+              output: result.output,
+              metadata: result.metadata
+            });
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          send(200, { ok: false, error: message });
+        }
+      });
+      return;
+    }
+    send(404, { error: "not found" });
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve());
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : void 0;
+  if (!port) {
+    await new Promise((resolve) => server.close(() => resolve()));
+    pluginLog(
+      "warn",
+      "plugin-tools control server failed to bind; bridge disabled"
+    );
+    return { close: async () => {
+    } };
+  }
+  return {
+    mcpServer: {
+      type: "stdio",
+      command: nodePath,
+      args: [scriptPath],
+      env: {
+        OPENCODE_PLUGIN_TOOLS_PORT: String(port),
+        OPENCODE_PLUGIN_TOOLS_TOKEN: token
+      }
+    },
+    close: () => new Promise((resolve) => {
+      server.close(() => resolve());
+      server.closeAllConnections?.();
+    })
+  };
+}
+
 // src/plugin/index.ts
 function apiKeyFromAuth(auth) {
   return auth?.type === "api" ? auth.key : void 0;
 }
+async function fetchLiveSkills(client, query) {
+  const app = client.app;
+  if (typeof app?.skills === "function") {
+    return app.skills(query);
+  }
+  const inner = client._client;
+  return inner?.get?.({
+    url: "/skill",
+    ...query?.query ? { query: query.query } : {}
+  });
+}
 var CursorPlugin = async (input) => {
   const _latestVersionPromise = (async () => {
     try {
@@ -1480,6 +2177,16 @@ var CursorPlugin = async (input) => {
     setLogBridge({ client, directory });
   }
   let resolvedCwd = directory ?? process.cwd();
+  let pluginSkillSources;
+  try {
+    pluginSkillSources = resolvePluginSkillSources();
+  } catch (error) {
+    pluginLog("warn", "plugin skill source discovery failed", {
+      error: error instanceof Error ? error.message : String(error),
+      impact: "plugin-bundled skills unavailable to the Cursor agent"
+    });
+    pluginSkillSources = void 0;
+  }
   let forwardMcp = true;
   let userMcp = {};
   let autoCompaction = false;
@@ -1488,6 +2195,134 @@ var CursorPlugin = async (input) => {
   let lastSkillHash = "";
   let currentSkillsCatalogue = "";
   const warnedOAuth = /* @__PURE__ */ new Set();
+  let forwardPluginTools = true;
+  let pluginToolOptions;
+  let mirroredTools = [];
+  let pluginToolsBridge;
+  let lastPermissionKey = "";
+  let pluginToolsMcpServer;
+  let pluginToolsWarned = false;
+  async function syncPluginTools(config) {
+    if (!forwardPluginTools) return void 0;
+    try {
+      const result = await mirrorPluginTools(config, input, pluginToolOptions);
+      if (Object.keys(result.failed).length > 0 && !pluginToolsWarned) {
+        pluginToolsWarned = true;
+        pluginLog("warn", "plugin tool mirror skipped some plugins", result.failed);
+      }
+      if (result.tools.length === 0) {
+        if (!Array.isArray(config?.plugin) && pluginToolsMcpServer) {
+          return pluginToolsMcpServer;
+        }
+        await pluginToolsBridge?.close();
+        pluginToolsBridge = void 0;
+        mirroredTools = [];
+        return void 0;
+      }
+      const ids = result.tools.map((t) => t.id).sort().join("|");
+      const permKey = JSON.stringify(config?.permission ?? null);
+      const currentIds = mirroredTools.map((t) => t.id).sort().join("|");
+      if (ids !== currentIds || permKey !== lastPermissionKey || !pluginToolsBridge) {
+        await pluginToolsBridge?.close();
+        pluginToolsBridge = await startPluginToolsBridge({
+          tools: result.tools,
+          directory: input?.directory ?? process.cwd(),
+          askGate: makeAskGate(config?.permission)
+        });
+        mirroredTools = result.tools;
+        lastPermissionKey = permKey;
+      }
+      pluginToolsMcpServer = pluginToolsBridge?.mcpServer;
+      return pluginToolsMcpServer;
+    } catch (error) {
+      pluginLog("warn", "plugin tool mirror failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return void 0;
+    }
+  }
+  function makeAskGate(permissionConfig) {
+    return async (req) => {
+      const patterns = Array.isArray(req.patterns) && req.patterns.length > 0 ? req.patterns : ["*"];
+      let needsAsk = false;
+      for (const pattern of patterns) {
+        const action = evaluatePermissionAction(
+          permissionConfig,
+          req.permission,
+          pattern
+        );
+        if (action === "deny") {
+          throw new Error(
+            `permission denied for "${req.permission}" (pattern "${pattern}")`
+          );
+        }
+        if (action !== "allow") needsAsk = true;
+      }
+      if (!needsAsk) return;
+      throw new Error(
+        `permission for "${req.permission}" is set to "ask", which can't be prompted from the Cursor agent \u2014 set it to "allow" to use this tool`
+      );
+    };
+  }
+  function evaluatePermissionAction(permissionConfig, permission, pattern) {
+    const wildcardMatch2 = (pattern2, value) => {
+      if (pattern2 === "*") return true;
+      if (!pattern2.includes("*")) return pattern2 === value;
+      const regex = pattern2.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+      return new RegExp(`^${regex}$`).test(value);
+    };
+    const normalize = (value) => value === "allow" || value === "deny" || value === "ask" ? value : void 0;
+    const home = process.env["HOME"] || homedir5();
+    const expandPattern = (pattern2) => {
+      if (pattern2 === "~") return home;
+      if (pattern2.startsWith("~/")) return home + pattern2.slice(1);
+      if (pattern2.startsWith("$HOME/")) return home + pattern2.slice(5);
+      if (pattern2.startsWith("$HOME")) return home + pattern2.slice(5);
+      return pattern2;
+    };
+    const rules = [];
+    const pushRule = (perm, pattern2, action) => {
+      const normalized = normalize(action);
+      if (typeof perm !== "string" || normalized === void 0) return;
+      rules.push({
+        permission: perm,
+        pattern: typeof pattern2 === "string" ? expandPattern(pattern2) : "*",
+        action: normalized
+      });
+    };
+    if (Array.isArray(permissionConfig)) {
+      for (const rule of permissionConfig) {
+        if (rule && typeof rule === "object") {
+          const r = rule;
+          pushRule(r.permission, r.pattern, r.action);
+        }
+      }
+    } else if (permissionConfig && typeof permissionConfig === "object") {
+      for (const [perm, value] of Object.entries(
+        permissionConfig
+      )) {
+        const direct = normalize(value);
+        if (direct) {
+          pushRule(perm, "*", value);
+          continue;
+        }
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          for (const [pattern2, action] of Object.entries(
+            value
+          )) {
+            pushRule(perm, pattern2, action);
+          }
+        }
+      }
+    }
+    for (let i = rules.length - 1; i >= 0; i--) {
+      const rule = rules[i];
+      if (wildcardMatch2(rule.permission, permission) && wildcardMatch2(rule.pattern, pattern)) {
+        return rule.action;
+      }
+    }
+    return "ask";
+  }
   return {
     auth: {
       provider: PROVIDER_ID,
@@ -1518,7 +2353,13 @@ var CursorPlugin = async (input) => {
       autoCompaction = existingOptions["autoCompaction"] === true;
       forwardMcp = existingOptions["forwardMcp"] !== false;
       userMcp = existingOptions["mcpServers"] ?? {};
-      const mcpServers = forwardMcp ? { ...userMcp, ...translateMcpServers(config.mcp) } : userMcp;
+      const baseMcpServers = forwardMcp ? { ...userMcp, ...translateMcpServers(config.mcp) } : userMcp;
+      forwardPluginTools = existingOptions["forwardPluginTools"] !== false;
+      pluginToolOptions = existingOptions["pluginTools"];
+      const pluginToolsServer = await syncPluginTools(
+        config
+      );
+      const mcpServers = pluginToolsServer ? { ...baseMcpServers, "opencode-plugin-tools": pluginToolsServer } : baseMcpServers;
       const modelParamDefaults = {};
       for (const item of models) {
         const params = defaultModelParams(item);
@@ -1534,7 +2375,8 @@ var CursorPlugin = async (input) => {
           const resolved = resolveSkills(
             resolvedCwd,
             config,
-            skillFilterOptions
+            skillFilterOptions,
+            pluginSkillSources
           );
           writeSkillMirror(
             resolvedCwd,
@@ -1610,17 +2452,22 @@ var CursorPlugin = async (input) => {
             client.config.get(),
             client.mcp.status(query)
           ]);
-          const liveMcp = cfgRes?.data?.mcp;
+          const liveConfig = cfgRes?.data;
+          const liveMcp = liveConfig?.mcp;
           const status = statusRes?.data;
           if (status) {
-            output.options["mcpServers"] = {
+            const liveToolsServer = await syncPluginTools(liveConfig);
+            const liveServers = {
               ...userMcp,
               ...translateMcpServers(liveMcp, status)
             };
-            const unshareable = findUnshareableOAuthServers(
-              liveMcp,
-              status
-            ).filter((name) => !warnedOAuth.has(name));
+            if (liveToolsServer) {
+              liveServers["opencode-plugin-tools"] = liveToolsServer;
+            }
+            output.options["mcpServers"] = liveServers;
+            const unshareable = findUnshareableOAuthServers(liveMcp, status).filter(
+              (name) => !warnedOAuth.has(name)
+            );
             if (unshareable.length > 0) {
               for (const name of unshareable) warnedOAuth.add(name);
               const plural = unshareable.length > 1;
@@ -1636,6 +2483,23 @@ var CursorPlugin = async (input) => {
           }
         } catch {
         }
+      } else if (client && forwardPluginTools && mirroredTools.length > 0) {
+        try {
+          const query = directory ? { query: { directory } } : void 0;
+          const cfgRes = await client.config.get(query);
+          const liveConfig = cfgRes?.data;
+          const liveToolsServer = await syncPluginTools(liveConfig);
+          const liveServers = {
+            ...userMcp
+          };
+          if (liveToolsServer) {
+            liveServers["opencode-plugin-tools"] = liveToolsServer;
+          }
+          if (Object.keys(liveServers).length > 0) {
+            output.options["mcpServers"] = liveServers;
+          }
+        } catch {
+        }
       }
       if (forwardSkills) {
         if (client) {
@@ -1643,10 +2507,18 @@ var CursorPlugin = async (input) => {
             const query = directory ? { query: { directory } } : void 0;
             const cfgRes = await client.config.get(query);
             const liveConfig = cfgRes?.data;
+            let liveSkills;
+            try {
+              let skillsRes;
+              skillsRes = await fetchLiveSkills(client, query);
+              liveSkills = skillsRes?.data;
+            } catch {
+            }
             const resolved = resolveSkills(
               resolvedCwd,
               liveConfig,
-              skillFilterOptions
+              skillFilterOptions,
+              { ...pluginSkillSources, liveSkills }
             );
             const hash = skillSetHash(resolved.skills);
             if (hash !== lastSkillHash) {
@@ -1664,6 +2536,30 @@ var CursorPlugin = async (input) => {
         output.options["skillsCatalogue"] = currentSkillsCatalogue;
       }
     },
+    // Stamp the child session id on the RUNNING `task` part. The provider
+    // creates the child session when the Cursor subagent starts and
+    // publishes call→child on the bridge registry; when opencode's
+    // processor lands the task part (`message.part.updated`), patch it
+    // (`part.update`, the native `ctx.metadata` equivalent) so the TUI
+    // card carries `state.metadata.sessionId` from the start — matching
+    // the native task tool, which publishes the id at execute time. The
+    // processor emits a running-state part update for every streamed
+    // tool part, so this fires early; the stamp is idempotent.
+    event: async (input2) => {
+      const evt = input2.event;
+      if (evt.type !== "message.part.updated") return;
+      const part = evt.properties.part;
+      if (!part || part.type !== "tool" || part.tool !== "task") return;
+      const childId = subagentCallChildId(part.callID);
+      if (!childId) return;
+      void stampTaskPartSessionId({
+        sessionID: part.sessionID,
+        messageID: part.messageID,
+        partID: part.id,
+        part,
+        childId
+      });
+    },
     tool: {
       cursor_update_plugin: {
         description: "Check if the @stablekernel/opencode-cursor plugin is up to date and update it if not. Call this when the user asks to update, upgrade, or refresh the cursor plugin. Clears the cached install so opencode fetches the latest version on next launch.",
@@ -1673,7 +2569,11 @@ var CursorPlugin = async (input) => {
             return {
               title: "cursor plugin (checks disabled)",
               output: "Update checks are disabled (CI or NO_UPDATE_NOTIFIER is set).",
-              metadata: { local: void 0, latest: void 0, status: "disabled" }
+              metadata: {
+                local: void 0,
+                latest: void 0,
+                status: "disabled"
+              }
             };
           }
           const local = getLocalVersion();
@@ -1702,7 +2602,7 @@ var CursorPlugin = async (input) => {
           const cachePath = PLUGIN_CACHE_PATH;
           const removeCommand = process.platform === "win32" ? `rmdir /s /q "${cachePath}"` : `rm -rf ${cachePath}`;
           try {
-            rmSync3(cachePath, { recursive: true, force: true });
+            rmSync4(cachePath, { recursive: true, force: true });
             clearVersionCache();
             return {
               title: "cursor plugin (updated)",
@@ -1731,9 +2631,7 @@ then restart opencode.`,
         args: {},
         execute: async () => {
           const result = await discoverModels({ forceRefresh: true });
-          const lines = result.models.map(
-            (m) => `- ${m.id} \u2014 ${m.displayName}`
-          );
+          const lines = result.models.map((m) => `- ${m.id} \u2014 ${m.displayName}`);
           const header = result.source === "live" ? `Refreshed ${result.models.length} Cursor models (live):` : `Could not fetch live models (${result.source}). ${result.warning ?? ""}`.trim();
           return {
             title: `Cursor models (${result.source})`,
@@ -1753,6 +2651,8 @@ then restart opencode.`,
     dispose: async () => {
       removeSystemRule(resolvedCwd);
       removeSkillMirror(resolvedCwd);
+      await pluginToolsBridge?.close();
+      pluginToolsBridge = void 0;
       clearSubagentBridge();
       clearLogBridge();
     }