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

package/dist/plugin/index.js

@@ -5,18 +5,135 @@ import {
   clearSubagentBridge,
   fingerprintApiKey,
   loadCursorSdk,
+  pluginLog,
   removeSystemRule,
   resolveControls,
   resolveCursorApiKey,
   setLogBridge,
   setSubagentBridge,
   streamAgentTurn
-} from "../chunk-COE6ZXMP.js";
+} from "../chunk-RDY3H2LE.js";
 
 // src/plugin/index.ts
-import { rmSync as rmSync2 } from "fs";
+import { rmSync as rmSync3 } from "fs";
 import semver2 from "semver";
 
+// src/model-limits.ts
+var MODEL_CONTEXT_LIMITS = {
+  "auto-smart": 2e5,
+  "claude-fable-5": 3e5,
+  "claude-haiku-4-5": 2e5,
+  "claude-opus-4-5": 2e5,
+  "claude-opus-4-6": 2e5,
+  "claude-opus-4-7": 3e5,
+  "claude-opus-4-8": 3e5,
+  "claude-opus-5": 3e5,
+  "claude-sonnet-4": 2e5,
+  "claude-sonnet-4-5": 2e5,
+  "claude-sonnet-4-6": 2e5,
+  "claude-sonnet-5": 2e5,
+  "composer-2": 2e5,
+  "composer-2.5": 2e5,
+  "default": 2e5,
+  "gemini-2.5-flash": 2e5,
+  "gemini-3-flash": 2e5,
+  "gemini-3.1-pro": 2e5,
+  "gemini-3.5-flash": 2e5,
+  "gemini-3.6-flash": 2e5,
+  "glm-5.2": 2e5,
+  "gpt-5-mini": 272e3,
+  "gpt-5.1": 272e3,
+  "gpt-5.2": 272e3,
+  "gpt-5.3-codex": 272e3,
+  "gpt-5.4": 272e3,
+  "gpt-5.4-mini": 272e3,
+  "gpt-5.4-nano": 272e3,
+  "gpt-5.5": 272e3,
+  "gpt-5.6-luna": 272e3,
+  "gpt-5.6-sol": 272e3,
+  "gpt-5.6-terra": 272e3,
+  "grok-4.5": 256e3
+};
+var DEFAULT_CONTEXT_LIMIT = 2e5;
+function resolveContextLimit(modelId) {
+  let best;
+  let bestLen = 0;
+  for (const [prefix, limit] of Object.entries(MODEL_CONTEXT_LIMITS)) {
+    if (modelId.startsWith(prefix) && prefix.length > bestLen) {
+      best = limit;
+      bestLen = prefix.length;
+    }
+  }
+  return best ?? DEFAULT_CONTEXT_LIMIT;
+}
+var MODEL_COST = {
+  "auto-smart": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  "claude-fable-5": { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 },
+  "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  "claude-opus-4-5": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-opus-4-6": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-opus-4-7": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-opus-4-8": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-opus-5": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-sonnet-4": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-sonnet-4-5": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-sonnet-5": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "composer-2": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  "composer-2.5": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  "default": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  "gemini-2.5-flash": { input: 0.3, output: 2.5, cacheRead: 0.03, cacheWrite: 0 },
+  "gemini-3-flash": { input: 0.5, output: 3, cacheRead: 0.05, cacheWrite: 0 },
+  "gemini-3.1-pro": { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 0 },
+  "gemini-3.5-flash": { input: 1.5, output: 9, cacheRead: 0.15, cacheWrite: 0 },
+  "gemini-3.6-flash": { input: 1.5, output: 7.5, cacheRead: 0.15, cacheWrite: 0 },
+  "glm-5.2": { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 0 },
+  "gpt-5-mini": { input: 0.25, output: 2, cacheRead: 0.025, cacheWrite: 0 },
+  "gpt-5.1": { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 0 },
+  "gpt-5.2": { input: 1.75, output: 14, cacheRead: 0.175, cacheWrite: 0 },
+  "gpt-5.3-codex": { input: 1.75, output: 14, cacheRead: 0.175, cacheWrite: 0 },
+  "gpt-5.4": { input: 2.5, output: 15, cacheRead: 0.25, cacheWrite: 0 },
+  "gpt-5.4-mini": { input: 0.75, output: 4.5, cacheRead: 0.075, cacheWrite: 0 },
+  "gpt-5.4-nano": { input: 0.2, output: 1.25, cacheRead: 0.02, cacheWrite: 0 },
+  "gpt-5.5": { input: 5, output: 30, cacheRead: 0.5, cacheWrite: 0 },
+  "gpt-5.6-luna": { input: 0.2, output: 1.2, cacheRead: 0.02, cacheWrite: 0.25 },
+  "gpt-5.6-sol": { input: 5, output: 30, cacheRead: 0.5, cacheWrite: 6.25 },
+  "gpt-5.6-terra": { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 2.5 },
+  "grok-4.5": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+};
+var DEFAULT_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+function resolveCost(modelId) {
+  let best;
+  let bestLen = 0;
+  for (const [prefix, cost] of Object.entries(MODEL_COST)) {
+    if (modelId.startsWith(prefix) && prefix.length > bestLen) {
+      best = cost;
+      bestLen = prefix.length;
+    }
+  }
+  return best ?? DEFAULT_COST;
+}
+var MODEL_OUTPUT_LIMITS = {
+  "claude-opus-4-7": 64e3,
+  "claude-opus-4-8": 64e3,
+  "claude-opus-5": 64e3,
+  "claude-fable-5": 64e3,
+  "gpt-5.5": 64e3,
+  "gpt-5.6-sol": 64e3
+};
+var DEFAULT_OUTPUT_LIMIT = 32e3;
+function resolveOutputLimit(modelId) {
+  let best;
+  let bestLen = 0;
+  for (const [prefix, limit] of Object.entries(MODEL_OUTPUT_LIMITS)) {
+    if (modelId.startsWith(prefix) && prefix.length > bestLen) {
+      best = limit;
+      bestLen = prefix.length;
+    }
+  }
+  return best ?? DEFAULT_OUTPUT_LIMIT;
+}
+
 // src/model-cache.ts
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir, tmpdir } from "os";
@@ -200,6 +317,7 @@ function toOpencodeModels(items) {
   const out = {};
   for (const item of items) {
     const params = defaultModelParams(item);
+    const cost = resolveCost(item.id);
     out[item.id] = {
       id: item.id,
       name: item.displayName || item.id,
@@ -208,7 +326,17 @@ function toOpencodeModels(items) {
       temperature: false,
       tool_call: true,
       variants: buildModelVariants(item),
-      options: Object.keys(params).length > 0 ? { params } : {}
+      options: Object.keys(params).length > 0 ? { params } : {},
+      limit: {
+        context: resolveContextLimit(item.id),
+        output: resolveOutputLimit(item.id)
+      },
+      cost: {
+        input: cost.input,
+        output: cost.output,
+        cache_read: cost.cacheRead,
+        cache_write: cost.cacheWrite
+      }
     };
   }
   return out;
@@ -238,8 +366,11 @@ function buildModelV2Map(items) {
         output: { text: true, audio: false, image: false, video: false, pdf: false },
         interleaved: false
       },
-      cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
-      limit: { context: 2e5, output: 32e3 },
+      cost: (() => {
+        const c = resolveCost(item.id);
+        return { input: c.input, output: c.output, cache: { read: c.cacheRead, write: c.cacheWrite } };
+      })(),
+      limit: { context: resolveContextLimit(item.id), output: resolveOutputLimit(item.id) },
       status: "active",
       options: Object.keys(params).length > 0 ? { params } : {},
       headers: {},
@@ -404,6 +535,10 @@ async function runDelegate(params) {
     modelSelection,
     mode,
     cwd: params.cwd,
+    // Default to the "project" settings layer so the delegate picks up
+    // `.cursor/skills/` and other project-level config from its cwd. An
+    // explicit `settingSources` from the caller overrides this default.
+    settingSources: params.settingSources ?? ["project"],
     ...params.sandbox !== void 0 ? { sandbox: params.sandbox } : {},
     ...params.agentId ? { resumeAgentId: params.agentId } : {}
   });
@@ -565,6 +700,11 @@ function buildCursorTools(deps) {
             prompt: args.prompt,
             model: args.model,
             cwd: args.additionalCwds?.length ? [baseCwd, ...args.additionalCwds] : baseCwd,
+            // Honour the user's project settings layer so delegated turns pick
+            // up `.cursor/skills/` from the delegate's cwd. The delegate defaults
+            // to ["project"] on its own, so this is only needed when the user
+            // explicitly configured settingSources on the provider.
+            settingSources: ["project"],
             ...args.mode ? { mode: args.mode } : {},
             ...args.thinking ? { thinking: args.thinking } : {},
             ...args.sandbox !== void 0 ? { sandbox: args.sandbox } : {},
@@ -645,7 +785,7 @@ function clearVersionCache() {
   }
 }
 function getLocalVersion() {
-  if (true) return "0.7.0";
+  if (true) return "0.7.1-next.0";
   try {
     const require2 = createRequire(import.meta.url);
     const pkg = require2("../package.json");
@@ -699,6 +839,589 @@ async function getLatestVersion() {
   return latest;
 }
 
+// src/provider/skill-mirror.ts
+import {
+  mkdirSync as mkdirSync3,
+  writeFileSync as writeFileSync3,
+  readFileSync as readFileSync4,
+  existsSync as existsSync2,
+  rmSync as rmSync2,
+  readdirSync as readdirSync2,
+  statSync as statSync2,
+  copyFileSync,
+  realpathSync as realpathSync2
+} from "fs";
+import { join as join4, relative as relative2, dirname as dirname2 } from "path";
+
+// src/plugin/skill-discovery.ts
+import {
+  readdirSync,
+  readFileSync as readFileSync3,
+  statSync,
+  existsSync,
+  realpathSync
+} from "fs";
+import { join as join3, relative, dirname, resolve as resolvePath, isAbsolute } from "path";
+import { homedir as homedir3 } from "os";
+import { execSync } from "child_process";
+function parseFrontmatter(content) {
+  if (!content.startsWith("---")) return {};
+  const end = content.indexOf("\n---", 3);
+  if (end === -1) return {};
+  const frontmatter = content.slice(3, end);
+  const result = {};
+  for (const line of frontmatter.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const colon = trimmed.indexOf(":");
+    if (colon === -1) continue;
+    const key = trimmed.slice(0, colon).trim();
+    let value = trimmed.slice(colon + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key === "name") result.name = value;
+    else if (key === "description") result.description = value;
+  }
+  return result;
+}
+var SKILL_DIR_NAMES = ["skill", "skills"];
+var EXTERNAL_DIR_NAMES = [".claude", ".agents"];
+function worktreeRoot(cwd) {
+  try {
+    const root = execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3e3
+    }).trim();
+    return root || cwd;
+  } catch {
+    return cwd;
+  }
+}
+function* walkUp(start, stop) {
+  let current = start;
+  while (current) {
+    yield current;
+    if (current === stop) break;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+}
+function scanSkillDir(dir) {
+  if (!existsSync(dir)) return [];
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const found = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    const skillDir = join3(dir, entry.name);
+    if (!existsSync(join3(skillDir, "SKILL.md"))) continue;
+    found.push({ id: entry.name, sourceDir: skillDir });
+  }
+  return found;
+}
+function entryKind(entry, fullPath) {
+  if (entry.isDirectory()) return "dir";
+  if (entry.isFile()) return "file";
+  if (!entry.isSymbolicLink()) return "other";
+  try {
+    const target = statSync(fullPath);
+    if (target.isDirectory()) return "dir";
+    if (target.isFile()) return "file";
+  } catch {
+  }
+  return "other";
+}
+function collectFiles(sourceDir) {
+  const files = [];
+  const visited = /* @__PURE__ */ new Set();
+  function walk(dir, base) {
+    let realDir;
+    try {
+      realDir = realpathSync(dir);
+    } catch {
+      return;
+    }
+    if (visited.has(realDir)) return;
+    visited.add(realDir);
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join3(dir, entry.name);
+      const relPath = relative(base, fullPath);
+      if (entry.name === "SKILL.md") continue;
+      const kind = entryKind(entry, fullPath);
+      if (kind === "dir") {
+        walk(fullPath, base);
+      } else if (kind === "file") {
+        files.push(relPath);
+      }
+    }
+  }
+  walk(sourceDir, sourceDir);
+  return files;
+}
+function loadSkill(id, sourceDir) {
+  const skillMdPath = join3(sourceDir, "SKILL.md");
+  let content;
+  try {
+    content = readFileSync3(skillMdPath, "utf8");
+  } catch {
+    return void 0;
+  }
+  const fm = parseFrontmatter(content);
+  if (!fm.name || !fm.description) return void 0;
+  return {
+    id,
+    name: fm.name,
+    description: fm.description,
+    sourceDir,
+    files: collectFiles(sourceDir)
+  };
+}
+function expandSkillPath(raw, cwd, home) {
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.startsWith("~/")) return join3(home, trimmed.slice(2));
+  if (isAbsolute(trimmed)) return trimmed;
+  return resolvePath(cwd, trimmed);
+}
+function discoverSkills(cwd, extraPaths) {
+  const home = homedir3();
+  const xdgConfig = process.env["XDG_CONFIG_HOME"] || join3(home, ".config");
+  const stop = worktreeRoot(cwd);
+  const scanRoots = [];
+  for (const ancestor of walkUp(cwd, stop)) {
+    for (const sub of SKILL_DIR_NAMES) {
+      scanRoots.push(join3(ancestor, ".opencode", sub));
+    }
+  }
+  for (const ancestor of walkUp(cwd, stop)) {
+    for (const ext of EXTERNAL_DIR_NAMES) {
+      scanRoots.push(join3(ancestor, ext, "skills"));
+    }
+  }
+  for (const sub of SKILL_DIR_NAMES) {
+    scanRoots.push(join3(xdgConfig, "opencode", sub));
+  }
+  for (const ext of EXTERNAL_DIR_NAMES) {
+    scanRoots.push(join3(home, ext, "skills"));
+  }
+  const tildeOpencode = join3(home, ".opencode");
+  if (existsSync(tildeOpencode)) {
+    for (const sub of SKILL_DIR_NAMES) {
+      scanRoots.push(join3(tildeOpencode, sub));
+    }
+  }
+  if (extraPaths) {
+    for (const raw of extraPaths) {
+      const expanded = expandSkillPath(raw, cwd, home);
+      if (!expanded) continue;
+      if (!existsSync(expanded)) continue;
+      scanRoots.push(expanded);
+    }
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const dir of scanRoots) {
+    const found = scanSkillDir(dir);
+    for (const { id, sourceDir } of found) {
+      if (byId.has(id)) continue;
+      const skill = loadSkill(id, sourceDir);
+      if (skill) byId.set(id, skill);
+    }
+  }
+  return Array.from(byId.values());
+}
+function wildcardMatch(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);
+}
+function resolveMapPermission(skillPerm, skillId) {
+  if (typeof skillPerm === "string") {
+    return skillPerm;
+  }
+  if (typeof skillPerm !== "object" || skillPerm === null) return void 0;
+  const map = skillPerm;
+  let action;
+  for (const [pattern, value] of Object.entries(map)) {
+    if (wildcardMatch(pattern, skillId)) {
+      action = value;
+    }
+  }
+  return action;
+}
+function resolveRuleArrayPermission(rules, skillId) {
+  let action;
+  for (const rule of rules) {
+    if (rule.permission !== "skill") continue;
+    if (wildcardMatch(rule.pattern, skillId)) {
+      action = rule.action;
+    }
+  }
+  return action;
+}
+function filterSkills(skills, config, options) {
+  const include = options?.include ?? [];
+  const exclude = options?.exclude ?? [];
+  const matchesAny = (patterns, id) => patterns.some((pattern) => wildcardMatch(pattern, id));
+  const permission = config?.permission;
+  const mapSkillPerm = permission?.["skill"];
+  const ruleArray = Array.isArray(permission?.["permission"]) ? permission["permission"] : void 0;
+  const v2Ruleset = Array.isArray(config?.permission) ? config.permission : void 0;
+  const permitted = [];
+  const withheld = [];
+  for (const skill of skills) {
+    if (matchesAny(exclude, skill.id)) {
+      withheld.push({ id: skill.id, reason: "excluded by plugin options" });
+      continue;
+    }
+    if (include.length > 0 && matchesAny(include, skill.id)) {
+      permitted.push(skill);
+      continue;
+    }
+    if (include.length > 0 && !matchesAny(include, skill.id)) {
+      withheld.push({
+        id: skill.id,
+        reason: "not in plugin include list"
+      });
+      continue;
+    }
+    let action;
+    if (v2Ruleset) {
+      action = resolveRuleArrayPermission(v2Ruleset, skill.id);
+    }
+    if (action === void 0 && ruleArray) {
+      action = resolveRuleArrayPermission(ruleArray, skill.id);
+    }
+    if (action === void 0 && mapSkillPerm !== void 0) {
+      action = resolveMapPermission(mapSkillPerm, skill.id);
+    }
+    if (action === void 0 || action === "allow") {
+      permitted.push(skill);
+    } else if (action === "deny") {
+      withheld.push({ id: skill.id, reason: "denied by permission config" });
+    } else if (action === "ask") {
+      withheld.push({
+        id: skill.id,
+        reason: "ask-permissioned skills are withheld (the ask prompt can't cross the Cursor boundary)"
+      });
+    }
+  }
+  return { skills: permitted, withheld };
+}
+function resolveSkills(cwd, config, options) {
+  const skillsConfig = config;
+  const extraPaths = skillsConfig?.skills?.paths;
+  let discovered;
+  try {
+    discovered = discoverSkills(cwd, extraPaths);
+  } catch {
+    discovered = [];
+  }
+  return filterSkills(discovered, config, options);
+}
+function skillSetHash(skills) {
+  const parts = skills.map((s2) => {
+    const files = ["SKILL.md", ...s2.files].map((file) => {
+      try {
+        const stat = statSync(join3(s2.sourceDir, file));
+        return `${file}:${stat.mtimeMs}:${stat.size}`;
+      } catch {
+        return `${file}:missing`;
+      }
+    });
+    files.sort();
+    return `${s2.id}:${s2.sourceDir}:${files.join(",")}`;
+  });
+  parts.sort();
+  return parts.join("|");
+}
+
+// src/provider/skill-mirror.ts
+var SKILLS_DIR = join4(".cursor", "skills");
+var IGNORE_FILE = ".gitignore";
+var SENTINEL = "generated: opencode-cursor";
+var MAX_FILE_BYTES = 1048576;
+var MAX_TOTAL_BYTES = 10485760;
+function isGenerated(content) {
+  if (!content.startsWith("---")) return false;
+  const end = content.indexOf("\n---", 3);
+  const frontmatter = end === -1 ? content : content.slice(0, end);
+  return frontmatter.split(/\r?\n/).includes(SENTINEL);
+}
+function stampSentinel(content) {
+  if (!content.startsWith("---")) {
+    return `---
+${SENTINEL}
+---
+
+${content}`;
+  }
+  const end = content.indexOf("\n---", 3);
+  if (end === -1) {
+    return `---
+${SENTINEL}
+${content.slice(3)}`;
+  }
+  const frontmatter = content.slice(3, end);
+  if (frontmatter.includes(SENTINEL)) return content;
+  return `---${frontmatter}
+${SENTINEL}
+${content.slice(end)}`;
+}
+function copyTree(srcDir, destDir, skillId, maxBytes, warn) {
+  let bytes = 0;
+  const skipped = [];
+  const visited = /* @__PURE__ */ new Set();
+  function walk(src, dest) {
+    let realSrc;
+    try {
+      realSrc = realpathSync2(src);
+    } catch {
+      return;
+    }
+    if (visited.has(realSrc)) return;
+    visited.add(realSrc);
+    let entries;
+    try {
+      entries = readdirSync2(src, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const srcPath = join4(src, entry.name);
+      const destPath = join4(dest, entry.name);
+      const kind = entryKind(entry, srcPath);
+      if (kind === "dir") {
+        walk(srcPath, destPath);
+      } else if (kind === "file") {
+        if (entry.name === "SKILL.md") continue;
+        try {
+          const size = statSync2(srcPath).size;
+          if (size > MAX_FILE_BYTES) {
+            skipped.push(relative2(srcDir, srcPath));
+            warn(
+              `Skill "${skillId}": skipped oversized file "${relative2(srcDir, srcPath)}" (${size} bytes > ${MAX_FILE_BYTES} limit). The rest of the skill is still mirrored.`
+            );
+            continue;
+          }
+          if (bytes + size > maxBytes) {
+            skipped.push(relative2(srcDir, srcPath));
+            warn(
+              `Skill "${skillId}": skipped file "${relative2(srcDir, srcPath)}" because the mirror's ${MAX_TOTAL_BYTES}-byte total size limit would be exceeded.`
+            );
+            continue;
+          }
+          mkdirSync3(dirname2(destPath), { recursive: true });
+          copyFileSync(srcPath, destPath);
+          bytes += size;
+        } catch {
+        }
+      }
+    }
+  }
+  walk(srcDir, destDir);
+  return { bytes, skipped };
+}
+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");
+  return true;
+}
+function ensureGitIgnored(dir, skillIds) {
+  const path = join4(dir, IGNORE_FILE);
+  const existing = existsSync2(path) ? readFileSync4(path, "utf8") : "";
+  const lines = existing.split(/\r?\n/);
+  const missing = [...skillIds, IGNORE_FILE].filter(
+    (entry) => !lines.includes(entry)
+  );
+  if (missing.length === 0) return;
+  const prefix = existing && !existing.endsWith("\n") ? `${existing}
+` : existing;
+  writeFileSync3(path, `${prefix}${missing.join("\n")}
+`, "utf8");
+}
+function writeSkillMirror(cwd, skills, warn) {
+  if (skills.length === 0) {
+    try {
+      pruneStale(cwd, /* @__PURE__ */ new Set(), warn);
+    } catch {
+    }
+    return "empty";
+  }
+  const dir = join4(cwd, SKILLS_DIR);
+  let totalBytes = 0;
+  let wroteAny = false;
+  let partial = false;
+  const mirroredIds = [];
+  for (const skill of skills) {
+    if (totalBytes >= MAX_TOTAL_BYTES) {
+      warn(
+        `Skill mirror: total size limit (${MAX_TOTAL_BYTES} bytes) reached; skipping remaining skills: ${skills.filter((s2) => !mirroredIds.includes(s2.id)).map((s2) => s2.id).join(", ")}`
+      );
+      break;
+    }
+    const skillDir = join4(dir, skill.id);
+    const skillMdPath = join4(skillDir, "SKILL.md");
+    if (existsSync2(skillMdPath)) {
+      try {
+        const existing = readFileSync4(skillMdPath, "utf8");
+        if (!isGenerated(existing)) {
+          warn(
+            `.cursor/skills/${skill.id}/SKILL.md exists but was not generated by opencode-cursor; leaving it untouched and skipping this skill.`
+          );
+          continue;
+        }
+      } catch {
+      }
+    }
+    try {
+      const sourceContent = readFileSync4(
+        join4(skill.sourceDir, "SKILL.md"),
+        "utf8"
+      );
+      const stamped = stampSentinel(sourceContent);
+      const skillMdBytes = Buffer.byteLength(stamped);
+      if (totalBytes + skillMdBytes > MAX_TOTAL_BYTES) {
+        warn(
+          `Skill mirror: total size limit (${MAX_TOTAL_BYTES} bytes) reached; skipping skill "${skill.id}" and all remaining skills.`
+        );
+        partial = true;
+        break;
+      }
+      const changed = writeIfChanged(skillMdPath, stamped);
+      if (changed) wroteAny = true;
+      totalBytes += skillMdBytes;
+      const { bytes, skipped } = copyTree(
+        skill.sourceDir,
+        skillDir,
+        skill.id,
+        MAX_TOTAL_BYTES - totalBytes,
+        warn
+      );
+      totalBytes += bytes;
+      if (skipped.length > 0) partial = true;
+      mirroredIds.push(skill.id);
+    } catch (error) {
+      partial = true;
+      warn(
+        `Failed to mirror skill "${skill.id}": ${error instanceof Error ? error.message : String(error)}. This skill will be unavailable this turn.`
+      );
+    }
+  }
+  try {
+    const staleRemoved = pruneStale(
+      cwd,
+      new Set(mirroredIds),
+      warn
+    );
+    if (staleRemoved) wroteAny = true;
+  } catch {
+  }
+  if (mirroredIds.length > 0) {
+    try {
+      ensureGitIgnored(dir, mirroredIds);
+    } catch {
+    }
+  }
+  if (partial) return "partial";
+  return wroteAny ? "written" : "unchanged";
+}
+function pruneStale(cwd, currentIds, warn) {
+  const dir = join4(cwd, SKILLS_DIR);
+  if (!existsSync2(dir)) return false;
+  let removed = false;
+  let entries;
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === "." || entry.name === "..") continue;
+    if (currentIds.has(entry.name)) continue;
+    const skillMdPath = join4(dir, entry.name, "SKILL.md");
+    if (!existsSync2(skillMdPath)) continue;
+    try {
+      const content = readFileSync4(skillMdPath, "utf8");
+      if (isGenerated(content)) {
+        rmSync2(join4(dir, entry.name), { recursive: true, force: true });
+        removed = true;
+      }
+    } catch {
+    }
+  }
+  return removed;
+}
+function removeSkillMirror(cwd) {
+  const dir = join4(cwd, SKILLS_DIR);
+  if (!existsSync2(dir)) return;
+  try {
+    const entries = readdirSync2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillMdPath = join4(dir, entry.name, "SKILL.md");
+      if (!existsSync2(skillMdPath)) continue;
+      try {
+        if (isGenerated(readFileSync4(skillMdPath, "utf8"))) {
+          rmSync2(join4(dir, entry.name), { recursive: true, force: true });
+        }
+      } catch {
+      }
+    }
+    const remaining = readdirSync2(dir, { withFileTypes: true });
+    const hasSentinelDir = remaining.some((e) => {
+      if (!e.isDirectory()) return false;
+      const p = join4(dir, e.name, "SKILL.md");
+      if (!existsSync2(p)) return false;
+      try {
+        return isGenerated(readFileSync4(p, "utf8"));
+      } catch {
+        return false;
+      }
+    });
+    if (!hasSentinelDir) {
+      const ignorePath = join4(dir, IGNORE_FILE);
+      if (existsSync2(ignorePath)) {
+        try {
+          rmSync2(ignorePath);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+function buildSkillsCatalogue(skills) {
+  if (skills.length === 0) return void 0;
+  const lines = skills.map(
+    (s2) => `- **${s2.id}**: ${s2.description}`
+  );
+  return [
+    "<available_skills>",
+    "The following skills are available. Load the matching skill from `.cursor/skills/<id>/SKILL.md` before starting relevant work:",
+    "",
+    ...lines,
+    "</available_skills>"
+  ].join("\n");
+}
+
 // src/plugin/index.ts
 function apiKeyFromAuth(auth) {
   return auth?.type === "api" ? auth.key : void 0;
@@ -750,6 +1473,10 @@ var CursorPlugin = async (input) => {
   let resolvedCwd = directory ?? process.cwd();
   let forwardMcp = true;
   let userMcp = {};
+  let forwardSkills = true;
+  let skillFilterOptions;
+  let lastSkillHash = "";
+  let currentSkillsCatalogue = "";
   const warnedOAuth = /* @__PURE__ */ new Set();
   return {
     auth: {
@@ -788,6 +1515,38 @@ var CursorPlugin = async (input) => {
       }
       const optionCwd = existingOptions["cwd"];
       resolvedCwd = (typeof optionCwd === "string" ? optionCwd : void 0) ?? directory ?? process.cwd();
+      forwardSkills = existingOptions["forwardSkills"] !== false;
+      const skillsOpt = existingOptions["skills"];
+      skillFilterOptions = skillsOpt;
+      if (forwardSkills) {
+        try {
+          const resolved = resolveSkills(
+            resolvedCwd,
+            config,
+            skillFilterOptions
+          );
+          writeSkillMirror(
+            resolvedCwd,
+            resolved.skills,
+            (msg) => pluginLog("warn", msg)
+          );
+          currentSkillsCatalogue = buildSkillsCatalogue(resolved.skills) ?? "";
+          lastSkillHash = skillSetHash(resolved.skills);
+          if (resolved.withheld.length > 0) {
+            pluginLog("warn", "skills withheld from mirror", {
+              withheld: resolved.withheld.map((w) => ({
+                id: w.id,
+                reason: w.reason
+              }))
+            });
+          }
+        } catch (error) {
+          pluginLog("warn", "skill mirror failed", {
+            error: error instanceof Error ? error.message : String(error),
+            impact: "skills unavailable to the Cursor agent this session"
+          });
+        }
+      }
       config.provider[PROVIDER_ID] = {
         name: "Cursor",
         npm: providerNpm(),
@@ -796,7 +1555,8 @@ var CursorPlugin = async (input) => {
           ...existingOptions,
           cwd: resolvedCwd,
           ...Object.keys(mcpServers).length > 0 ? { mcpServers } : {},
-          ...Object.keys(modelParamDefaults).length > 0 ? { modelParamDefaults } : {}
+          ...Object.keys(modelParamDefaults).length > 0 ? { modelParamDefaults } : {},
+          ...currentSkillsCatalogue ? { skillsCatalogue: currentSkillsCatalogue } : {}
         },
         models: { ...toOpencodeModels(models), ...existing.models ?? {} }
       };
@@ -863,6 +1623,32 @@ var CursorPlugin = async (input) => {
         } catch {
         }
       }
+      if (forwardSkills) {
+        if (client) {
+          try {
+            const query = directory ? { query: { directory } } : void 0;
+            const cfgRes = await client.config.get(query);
+            const liveConfig = cfgRes?.data;
+            const resolved = resolveSkills(
+              resolvedCwd,
+              liveConfig,
+              skillFilterOptions
+            );
+            const hash = skillSetHash(resolved.skills);
+            if (hash !== lastSkillHash) {
+              writeSkillMirror(
+                resolvedCwd,
+                resolved.skills,
+                (msg) => pluginLog("warn", msg)
+              );
+              currentSkillsCatalogue = buildSkillsCatalogue(resolved.skills) ?? "";
+              lastSkillHash = hash;
+            }
+          } catch {
+          }
+        }
+        output.options["skillsCatalogue"] = currentSkillsCatalogue;
+      }
     },
     tool: {
       cursor_update_plugin: {
@@ -902,7 +1688,7 @@ var CursorPlugin = async (input) => {
           const cachePath = PLUGIN_CACHE_PATH;
           const removeCommand = process.platform === "win32" ? `rmdir /s /q "${cachePath}"` : `rm -rf ${cachePath}`;
           try {
-            rmSync2(cachePath, { recursive: true, force: true });
+            rmSync3(cachePath, { recursive: true, force: true });
             clearVersionCache();
             return {
               title: "cursor plugin (updated)",
@@ -952,6 +1738,7 @@ then restart opencode.`,
     },
     dispose: async () => {
       removeSystemRule(resolvedCwd);
+      removeSkillMirror(resolvedCwd);
       clearSubagentBridge();
       clearLogBridge();
     }