opencode-dynamic-skills 1.1.0 → 1.3.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);
     }
@@ -17899,6 +18059,9 @@ function createSkillResourceReader(provider) {
   };
 }
 
+// src/lib/formatLoadedSkill.ts
+import path3 from "path";
+
 // src/lib/SkillLinks.ts
 import path2 from "path";
 var SCHEME_PATTERN = /^[a-z][a-z0-9+.-]*:/i;
@@ -17952,11 +18115,116 @@ function extractSkillLinks(content) {
 }
 
 // src/lib/formatLoadedSkill.ts
-function formatLoadedSkill(args) {
-  const linkedResources = extractSkillLinks(args.skill.content);
+var MAX_REFERENCE_DEPTH = 3;
+function normalizeSkillResourcePath2(inputPath) {
+  const unixPath = inputPath.replace(/\\/g, "/").trim();
+  if (unixPath.length === 0 || unixPath.startsWith("/")) {
+    return null;
+  }
+  const normalizedPath = path3.posix.normalize(unixPath).replace(/^\.\//, "");
+  if (normalizedPath.length === 0 || normalizedPath === "." || normalizedPath.startsWith("../") || normalizedPath.includes("/../")) {
+    return null;
+  }
+  return normalizedPath;
+}
+function buildSkillResourceIndex(skill) {
+  const resources = new Map;
+  const basenameIndex = new Map;
+  for (const resourceMap of [skill.files, skill.references, skill.scripts, skill.assets]) {
+    for (const [relativePath, resource] of resourceMap.entries()) {
+      const normalizedPath = normalizeSkillResourcePath2(relativePath);
+      if (!normalizedPath) {
+        continue;
+      }
+      const resolvedResource = {
+        relativePath: normalizedPath,
+        absolutePath: resource.absolutePath,
+        mimeType: resource.mimeType
+      };
+      resources.set(normalizedPath, resolvedResource);
+      const basename2 = path3.posix.basename(normalizedPath);
+      const basenameMatches = basenameIndex.get(basename2) ?? [];
+      basenameMatches.push(resolvedResource);
+      basenameIndex.set(basename2, basenameMatches);
+    }
+  }
+  return {
+    resources,
+    basenameIndex
+  };
+}
+function resolveReferencedSkillResource(resourceIndex, resourcePath) {
+  const normalizedPath = normalizeSkillResourcePath2(resourcePath);
+  if (!normalizedPath) {
+    return null;
+  }
+  const { resources, basenameIndex } = resourceIndex;
+  const exactMatch = resources.get(normalizedPath);
+  if (exactMatch) {
+    return exactMatch;
+  }
+  const basenameMatches = basenameIndex.get(path3.posix.basename(normalizedPath)) ?? [];
+  return basenameMatches.length === 1 ? basenameMatches[0] : null;
+}
+async function collectReferencedSkillFiles(args) {
+  const depth = args.depth ?? 0;
+  const visited = args.visited ?? new Set;
+  if (depth >= MAX_REFERENCE_DEPTH) {
+    return [];
+  }
+  const referencedFiles = [];
+  for (const link of extractSkillLinks(args.content)) {
+    const resolvedResource = resolveReferencedSkillResource(args.resourceIndex, link.resourcePath);
+    if (!resolvedResource || visited.has(resolvedResource.relativePath)) {
+      continue;
+    }
+    visited.add(resolvedResource.relativePath);
+    const fileContent = await readSkillFile(resolvedResource.absolutePath);
+    referencedFiles.push({
+      ...resolvedResource,
+      content: fileContent
+    });
+    const nestedReferences = await collectReferencedSkillFiles({
+      skill: args.skill,
+      content: fileContent,
+      resourceIndex: args.resourceIndex,
+      depth: depth + 1,
+      visited
+    });
+    referencedFiles.push(...nestedReferences);
+  }
+  return referencedFiles;
+}
+function formatExpandedReferences(references) {
+  if (references.length === 0) {
+    return [];
+  }
+  const output = ["", "### Expanded referenced skill files", ""];
+  for (const reference of references) {
+    output.push(`#### ${reference.relativePath}`);
+    output.push(`**Absolute path**: ${reference.absolutePath}`);
+    output.push(`**MIME type**: ${reference.mimeType}`);
+    output.push("");
+    output.push("````text");
+    output.push(reference.content.trim());
+    output.push("````");
+    output.push("");
+  }
+  return output;
+}
+async function formatLoadedSkill(args) {
+  const invocationName = args.invocationName ?? args.skill.name;
+  const normalizedSkillRoot = `${args.skill.fullPath.replace(/\\/g, "/")}/`;
+  const resourceIndex = buildSkillResourceIndex(args.skill);
+  const referencedFiles = await collectReferencedSkillFiles({
+    skill: args.skill,
+    content: args.skill.content,
+    resourceIndex
+  });
   const output = [
-    `## Skill: ${args.skill.name}`,
+    `# /${invocationName} Command`,
     "",
+    `**Description**: ${args.skill.description}`,
     `**Skill identifier**: ${args.skill.toolName}`,
     `**Base directory**: ${args.skill.fullPath}`
   ];
@@ -17966,21 +18234,28 @@ function formatLoadedSkill(args) {
   if (args.userMessage?.trim()) {
     output.push(`**User request**: ${args.userMessage.trim()}`);
   }
-  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 (linkedResources.length > 0) {
-    output.push("", "### Linked files", "");
-    for (const link of linkedResources) {
-      output.push(`- ${link.originalPath} -> ${link.resourcePath}`);
+  output.push("", "---", "", "## Command Instructions", "");
+  output.push("<skill-instruction>");
+  output.push(`Base directory for this skill: ${normalizedSkillRoot}`);
+  output.push("File references (@path), markdown links, and relative file mentions in this skill resolve from the skill root.");
+  output.push("Use skill_resource with the exact root-relative path if you need additional files beyond the expanded references below.");
+  output.push("", args.skill.content, "</skill-instruction>");
+  if (args.skill.files.size > 0) {
+    output.push("", "### Available files", "");
+    for (const relativePath of Array.from(args.skill.files.keys()).sort()) {
+      output.push(`- ${relativePath}`);
     }
   }
-  output.push("", args.skill.content);
+  output.push(...formatExpandedReferences(referencedFiles));
+  if (args.userMessage?.trim()) {
+    output.push("", "<user-request>", args.userMessage.trim(), "</user-request>");
+  }
   return output.join(`
 `);
 }
 
 // src/tools/Skill.ts
-function normalizeSkillSelector(selector) {
+function normalizeSkillSelector2(selector) {
   return selector.trim().toLowerCase().replace(/[/-]/g, "_");
 }
 function findSkill(registry2, selector) {
@@ -17988,9 +18263,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;
     }
   }
@@ -18010,7 +18285,7 @@ function createSkillTool(registry2) {
         const available = registry2.controller.skills.map((entry) => entry.name).join(", ");
         throw new Error(`Skill "${args.name}" not found. Available: ${available || "none"}`);
       }
-      return formatLoadedSkill({
+      return await formatLoadedSkill({
         skill,
         invocationName: args.name.replace(/^\//, ""),
         userMessage: args.user_message
@@ -18020,7 +18295,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 +18305,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 +18322,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 +18330,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 +18341,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 +18463,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 +18482,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 {
@@ -18524,10 +18802,10 @@ async function loadConfig({
 var defaultConfigDir = resolve(process3.cwd(), "config");
 var defaultGeneratedDir = resolve(process3.cwd(), "src/generated");
 function getProjectRoot(filePath, options2 = {}) {
-  let path3 = process2.cwd();
-  while (path3.includes("storage"))
-    path3 = resolve2(path3, "..");
-  const finalPath = resolve2(path3, filePath || "");
+  let path4 = process2.cwd();
+  while (path4.includes("storage"))
+    path4 = resolve2(path4, "..");
+  const finalPath = resolve2(path4, filePath || "");
   if (options2?.relative)
     return relative3(process2.cwd(), finalPath);
   return finalPath;
@@ -19974,10 +20252,10 @@ function applyEnvVarsToConfig(name, config3, verbose = false) {
     return config3;
   const envPrefix = name.toUpperCase().replace(/-/g, "_");
   const result = { ...config3 };
-  function processObject(obj, path3 = []) {
+  function processObject(obj, path4 = []) {
     const result2 = { ...obj };
     for (const [key, value] of Object.entries(obj)) {
-      const envPath = [...path3, key];
+      const envPath = [...path4, key];
       const formatKey = (k) => k.replace(/([A-Z])/g, "_$1").toUpperCase();
       const envKey = `${envPrefix}_${envPath.map(formatKey).join("_")}`;
       const oldEnvKey = `${envPrefix}_${envPath.map((p) => p.toUpperCase()).join("_")}`;
@@ -20159,10 +20437,10 @@ async function loadConfig3({
 var defaultConfigDir2 = resolve3(process6.cwd(), "config");
 var defaultGeneratedDir2 = resolve3(process6.cwd(), "src/generated");
 function getProjectRoot2(filePath, options2 = {}) {
-  let path3 = process7.cwd();
-  while (path3.includes("storage"))
-    path3 = resolve4(path3, "..");
-  const finalPath = resolve4(path3, filePath || "");
+  let path4 = process7.cwd();
+  while (path4.includes("storage"))
+    path4 = resolve4(path4, "..");
+  const finalPath = resolve4(path4, filePath || "");
   if (options2?.relative)
     return relative2(process7.cwd(), finalPath);
   return finalPath;
@@ -21599,10 +21877,10 @@ class EnvVarError extends BunfigError {
 
 class FileSystemError extends BunfigError {
   code = "FILE_SYSTEM_ERROR";
-  constructor(operation, path3, cause) {
-    super(`File system ${operation} failed for "${path3}": ${cause.message}`, {
+  constructor(operation, path4, cause) {
+    super(`File system ${operation} failed for "${path4}": ${cause.message}`, {
       operation,
-      path: path3,
+      path: path4,
       originalError: cause.name,
       originalMessage: cause.message
     });
@@ -21675,8 +21953,8 @@ var ErrorFactory = {
   envVar(envKey, envValue, expectedType, configName) {
     return new EnvVarError(envKey, envValue, expectedType, configName);
   },
-  fileSystem(operation, path3, cause) {
-    return new FileSystemError(operation, path3, cause);
+  fileSystem(operation, path4, cause) {
+    return new FileSystemError(operation, path4, cause);
   },
   typeGeneration(configDir, outputPath, cause) {
     return new TypeGenerationError(configDir, outputPath, cause);
@@ -21812,9 +22090,9 @@ class EnvProcessor {
     }
     return key.replace(/([A-Z])/g, "_$1").toUpperCase();
   }
-  processObject(obj, path3, envPrefix, options2) {
+  processObject(obj, path4, envPrefix, options2) {
     for (const [key, value] of Object.entries(obj)) {
-      const envPath = [...path3, key];
+      const envPath = [...path4, key];
       const formattedKeys = envPath.map((k) => this.formatEnvKey(k, options2.useCamelCase));
       const envKey = `${envPrefix}_${formattedKeys.join("_")}`;
       const oldEnvKey = options2.useBackwardCompatibility ? `${envPrefix}_${envPath.map((p) => p.toUpperCase()).join("_")}` : null;
@@ -21899,9 +22177,9 @@ class EnvProcessor {
         return this.formatAsText(envVars, configName);
     }
   }
-  extractEnvVarInfo(obj, path3, prefix, envVars) {
+  extractEnvVarInfo(obj, path4, prefix, envVars) {
     for (const [key, value] of Object.entries(obj)) {
-      const envPath = [...path3, key];
+      const envPath = [...path4, key];
       const envKey = `${prefix}_${envPath.map((k) => this.formatEnvKey(k, true)).join("_")}`;
       if (typeof value === "object" && value !== null && !Array.isArray(value)) {
         this.extractEnvVarInfo(value, envPath, prefix, envVars);
@@ -22307,8 +22585,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;
@@ -22316,15 +22594,15 @@ class ConfigFileLoader {
   }
   async preloadConfigurations(configPaths, options2 = {}) {
     const preloaded = new Map;
-    await Promise.allSettled(configPaths.map(async (path3) => {
+    await Promise.allSettled(configPaths.map(async (path4) => {
       try {
-        const result = await this.loadFromPath(path3, {}, options2);
+        const result = await this.loadFromPath(path4, {}, options2);
         if (result) {
-          preloaded.set(path3, result.config);
+          preloaded.set(path4, result.config);
         }
       } catch (error45) {
         if (options2.verbose) {
-          console.warn(`Failed to preload ${path3}:`, error45);
+          console.warn(`Failed to preload ${path4}:`, error45);
         }
       }
     }));
@@ -22403,13 +22681,13 @@ class ConfigValidator {
       warnings
     };
   }
-  validateObjectAgainstSchema(value, schema, path3, errors3, warnings, options2) {
+  validateObjectAgainstSchema(value, schema, path4, errors3, warnings, options2) {
     if (options2.validateTypes && schema.type) {
       const actualType = Array.isArray(value) ? "array" : typeof value;
       const expectedTypes = Array.isArray(schema.type) ? schema.type : [schema.type];
       if (!expectedTypes.includes(actualType)) {
         errors3.push({
-          path: path3,
+          path: path4,
           message: `Expected type ${expectedTypes.join(" or ")}, got ${actualType}`,
           expected: expectedTypes.join(" or "),
           actual: actualType,
@@ -22421,7 +22699,7 @@ class ConfigValidator {
     }
     if (schema.enum && !schema.enum.includes(value)) {
       errors3.push({
-        path: path3,
+        path: path4,
         message: `Value must be one of: ${schema.enum.join(", ")}`,
         expected: schema.enum.join(", "),
         actual: value,
@@ -22433,7 +22711,7 @@ class ConfigValidator {
     if (typeof value === "string") {
       if (schema.minLength !== undefined && value.length < schema.minLength) {
         errors3.push({
-          path: path3,
+          path: path4,
           message: `String length must be at least ${schema.minLength}`,
           expected: `>= ${schema.minLength}`,
           actual: value.length,
@@ -22442,7 +22720,7 @@ class ConfigValidator {
       }
       if (schema.maxLength !== undefined && value.length > schema.maxLength) {
         errors3.push({
-          path: path3,
+          path: path4,
           message: `String length must not exceed ${schema.maxLength}`,
           expected: `<= ${schema.maxLength}`,
           actual: value.length,
@@ -22453,7 +22731,7 @@ class ConfigValidator {
         const regex = new RegExp(schema.pattern);
         if (!regex.test(value)) {
           errors3.push({
-            path: path3,
+            path: path4,
             message: `String does not match pattern ${schema.pattern}`,
             expected: schema.pattern,
             actual: value,
@@ -22465,7 +22743,7 @@ class ConfigValidator {
     if (typeof value === "number") {
       if (schema.minimum !== undefined && value < schema.minimum) {
         errors3.push({
-          path: path3,
+          path: path4,
           message: `Value must be at least ${schema.minimum}`,
           expected: `>= ${schema.minimum}`,
           actual: value,
@@ -22474,7 +22752,7 @@ class ConfigValidator {
       }
       if (schema.maximum !== undefined && value > schema.maximum) {
         errors3.push({
-          path: path3,
+          path: path4,
           message: `Value must not exceed ${schema.maximum}`,
           expected: `<= ${schema.maximum}`,
           actual: value,
@@ -22484,7 +22762,7 @@ class ConfigValidator {
     }
     if (Array.isArray(value) && schema.items) {
       for (let i = 0;i < value.length; i++) {
-        const itemPath = path3 ? `${path3}[${i}]` : `[${i}]`;
+        const itemPath = path4 ? `${path4}[${i}]` : `[${i}]`;
         this.validateObjectAgainstSchema(value[i], schema.items, itemPath, errors3, warnings, options2);
         if (options2.stopOnFirstError && errors3.length > 0)
           return;
@@ -22496,7 +22774,7 @@ class ConfigValidator {
         for (const requiredProp of schema.required) {
           if (!(requiredProp in obj)) {
             errors3.push({
-              path: path3 ? `${path3}.${requiredProp}` : requiredProp,
+              path: path4 ? `${path4}.${requiredProp}` : requiredProp,
               message: `Missing required property '${requiredProp}'`,
               expected: "required",
               rule: "required"
@@ -22509,7 +22787,7 @@ class ConfigValidator {
       if (schema.properties) {
         for (const [propName, propSchema] of Object.entries(schema.properties)) {
           if (propName in obj) {
-            const propPath = path3 ? `${path3}.${propName}` : propName;
+            const propPath = path4 ? `${path4}.${propName}` : propName;
             this.validateObjectAgainstSchema(obj[propName], propSchema, propPath, errors3, warnings, options2);
             if (options2.stopOnFirstError && errors3.length > 0)
               return;
@@ -22521,7 +22799,7 @@ class ConfigValidator {
         for (const propName of Object.keys(obj)) {
           if (!allowedProps.has(propName)) {
             warnings.push({
-              path: path3 ? `${path3}.${propName}` : propName,
+              path: path4 ? `${path4}.${propName}` : propName,
               message: `Additional property '${propName}' is not allowed`,
               rule: "additionalProperties"
             });
@@ -22555,12 +22833,12 @@ class ConfigValidator {
       warnings
     };
   }
-  validateWithRule(value, rule, path3) {
+  validateWithRule(value, rule, path4) {
     const errors3 = [];
     if (rule.required && (value === undefined || value === null)) {
       errors3.push({
-        path: path3,
-        message: rule.message || `Property '${path3}' is required`,
+        path: path4,
+        message: rule.message || `Property '${path4}' is required`,
         expected: "required",
         rule: "required"
       });
@@ -22573,7 +22851,7 @@ class ConfigValidator {
       const actualType = Array.isArray(value) ? "array" : typeof value;
       if (actualType !== rule.type) {
         errors3.push({
-          path: path3,
+          path: path4,
           message: rule.message || `Expected type ${rule.type}, got ${actualType}`,
           expected: rule.type,
           actual: actualType,
@@ -22585,7 +22863,7 @@ class ConfigValidator {
       const length = Array.isArray(value) ? value.length : typeof value === "string" ? value.length : typeof value === "number" ? value : 0;
       if (length < rule.min) {
         errors3.push({
-          path: path3,
+          path: path4,
           message: rule.message || `Value must be at least ${rule.min}`,
           expected: `>= ${rule.min}`,
           actual: length,
@@ -22597,7 +22875,7 @@ class ConfigValidator {
       const length = Array.isArray(value) ? value.length : typeof value === "string" ? value.length : typeof value === "number" ? value : 0;
       if (length > rule.max) {
         errors3.push({
-          path: path3,
+          path: path4,
           message: rule.message || `Value must not exceed ${rule.max}`,
           expected: `<= ${rule.max}`,
           actual: length,
@@ -22608,7 +22886,7 @@ class ConfigValidator {
     if (rule.pattern && typeof value === "string") {
       if (!rule.pattern.test(value)) {
         errors3.push({
-          path: path3,
+          path: path4,
           message: rule.message || `Value does not match pattern ${rule.pattern}`,
           expected: rule.pattern.toString(),
           actual: value,
@@ -22618,7 +22896,7 @@ class ConfigValidator {
     }
     if (rule.enum && !rule.enum.includes(value)) {
       errors3.push({
-        path: path3,
+        path: path4,
         message: rule.message || `Value must be one of: ${rule.enum.join(", ")}`,
         expected: rule.enum.join(", "),
         actual: value,
@@ -22629,7 +22907,7 @@ class ConfigValidator {
       const customError = rule.validator(value);
       if (customError) {
         errors3.push({
-          path: path3,
+          path: path4,
           message: rule.message || customError,
           rule: "custom"
         });
@@ -22637,10 +22915,10 @@ class ConfigValidator {
     }
     return errors3;
   }
-  getValueByPath(obj, path3) {
-    if (!path3)
+  getValueByPath(obj, path4) {
+    if (!path4)
       return obj;
-    const keys = path3.split(".");
+    const keys = path4.split(".");
     let current = obj;
     for (const key of keys) {
       if (current && typeof current === "object" && key in current) {
@@ -23066,10 +23344,10 @@ async function loadConfig5(options2) {
 function applyEnvVarsToConfig2(name, config4, verbose = false) {
   const _envProcessor = new EnvProcessor;
   const envPrefix = name.toUpperCase().replace(/[^A-Z0-9]/g, "_");
-  function processConfigLevel(obj, path3 = []) {
+  function processConfigLevel(obj, path4 = []) {
     const result = { ...obj };
     for (const [key, value] of Object.entries(obj)) {
-      const currentPath = [...path3, key];
+      const currentPath = [...path4, key];
       const envKeys = [
         `${envPrefix}_${currentPath.join("_").toUpperCase()}`,
         `${envPrefix}_${currentPath.map((k) => k.toUpperCase()).join("")}`,
@@ -23114,8 +23392,47 @@ 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_TUI_COMMANDS_DIRECTORY = join4(MANAGED_PLUGIN_CONFIG_DIRECTORY, "commands");
+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 = [];
@@ -23135,14 +23452,14 @@ function getOpenCodeConfigPaths() {
   paths.push(join4(home, ".opencode"));
   return paths;
 }
-function expandTildePath(path3) {
-  if (path3 === "~") {
+function expandTildePath(path4) {
+  if (path4 === "~") {
     return homedir3();
   }
-  if (path3.startsWith("~/")) {
-    return join4(homedir3(), path3.slice(2));
+  if (path4.startsWith("~/")) {
+    return join4(homedir3(), path4.slice(2));
   }
-  return path3;
+  return path4;
 }
 var createPathKey = (absolutePath) => {
   const normalizedPath = normalize(absolutePath);
@@ -23206,34 +23523,303 @@ 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 createDefaultTuiCommandMirrorConfig() {
+  return {
+    enabled: true,
+    directory: MANAGED_TUI_COMMANDS_DIRECTORY
+  };
+}
+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(),
+    tuiCommandMirror: createDefaultTuiCommandMirrorConfig()
+  };
+}
+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 tuiCommandMirror = {
+    ...baseConfig.tuiCommandMirror,
+    ...override.tuiCommandMirror
+  };
+  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
+    },
+    tuiCommandMirror: {
+      enabled: tuiCommandMirror.enabled === true,
+      directory: trimString(tuiCommandMirror.directory) || MANAGED_TUI_COMMANDS_DIRECTORY
+    }
+  };
+}
+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)}`,
+    "  },",
+    "",
+    "  // TUI compatibility layer. Enabled by default so dynamic skills are mirrored as proxy command files and can appear in TUI slash autocomplete after restart.",
+    '  "tuiCommandMirror": {',
+    `    "enabled": ${JSON.stringify(config3.tuiCommandMirror.enabled)},`,
+    `    "directory": ${JSON.stringify(config3.tuiCommandMirror.directory)}`,
+    "  }",
+    "}",
+    ""
+  ].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);
+  mergedConfig.tuiCommandMirror = {
+    enabled: mergedConfig.tuiCommandMirror.enabled,
+    directory: resolveBasePath(mergedConfig.tuiCommandMirror.directory, 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,21 +23854,21 @@ 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;
     }
   }
   return null;
 }
-function renderSlashSkillPrompt(args) {
+async function renderSlashSkillPrompt(args) {
   return [
     SLASH_COMMAND_SENTINEL,
-    formatLoadedSkill({
+    await formatLoadedSkill({
       invocationName: args.invocationName,
       skill: args.skill,
       userMessage: args.userPrompt || "Apply this skill to the current request."
@@ -23328,37 +23914,40 @@ 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) {
     return null;
   }
-  return renderSlashSkillPrompt({
+  return await renderSlashSkillPrompt({
     invocationName: parsedCommand.invocationName,
     skill,
     userPrompt: parsedCommand.userPrompt
   });
 }
 
-// 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/commands/MirroredSkillCommand.ts
+async function rewriteMirroredSkillCommandParts(args) {
+  if (!args.mirroredCommands.has(args.commandName)) {
+    return false;
+  }
+  await args.registry.controller.ready.whenReady();
+  const skill = findSkillBySelector(args.registry, args.commandName);
+  if (!skill) {
+    return false;
+  }
+  const preservedParts = args.output.parts.filter((part) => part.type !== "text");
+  const text = await formatLoadedSkill({
+    skill,
+    invocationName: args.commandName,
+    userMessage: args.commandArguments
+  });
+  args.output.parts = [{ type: "text", text }, ...preservedParts];
+  return true;
+}
 
 // src/lib/xml.ts
 function escapeXml(str2) {
@@ -23413,6 +24002,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 +24033,244 @@ 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 += `
-`;
+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 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}*
-`;
-      }
+    const notificationCommand = getNotificationCommand(platform, truncateNotificationText(title, 80), truncateNotificationText(message));
+    if (!notificationCommand) {
+      args.logger.debug("Notifications are not supported on this platform.", platform);
+      return;
     }
-    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);
+    try {
+      await runner(notificationCommand.command, notificationCommand.args);
+    } catch (error45) {
+      args.logger.warn("Failed to send notification.", error45);
+    }
+  }
+  return {
+    async skillLoaded(skillNames) {
+      if (!args.config.success || skillNames.length === 0) {
+        return;
       }
-      if (args.type === "SkillResource") {
-        return renderResource(args.data);
+      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;
       }
-      if (args.type === "SkillSearchResults") {
-        return renderSearchResult(args.data);
+      await notify(NOTIFICATION_TITLE, `Injected ${relativePath} from ${skillName}`);
+    },
+    async error(title, message) {
+      if (!args.config.errors) {
+        return;
       }
-      return renderObject({}, 3);
+      await notify(title, message);
     }
   };
-  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}`);
-    }
-  };
-  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];
-    }
-  }
-  if (modelId && modelId in modelRenderers) {
-    return modelRenderers[modelId];
-  }
-  return config3.promptRenderer;
+// src/services/TuiCommandMirror.ts
+import { mkdir as mkdir5, readdir as readdir3, readFile as readFile2, rm, writeFile as writeFile5 } from "fs/promises";
+import { join as join6 } from "path";
+var SHADOW_COMMAND_MARKER = "<!-- opencode-dynamic-skills:tui-command-mirror -->";
+function normalizeName(name) {
+  return name.trim().toLowerCase();
 }
-
-// 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
+function isManagedShadowCommand(content) {
+  return content.includes(SHADOW_COMMAND_MARKER);
+}
+function renderShadowCommandFile(skill) {
+  return [
+    "---",
+    `description: ${JSON.stringify(skill.description)}`,
+    "---",
+    "",
+    SHADOW_COMMAND_MARKER,
+    `Dynamic skill proxy for ${skill.name}.`,
+    "This file is managed by opencode-dynamic-skills so OpenCode TUI can surface the skill as a slash command.",
+    "The plugin replaces this template before execution.",
+    "",
+    "$ARGUMENTS",
+    ""
+  ].join(`
+`);
+}
+async function syncTuiCommandMirror(args) {
+  if (!args.enabled) {
+    return {
+      mirrored: [],
+      written: [],
+      skipped: [],
+      removed: []
     };
-  };
-  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);
+  }
+  await mkdir5(args.directory, { recursive: true });
+  const reservedCommands = new Set(args.reservedSlashCommands.map(normalizeName));
+  const mirrored = [];
+  const written = [];
+  const skipped = [];
+  const removed = [];
+  const desiredNames = new Set;
+  for (const skill of args.skills) {
+    const normalizedSkillName = normalizeName(skill.name);
+    if (reservedCommands.has(normalizedSkillName)) {
+      skipped.push(skill.name);
+      continue;
+    }
+    desiredNames.add(normalizedSkillName);
+    const commandPath = join6(args.directory, `${skill.name}.md`);
+    const renderedCommand = renderShadowCommandFile(skill);
+    try {
+      const existingContent = await readFile2(commandPath, "utf8");
+      if (!isManagedShadowCommand(existingContent)) {
+        skipped.push(skill.name);
+        continue;
+      }
+      if (existingContent === renderedCommand) {
+        mirrored.push(skill.name);
+        continue;
       }
+    } catch {}
+    await writeFile5(commandPath, renderedCommand, "utf8");
+    mirrored.push(skill.name);
+    written.push(skill.name);
+  }
+  for (const entry of await readdir3(args.directory, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      continue;
     }
-  };
-  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();
-  };
+    const commandPath = join6(args.directory, entry.name);
+    const content = await readFile2(commandPath, "utf8").catch(() => "");
+    if (!isManagedShadowCommand(content)) {
+      continue;
+    }
+    const name = entry.name.replace(/\.md$/i, "");
+    if (desiredNames.has(normalizeName(name))) {
+      continue;
+    }
+    await rm(commandPath, { force: true });
+    removed.push(name);
+  }
+  args.logger.debug("[OpenCodeDynamicSkills] TUI command mirror synced", {
+    directory: args.directory,
+    mirrored,
+    written,
+    removed,
+    skipped
+  });
   return {
-    reset: reset3,
-    track,
-    untrackMessage,
-    untrackSession,
-    getModelInfo
+    mirrored,
+    written,
+    skipped,
+    removed
   };
 }
 
 // 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();
-  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 renderXmlPrompt = createXmlPromptRenderer().render;
+  const notifier = createNotifier({
+    config: config3.notifications,
+    logger: api2.logger
+  });
+  const mirroredSkillCommands = new Set;
+  const registryInitialisation = api2.registry.initialise();
+  if (config3.tuiCommandMirror.enabled) {
+    try {
+      await registryInitialisation;
+      const mirrorResult = await syncTuiCommandMirror({
+        skills: api2.registry.controller.skills,
+        directory: config3.tuiCommandMirror.directory,
+        enabled: config3.tuiCommandMirror.enabled,
+        logger: api2.logger,
+        reservedSlashCommands: config3.reservedSlashCommands
+      });
+      for (const commandName of mirrorResult.mirrored) {
+        mirroredSkillCommands.add(commandName);
+      }
+      if (mirrorResult.written.length > 0 || mirrorResult.removed.length > 0) {
+        api2.logger.warn("[OpenCodeDynamicSkills] TUI command mirror updated. Restart OpenCode to refresh slash autocomplete.", {
+          directory: config3.tuiCommandMirror.directory,
+          mirrored: mirrorResult.mirrored,
+          written: mirrorResult.written,
+          removed: mirrorResult.removed,
+          skipped: mirrorResult.skipped
         });
       }
-      const format = getModelFormat({
-        modelId: input.model?.modelID,
-        providerId: input.model?.providerID,
-        config: config3
-      });
-      promptRenderer.getFormatter(format);
+    } catch (error45) {
+      api2.logger.warn("[OpenCodeDynamicSkills] Failed to sync TUI command mirror. Dynamic skills will still work after submit, but TUI slash autocomplete may miss them.", error45 instanceof Error ? error45.message : String(error45));
+    }
+  }
+  return {
+    "chat.message": async (_input, output) => {
       for (const part of output.parts) {
         if (part.type !== "text") {
           continue;
@@ -23812,22 +24284,40 @@ 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;
       }
     },
+    "command.execute.before": async (input, output) => {
+      const rewritten = await rewriteMirroredSkillCommandParts({
+        commandName: input.command,
+        commandArguments: input.arguments,
+        mirroredCommands: mirroredSkillCommands,
+        registry: api2.registry,
+        output
+      });
+      if (!rewritten) {
+        return;
+      }
+      const skill = api2.registry.controller.skills.find((entry) => entry.name === input.command);
+      if (skill) {
+        await notifier.skillLoaded([skill.toolName]);
+      }
+    },
     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 +24329,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(await formatLoadedSkill({ 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,21 +24353,9 @@ 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({
+          const output = renderXmlPrompt({
             data: results,
             type: "SkillSearchResults"
           });
@@ -23896,21 +24368,9 @@ 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({
+          return renderXmlPrompt({
             data: results,
             type: "SkillSearchResults"
           });
@@ -23923,31 +24383,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(renderXmlPrompt({ 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
-          });
         }
       })
     }