opencode-dynamic-skills 1.1.0 → 1.2.0

package/dist/index.js

@@ -15889,7 +15889,7 @@ function toolName(skillPath) {
 
 // src/lib/SkillFs.ts
 import { join } from "path";
-import { existsSync } from "fs";
+import { existsSync, statSync } from "fs";
 
 // node_modules/mime/dist/types/other.js
 var types = {
@@ -17075,13 +17075,24 @@ var Mime_default = Mime;
 var src_default = new Mime_default(standard_default, other_default)._freeze();
 
 // src/lib/SkillFs.ts
+function isRegularFile(filePath) {
+  try {
+    return statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
 var readSkillFile = async (path) => {
   const file2 = Bun.file(path);
   return file2.text();
 };
 var listSkillFiles = (skillPath, subdirectory) => {
   const glob = new Bun.Glob(join(subdirectory, "**", "*"));
-  return Array.from(glob.scanSync({ cwd: skillPath, absolute: true }));
+  return Array.from(glob.scanSync({ cwd: skillPath, absolute: true })).filter(isRegularFile);
+};
+var listAllSkillFiles = (skillPath) => {
+  const glob = new Bun.Glob("**/*");
+  return Array.from(glob.scanSync({ cwd: skillPath, absolute: true })).filter(isRegularFile).filter((filePath) => !filePath.endsWith("/SKILL.md") && !filePath.endsWith("\\SKILL.md"));
 };
 var findSkillPaths = async (basePath) => {
   const glob = new Bun.Glob("**/SKILL.md");
@@ -17682,6 +17693,7 @@ async function parseSkill(args) {
   const scriptPaths = listSkillFiles(skillFullPath, "scripts");
   const referencePaths = listSkillFiles(skillFullPath, "references");
   const assetPaths = listSkillFiles(skillFullPath, "assets");
+  const indexedFilePaths = listAllSkillFiles(skillFullPath);
   return {
     allowedTools: frontmatter.data["allowed-tools"],
     compatibility: frontmatter.data.compatibility,
@@ -17693,6 +17705,7 @@ async function parseSkill(args) {
     metadata: frontmatter.data.metadata,
     name: frontmatter.data.name,
     path: args.skillPath,
+    files: createSkillResourceMap(skillFullPath, indexedFilePaths),
     scripts: createSkillResourceMap(skillFullPath, scriptPaths),
     references: createSkillResourceMap(skillFullPath, referencePaths),
     assets: createSkillResourceMap(skillFullPath, assetPaths)
@@ -17735,6 +17748,9 @@ function createSkillFinder(provider) {
 // src/tools/SkillRecommender.ts
 var DEFAULT_RECOMMENDATION_LIMIT = 5;
 var MIN_TERM_LENGTH = 3;
+function normalizeSkillSelector(selector) {
+  return selector.trim().toLowerCase().replace(/[/-]/g, "_");
+}
 function getRecommendationReason(nameMatches, descMatches) {
   const reasons = [];
   if (nameMatches > 0) {
@@ -17748,46 +17764,190 @@ function getRecommendationReason(nameMatches, descMatches) {
   }
   return reasons.join("; ");
 }
-function createSkillRecommender(provider) {
+function formatResults(provider, task, recommendations) {
+  return {
+    mode: "recommend",
+    query: task,
+    skills: recommendations.map(({ name, description }) => ({
+      name,
+      description
+    })),
+    recommendations,
+    guidance: recommendations.length > 0 ? "Use skill_use to load one of the recommended skills if you want to apply it." : "No strong skill recommendation was found. Try skill_find with a narrower query.",
+    summary: {
+      total: provider.controller.skills.length,
+      matches: recommendations.length,
+      feedback: recommendations.length > 0 ? `Recommended ${recommendations.length} skill(s) for: **${task}**` : `No strong recommendations found for: **${task}**`
+    },
+    debug: provider.debug
+  };
+}
+function getHeuristicRecommendations(provider, task, limit) {
+  const parsedQuery = parseQuery(task);
+  const rankingTerms = parsedQuery.include.filter((term) => term.length >= MIN_TERM_LENGTH);
+  const rankedMatches = provider.controller.skills.map((skill) => rankSkill(skill, rankingTerms)).filter((ranking) => ranking.totalScore > 0).sort((left, right) => {
+    if (right.totalScore !== left.totalScore) {
+      return right.totalScore - left.totalScore;
+    }
+    if (right.nameMatches !== left.nameMatches) {
+      return right.nameMatches - left.nameMatches;
+    }
+    return left.skill.name.localeCompare(right.skill.name);
+  });
+  return rankedMatches.slice(0, limit).map((skill) => ({
+    name: skill.skill.toolName,
+    description: skill.skill.description,
+    score: skill.totalScore,
+    reason: getRecommendationReason(skill.nameMatches, skill.descMatches)
+  }));
+}
+function buildModelRecommendationPrompt(args) {
+  const catalog = args.skills.map((skill) => `- ${skill.toolName}: ${skill.description} (directory=${skill.name}, aliases=/${skill.name})`).join(`
+`);
+  return [
+    `User request: ${args.task}`,
+    `Maximum recommendations: ${args.limit}`,
+    "Available skills:",
+    catalog,
+    "",
+    "Return strict JSON only. Do not include markdown fences unless required by the model."
+  ].join(`
+`);
+}
+function extractJsonPayload(text) {
+  const fencedMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fencedMatch?.[1]) {
+    return fencedMatch[1].trim();
+  }
+  const firstBrace = text.indexOf("{");
+  const lastBrace = text.lastIndexOf("}");
+  if (firstBrace >= 0 && lastBrace > firstBrace) {
+    return text.slice(firstBrace, lastBrace + 1);
+  }
+  throw new Error("Model response did not contain a JSON object");
+}
+function parseModelRecommendations(text) {
+  const payload = JSON.parse(extractJsonPayload(text));
+  if (!Array.isArray(payload.recommendations)) {
+    throw new Error("Model response is missing a recommendations array");
+  }
+  return payload.recommendations.filter((recommendation) => recommendation.name?.trim()).map((recommendation) => ({
+    name: recommendation.name.trim(),
+    reason: recommendation.reason?.trim()
+  }));
+}
+function getAssistantText(messages) {
+  const assistantMessage = [...messages].reverse().find((message) => message.info.role === "assistant");
+  if (!assistantMessage) {
+    throw new Error("Model session did not return an assistant message");
+  }
+  const text = assistantMessage.parts.filter((part) => part.type === "text").map((part) => part.text ?? "").join(`
+`).trim();
+  if (!text) {
+    throw new Error("Model session did not return assistant text");
+  }
+  return text;
+}
+function mapModelRecommendationsToSkills(skills, recommendations, limit) {
+  const skillByName = new Map;
+  for (const skill of skills) {
+    skillByName.set(normalizeSkillSelector(skill.toolName), skill);
+    skillByName.set(normalizeSkillSelector(skill.name), skill);
+  }
+  const results = [];
+  const seen = new Set;
+  for (const [index, recommendation] of recommendations.entries()) {
+    const skill = skillByName.get(normalizeSkillSelector(recommendation.name));
+    if (!skill || seen.has(skill.toolName)) {
+      continue;
+    }
+    seen.add(skill.toolName);
+    results.push({
+      name: skill.toolName,
+      description: skill.description,
+      score: Math.max(limit - index, 1),
+      reason: recommendation.reason || "Recommended by the configured skill_recommend model"
+    });
+    if (results.length >= limit) {
+      break;
+    }
+  }
+  return results;
+}
+function shouldUseModel(config2, client) {
+  return config2.strategy === "model" && Boolean(client) && config2.model.includes("/");
+}
+function parseConfiguredModel(model) {
+  const trimmedModel = model.trim();
+  const separatorIndex = trimmedModel.indexOf("/");
+  if (separatorIndex <= 0 || separatorIndex === trimmedModel.length - 1) {
+    throw new Error(`Invalid skillRecommend.model: ${model}`);
+  }
+  return {
+    providerID: trimmedModel.slice(0, separatorIndex).trim(),
+    modelID: trimmedModel.slice(separatorIndex + 1).trim()
+  };
+}
+function unwrapClientData(response, action) {
+  if (response.error) {
+    const message = response.error instanceof Error ? response.error.message : String(response.error);
+    throw new Error(`${action} failed: ${message}`);
+  }
+  if (response.data === undefined) {
+    throw new Error(`${action} failed: missing response data`);
+  }
+  return response.data;
+}
+function getModelSessionClient(client) {
+  return client;
+}
+async function getModelRecommendations(provider, options2, task, limit) {
+  if (!options2.client) {
+    throw new Error("Model-based recommendation requires an OpenCode client");
+  }
+  const client = getModelSessionClient(options2.client);
+  const selectedModel = parseConfiguredModel(options2.config.model);
+  const session = unwrapClientData(await client.session.create(), "session.create");
+  try {
+    unwrapClientData(await client.session.chat(session.id, {
+      providerID: selectedModel.providerID,
+      modelID: selectedModel.modelID,
+      parts: [
+        {
+          type: "text",
+          text: buildModelRecommendationPrompt({
+            task,
+            limit,
+            skills: provider.controller.skills
+          })
+        }
+      ],
+      system: options2.config.systemPrompt,
+      tools: {}
+    }), "session.chat");
+    const messages = unwrapClientData(await client.session.messages(session.id), "session.messages");
+    const modelOutput = getAssistantText(messages);
+    const parsedRecommendations = parseModelRecommendations(modelOutput);
+    return mapModelRecommendationsToSkills(provider.controller.skills, parsedRecommendations, limit);
+  } finally {
+    await client.session.delete(session.id).catch(() => {
+      return;
+    });
+  }
+}
+function createSkillRecommender(provider, options2) {
   return async (args) => {
     await provider.controller.ready.whenReady();
     const limit = Math.max(1, Math.min(args.limit ?? DEFAULT_RECOMMENDATION_LIMIT, 10));
-    const parsedQuery = parseQuery(args.task);
-    const rankingTerms = parsedQuery.include.filter((term) => term.length >= MIN_TERM_LENGTH);
-    const rankedMatches = provider.controller.skills.map((skill) => rankSkill(skill, rankingTerms)).filter((ranking) => ranking.totalScore > 0).sort((left, right) => {
-      if (right.totalScore !== left.totalScore) {
-        return right.totalScore - left.totalScore;
-      }
-      if (right.nameMatches !== left.nameMatches) {
-        return right.nameMatches - left.nameMatches;
+    if (shouldUseModel(options2.config, options2.client)) {
+      try {
+        const modelRecommendations = await getModelRecommendations(provider, options2, args.task, limit);
+        return formatResults(provider, args.task, modelRecommendations);
+      } catch (error45) {
+        provider.logger.warn("Model-based skill_recommend failed; falling back to heuristic ranking.", error45);
       }
-      return left.skill.name.localeCompare(right.skill.name);
-    });
-    const topMatches = rankedMatches.slice(0, limit);
-    const recommendations = topMatches.map((skill) => {
-      return {
-        name: skill.skill.toolName,
-        description: skill.skill.description,
-        score: skill.totalScore,
-        reason: getRecommendationReason(skill.nameMatches, skill.descMatches)
-      };
-    });
-    return {
-      mode: "recommend",
-      query: args.task,
-      skills: recommendations.map(({ name, description }) => ({
-        name,
-        description
-      })),
-      recommendations,
-      guidance: recommendations.length > 0 ? "Use skill_use to load one of the recommended skills if you want to apply it." : "No strong skill recommendation was found. Try skill_find with a narrower query.",
-      summary: {
-        total: provider.controller.skills.length,
-        matches: recommendations.length,
-        feedback: recommendations.length > 0 ? `Recommended ${recommendations.length} skill(s) for: **${args.task}**` : `No strong recommendations found for: **${args.task}**`
-      },
-      debug: provider.debug
-    };
+    }
+    return formatResults(provider, args.task, getHeuristicRecommendations(provider, args.task, limit));
   };
 }
 
@@ -17809,7 +17969,7 @@ function normalizeSkillResourcePath(inputPath) {
 }
 function getSkillResources(skill) {
   const resources = new Map;
-  for (const resourceMap of [skill.references, skill.scripts, skill.assets]) {
+  for (const resourceMap of [skill.files, skill.references, skill.scripts, skill.assets]) {
     for (const [relativePath, resource] of resourceMap.entries()) {
       resources.set(normalizeSkillResourcePath(relativePath), resource);
     }
@@ -17968,6 +18128,12 @@ function formatLoadedSkill(args) {
   }
   output.push("", "Relative file references in this skill resolve from the skill root directory.");
   output.push("Use skill_resource with the exact root-relative path when you need a linked file.");
+  if (args.skill.files.size > 0) {
+    output.push("", "### Available files", "");
+    for (const relativePath of Array.from(args.skill.files.keys()).sort()) {
+      output.push(`- ${relativePath}`);
+    }
+  }
   if (linkedResources.length > 0) {
     output.push("", "### Linked files", "");
     for (const link of linkedResources) {
@@ -17980,7 +18146,7 @@ function formatLoadedSkill(args) {
 }
 
 // src/tools/Skill.ts
-function normalizeSkillSelector(selector) {
+function normalizeSkillSelector2(selector) {
   return selector.trim().toLowerCase().replace(/[/-]/g, "_");
 }
 function findSkill(registry2, selector) {
@@ -17988,9 +18154,9 @@ function findSkill(registry2, selector) {
   if (directMatch) {
     return directMatch;
   }
-  const normalizedSelector = normalizeSkillSelector(selector);
+  const normalizedSelector = normalizeSkillSelector2(selector);
   for (const skill of registry2.controller.skills) {
-    if (normalizeSkillSelector(skill.name) === normalizedSelector || normalizeSkillSelector(skill.toolName) === normalizedSelector) {
+    if (normalizeSkillSelector2(skill.name) === normalizedSelector || normalizeSkillSelector2(skill.toolName) === normalizedSelector) {
       return skill;
     }
   }
@@ -18020,7 +18186,7 @@ function createSkillTool(registry2) {
 }
 
 // src/tools/SkillUser.ts
-function normalizeSkillSelector2(selector) {
+function normalizeSkillSelector3(selector) {
   return selector.trim().toLowerCase().replace(/[/-]/g, "_");
 }
 function createSkillLoader(provider) {
@@ -18030,8 +18196,8 @@ function createSkillLoader(provider) {
     const loaded = [];
     const notFound = [];
     for (const name of skillNames) {
-      const normalizedName = normalizeSkillSelector2(name);
-      const skill = registry2.get(name) ?? registry2.skills.find((candidate) => normalizeSkillSelector2(candidate.name) === normalizedName || normalizeSkillSelector2(candidate.toolName) === normalizedName);
+      const normalizedName = normalizeSkillSelector3(name);
+      const skill = registry2.get(name) ?? registry2.skills.find((candidate) => normalizeSkillSelector3(candidate.name) === normalizedName || normalizeSkillSelector3(candidate.toolName) === normalizedName);
       if (skill) {
         loaded.push(skill);
       } else {
@@ -18047,7 +18213,7 @@ function createSkillLoader(provider) {
 }
 
 // src/api.ts
-var createApi = async (config2) => {
+var createApi = async (config2, client) => {
   const logger = createLogger(config2);
   const registry2 = await createSkillRegistry(config2, logger);
   return {
@@ -18055,7 +18221,10 @@ var createApi = async (config2) => {
     logger,
     config: config2,
     findSkills: createSkillFinder(registry2),
-    recommendSkills: createSkillRecommender(registry2),
+    recommendSkills: createSkillRecommender(registry2, {
+      client,
+      config: config2.skillRecommend
+    }),
     readResource: createSkillResourceReader(registry2),
     loadSkill: createSkillLoader(registry2),
     skillTool: createSkillTool(registry2)
@@ -18063,7 +18232,7 @@ var createApi = async (config2) => {
 };
 
 // node_modules/bunfig/dist/index.js
-import { existsSync as existsSync2, statSync } from "fs";
+import { existsSync as existsSync2, statSync as statSync2 } from "fs";
 import { existsSync as existsSync8, mkdirSync as mkdirSync3, readdirSync as readdirSync3, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname3, resolve as resolve7 } from "path";
@@ -18185,7 +18354,7 @@ class ConfigCache {
       if (!existsSync2(configPath)) {
         return true;
       }
-      const stats = statSync(configPath);
+      const stats = statSync2(configPath);
       return stats.mtime > cachedTimestamp;
     } catch {
       return true;
@@ -18204,7 +18373,7 @@ class ConfigCache {
   }
   setWithFileCheck(configName, value, configPath, customTtl) {
     try {
-      const stats = existsSync2(configPath) ? statSync(configPath) : null;
+      const stats = existsSync2(configPath) ? statSync2(configPath) : null;
       const fileTimestamp = stats ? stats.mtime : new Date;
       this.set(configName, { value, fileTimestamp }, configPath, customTtl);
     } catch {
@@ -22307,8 +22476,8 @@ class ConfigFileLoader {
   }
   async getFileModificationTime(filePath) {
     try {
-      const { statSync: statSync2 } = await import("fs");
-      const stats = statSync2(filePath);
+      const { statSync: statSync22 } = await import("fs");
+      const stats = statSync22(filePath);
       return stats.mtime;
     } catch {
       return null;
@@ -23114,8 +23283,46 @@ var defaultConfigDir3 = resolve7(process12.cwd(), "config");
 var defaultGeneratedDir3 = resolve7(process12.cwd(), "src/generated");
 
 // src/config.ts
+import { access as access3, mkdir as mkdir3, readFile, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import { dirname as dirname6, isAbsolute as isAbsolute2, join as join4, normalize, resolve as resolve8 } from "path";
+var DEFAULT_RESERVED_SLASH_COMMANDS = [
+  "agent",
+  "agents",
+  "compact",
+  "connect",
+  "details",
+  "editor",
+  "exit",
+  "export",
+  "fork",
+  "help",
+  "init",
+  "mcp",
+  "model",
+  "models",
+  "new",
+  "open",
+  "redo",
+  "sessions",
+  "share",
+  "skills",
+  "terminal",
+  "themes",
+  "thinking",
+  "undo",
+  "unshare"
+];
+var DEFAULT_SKILL_RECOMMEND_SYSTEM_PROMPT = [
+  "You are selecting the most relevant dynamic skills for a user request.",
+  "Return strict JSON only with this shape:",
+  '{"recommendations":[{"name":"skill_tool_name","reason":"why it matches"}]}',
+  "Only recommend skills from the provided catalog.",
+  "Prefer the smallest set of high-confidence matches."
+].join(" ");
+var MANAGED_PLUGIN_CONFIG_DIRECTORY = join4(homedir3(), ".config", "opencode");
+var MANAGED_PLUGIN_JSONC_FILENAME = "opencode-dynamic-skills.config.jsonc";
+var MANAGED_PLUGIN_JSON_FILENAME = "opencode-dynamic-skills.config.json";
 function getOpenCodeConfigPaths() {
   const home = homedir3();
   const paths = [];
@@ -23206,34 +23413,278 @@ var defaultSkillBasePaths = [
   join4(homedir3(), ".claude", "skills"),
   join4(homedir3(), ".agents", "skills")
 ];
-var options2 = {
-  name: "opencode-dynamic-skills",
-  cwd: "./",
-  defaultConfig: {
+function createDefaultSkillRecommendConfig() {
+  return {
+    strategy: "heuristic",
+    model: "",
+    systemPrompt: DEFAULT_SKILL_RECOMMEND_SYSTEM_PROMPT
+  };
+}
+function createDefaultNotificationConfig() {
+  return {
+    enabled: false,
+    success: true,
+    errors: true
+  };
+}
+function createDefaultPluginConfig() {
+  return {
     debug: false,
     basePaths: defaultSkillBasePaths,
-    promptRenderer: "xml",
-    modelRenderers: {},
     slashCommandName: "skill",
-    enableSkillAliases: true
+    enableSkillAliases: true,
+    reservedSlashCommands: [...DEFAULT_RESERVED_SLASH_COMMANDS],
+    notifications: createDefaultNotificationConfig(),
+    skillRecommend: createDefaultSkillRecommendConfig()
+  };
+}
+function createConfigOptions(defaultConfig3) {
+  return {
+    name: "opencode-dynamic-skills",
+    cwd: "./",
+    defaultConfig: defaultConfig3
+  };
+}
+function stripJsonComments(input) {
+  let output = "";
+  let inString = false;
+  let escaped = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let index = 0;index < input.length; index += 1) {
+    const current = input[index] ?? "";
+    const next = input[index + 1] ?? "";
+    if (inLineComment) {
+      if (current === `
+` || current === "\r") {
+        inLineComment = false;
+        output += current;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (current === "*" && next === "/") {
+        inBlockComment = false;
+        index += 1;
+        continue;
+      }
+      if (current === `
+` || current === "\r") {
+        output += current;
+      }
+      continue;
+    }
+    if (inString) {
+      output += current;
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (current === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (current === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (current === "/" && next === "/") {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      inBlockComment = true;
+      index += 1;
+      continue;
+    }
+    if (current === '"') {
+      inString = true;
+    }
+    output += current;
   }
-};
+  return output;
+}
+function removeTrailingJsonCommas(input) {
+  let output = "";
+  let inString = false;
+  let escaped = false;
+  for (let index = 0;index < input.length; index += 1) {
+    const current = input[index] ?? "";
+    if (inString) {
+      output += current;
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (current === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (current === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (current === '"') {
+      inString = true;
+      output += current;
+      continue;
+    }
+    if (current === ",") {
+      let lookahead = index + 1;
+      while (lookahead < input.length && /\s/.test(input[lookahead] ?? "")) {
+        lookahead += 1;
+      }
+      const nextToken = input[lookahead];
+      if (nextToken === "}" || nextToken === "]") {
+        continue;
+      }
+    }
+    output += current;
+  }
+  return output;
+}
+function parseJsonc(input) {
+  return JSON.parse(removeTrailingJsonCommas(stripJsonComments(input)));
+}
+function trimString(value) {
+  return value?.trim() ?? "";
+}
+function mergePluginConfig(baseConfig, override) {
+  const skillRecommend = {
+    ...baseConfig.skillRecommend,
+    ...override.skillRecommend
+  };
+  const notifications = {
+    ...baseConfig.notifications,
+    ...override.notifications
+  };
+  const overrideReservedSlashCommands = override.reservedSlashCommands?.map((command) => trimString(command)).filter(Boolean) ?? [];
+  return {
+    ...baseConfig,
+    ...override,
+    skillRecommend: {
+      strategy: skillRecommend.strategy === "model" ? "model" : "heuristic",
+      model: trimString(skillRecommend.model),
+      systemPrompt: trimString(skillRecommend.systemPrompt) || DEFAULT_SKILL_RECOMMEND_SYSTEM_PROMPT
+    },
+    reservedSlashCommands: overrideReservedSlashCommands.length > 0 ? overrideReservedSlashCommands : baseConfig.reservedSlashCommands,
+    notifications: {
+      enabled: notifications.enabled === true,
+      success: notifications.success !== false,
+      errors: notifications.errors !== false
+    }
+  };
+}
+function getManagedPluginConfigPaths(configDirectory = MANAGED_PLUGIN_CONFIG_DIRECTORY) {
+  return [
+    join4(configDirectory, MANAGED_PLUGIN_JSONC_FILENAME),
+    join4(configDirectory, MANAGED_PLUGIN_JSON_FILENAME)
+  ];
+}
+async function fileExists(filePath) {
+  try {
+    await access3(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function renderManagedPluginConfigJsonc(config3 = createDefaultPluginConfig()) {
+  const basePaths = config3.basePaths.map((basePath) => `    ${JSON.stringify(basePath)}`).join(`,
+`);
+  return [
+    "{",
+    "  // Enable verbose plugin logging output.",
+    `  "debug": ${JSON.stringify(config3.debug)},`,
+    "",
+    "  // Global skill roots. Project-local .opencode/.claude/.agents paths are appended automatically.",
+    '  "basePaths": [',
+    basePaths,
+    "  ],",
+    "",
+    "  // Explicit slash entrypoint, for example: /skill git-release",
+    `  "slashCommandName": ${JSON.stringify(config3.slashCommandName)},`,
+    "",
+    "  // When true, /<skill-name> alias invocations can be intercepted after submit.",
+    `  "enableSkillAliases": ${JSON.stringify(config3.enableSkillAliases)},`,
+    "",
+    "  // Builtin or protected slash commands that should never be intercepted as /<skill-name> aliases.",
+    '  "reservedSlashCommands": [',
+    config3.reservedSlashCommands.map((command) => `    ${JSON.stringify(command)}`).join(`,
+`),
+    "  ],",
+    "",
+    "  // Best-effort OS notifications triggered by this plugin.",
+    '  "notifications": {',
+    `    "enabled": ${JSON.stringify(config3.notifications.enabled)},`,
+    `    "success": ${JSON.stringify(config3.notifications.success)},`,
+    `    "errors": ${JSON.stringify(config3.notifications.errors)}`,
+    "  },",
+    "",
+    '  // skill_recommend strategy. Set strategy to "model" and fill model with provider/model to use an internal LLM call.',
+    '  "skillRecommend": {',
+    `    "strategy": ${JSON.stringify(config3.skillRecommend.strategy)},`,
+    "    // Model format: provider/model, for example openai/gpt-5.2",
+    `    "model": ${JSON.stringify(config3.skillRecommend.model)},`,
+    '    // The model must return strict JSON: {"recommendations":[{"name":"skill_tool_name","reason":"why it matches"}]}',
+    `    "systemPrompt": ${JSON.stringify(config3.skillRecommend.systemPrompt)}`,
+    "  }",
+    "}",
+    ""
+  ].join(`
+`);
+}
+async function ensureManagedPluginConfigFile(configDirectory = MANAGED_PLUGIN_CONFIG_DIRECTORY) {
+  for (const candidatePath of getManagedPluginConfigPaths(configDirectory)) {
+    if (await fileExists(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  await mkdir3(configDirectory, { recursive: true });
+  const configPath = join4(configDirectory, MANAGED_PLUGIN_JSONC_FILENAME);
+  await writeFile3(configPath, renderManagedPluginConfigJsonc(), "utf8");
+  return configPath;
+}
+async function loadManagedPluginConfig(configDirectory = MANAGED_PLUGIN_CONFIG_DIRECTORY) {
+  for (const candidatePath of getManagedPluginConfigPaths(configDirectory)) {
+    if (!await fileExists(candidatePath)) {
+      continue;
+    }
+    const content = await readFile(candidatePath, "utf8");
+    if (candidatePath.endsWith(".jsonc")) {
+      return parseJsonc(content);
+    }
+    return JSON.parse(content);
+  }
+  return {};
+}
 async function getPluginConfig(ctx) {
-  const resolvedConfig = await loadConfig5(options2);
+  const defaultConfig3 = createDefaultPluginConfig();
+  await ensureManagedPluginConfigFile();
+  const managedConfig = await loadManagedPluginConfig();
+  const resolvedConfig = await loadConfig5(createConfigOptions(defaultConfig3));
+  const mergedConfig = mergePluginConfig(mergePluginConfig(defaultConfig3, managedConfig), resolvedConfig);
   const configuredBasePaths = [
-    ...resolvedConfig.basePaths,
+    ...mergedConfig.basePaths,
     ...getProjectSkillBasePaths(ctx.directory, ctx.worktree)
   ];
-  resolvedConfig.basePaths = normalizeBasePaths(configuredBasePaths, ctx.directory);
-  return resolvedConfig;
+  mergedConfig.basePaths = normalizeBasePaths(configuredBasePaths, ctx.directory);
+  return mergedConfig;
 }
 
 // src/commands/SlashCommand.ts
 var SLASH_COMMAND_SENTINEL = "<!-- opencode-dynamic-skills:slash-expanded -->";
 var RECOMMEND_COMMAND_SENTINEL = "<!-- opencode-dynamic-skills:skill-recommend-expanded -->";
-function normalizeSkillSelector3(selector) {
+function normalizeSkillSelector4(selector) {
   return selector.trim().toLowerCase().replace(/[/-]/g, "_");
 }
+function isReservedSlashCommand(invocationName, reservedSlashCommands) {
+  const normalizedInvocationName = invocationName.trim().toLowerCase();
+  return reservedSlashCommands.some((reservedCommand) => reservedCommand.trim().toLowerCase() === normalizedInvocationName);
+}
 function parseSlashCommand(text, slashCommandName) {
   const trimmedText = text.trim();
   if (!trimmedText.startsWith("/")) {
@@ -23268,12 +23719,12 @@ function findSkillBySelector(registry2, selector) {
   if (directMatch) {
     return directMatch;
   }
-  const normalizedSelector = normalizeSkillSelector3(selector);
+  const normalizedSelector = normalizeSkillSelector4(selector);
   for (const skill of registry2.controller.skills) {
-    if (normalizeSkillSelector3(skill.toolName) === normalizedSelector) {
+    if (normalizeSkillSelector4(skill.toolName) === normalizedSelector) {
       return skill;
     }
-    if (normalizeSkillSelector3(skill.name) === normalizedSelector) {
+    if (normalizeSkillSelector4(skill.name) === normalizedSelector) {
       return skill;
     }
   }
@@ -23328,6 +23779,9 @@ async function rewriteSlashCommandText(args) {
   if (isAliasInvocation && !args.enableSkillAliases) {
     return null;
   }
+  if (isAliasInvocation && isReservedSlashCommand(parsedCommand.invocationName, args.reservedSlashCommands ?? [])) {
+    return null;
+  }
   await args.registry.controller.ready.whenReady();
   const skill = findSkillBySelector(args.registry, parsedCommand.skillSelector);
   if (!skill) {
@@ -23340,26 +23794,6 @@ async function rewriteSlashCommandText(args) {
   });
 }
 
-// src/lib/renderers/JsonPromptRenderer.ts
-var createJsonPromptRenderer = () => {
-  const renderer = {
-    format: "json",
-    render(args) {
-      if (args.type === "Skill") {
-        return JSON.stringify({
-          Skill: {
-            ...args.data,
-            linkedResources: extractSkillLinks(args.data.content),
-            skillRootInstruction: "Resolve linked files relative to the skill root and use skill_resource with the exact root-relative path."
-          }
-        }, null, 2);
-      }
-      return JSON.stringify({ [args.type]: args.data }, null, 2);
-    }
-  };
-  return renderer;
-};
-
 // src/lib/xml.ts
 function escapeXml(str2) {
   return String(str2).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
@@ -23413,6 +23847,7 @@ var createXmlPromptRenderer = () => {
       ...skill,
       linkedResources: extractSkillLinks(skill.content),
       skillRootInstruction: "Resolve linked files relative to the skill root and use skill_resource with the exact root-relative path.",
+      files: resourceMapToArray(skill.files),
       references: resourceMapToArray(skill.references),
       scripts: resourceMapToArray(skill.scripts),
       assets: resourceMapToArray(skill.assets)
@@ -23443,362 +23878,120 @@ var createXmlPromptRenderer = () => {
   return renderer;
 };
 
-// node_modules/dedent/dist/dedent.mjs
-function ownKeys(object2, enumerableOnly) {
-  var keys = Object.keys(object2);
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object2);
-    enumerableOnly && (symbols = symbols.filter(function(sym) {
-      return Object.getOwnPropertyDescriptor(object2, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
-  }
-  return keys;
-}
-function _objectSpread(target) {
-  for (var i = 1;i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-    i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
-      _defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-    });
-  }
-  return target;
+// src/services/Notifier.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var NOTIFICATION_TITLE = "OpenCode Dynamic Skills";
+function createDefaultRunner() {
+  return async (command, args) => {
+    await execFileAsync(command, args);
+  };
 }
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
-  } else {
-    obj[key] = value;
+function truncateNotificationText(value, maxLength = 180) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) {
+    return normalized;
   }
-  return obj;
+  return `${normalized.slice(0, maxLength - 1)}\u2026`;
 }
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-  return typeof key === "symbol" ? key : String(key);
+function escapeAppleScript(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
 }
-function _toPrimitive(input, hint) {
-  if (typeof input !== "object" || input === null)
-    return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || "default");
-    if (typeof res !== "object")
-      return res;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
-  }
-  return (hint === "string" ? String : Number)(input);
-}
-var dedent = createDedent({});
-var dedent_default = dedent;
-function createDedent(options3) {
-  dedent2.withOptions = (newOptions) => createDedent(_objectSpread(_objectSpread({}, options3), newOptions));
-  return dedent2;
-  function dedent2(strings, ...values) {
-    const raw = typeof strings === "string" ? [strings] : strings.raw;
-    const {
-      alignValues = false,
-      escapeSpecialCharacters = Array.isArray(strings),
-      trimWhitespace = true
-    } = options3;
-    let result = "";
-    for (let i = 0;i < raw.length; i++) {
-      let next = raw[i];
-      if (escapeSpecialCharacters) {
-        next = next.replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`").replace(/\\\$/g, "$").replace(/\\\{/g, "{");
-      }
-      result += next;
-      if (i < values.length) {
-        const value = alignValues ? alignValue(values[i], result) : values[i];
-        result += value;
-      }
-    }
-    const lines = result.split(`
-`);
-    let mindent = null;
-    for (const l of lines) {
-      const m = l.match(/^(\s+)\S+/);
-      if (m) {
-        const indent = m[1].length;
-        if (!mindent) {
-          mindent = indent;
-        } else {
-          mindent = Math.min(mindent, indent);
-        }
-      }
-    }
-    if (mindent !== null) {
-      const m = mindent;
-      result = lines.map((l) => l[0] === " " || l[0] === "\t" ? l.slice(m) : l).join(`
-`);
-    }
-    if (trimWhitespace) {
-      result = result.trim();
-    }
-    if (escapeSpecialCharacters) {
-      result = result.replace(/\\n/g, `
-`).replace(/\\t/g, "\t").replace(/\\r/g, "\r").replace(/\\v/g, "\v").replace(/\\b/g, "\b").replace(/\\f/g, "\f").replace(/\\0/g, "\x00").replace(/\\x([\da-fA-F]{2})/g, (_, h) => String.fromCharCode(parseInt(h, 16))).replace(/\\u\{([\da-fA-F]{1,6})\}/g, (_, h) => String.fromCodePoint(parseInt(h, 16))).replace(/\\u([\da-fA-F]{4})/g, (_, h) => String.fromCharCode(parseInt(h, 16)));
-    }
-    if (typeof Bun !== "undefined") {
-      result = result.replace(/\\u(?:\{([\da-fA-F]{1,6})\}|([\da-fA-F]{4}))/g, (_, braced, unbraced) => {
-        var _ref;
-        const hex3 = (_ref = braced !== null && braced !== undefined ? braced : unbraced) !== null && _ref !== undefined ? _ref : "";
-        return String.fromCodePoint(parseInt(hex3, 16));
-      });
-    }
-    return result;
-  }
+function escapeXml2(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
-function alignValue(value, precedingText) {
-  if (typeof value !== "string" || !value.includes(`
-`)) {
-    return value;
-  }
-  const currentLine = precedingText.slice(precedingText.lastIndexOf(`
-`) + 1);
-  const indentMatch = currentLine.match(/^(\s+)/);
-  if (indentMatch) {
-    const indent = indentMatch[1];
-    return value.replace(/\n/g, `
-${indent}`);
+function buildWindowsToastScript(title, message) {
+  const xml = `<toast><visual><binding template='ToastGeneric'><text>${escapeXml2(title)}</text><text>${escapeXml2(message)}</text></binding></visual></toast>`;
+  return [
+    "[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] > $null",
+    "[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime] > $null",
+    "$xml = New-Object Windows.Data.Xml.Dom.XmlDocument",
+    `$xml.LoadXml(@'${xml}'@)`,
+    "$toast = [Windows.UI.Notifications.ToastNotification]::new($xml)",
+    `$notifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('${NOTIFICATION_TITLE}')`,
+    "$notifier.Show($toast)"
+  ].join("; ");
+}
+function getNotificationCommand(platform, title, message) {
+  switch (platform) {
+    case "darwin":
+      return {
+        command: "osascript",
+        args: [
+          "-e",
+          `display notification "${escapeAppleScript(message)}" with title "${escapeAppleScript(title)}"`
+        ]
+      };
+    case "linux":
+      return {
+        command: "notify-send",
+        args: [title, message]
+      };
+    case "win32":
+      return {
+        command: "powershell",
+        args: ["-NoProfile", "-Command", buildWindowsToastScript(title, message)]
+      };
+    default:
+      return null;
   }
-  return value;
 }
-
-// src/lib/renderers/MdPromptRenderer.ts
-var createMdPromptRenderer = () => {
-  const renderObject = (obj, headingLevel, indentLevel = 0) => {
-    const entries = Object.entries(obj);
-    let output = "";
-    for (const [key, value] of entries) {
-      if (value === null || value === undefined) {
-        continue;
-      }
-      const heading = "#".repeat(headingLevel);
-      output += `${heading} ${key}`;
-      if (typeof value === "object" && !Array.isArray(value)) {
-        output += renderObject(value, Math.min(headingLevel + 1, 6), indentLevel);
-      } else if (Array.isArray(value)) {
-        output += renderArray(value, indentLevel);
-      } else {
-        const indent = "  ".repeat(indentLevel);
-        const escapedValue = htmlEscape(String(value));
-        output += `${indent}- **${key}**: *${escapedValue}*`;
-      }
-      output += `
-`;
-    }
-    return output;
-  };
-  const renderArray = (arr, indentLevel) => {
-    const indent = "  ".repeat(indentLevel);
-    let output = "";
-    for (const item of arr) {
-      if (item === null || item === undefined) {
-        continue;
-      }
-      if (typeof item === "object" && !Array.isArray(item)) {
-        const nestedObj = item;
-        for (const [key, value] of Object.entries(nestedObj)) {
-          if (value === null || value === undefined) {
-            continue;
-          }
-          if (typeof value === "object") {
-            if (Array.isArray(value)) {
-              output += `${indent}- **${key}**:
-`;
-              output += renderArray(value, indentLevel + 1);
-            } else {
-              output += `${indent}- **${key}**
-`;
-              output += renderObject(value, 4, indentLevel + 1);
-            }
-          } else {
-            const escapedValue = htmlEscape(String(value));
-            output += `${indent}- **${key}**: *${escapedValue}*
-`;
-          }
-        }
-      } else if (Array.isArray(item)) {
-        output += renderArray(item, indentLevel + 1);
-      } else {
-        const escapedValue = htmlEscape(String(item));
-        output += `${indent}- *${escapedValue}*
-`;
-      }
-    }
-    return output;
-  };
-  const htmlEscape = (value) => {
-    return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-  };
-  const renderSkill = (skill) => {
-    const linkedResources = extractSkillLinks(skill.content);
-    return dedent_default`
-      # ${skill.name}
-
-      > Skill root:
-      > ${skill.fullPath}
-
-      Relative file references in this skill resolve from the skill root directory.
-      Always use skill_resource with the exact root-relative path for linked files.
-
-      ${linkedResources.length > 0 ? dedent_default`
-            ## Linked files detected in skill content
-
-            ${linkedResources.map((link) => `- [${link.label}](${link.originalPath}) \u2192 use skill_resource with ${link.resourcePath}`).join(`
-`)}
-          ` : ""}
-
-      ${skill.content}
-
-      ## Metadata
-
-      ${skill.metadata ? renderObject(skill.metadata, 3) : ""}
- 
-      ## References
-
-      ${skill.references ? renderArray(resourceMapToArray(skill.references), 1) : ""}
-
-      ## Scripts
-
-      ${skill.scripts ? renderArray(resourceMapToArray(skill.scripts), 1) : ""}
-
-      ## Assets
-
-      ${skill.assets ? renderArray(resourceMapToArray(skill.assets), 1) : ""}
-    `;
-  };
-  const renderResource = (resource) => {
-    return renderObject(resource, 3);
-  };
-  const renderSearchResult = (result) => {
-    return renderObject(result, 3);
-  };
-  const renderer = {
-    format: "md",
-    render(args) {
-      if (args.type === "Skill") {
-        return renderSkill(args.data);
-      }
-      if (args.type === "SkillResource") {
-        return renderResource(args.data);
-      }
-      if (args.type === "SkillSearchResults") {
-        return renderSearchResult(args.data);
-      }
-      return renderObject({}, 3);
+function createNotifier(args) {
+  const runner = args.shell ?? createDefaultRunner();
+  const platform = args.platform ?? process.platform;
+  async function notify(title, message) {
+    if (!args.config.enabled) {
+      return;
     }
-  };
-  return renderer;
-};
-
-// src/lib/createPromptRenderer.ts
-function createPromptRenderer() {
-  const renderers = {
-    json: createJsonPromptRenderer(),
-    xml: createXmlPromptRenderer(),
-    md: createMdPromptRenderer()
-  };
-  const getFormatter = (format) => {
-    switch (format) {
-      case "json":
-        return renderers.json.render;
-      case "xml":
-        return renderers.xml.render;
-      case "md":
-        return renderers.md.render;
-      default:
-        throw new Error(`Unsupported format: ${format}`);
+    const notificationCommand = getNotificationCommand(platform, truncateNotificationText(title, 80), truncateNotificationText(message));
+    if (!notificationCommand) {
+      args.logger.debug("Notifications are not supported on this platform.", platform);
+      return;
     }
-  };
-  return {
-    getFormatter
-  };
-}
-
-// src/lib/getModelFormat.ts
-function getModelFormat(args) {
-  const { modelId, providerId, config: config3 } = args;
-  const modelRenderers = config3.modelRenderers ?? {};
-  if (providerId && modelId) {
-    const combinedKey = `${providerId}-${modelId}`;
-    if (combinedKey in modelRenderers) {
-      return modelRenderers[combinedKey];
+    try {
+      await runner(notificationCommand.command, notificationCommand.args);
+    } catch (error45) {
+      args.logger.warn("Failed to send notification.", error45);
     }
   }
-  if (modelId && modelId in modelRenderers) {
-    return modelRenderers[modelId];
-  }
-  return config3.promptRenderer;
-}
-
-// src/services/MessageModelIdAccountant.ts
-function createMessageModelIdAccountant() {
-  const modelUsage = new Map;
-  const track = (info) => {
-    if (!modelUsage.has(info.sessionID)) {
-      modelUsage.set(info.sessionID, {});
-    }
-    const sessionMap = modelUsage.get(info.sessionID);
-    sessionMap[info.messageID] = {
-      modelID: info.modelID,
-      providerID: info.providerID
-    };
-  };
-  const untrackMessage = (args) => {
-    const sessionMap = modelUsage.get(args.sessionID);
-    if (sessionMap && sessionMap[args.messageID]) {
-      delete sessionMap[args.messageID];
-      if (Object.keys(sessionMap).length === 0) {
-        modelUsage.delete(args.sessionID);
+  return {
+    async skillLoaded(skillNames) {
+      if (!args.config.success || skillNames.length === 0) {
+        return;
       }
+      const count = skillNames.length;
+      const message = count === 1 ? `Injected skill: ${skillNames[0]}` : `Injected ${count} skills: ${skillNames.join(", ")}`;
+      await notify(NOTIFICATION_TITLE, message);
+    },
+    async resourceLoaded(skillName, relativePath) {
+      if (!args.config.success) {
+        return;
+      }
+      await notify(NOTIFICATION_TITLE, `Injected ${relativePath} from ${skillName}`);
+    },
+    async error(title, message) {
+      if (!args.config.errors) {
+        return;
+      }
+      await notify(title, message);
     }
   };
-  const untrackSession = (sessionID) => {
-    modelUsage.delete(sessionID);
-  };
-  const getModelInfo = (args) => {
-    const sessionMap = modelUsage.get(args.sessionID);
-    return sessionMap ? sessionMap[args.messageID] : undefined;
-  };
-  const reset3 = () => {
-    modelUsage.clear();
-  };
-  return {
-    reset: reset3,
-    track,
-    untrackMessage,
-    untrackSession,
-    getModelInfo
-  };
 }
 
 // src/index.ts
 var SkillsPlugin = async (ctx) => {
   const config3 = await getPluginConfig(ctx);
-  const api2 = await createApi(config3);
+  const api2 = await createApi(config3, ctx.client);
   const sendPrompt = createInstructionInjector(ctx);
-  const promptRenderer = createPromptRenderer();
-  const modelIdAccountant = createMessageModelIdAccountant();
+  const renderer = createXmlPromptRenderer().render;
+  const notifier = createNotifier({
+    config: config3.notifications,
+    logger: api2.logger
+  });
   api2.registry.initialise();
   return {
-    "chat.message": async (input, output) => {
-      if (input.messageID && input.model?.providerID && input.model?.modelID) {
-        modelIdAccountant.track({
-          messageID: input.messageID,
-          providerID: input.model.providerID,
-          modelID: input.model.modelID,
-          sessionID: input.sessionID
-        });
-      }
-      const format = getModelFormat({
-        modelId: input.model?.modelID,
-        providerId: input.model?.providerID,
-        config: config3
-      });
-      promptRenderer.getFormatter(format);
+    "chat.message": async (_input, output) => {
       for (const part of output.parts) {
         if (part.type !== "text") {
           continue;
@@ -23812,22 +24005,24 @@ var SkillsPlugin = async (ctx) => {
           text: part.text,
           registry: api2.registry,
           slashCommandName: config3.slashCommandName,
-          enableSkillAliases: config3.enableSkillAliases
+          enableSkillAliases: config3.enableSkillAliases,
+          reservedSlashCommands: config3.reservedSlashCommands
         });
         if (!rewrittenText) {
           continue;
         }
         part.text = rewrittenText;
+        const parsedSkillName = part.text.match(/\*\*Skill identifier\*\*: ([^\n]+)/)?.[1];
+        if (parsedSkillName) {
+          await notifier.skillLoaded([parsedSkillName]);
+        }
         break;
       }
     },
     async event(args) {
       switch (args.event.type) {
-        case "message.removed":
-          modelIdAccountant.untrackMessage(args.event.properties);
-          break;
-        case "session.deleted":
-          modelIdAccountant.untrackSession(args.event.properties.info.id);
+        case "session.error":
+          await notifier.error("OpenCode session error", "A session error occurred in the current session.");
           break;
       }
     },
@@ -23839,29 +24034,23 @@ var SkillsPlugin = async (ctx) => {
           skill_names: tool.schema.array(tool.schema.string()).describe("An array of skill names to load.")
         },
         execute: async (args, toolCtx) => {
-          const messageID = toolCtx.messageID;
-          const sessionID = toolCtx.sessionID;
-          const modelInfo = modelIdAccountant.getModelInfo({
-            messageID,
-            sessionID
-          });
-          const format = getModelFormat({
-            modelId: modelInfo?.modelID,
-            providerId: modelInfo?.providerID,
-            config: config3
-          });
-          const renderer = promptRenderer.getFormatter(format);
-          const results = await api2.loadSkill(args.skill_names);
-          for await (const skill of results.loaded) {
-            await sendPrompt(renderer({ data: skill, type: "Skill" }), {
-              sessionId: toolCtx.sessionID,
-              agent: toolCtx.agent
+          try {
+            const results = await api2.loadSkill(args.skill_names);
+            for await (const skill of results.loaded) {
+              await sendPrompt(renderer({ data: skill, type: "Skill" }), {
+                sessionId: toolCtx.sessionID,
+                agent: toolCtx.agent
+              });
+            }
+            await notifier.skillLoaded(results.loaded.map((skill) => skill.toolName));
+            return JSON.stringify({
+              loaded: results.loaded.map((skill) => skill.toolName),
+              not_found: results.notFound
             });
+          } catch (error45) {
+            await notifier.error("skill_use failed", error45 instanceof Error ? error45.message : String(error45));
+            throw error45;
           }
-          return JSON.stringify({
-            loaded: results.loaded.map((skill) => skill.toolName),
-            not_found: results.notFound
-          });
         }
       }),
       skill_find: tool({
@@ -23869,19 +24058,7 @@ var SkillsPlugin = async (ctx) => {
         args: {
           query: tool.schema.union([tool.schema.string(), tool.schema.array(tool.schema.string())]).describe("The search query string or array of strings.")
         },
-        execute: async (args, toolCtx) => {
-          const messageID = toolCtx.messageID;
-          const sessionID = toolCtx.sessionID;
-          const modelInfo = modelIdAccountant.getModelInfo({
-            messageID,
-            sessionID
-          });
-          const format = getModelFormat({
-            config: config3,
-            modelId: modelInfo?.modelID,
-            providerId: modelInfo?.providerID
-          });
-          const renderer = promptRenderer.getFormatter(format);
+        execute: async (args) => {
           const results = await api2.findSkills(args);
           const output = renderer({
             data: results,
@@ -23896,19 +24073,7 @@ var SkillsPlugin = async (ctx) => {
           task: tool.schema.string().describe("The task or request to recommend skills for."),
           limit: tool.schema.number().int().min(1).max(10).optional().describe("Maximum number of recommendations to return.")
         },
-        execute: async (args, toolCtx) => {
-          const messageID = toolCtx.messageID;
-          const sessionID = toolCtx.sessionID;
-          const modelInfo = modelIdAccountant.getModelInfo({
-            messageID,
-            sessionID
-          });
-          const format = getModelFormat({
-            config: config3,
-            modelId: modelInfo?.modelID,
-            providerId: modelInfo?.providerID
-          });
-          const renderer = promptRenderer.getFormatter(format);
+        execute: async (args) => {
           const results = await api2.recommendSkills(args);
           return renderer({
             data: results,
@@ -23923,31 +24088,25 @@ var SkillsPlugin = async (ctx) => {
           relative_path: tool.schema.string().describe("The relative path to the resource file within the skill directory.")
         },
         execute: async (args, toolCtx) => {
-          const messageID = toolCtx.messageID;
-          const sessionID = toolCtx.sessionID;
-          const modelInfo = modelIdAccountant.getModelInfo({
-            messageID,
-            sessionID
-          });
-          const format = getModelFormat({
-            config: config3,
-            modelId: modelInfo?.modelID,
-            providerId: modelInfo?.providerID
-          });
-          const renderer = promptRenderer.getFormatter(format);
-          const result = await api2.readResource(args);
-          if (!result.injection) {
-            throw new Error("Failed to read resource");
+          try {
+            const result = await api2.readResource(args);
+            if (!result.injection) {
+              throw new Error("Failed to read resource");
+            }
+            await sendPrompt(renderer({ data: result.injection, type: "SkillResource" }), {
+              sessionId: toolCtx.sessionID,
+              agent: toolCtx.agent
+            });
+            await notifier.resourceLoaded(args.skill_name, result.injection.resource_path);
+            return JSON.stringify({
+              result: "Resource injected successfully",
+              resource_path: result.injection.resource_path,
+              resource_mimetype: result.injection.resource_mimetype
+            });
+          } catch (error45) {
+            await notifier.error("skill_resource failed", error45 instanceof Error ? error45.message : String(error45));
+            throw error45;
           }
-          await sendPrompt(renderer({ data: result.injection, type: "SkillResource" }), {
-            sessionId: toolCtx.sessionID,
-            agent: toolCtx.agent
-          });
-          return JSON.stringify({
-            result: "Resource injected successfully",
-            resource_path: result.injection.resource_path,
-            resource_mimetype: result.injection.resource_mimetype
-          });
         }
       })
     }