opencode-dynamic-skills 1.2.0 → 1.3.0

package/README.md

@@ -143,6 +143,10 @@ Example:
     "model": "openai/gpt-5.2",
     "systemPrompt": "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.",
   },
+  "tuiCommandMirror": {
+    "enabled": true,
+    "directory": "~/.config/opencode/commands",
+  },
 }
 ```
 
@@ -155,6 +159,9 @@ Fields:
 - `reservedSlashCommands`
 - `notifications`
 - `skillRecommend`
+- `tuiCommandMirror`
+
+`tuiCommandMirror` is enabled by default. The plugin mirrors dynamic skills into proxy command files so TUI slash autocomplete can surface `/<skill-name>` after an OpenCode restart.
 
 Injected skill content now always uses a single XML renderer. The previous custom renderer selection feature was removed.
 

package/dist/commands/MirroredSkillCommand.d.ts

@@ -0,0 +1,15 @@
+import type { SkillRegistry } from '../types';
+type HookPart = {
+    type: string;
+    text?: string;
+} & Record<string, unknown>;
+export declare function rewriteMirroredSkillCommandParts(args: {
+    commandName: string;
+    commandArguments: string;
+    mirroredCommands: Set<string>;
+    registry: SkillRegistry;
+    output: {
+        parts: HookPart[];
+    };
+}): Promise<boolean>;
+export {};

package/dist/commands/MirroredSkillCommand.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/SlashCommand.d.ts

@@ -12,7 +12,7 @@ export declare function renderSlashSkillPrompt(args: {
     invocationName: string;
     skill: Skill;
     userPrompt: string;
-}): string;
+}): Promise<string>;
 export declare function renderRecommendSlashPrompt(task: string): string;
 export declare function rewriteRecommendSlashCommandText(text: string): Promise<string | null>;
 export declare function rewriteSlashCommandText(args: {

package/dist/config.d.ts

@@ -1,13 +1,15 @@
 import type { PluginInput } from '@opencode-ai/plugin';
-import type { NotificationConfig, PluginConfig, SkillRecommendConfig } from './types';
+import type { NotificationConfig, PluginConfig, SkillRecommendConfig, TuiCommandMirrorConfig } from './types';
 export declare const DEFAULT_RESERVED_SLASH_COMMANDS: readonly ["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"];
 export declare const DEFAULT_SKILL_RECOMMEND_SYSTEM_PROMPT: string;
 export declare const MANAGED_PLUGIN_CONFIG_DIRECTORY: string;
+export declare const MANAGED_TUI_COMMANDS_DIRECTORY: string;
 export declare const MANAGED_PLUGIN_JSONC_FILENAME = "opencode-dynamic-skills.config.jsonc";
 export declare const MANAGED_PLUGIN_JSON_FILENAME = "opencode-dynamic-skills.config.json";
 type PartialPluginConfig = Partial<Omit<PluginConfig, 'skillRecommend' | 'notifications'>> & {
     skillRecommend?: Partial<SkillRecommendConfig>;
     notifications?: Partial<NotificationConfig>;
+    tuiCommandMirror?: Partial<TuiCommandMirrorConfig>;
 };
 /**
  * Gets OpenCode-compatible config paths for the current platform.
@@ -55,6 +57,7 @@ export declare function normalizeBasePaths(basePaths: string[], projectDirectory
 export declare function getProjectSkillBasePaths(directory: string, worktree?: string): string[];
 export declare function createDefaultSkillRecommendConfig(): SkillRecommendConfig;
 export declare function createDefaultNotificationConfig(): NotificationConfig;
+export declare function createDefaultTuiCommandMirrorConfig(): TuiCommandMirrorConfig;
 export declare function createDefaultPluginConfig(): PluginConfig;
 export declare function stripJsonComments(input: string): string;
 export declare function removeTrailingJsonCommas(input: string): string;

package/dist/index.js

@@ -18059,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;
@@ -18112,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}`
   ];
@@ -18126,21 +18234,22 @@ 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.");
+  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}`);
     }
   }
-  if (linkedResources.length > 0) {
-    output.push("", "### Linked files", "");
-    for (const link of linkedResources) {
-      output.push(`- ${link.originalPath} -> ${link.resourcePath}`);
-    }
+  output.push(...formatExpandedReferences(referencedFiles));
+  if (args.userMessage?.trim()) {
+    output.push("", "<user-request>", args.userMessage.trim(), "</user-request>");
   }
-  output.push("", args.skill.content);
   return output.join(`
 `);
 }
@@ -18176,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
@@ -18693,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;
@@ -20143,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("_")}`;
@@ -20328,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;
@@ -21768,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
     });
@@ -21844,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);
@@ -21981,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;
@@ -22068,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);
@@ -22485,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);
         }
       }
     }));
@@ -22572,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,
@@ -22590,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,
@@ -22602,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,
@@ -22611,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,
@@ -22622,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,
@@ -22634,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,
@@ -22643,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,
@@ -22653,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;
@@ -22665,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"
@@ -22678,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;
@@ -22690,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"
             });
@@ -22724,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"
       });
@@ -22742,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,
@@ -22754,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,
@@ -22766,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,
@@ -22777,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,
@@ -22787,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,
@@ -22798,7 +22907,7 @@ class ConfigValidator {
       const customError = rule.validator(value);
       if (customError) {
         errors3.push({
-          path: path3,
+          path: path4,
           message: rule.message || customError,
           rule: "custom"
         });
@@ -22806,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) {
@@ -23235,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("")}`,
@@ -23321,6 +23430,7 @@ var DEFAULT_SKILL_RECOMMEND_SYSTEM_PROMPT = [
   "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() {
@@ -23342,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);
@@ -23427,6 +23537,12 @@ function createDefaultNotificationConfig() {
     errors: true
   };
 }
+function createDefaultTuiCommandMirrorConfig() {
+  return {
+    enabled: true,
+    directory: MANAGED_TUI_COMMANDS_DIRECTORY
+  };
+}
 function createDefaultPluginConfig() {
   return {
     debug: false,
@@ -23435,7 +23551,8 @@ function createDefaultPluginConfig() {
     enableSkillAliases: true,
     reservedSlashCommands: [...DEFAULT_RESERVED_SLASH_COMMANDS],
     notifications: createDefaultNotificationConfig(),
-    skillRecommend: createDefaultSkillRecommendConfig()
+    skillRecommend: createDefaultSkillRecommendConfig(),
+    tuiCommandMirror: createDefaultTuiCommandMirrorConfig()
   };
 }
 function createConfigOptions(defaultConfig3) {
@@ -23561,6 +23678,10 @@ function mergePluginConfig(baseConfig, override) {
     ...baseConfig.notifications,
     ...override.notifications
   };
+  const tuiCommandMirror = {
+    ...baseConfig.tuiCommandMirror,
+    ...override.tuiCommandMirror
+  };
   const overrideReservedSlashCommands = override.reservedSlashCommands?.map((command) => trimString(command)).filter(Boolean) ?? [];
   return {
     ...baseConfig,
@@ -23575,6 +23696,10 @@ function mergePluginConfig(baseConfig, override) {
       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
     }
   };
 }
@@ -23631,6 +23756,12 @@ function renderManagedPluginConfigJsonc(config3 = createDefaultPluginConfig()) {
     `    "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)}`,
     "  }",
     "}",
     ""
@@ -23672,6 +23803,10 @@ async function getPluginConfig(ctx) {
     ...getProjectSkillBasePaths(ctx.directory, ctx.worktree)
   ];
   mergedConfig.basePaths = normalizeBasePaths(configuredBasePaths, ctx.directory);
+  mergedConfig.tuiCommandMirror = {
+    enabled: mergedConfig.tuiCommandMirror.enabled,
+    directory: resolveBasePath(mergedConfig.tuiCommandMirror.directory, ctx.directory)
+  };
   return mergedConfig;
 }
 
@@ -23730,10 +23865,10 @@ function findSkillBySelector(registry2, selector) {
   }
   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."
@@ -23787,13 +23922,33 @@ async function rewriteSlashCommandText(args) {
   if (!skill) {
     return null;
   }
-  return renderSlashSkillPrompt({
+  return await renderSlashSkillPrompt({
     invocationName: parsedCommand.invocationName,
     skill,
     userPrompt: parsedCommand.userPrompt
   });
 }
 
+// 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) {
   return String(str2).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
@@ -23979,17 +24134,141 @@ function createNotifier(args) {
   };
 }
 
+// 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();
+}
+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: []
+    };
+  }
+  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 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 {
+    mirrored,
+    written,
+    skipped,
+    removed
+  };
+}
+
 // src/index.ts
 var SkillsPlugin = async (ctx) => {
   const config3 = await getPluginConfig(ctx);
   const api2 = await createApi(config3, ctx.client);
   const sendPrompt = createInstructionInjector(ctx);
-  const renderer = createXmlPromptRenderer().render;
+  const renderXmlPrompt = createXmlPromptRenderer().render;
   const notifier = createNotifier({
     config: config3.notifications,
     logger: api2.logger
   });
-  api2.registry.initialise();
+  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
+        });
+      }
+    } 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) {
@@ -24019,6 +24298,22 @@ var SkillsPlugin = async (ctx) => {
         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 "session.error":
@@ -24037,7 +24332,7 @@ var SkillsPlugin = async (ctx) => {
           try {
             const results = await api2.loadSkill(args.skill_names);
             for await (const skill of results.loaded) {
-              await sendPrompt(renderer({ data: skill, type: "Skill" }), {
+              await sendPrompt(await formatLoadedSkill({ skill }), {
                 sessionId: toolCtx.sessionID,
                 agent: toolCtx.agent
               });
@@ -24060,7 +24355,7 @@ var SkillsPlugin = async (ctx) => {
         },
         execute: async (args) => {
           const results = await api2.findSkills(args);
-          const output = renderer({
+          const output = renderXmlPrompt({
             data: results,
             type: "SkillSearchResults"
           });
@@ -24075,7 +24370,7 @@ var SkillsPlugin = async (ctx) => {
         },
         execute: async (args) => {
           const results = await api2.recommendSkills(args);
-          return renderer({
+          return renderXmlPrompt({
             data: results,
             type: "SkillSearchResults"
           });
@@ -24093,7 +24388,7 @@ var SkillsPlugin = async (ctx) => {
             if (!result.injection) {
               throw new Error("Failed to read resource");
             }
-            await sendPrompt(renderer({ data: result.injection, type: "SkillResource" }), {
+            await sendPrompt(renderXmlPrompt({ data: result.injection, type: "SkillResource" }), {
               sessionId: toolCtx.sessionID,
               agent: toolCtx.agent
             });

package/dist/lib/formatLoadedSkill.d.ts

@@ -3,4 +3,4 @@ export declare function formatLoadedSkill(args: {
     skill: Skill;
     invocationName?: string;
     userMessage?: string;
-}): string;
+}): Promise<string>;

package/dist/lib/formatLoadedSkill.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/TuiCommandMirror.d.ts

@@ -0,0 +1,15 @@
+import type { PluginLogger, Skill } from '../types';
+export declare const SHADOW_COMMAND_MARKER = "<!-- opencode-dynamic-skills:tui-command-mirror -->";
+export declare function renderShadowCommandFile(skill: Skill): string;
+export declare function syncTuiCommandMirror(args: {
+    skills: Skill[];
+    directory: string;
+    enabled: boolean;
+    logger: PluginLogger;
+    reservedSlashCommands: string[];
+}): Promise<{
+    mirrored: string[];
+    written: string[];
+    skipped: string[];
+    removed: string[];
+}>;

package/dist/services/TuiCommandMirror.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -159,6 +159,7 @@ export type PluginConfig = {
     reservedSlashCommands: string[];
     notifications: NotificationConfig;
     skillRecommend: SkillRecommendConfig;
+    tuiCommandMirror: TuiCommandMirrorConfig;
 };
 export type NotificationConfig = {
     enabled: boolean;
@@ -170,6 +171,10 @@ export type SkillRecommendConfig = {
     model: string;
     systemPrompt: string;
 };
+export type TuiCommandMirrorConfig = {
+    enabled: boolean;
+    directory: string;
+};
 export type LogType = 'log' | 'debug' | 'error' | 'warn';
 export type PluginLogger = Record<LogType, (...message: unknown[]) => void>;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-dynamic-skills",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "OpenCode plugin for dynamic skill loading, slash skill commands, and skill-root-relative resources",
   "homepage": "https://github.com/Wu-H-Y/opencode-dynamic-skills#readme",
   "bugs": {