agentpacks 0.9.0 → 1.0.0

package/dist/node/api.js

@@ -11,6 +11,7 @@ var TARGET_IDS = [
   "cursor",
   "claudecode",
   "codexcli",
+  "mistralvibe",
   "geminicli",
   "copilot",
   "agentsmd",
@@ -351,6 +352,8 @@ function agentMatchesTarget(agent, targetId) {
 // src/features/skills.ts
 import { readFileSync as readFileSync6, existsSync as existsSync3 } from "fs";
 import { basename as basename4, join as join2 } from "path";
+var SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SKILL_NAME_MAX_LENGTH = 64;
 function parseSkills(skillsDir, packName) {
   const dirs = listDirs(skillsDir);
   const skills = [];
@@ -374,6 +377,59 @@ function parseSkillFile(filepath, skillDir, packName) {
     content
   };
 }
+function buildSkillFrontmatter(skill) {
+  return {
+    ...skill.meta,
+    name: skill.name
+  };
+}
+function serializeSkill(skill) {
+  return serializeFrontmatter(buildSkillFrontmatter(skill), skill.content);
+}
+function normalizeImportedSkillMarkdown(source, skillName) {
+  const { data, content } = parseFrontmatter(source);
+  const normalized = {
+    ...data,
+    name: skillName
+  };
+  let addedDescription = false;
+  const description = normalized.description;
+  if (typeof description !== "string" || description.trim().length === 0) {
+    normalized.description = `Imported skill: ${skillName}`;
+    addedDescription = true;
+  }
+  return {
+    content: serializeFrontmatter(normalized, content),
+    addedDescription
+  };
+}
+function validateAgentSkillsFrontmatter(skill) {
+  const errors = [];
+  const dirName = basename4(skill.sourceDir);
+  const declaredName = skill.meta.name;
+  if (typeof declaredName !== "string" || declaredName.trim().length === 0) {
+    errors.push('Missing required frontmatter field "name".');
+  } else {
+    if (declaredName.length > SKILL_NAME_MAX_LENGTH) {
+      errors.push(`Invalid "name": must be at most ${SKILL_NAME_MAX_LENGTH} characters.`);
+    }
+    if (!SKILL_NAME_PATTERN.test(declaredName)) {
+      errors.push('Invalid "name": use lowercase letters, numbers, and single hyphens only.');
+    }
+    if (declaredName !== dirName) {
+      errors.push(`Invalid "name": must match containing directory "${dirName}".`);
+    }
+  }
+  const description = skill.meta.description;
+  if (typeof description !== "string" || description.trim().length === 0) {
+    errors.push('Missing required frontmatter field "description".');
+  }
+  const allowedTools = skill.meta["allowed-tools"];
+  if (allowedTools !== undefined && (!Array.isArray(allowedTools) || allowedTools.some((tool) => typeof tool !== "string" || tool.length === 0))) {
+    errors.push('Invalid "allowed-tools": expected an array of non-empty strings.');
+  }
+  return errors;
+}
 function skillMatchesTarget(skill, targetId) {
   const { targets } = skill.meta;
   if (!targets || targets === "*")
@@ -1638,7 +1694,7 @@ class OpenCodeTarget extends BaseTarget {
         const skillSubDir = join10(skillDir, skill.name);
         ensureDir(skillSubDir);
         const filepath = join10(skillSubDir, "SKILL.md");
-        writeGeneratedFile(filepath, skill.content);
+        writeGeneratedFile(filepath, serializeSkill(skill));
         filesWritten.push(filepath);
       }
     }
@@ -1893,12 +1949,8 @@ class CursorTarget extends BaseTarget {
       for (const skill of skills) {
         const skillSubDir = join11(skillsDir, skill.name);
         ensureDir(skillSubDir);
-        const frontmatter = {
-          name: skill.name,
-          description: skill.meta.description ?? ""
-        };
         const filepath = join11(skillSubDir, "SKILL.md");
-        const content = serializeFrontmatter(frontmatter, skill.content);
+        const content = serializeSkill(skill);
         writeGeneratedFile(filepath, content);
         filesWritten.push(filepath);
       }
@@ -2198,7 +2250,7 @@ ${content}`;
         const skillSubDir = join12(skillsDir, skill.name);
         ensureDir(skillSubDir);
         const filepath = join12(skillSubDir, "SKILL.md");
-        writeGeneratedFile(filepath, skill.content);
+        writeGeneratedFile(filepath, serializeSkill(skill));
         filesWritten.push(filepath);
       }
     }
@@ -2328,7 +2380,7 @@ class CodexCliTarget extends BaseTarget {
         const skillSubDir = join13(skillsDir, skill.name);
         ensureDir(skillSubDir);
         const filepath = join13(skillSubDir, "SKILL.md");
-        writeGeneratedFile(filepath, skill.content);
+        writeGeneratedFile(filepath, serializeSkill(skill));
         filesWritten.push(filepath);
       }
     }
@@ -2336,12 +2388,168 @@ class CodexCliTarget extends BaseTarget {
   }
 }
 
-// src/targets/gemini-cli.ts
+// src/targets/mistral-vibe.ts
 import { resolve as resolve11, join as join14 } from "path";
-var TARGET_ID5 = "geminicli";
+var TARGET_ID5 = "mistralvibe";
 
-class GeminiCliTarget extends BaseTarget {
+class MistralVibeTarget extends BaseTarget {
   id = TARGET_ID5;
+  name = "Mistral Vibe";
+  supportedFeatures = [
+    "rules",
+    "commands",
+    "agents",
+    "skills",
+    "mcp",
+    "ignore",
+    "models"
+  ];
+  generate(options) {
+    const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
+    const root = resolve11(projectRoot, baseDir);
+    const effective = this.getEffectiveFeatures(enabledFeatures);
+    const filesWritten = [];
+    const filesDeleted = [];
+    const warnings = [];
+    const vibeDir = resolve11(root, ".vibe");
+    ensureDir(vibeDir);
+    if (effective.includes("rules")) {
+      const rulesDir = resolve11(vibeDir, "rules");
+      if (deleteExisting) {
+        removeIfExists(rulesDir);
+        filesDeleted.push(rulesDir);
+      }
+      ensureDir(rulesDir);
+      const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID5));
+      for (const rule of rules) {
+        const filepath = join14(rulesDir, `${rule.name}.md`);
+        writeGeneratedFile(filepath, rule.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("agents")) {
+      const agentsDir = resolve11(vibeDir, "agents");
+      if (deleteExisting) {
+        removeIfExists(agentsDir);
+        filesDeleted.push(agentsDir);
+      }
+      ensureDir(agentsDir);
+      const agents = features.agents.filter((a) => agentMatchesTarget(a, TARGET_ID5));
+      for (const agent of agents) {
+        const filepath = join14(agentsDir, `${agent.name}.md`);
+        writeGeneratedFile(filepath, agent.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("skills")) {
+      const skillsDir = resolve11(vibeDir, "skills");
+      if (deleteExisting) {
+        removeIfExists(skillsDir);
+        filesDeleted.push(skillsDir);
+      }
+      ensureDir(skillsDir);
+      const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID5));
+      for (const skill of skills) {
+        const skillSubDir = join14(skillsDir, skill.name);
+        ensureDir(skillSubDir);
+        const filepath = join14(skillSubDir, "SKILL.md");
+        writeGeneratedFile(filepath, serializeSkill(skill));
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("commands")) {
+      const commandsDir = resolve11(vibeDir, "commands");
+      if (deleteExisting) {
+        removeIfExists(commandsDir);
+        filesDeleted.push(commandsDir);
+      }
+      ensureDir(commandsDir);
+      const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID5));
+      for (const command of commands) {
+        const filepath = join14(commandsDir, `${command.name}.md`);
+        writeGeneratedFile(filepath, command.content);
+        filesWritten.push(filepath);
+      }
+    }
+    let hasMcpConfig = false;
+    if (effective.includes("mcp")) {
+      const mcpEntries = Object.entries(features.mcpServers);
+      if (mcpEntries.length > 0) {
+        const filepath = resolve11(vibeDir, "mcp.json");
+        writeGeneratedJson(filepath, { mcpServers: features.mcpServers }, {
+          header: false
+        });
+        filesWritten.push(filepath);
+        hasMcpConfig = true;
+      }
+    }
+    if (effective.includes("ignore") && features.ignorePatterns.length > 0) {
+      const filepath = resolve11(root, ".vibeignore");
+      writeGeneratedFile(filepath, features.ignorePatterns.join(`
+`) + `
+`);
+      filesWritten.push(filepath);
+    }
+    let defaultModel;
+    let smallModel;
+    if (effective.includes("models") && features.models) {
+      const resolved = resolveModels(features.models, options.modelProfile, TARGET_ID5);
+      defaultModel = resolved.default;
+      smallModel = resolved.small;
+      const guidance = generateModelGuidanceMarkdown(resolved);
+      if (guidance) {
+        const filepath = join14(vibeDir, "model-config.md");
+        writeGeneratedFile(filepath, guidance);
+        filesWritten.push(filepath);
+      }
+    }
+    const vibeConfig = buildVibeConfigToml({
+      hasMcpConfig,
+      defaultModel,
+      smallModel,
+      profile: options.modelProfile
+    });
+    if (vibeConfig.length > 0) {
+      const filepath = resolve11(vibeDir, "config.toml");
+      writeGeneratedFile(filepath, vibeConfig);
+      filesWritten.push(filepath);
+    }
+    return this.createResult(filesWritten, filesDeleted, warnings);
+  }
+}
+function buildVibeConfigToml(options) {
+  const lines = [];
+  if (options.defaultModel || options.smallModel || options.profile) {
+    lines.push("[models]");
+    if (options.defaultModel) {
+      lines.push(`default = "${escapeTomlString(options.defaultModel)}"`);
+    }
+    if (options.smallModel) {
+      lines.push(`small = "${escapeTomlString(options.smallModel)}"`);
+    }
+    if (options.profile) {
+      lines.push(`profile = "${escapeTomlString(options.profile)}"`);
+    }
+    lines.push("");
+  }
+  if (options.hasMcpConfig) {
+    lines.push("[mcp]");
+    lines.push('config_path = ".vibe/mcp.json"');
+    lines.push("");
+  }
+  return lines.join(`
+`).trim();
+}
+function escapeTomlString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+
+// src/targets/gemini-cli.ts
+import { resolve as resolve12, join as join15 } from "path";
+var TARGET_ID6 = "geminicli";
+
+class GeminiCliTarget extends BaseTarget {
+  id = TARGET_ID6;
   name = "Gemini CLI";
   supportedFeatures = [
     "rules",
@@ -2353,49 +2561,49 @@ class GeminiCliTarget extends BaseTarget {
   ];
   generate(options) {
     const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
-    const root = resolve11(projectRoot, baseDir);
+    const root = resolve12(projectRoot, baseDir);
     const effective = this.getEffectiveFeatures(enabledFeatures);
     const filesWritten = [];
     const filesDeleted = [];
     const warnings = [];
-    const geminiDir = resolve11(root, ".gemini");
+    const geminiDir = resolve12(root, ".gemini");
     if (effective.includes("rules")) {
-      const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID5));
+      const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID6));
       const rootRules = getRootRules(rules);
       const detailRules = getDetailRules(rules);
       if (rootRules.length > 0) {
         const geminiMd = rootRules.map((r) => r.content).join(`
 
 `);
-        const filepath = resolve11(root, "GEMINI.md");
+        const filepath = resolve12(root, "GEMINI.md");
         writeGeneratedFile(filepath, geminiMd);
         filesWritten.push(filepath);
       }
       if (detailRules.length > 0) {
-        const memoriesDir = resolve11(geminiDir, "memories");
+        const memoriesDir = resolve12(geminiDir, "memories");
         if (deleteExisting) {
           removeIfExists(memoriesDir);
           filesDeleted.push(memoriesDir);
         }
         ensureDir(memoriesDir);
         for (const rule of detailRules) {
-          const filepath = join14(memoriesDir, `${rule.name}.md`);
+          const filepath = join15(memoriesDir, `${rule.name}.md`);
           writeGeneratedFile(filepath, rule.content);
           filesWritten.push(filepath);
         }
       }
     }
     if (effective.includes("commands")) {
-      const commandsDir = resolve11(geminiDir, "commands");
+      const commandsDir = resolve12(geminiDir, "commands");
       if (deleteExisting) {
         removeIfExists(commandsDir);
         filesDeleted.push(commandsDir);
       }
       ensureDir(commandsDir);
-      const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID5));
+      const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID6));
       for (const cmd of commands) {
         const toml = buildGeminiCommand(cmd.name, cmd.meta.description ?? "", cmd.content);
-        const filepath = join14(commandsDir, `${cmd.name}.toml`);
+        const filepath = join15(commandsDir, `${cmd.name}.toml`);
         writeGeneratedFile(filepath, toml, { type: "md" });
         filesWritten.push(filepath);
       }
@@ -2404,14 +2612,14 @@ class GeminiCliTarget extends BaseTarget {
       const mcpEntries = Object.entries(features.mcpServers);
       if (mcpEntries.length > 0) {
         const settings = buildGeminiSettings(features.mcpServers);
-        const filepath = resolve11(geminiDir, "settings.json");
+        const filepath = resolve12(geminiDir, "settings.json");
         writeGeneratedJson(filepath, settings, { header: false });
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("ignore")) {
       if (features.ignorePatterns.length > 0) {
-        const filepath = resolve11(root, ".geminiignore");
+        const filepath = resolve12(root, ".geminiignore");
         const content = features.ignorePatterns.join(`
 `) + `
 `;
@@ -2450,11 +2658,11 @@ function buildGeminiSettings(servers) {
 }
 
 // src/targets/copilot.ts
-import { resolve as resolve12, join as join15 } from "path";
-var TARGET_ID6 = "copilot";
+import { resolve as resolve13, join as join16 } from "path";
+var TARGET_ID7 = "copilot";
 
 class CopilotTarget extends BaseTarget {
-  id = TARGET_ID6;
+  id = TARGET_ID7;
   name = "GitHub Copilot";
   supportedFeatures = [
     "rules",
@@ -2467,81 +2675,81 @@ class CopilotTarget extends BaseTarget {
   ];
   generate(options) {
     const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
-    const root = resolve12(projectRoot, baseDir);
+    const root = resolve13(projectRoot, baseDir);
     const effective = this.getEffectiveFeatures(enabledFeatures);
     const filesWritten = [];
     const filesDeleted = [];
     const warnings = [];
-    const githubDir = resolve12(root, ".github");
+    const githubDir = resolve13(root, ".github");
     if (effective.includes("rules")) {
-      const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID6));
+      const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID7));
       if (rules.length > 0) {
         const combinedContent = rules.map((r) => r.content).join(`
 
 ---
 
 `);
-        const filepath = resolve12(githubDir, "copilot-instructions.md");
+        const filepath = resolve13(githubDir, "copilot-instructions.md");
         ensureDir(githubDir);
         writeGeneratedFile(filepath, combinedContent);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("agents")) {
-      const copilotDir = resolve12(githubDir, "copilot");
-      const agentsDir = resolve12(copilotDir, "agents");
+      const copilotDir = resolve13(githubDir, "copilot");
+      const agentsDir = resolve13(copilotDir, "agents");
       if (deleteExisting) {
         removeIfExists(agentsDir);
         filesDeleted.push(agentsDir);
       }
       ensureDir(agentsDir);
-      const agents = features.agents.filter((a) => agentMatchesTarget(a, TARGET_ID6));
+      const agents = features.agents.filter((a) => agentMatchesTarget(a, TARGET_ID7));
       for (const agent of agents) {
-        const filepath = join15(agentsDir, `${agent.name}.md`);
+        const filepath = join16(agentsDir, `${agent.name}.md`);
         writeGeneratedFile(filepath, agent.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("skills")) {
-      const copilotDir = resolve12(githubDir, "copilot");
-      const skillsDir = resolve12(copilotDir, "skills");
+      const copilotDir = resolve13(githubDir, "copilot");
+      const skillsDir = resolve13(copilotDir, "skills");
       if (deleteExisting) {
         removeIfExists(skillsDir);
         filesDeleted.push(skillsDir);
       }
       ensureDir(skillsDir);
-      const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID6));
+      const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID7));
       for (const skill of skills) {
-        const skillSubDir = join15(skillsDir, skill.name);
+        const skillSubDir = join16(skillsDir, skill.name);
         ensureDir(skillSubDir);
-        const filepath = join15(skillSubDir, "SKILL.md");
-        writeGeneratedFile(filepath, skill.content);
+        const filepath = join16(skillSubDir, "SKILL.md");
+        writeGeneratedFile(filepath, serializeSkill(skill));
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("commands")) {
-      const copilotDir = resolve12(githubDir, "copilot");
-      const commandsDir = resolve12(copilotDir, "commands");
+      const copilotDir = resolve13(githubDir, "copilot");
+      const commandsDir = resolve13(copilotDir, "commands");
       if (deleteExisting) {
         removeIfExists(commandsDir);
         filesDeleted.push(commandsDir);
       }
       ensureDir(commandsDir);
-      const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID6));
+      const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID7));
       for (const cmd of commands) {
-        const filepath = join15(commandsDir, `${cmd.name}.md`);
+        const filepath = join16(commandsDir, `${cmd.name}.md`);
         writeGeneratedFile(filepath, cmd.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("ignore")) {}
     if (effective.includes("models") && features.models) {
-      const resolved = resolveModels(features.models, options.modelProfile, TARGET_ID6);
+      const resolved = resolveModels(features.models, options.modelProfile, TARGET_ID7);
       const guidance = generateModelGuidanceMarkdown(resolved);
       if (guidance) {
-        const copilotDir = resolve12(githubDir, "copilot");
+        const copilotDir = resolve13(githubDir, "copilot");
         ensureDir(copilotDir);
-        const filepath = join15(copilotDir, "model-config.md");
+        const filepath = join16(copilotDir, "model-config.md");
         writeGeneratedFile(filepath, guidance);
         filesWritten.push(filepath);
       }
@@ -2551,14 +2759,14 @@ class CopilotTarget extends BaseTarget {
 }
 
 // src/targets/agents-md.ts
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 class AgentsMdTarget extends BaseTarget {
   id = "agentsmd";
   name = "AGENTS.md";
   supportedFeatures = ["rules"];
   generate(options) {
     const { projectRoot, baseDir, features } = options;
-    const root = resolve13(projectRoot, baseDir);
+    const root = resolve14(projectRoot, baseDir);
     const filesWritten = [];
     const warnings = [];
     const rootRules = getRootRules(features.rules);
@@ -2570,7 +2778,7 @@ class AgentsMdTarget extends BaseTarget {
     const content = sections.join(`
 
 `);
-    const filepath = resolve13(root, "AGENTS.md");
+    const filepath = resolve14(root, "AGENTS.md");
     writeGeneratedFile(filepath, content);
     filesWritten.push(filepath);
     return this.createResult(filesWritten, [], warnings);
@@ -2578,7 +2786,7 @@ class AgentsMdTarget extends BaseTarget {
 }
 
 // src/targets/generic-md-target.ts
-import { resolve as resolve14, join as join16 } from "path";
+import { resolve as resolve15, join as join17 } from "path";
 function createGenericMdTarget(config) {
   return new GenericMdTarget(config);
 }
@@ -2597,16 +2805,16 @@ class GenericMdTarget extends BaseTarget {
   }
   generate(options) {
     const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
-    const root = resolve14(projectRoot, baseDir);
+    const root = resolve15(projectRoot, baseDir);
     const effective = this.getEffectiveFeatures(enabledFeatures);
     const filesWritten = [];
     const filesDeleted = [];
     const warnings = [];
-    const configDir = resolve14(root, this.config.configDir);
+    const configDir = resolve15(root, this.config.configDir);
     const rulesSubDir = this.config.rulesDir ?? "rules";
     const ext = this.config.ruleExtension ?? ".md";
     if (effective.includes("rules")) {
-      const rulesDir = resolve14(configDir, rulesSubDir);
+      const rulesDir = resolve15(configDir, rulesSubDir);
       if (deleteExisting) {
         removeIfExists(rulesDir);
         filesDeleted.push(rulesDir);
@@ -2614,13 +2822,13 @@ class GenericMdTarget extends BaseTarget {
       ensureDir(rulesDir);
       const rules = features.rules.filter((r) => ruleMatchesTarget(r, this.id));
       for (const rule of rules) {
-        const filepath = join16(rulesDir, `${rule.name}${ext}`);
+        const filepath = join17(rulesDir, `${rule.name}${ext}`);
         writeGeneratedFile(filepath, rule.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("commands")) {
-      const commandsDir = resolve14(configDir, "commands");
+      const commandsDir = resolve15(configDir, "commands");
       if (deleteExisting) {
         removeIfExists(commandsDir);
         filesDeleted.push(commandsDir);
@@ -2628,7 +2836,7 @@ class GenericMdTarget extends BaseTarget {
       ensureDir(commandsDir);
       const commands = features.commands.filter((c) => commandMatchesTarget(c, this.id));
       for (const cmd of commands) {
-        const filepath = join16(commandsDir, `${cmd.name}.md`);
+        const filepath = join17(commandsDir, `${cmd.name}.md`);
         writeGeneratedFile(filepath, cmd.content);
         filesWritten.push(filepath);
       }
@@ -2637,7 +2845,7 @@ class GenericMdTarget extends BaseTarget {
       const mcpEntries = Object.entries(features.mcpServers);
       if (mcpEntries.length > 0) {
         const mcpDir = this.config.mcpInConfigDir ? configDir : root;
-        const filepath = resolve14(mcpDir, "mcp.json");
+        const filepath = resolve15(mcpDir, "mcp.json");
         writeGeneratedJson(filepath, { mcpServers: features.mcpServers }, {
           header: false
         });
@@ -2646,7 +2854,7 @@ class GenericMdTarget extends BaseTarget {
     }
     if (effective.includes("ignore") && this.config.ignoreFile) {
       if (features.ignorePatterns.length > 0) {
-        const filepath = resolve14(root, this.config.ignoreFile);
+        const filepath = resolve15(root, this.config.ignoreFile);
         writeGeneratedFile(filepath, features.ignorePatterns.join(`
 `) + `
 `);
@@ -2658,7 +2866,7 @@ class GenericMdTarget extends BaseTarget {
       const guidance = generateModelGuidanceMarkdown(resolved);
       if (guidance) {
         ensureDir(configDir);
-        const filepath = join16(configDir, "model-config.md");
+        const filepath = join17(configDir, "model-config.md");
         writeGeneratedFile(filepath, guidance);
         filesWritten.push(filepath);
       }
@@ -2770,6 +2978,7 @@ var TARGETS = [
   new CursorTarget,
   new ClaudeCodeTarget,
   new CodexCliTarget,
+  new MistralVibeTarget,
   new GeminiCliTarget,
   new CopilotTarget,
   new AgentsMdTarget,
@@ -2802,12 +3011,12 @@ function listTargetIds() {
 }
 
 // src/exporters/cursor-plugin.ts
-import { resolve as resolve15, join as join17 } from "path";
+import { resolve as resolve16, join as join18 } from "path";
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
 function exportCursorPlugin(pack, outputDir) {
   const filesWritten = [];
   const pluginName = normalizeCursorPluginName(pack.manifest.name);
-  const pluginDir = resolve15(outputDir, pluginName);
+  const pluginDir = resolve16(outputDir, pluginName);
   mkdirSync4(pluginDir, { recursive: true });
   const manifest = {
     name: pluginName
@@ -2838,7 +3047,7 @@ function exportCursorPlugin(pack, outputDir) {
     manifest.keywords = pack.manifest.tags;
   }
   if (pack.rules.length > 0) {
-    const rulesDir = join17(pluginDir, "rules");
+    const rulesDir = join18(pluginDir, "rules");
     ensureDir(rulesDir);
     manifest.rules = "rules";
     for (const rule of pack.rules) {
@@ -2851,13 +3060,13 @@ function exportCursorPlugin(pack, outputDir) {
       if (globs)
         fm.globs = globs;
       const filename = `${rule.name}.mdc`;
-      const filepath = join17(rulesDir, filename);
+      const filepath = join18(rulesDir, filename);
       writeFileSync4(filepath, serializeFrontmatter(fm, rule.content));
       filesWritten.push(filepath);
     }
   }
   if (pack.agents.length > 0) {
-    const agentsDir = join17(pluginDir, "agents");
+    const agentsDir = join18(pluginDir, "agents");
     ensureDir(agentsDir);
     manifest.agents = "agents";
     for (const agent of pack.agents) {
@@ -2866,29 +3075,26 @@ function exportCursorPlugin(pack, outputDir) {
         description: agent.meta.description ?? ""
       };
       const filename = `${agent.name}.md`;
-      const filepath = join17(agentsDir, filename);
+      const filepath = join18(agentsDir, filename);
       writeFileSync4(filepath, serializeFrontmatter(fm, agent.content));
       filesWritten.push(filepath);
     }
   }
   if (pack.skills.length > 0) {
-    const skillsDir = join17(pluginDir, "skills");
+    const skillsDir = join18(pluginDir, "skills");
     ensureDir(skillsDir);
     manifest.skills = "skills";
     for (const skill of pack.skills) {
-      const skillSubDir = join17(skillsDir, skill.name);
+      const skillSubDir = join18(skillsDir, skill.name);
       ensureDir(skillSubDir);
-      const fm = {
-        name: skill.name,
-        description: skill.meta.description ?? ""
-      };
-      const filepath = join17(skillSubDir, "SKILL.md");
-      writeFileSync4(filepath, serializeFrontmatter(fm, skill.content));
+      const filepath = join18(skillSubDir, "SKILL.md");
+      const content = serializeFrontmatter(buildSkillFrontmatter(skill), skill.content);
+      writeFileSync4(filepath, content);
       filesWritten.push(filepath);
     }
   }
   if (pack.commands.length > 0) {
-    const commandsDir = join17(pluginDir, "commands");
+    const commandsDir = join18(pluginDir, "commands");
     ensureDir(commandsDir);
     manifest.commands = "commands";
     for (const cmd of pack.commands) {
@@ -2899,7 +3105,7 @@ function exportCursorPlugin(pack, outputDir) {
         fm.description = cmd.meta.description;
       }
       const filename = `${cmd.name}.md`;
-      const filepath = join17(commandsDir, filename);
+      const filepath = join18(commandsDir, filename);
       writeFileSync4(filepath, serializeFrontmatter(fm, cmd.content));
       filesWritten.push(filepath);
     }
@@ -2907,9 +3113,9 @@ function exportCursorPlugin(pack, outputDir) {
   if (pack.hooks) {
     const events = resolveHooksForTarget(pack.hooks, "cursor");
     if (Object.keys(events).length > 0) {
-      const hooksDir = join17(pluginDir, "hooks");
+      const hooksDir = join18(pluginDir, "hooks");
       ensureDir(hooksDir);
-      const filepath = join17(hooksDir, "hooks.json");
+      const filepath = join18(hooksDir, "hooks.json");
       writeFileSync4(filepath, JSON.stringify({ version: pack.hooks.version ?? 1, hooks: events }, null, 2) + `
 `);
       filesWritten.push(filepath);
@@ -2918,14 +3124,14 @@ function exportCursorPlugin(pack, outputDir) {
   }
   if (pack.mcp && Object.keys(pack.mcp.servers).length > 0) {
     manifest.mcpServers = ".mcp.json";
-    const filepath = join17(pluginDir, ".mcp.json");
+    const filepath = join18(pluginDir, ".mcp.json");
     writeFileSync4(filepath, JSON.stringify({ mcpServers: pack.mcp.servers }, null, 2) + `
 `);
     filesWritten.push(filepath);
   }
-  const manifestDir = join17(pluginDir, ".cursor-plugin");
+  const manifestDir = join18(pluginDir, ".cursor-plugin");
   ensureDir(manifestDir);
-  const manifestPath = join17(manifestDir, "plugin.json");
+  const manifestPath = join18(manifestDir, "plugin.json");
   writeFileSync4(manifestPath, JSON.stringify(manifest, null, 2) + `
 `);
   filesWritten.push(manifestPath);
@@ -2950,10 +3156,10 @@ function toCursorPluginAuthor(author) {
 
 // src/importers/rulesync.ts
 import { existsSync as existsSync10, readFileSync as readFileSync10, copyFileSync, writeFileSync as writeFileSync5 } from "fs";
-import { resolve as resolve16, join as join18, basename as basename6 } from "path";
+import { resolve as resolve17, join as join19, basename as basename6 } from "path";
 import { parse as parseJsonc2 } from "jsonc-parser";
 function importFromRulesync(projectRoot, outputPackDir) {
-  const rulesyncDir = resolve16(projectRoot, ".rulesync");
+  const rulesyncDir = resolve17(projectRoot, ".rulesync");
   const warnings = [];
   const filesImported = [];
   if (!existsSync10(rulesyncDir)) {
@@ -2964,79 +3170,85 @@ function importFromRulesync(projectRoot, outputPackDir) {
       configGenerated: false
     };
   }
-  const packDir = outputPackDir ?? resolve16(projectRoot, "packs", "default");
+  const packDir = outputPackDir ?? resolve17(projectRoot, "packs", "default");
   ensureDir(packDir);
-  const rulesDir = resolve16(rulesyncDir, "rules");
+  const rulesDir = resolve17(rulesyncDir, "rules");
   if (existsSync10(rulesDir)) {
-    const outRulesDir = resolve16(packDir, "rules");
+    const outRulesDir = resolve17(packDir, "rules");
     ensureDir(outRulesDir);
     const files = listFiles(rulesDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join18(outRulesDir, basename6(file));
+      const dest = join19(outRulesDir, basename6(file));
       copyFileSync(file, dest);
       filesImported.push(dest);
     }
   }
-  const commandsDir = resolve16(rulesyncDir, "commands");
+  const commandsDir = resolve17(rulesyncDir, "commands");
   if (existsSync10(commandsDir)) {
-    const outCommandsDir = resolve16(packDir, "commands");
+    const outCommandsDir = resolve17(packDir, "commands");
     ensureDir(outCommandsDir);
     const files = listFiles(commandsDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join18(outCommandsDir, basename6(file));
+      const dest = join19(outCommandsDir, basename6(file));
       copyFileSync(file, dest);
       filesImported.push(dest);
     }
   }
-  const subagentsDir = resolve16(rulesyncDir, "subagents");
+  const subagentsDir = resolve17(rulesyncDir, "subagents");
   if (existsSync10(subagentsDir)) {
-    const outAgentsDir = resolve16(packDir, "agents");
+    const outAgentsDir = resolve17(packDir, "agents");
     ensureDir(outAgentsDir);
     const files = listFiles(subagentsDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join18(outAgentsDir, basename6(file));
+      const dest = join19(outAgentsDir, basename6(file));
       copyFileSync(file, dest);
       filesImported.push(dest);
     }
   }
-  const skillsDir = resolve16(rulesyncDir, "skills");
+  const skillsDir = resolve17(rulesyncDir, "skills");
   if (existsSync10(skillsDir)) {
-    const outSkillsDir = resolve16(packDir, "skills");
+    const outSkillsDir = resolve17(packDir, "skills");
     ensureDir(outSkillsDir);
     const skillDirs = listDirs(skillsDir);
     for (const skillDir of skillDirs) {
       const skillName = basename6(skillDir);
       if (skillName.startsWith("."))
         continue;
-      const skillMd = join18(skillDir, "SKILL.md");
+      const skillMd = join19(skillDir, "SKILL.md");
       if (existsSync10(skillMd)) {
-        const outSkillDir = join18(outSkillsDir, skillName);
+        const outSkillDir = join19(outSkillsDir, skillName);
         ensureDir(outSkillDir);
-        copyFileSync(skillMd, join18(outSkillDir, "SKILL.md"));
-        filesImported.push(join18(outSkillDir, "SKILL.md"));
+        const rawSkill = readFileSync10(skillMd, "utf-8");
+        const normalized = normalizeImportedSkillMarkdown(rawSkill, skillName);
+        const dest = join19(outSkillDir, "SKILL.md");
+        writeFileSync5(dest, normalized.content);
+        filesImported.push(dest);
+        if (normalized.addedDescription) {
+          warnings.push(`skills/${skillName}/SKILL.md missing description; added import placeholder.`);
+        }
       }
     }
   }
-  const hooksJson = resolve16(rulesyncDir, "hooks.json");
+  const hooksJson = resolve17(rulesyncDir, "hooks.json");
   if (existsSync10(hooksJson)) {
-    const outHooksDir = resolve16(packDir, "hooks");
+    const outHooksDir = resolve17(packDir, "hooks");
     ensureDir(outHooksDir);
-    copyFileSync(hooksJson, join18(outHooksDir, "hooks.json"));
-    filesImported.push(join18(outHooksDir, "hooks.json"));
+    copyFileSync(hooksJson, join19(outHooksDir, "hooks.json"));
+    filesImported.push(join19(outHooksDir, "hooks.json"));
   }
-  const mcpJson = resolve16(rulesyncDir, "mcp.json");
+  const mcpJson = resolve17(rulesyncDir, "mcp.json");
   if (existsSync10(mcpJson)) {
-    copyFileSync(mcpJson, join18(packDir, "mcp.json"));
-    filesImported.push(join18(packDir, "mcp.json"));
+    copyFileSync(mcpJson, join19(packDir, "mcp.json"));
+    filesImported.push(join19(packDir, "mcp.json"));
   }
-  const aiIgnore = resolve16(rulesyncDir, ".aiignore");
-  const rulesyncIgnore = resolve16(projectRoot, ".rulesyncignore");
+  const aiIgnore = resolve17(rulesyncDir, ".aiignore");
+  const rulesyncIgnore = resolve17(projectRoot, ".rulesyncignore");
   if (existsSync10(aiIgnore)) {
-    copyFileSync(aiIgnore, join18(packDir, "ignore"));
-    filesImported.push(join18(packDir, "ignore"));
+    copyFileSync(aiIgnore, join19(packDir, "ignore"));
+    filesImported.push(join19(packDir, "ignore"));
   } else if (existsSync10(rulesyncIgnore)) {
-    copyFileSync(rulesyncIgnore, join18(packDir, "ignore"));
-    filesImported.push(join18(packDir, "ignore"));
+    copyFileSync(rulesyncIgnore, join19(packDir, "ignore"));
+    filesImported.push(join19(packDir, "ignore"));
   }
   const packJson = {
     name: "default",
@@ -3048,14 +3260,14 @@ function importFromRulesync(projectRoot, outputPackDir) {
     targets: "*",
     features: "*"
   };
-  writeFileSync5(join18(packDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
+  writeFileSync5(join19(packDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
 `);
-  filesImported.push(join18(packDir, "pack.json"));
+  filesImported.push(join19(packDir, "pack.json"));
   let configGenerated = false;
-  const rulesyncConfig = resolve16(projectRoot, "rulesync.jsonc");
+  const rulesyncConfig = resolve17(projectRoot, "rulesync.jsonc");
   if (existsSync10(rulesyncConfig)) {
     const agentpacksConfig = convertRulesyncConfig(rulesyncConfig, packDir);
-    const configPath = resolve16(projectRoot, "agentpacks.jsonc");
+    const configPath = resolve17(projectRoot, "agentpacks.jsonc");
     writeFileSync5(configPath, agentpacksConfig);
     configGenerated = true;
   }
@@ -3069,7 +3281,7 @@ function convertRulesyncConfig(rulesyncPath, _packDir) {
   const baseDirs = parsed.baseDirs ?? ["."];
   const global = parsed.global ?? false;
   const deleteVal = parsed.delete ?? true;
-  const relPackDir = "./" + join18("packs", "default");
+  const relPackDir = "./" + join19("packs", "default");
   const config = {
     $schema: "https://unpkg.com/agentpacks/schema.json",
     packs: [relPackDir],
@@ -3087,9 +3299,9 @@ function convertRulesyncConfig(rulesyncPath, _packDir) {
 
 // src/importers/cursor.ts
 import { existsSync as existsSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync6, copyFileSync as copyFileSync2 } from "fs";
-import { resolve as resolve17, join as join19, basename as basename7 } from "path";
+import { resolve as resolve18, join as join20, basename as basename7 } from "path";
 function importFromCursor(projectRoot, outputPackDir) {
-  const cursorDir = resolve17(projectRoot, ".cursor");
+  const cursorDir = resolve18(projectRoot, ".cursor");
   const warnings = [];
   const filesImported = [];
   if (!existsSync11(cursorDir)) {
@@ -3100,11 +3312,11 @@ function importFromCursor(projectRoot, outputPackDir) {
       configGenerated: false
     };
   }
-  const packDir = outputPackDir ?? resolve17(projectRoot, "packs", "cursor-import");
+  const packDir = outputPackDir ?? resolve18(projectRoot, "packs", "cursor-import");
   ensureDir(packDir);
-  const rulesDir = resolve17(cursorDir, "rules");
+  const rulesDir = resolve18(cursorDir, "rules");
   if (existsSync11(rulesDir)) {
-    const outRulesDir = resolve17(packDir, "rules");
+    const outRulesDir = resolve18(packDir, "rules");
     ensureDir(outRulesDir);
     const files = listFiles(rulesDir, { extension: ".mdc" });
     for (const file of files) {
@@ -3120,64 +3332,70 @@ function importFromCursor(projectRoot, outputPackDir) {
       meta.cursor = { ...data };
       const mdContent = buildAgentpacksRule(meta, content);
       const name = basename7(file, ".mdc");
-      const dest = join19(outRulesDir, `${name}.md`);
+      const dest = join20(outRulesDir, `${name}.md`);
       writeFileSync6(dest, mdContent);
       filesImported.push(dest);
     }
     const mdFiles = listFiles(rulesDir, { extension: ".md" });
     for (const file of mdFiles) {
-      const dest = join19(outRulesDir, basename7(file));
+      const dest = join20(outRulesDir, basename7(file));
       copyFileSync2(file, dest);
       filesImported.push(dest);
     }
   }
-  const agentsDir = resolve17(cursorDir, "agents");
+  const agentsDir = resolve18(cursorDir, "agents");
   if (existsSync11(agentsDir)) {
-    const outDir = resolve17(packDir, "agents");
+    const outDir = resolve18(packDir, "agents");
     ensureDir(outDir);
     const files = listFiles(agentsDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join19(outDir, basename7(file));
+      const dest = join20(outDir, basename7(file));
       copyFileSync2(file, dest);
       filesImported.push(dest);
     }
   }
-  const skillsDir = resolve17(cursorDir, "skills");
+  const skillsDir = resolve18(cursorDir, "skills");
   if (existsSync11(skillsDir)) {
-    const outDir = resolve17(packDir, "skills");
+    const outDir = resolve18(packDir, "skills");
     ensureDir(outDir);
     const dirs = listDirs(skillsDir);
     for (const dir of dirs) {
       const name = basename7(dir);
-      const skillMd = join19(dir, "SKILL.md");
+      const skillMd = join20(dir, "SKILL.md");
       if (existsSync11(skillMd)) {
-        const outSkillDir = join19(outDir, name);
+        const outSkillDir = join20(outDir, name);
         ensureDir(outSkillDir);
-        copyFileSync2(skillMd, join19(outSkillDir, "SKILL.md"));
-        filesImported.push(join19(outSkillDir, "SKILL.md"));
+        const rawSkill = readFileSync11(skillMd, "utf-8");
+        const normalized = normalizeImportedSkillMarkdown(rawSkill, name);
+        const dest = join20(outSkillDir, "SKILL.md");
+        writeFileSync6(dest, normalized.content);
+        filesImported.push(dest);
+        if (normalized.addedDescription) {
+          warnings.push(`skills/${name}/SKILL.md missing description; added import placeholder.`);
+        }
       }
     }
   }
-  const commandsDir = resolve17(cursorDir, "commands");
+  const commandsDir = resolve18(cursorDir, "commands");
   if (existsSync11(commandsDir)) {
-    const outDir = resolve17(packDir, "commands");
+    const outDir = resolve18(packDir, "commands");
     ensureDir(outDir);
     const files = listFiles(commandsDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join19(outDir, basename7(file));
+      const dest = join20(outDir, basename7(file));
       copyFileSync2(file, dest);
       filesImported.push(dest);
     }
   }
-  const mcpJson = resolve17(cursorDir, "mcp.json");
+  const mcpJson = resolve18(cursorDir, "mcp.json");
   if (existsSync11(mcpJson)) {
-    copyFileSync2(mcpJson, join19(packDir, "mcp.json"));
-    filesImported.push(join19(packDir, "mcp.json"));
+    copyFileSync2(mcpJson, join20(packDir, "mcp.json"));
+    filesImported.push(join20(packDir, "mcp.json"));
   }
-  const cursorIgnore = resolve17(projectRoot, ".cursorignore");
+  const cursorIgnore = resolve18(projectRoot, ".cursorignore");
   if (existsSync11(cursorIgnore)) {
-    copyFileSync2(cursorIgnore, join19(packDir, "ignore"));
-    filesImported.push(join19(packDir, "ignore"));
+    copyFileSync2(cursorIgnore, join20(packDir, "ignore"));
+    filesImported.push(join20(packDir, "ignore"));
   }
   writePackJson(packDir, "cursor-import", filesImported);
   return { packDir, filesImported, warnings, configGenerated: false };
@@ -3206,7 +3424,7 @@ function writePackJson(packDir, name, filesImported) {
     targets: "*",
     features: "*"
   };
-  const dest = join19(packDir, "pack.json");
+  const dest = join20(packDir, "pack.json");
   writeFileSync6(dest, JSON.stringify(packJson, null, 2) + `
 `);
   filesImported.push(dest);
@@ -3214,12 +3432,12 @@ function writePackJson(packDir, name, filesImported) {
 
 // src/importers/claude-code.ts
 import { existsSync as existsSync12, readFileSync as readFileSync12, writeFileSync as writeFileSync7, copyFileSync as copyFileSync3 } from "fs";
-import { resolve as resolve18, join as join20, basename as basename8 } from "path";
+import { resolve as resolve19, join as join21, basename as basename8 } from "path";
 function importFromClaudeCode(projectRoot, outputPackDir) {
   const warnings = [];
   const filesImported = [];
-  const claudeDir = resolve18(projectRoot, ".claude");
-  const hasClaudeMd = existsSync12(resolve18(projectRoot, "CLAUDE.md"));
+  const claudeDir = resolve19(projectRoot, ".claude");
+  const hasClaudeMd = existsSync12(resolve19(projectRoot, "CLAUDE.md"));
   const hasClaudeDir = existsSync12(claudeDir);
   if (!hasClaudeMd && !hasClaudeDir) {
     return {
@@ -3229,12 +3447,12 @@ function importFromClaudeCode(projectRoot, outputPackDir) {
       configGenerated: false
     };
   }
-  const packDir = outputPackDir ?? resolve18(projectRoot, "packs", "claude-import");
+  const packDir = outputPackDir ?? resolve19(projectRoot, "packs", "claude-import");
   ensureDir(packDir);
-  const rulesDir = resolve18(packDir, "rules");
+  const rulesDir = resolve19(packDir, "rules");
   ensureDir(rulesDir);
   if (hasClaudeMd) {
-    const raw = readFileSync12(resolve18(projectRoot, "CLAUDE.md"), "utf-8");
+    const raw = readFileSync12(resolve19(projectRoot, "CLAUDE.md"), "utf-8");
     const ruleContent = [
       "---",
       "root: true",
@@ -3244,21 +3462,21 @@ function importFromClaudeCode(projectRoot, outputPackDir) {
       raw
     ].join(`
 `);
-    const dest = join20(rulesDir, "claude-root.md");
+    const dest = join21(rulesDir, "claude-root.md");
     writeFileSync7(dest, ruleContent);
     filesImported.push(dest);
   }
   if (hasClaudeDir) {
-    const claudeRulesDir = resolve18(claudeDir, "rules");
+    const claudeRulesDir = resolve19(claudeDir, "rules");
     if (existsSync12(claudeRulesDir)) {
       const files = listFiles(claudeRulesDir, { extension: ".md" });
       for (const file of files) {
-        const dest = join20(rulesDir, basename8(file));
+        const dest = join21(rulesDir, basename8(file));
         copyFileSync3(file, dest);
         filesImported.push(dest);
       }
     }
-    const settingsPath = resolve18(claudeDir, "settings.json");
+    const settingsPath = resolve19(claudeDir, "settings.json");
     if (existsSync12(settingsPath)) {
       try {
         const raw = readFileSync12(settingsPath, "utf-8");
@@ -3266,7 +3484,7 @@ function importFromClaudeCode(projectRoot, outputPackDir) {
         const mcpServers = settings.mcpServers ?? settings.mcp_servers;
         if (mcpServers && typeof mcpServers === "object") {
           const mcpConfig = { servers: mcpServers };
-          const dest = join20(packDir, "mcp.json");
+          const dest = join21(packDir, "mcp.json");
           writeFileSync7(dest, JSON.stringify(mcpConfig, null, 2) + `
 `);
           filesImported.push(dest);
@@ -3286,7 +3504,7 @@ function importFromClaudeCode(projectRoot, outputPackDir) {
     targets: "*",
     features: "*"
   };
-  const packJsonPath = join20(packDir, "pack.json");
+  const packJsonPath = join21(packDir, "pack.json");
   writeFileSync7(packJsonPath, JSON.stringify(packJson, null, 2) + `
 `);
   filesImported.push(packJsonPath);
@@ -3295,11 +3513,11 @@ function importFromClaudeCode(projectRoot, outputPackDir) {
 
 // src/importers/opencode.ts
 import { existsSync as existsSync13, readFileSync as readFileSync13, writeFileSync as writeFileSync8, copyFileSync as copyFileSync4 } from "fs";
-import { resolve as resolve19, join as join21, basename as basename9 } from "path";
+import { resolve as resolve20, join as join22, basename as basename9 } from "path";
 function importFromOpenCode(projectRoot, outputPackDir) {
   const warnings = [];
   const filesImported = [];
-  const ocDir = resolve19(projectRoot, ".opencode");
+  const ocDir = resolve20(projectRoot, ".opencode");
   if (!existsSync13(ocDir)) {
     return {
       packDir: "",
@@ -3308,45 +3526,51 @@ function importFromOpenCode(projectRoot, outputPackDir) {
       configGenerated: false
     };
   }
-  const packDir = outputPackDir ?? resolve19(projectRoot, "packs", "opencode-import");
+  const packDir = outputPackDir ?? resolve20(projectRoot, "packs", "opencode-import");
   ensureDir(packDir);
-  importDirMd(resolve19(ocDir, "rules"), resolve19(packDir, "rules"), filesImported);
-  importDirMd(resolve19(ocDir, "commands"), resolve19(packDir, "commands"), filesImported);
-  importDirMd(resolve19(ocDir, "agents"), resolve19(packDir, "agents"), filesImported);
-  const skillDir = resolve19(ocDir, "skill");
+  importDirMd(resolve20(ocDir, "rules"), resolve20(packDir, "rules"), filesImported);
+  importDirMd(resolve20(ocDir, "commands"), resolve20(packDir, "commands"), filesImported);
+  importDirMd(resolve20(ocDir, "agents"), resolve20(packDir, "agents"), filesImported);
+  const skillDir = resolve20(ocDir, "skill");
   if (existsSync13(skillDir)) {
-    const outSkillDir = resolve19(packDir, "skills");
+    const outSkillDir = resolve20(packDir, "skills");
     ensureDir(outSkillDir);
     const dirs = listDirs(skillDir);
     for (const dir of dirs) {
       const name = basename9(dir);
       if (name.startsWith("."))
         continue;
-      const skillMd = join21(dir, "SKILL.md");
+      const skillMd = join22(dir, "SKILL.md");
       if (existsSync13(skillMd)) {
-        const outDir = join21(outSkillDir, name);
+        const outDir = join22(outSkillDir, name);
         ensureDir(outDir);
-        copyFileSync4(skillMd, join21(outDir, "SKILL.md"));
-        filesImported.push(join21(outDir, "SKILL.md"));
+        const rawSkill = readFileSync13(skillMd, "utf-8");
+        const normalized = normalizeImportedSkillMarkdown(rawSkill, name);
+        const dest2 = join22(outDir, "SKILL.md");
+        writeFileSync8(dest2, normalized.content);
+        filesImported.push(dest2);
+        if (normalized.addedDescription) {
+          warnings.push(`skills/${name}/SKILL.md missing description; added import placeholder.`);
+        }
       }
     }
   }
-  const pluginsDir = resolve19(ocDir, "plugins");
+  const pluginsDir = resolve20(ocDir, "plugins");
   if (existsSync13(pluginsDir)) {
-    const outPluginsDir = resolve19(packDir, "plugins");
+    const outPluginsDir = resolve20(packDir, "plugins");
     ensureDir(outPluginsDir);
     const files = listFiles(pluginsDir);
     for (const file of files) {
       if (file.endsWith(".ts") || file.endsWith(".js")) {
-        const dest2 = join21(outPluginsDir, basename9(file));
+        const dest2 = join22(outPluginsDir, basename9(file));
         copyFileSync4(file, dest2);
         filesImported.push(dest2);
       }
     }
   }
-  const agentsMd = resolve19(projectRoot, "AGENTS.md");
+  const agentsMd = resolve20(projectRoot, "AGENTS.md");
   if (existsSync13(agentsMd)) {
-    const outRulesDir = resolve19(packDir, "rules");
+    const outRulesDir = resolve20(packDir, "rules");
     ensureDir(outRulesDir);
     const raw = readFileSync13(agentsMd, "utf-8");
     const ruleContent = [
@@ -3358,18 +3582,18 @@ function importFromOpenCode(projectRoot, outputPackDir) {
       raw
     ].join(`
 `);
-    const dest2 = join21(outRulesDir, "agents-md-root.md");
+    const dest2 = join22(outRulesDir, "agents-md-root.md");
     writeFileSync8(dest2, ruleContent);
     filesImported.push(dest2);
   }
-  const ocJson = resolve19(projectRoot, "opencode.json");
+  const ocJson = resolve20(projectRoot, "opencode.json");
   if (existsSync13(ocJson)) {
     try {
       const raw = readFileSync13(ocJson, "utf-8");
       const config = JSON.parse(raw);
       const mcpObj = config.mcp;
       if (mcpObj) {
-        const dest2 = join21(packDir, "mcp.json");
+        const dest2 = join22(packDir, "mcp.json");
         writeFileSync8(dest2, JSON.stringify({ servers: mcpObj }, null, 2) + `
 `);
         filesImported.push(dest2);
@@ -3378,10 +3602,10 @@ function importFromOpenCode(projectRoot, outputPackDir) {
       warnings.push("Failed to parse opencode.json");
     }
   }
-  const ocIgnore = resolve19(projectRoot, ".opencodeignore");
+  const ocIgnore = resolve20(projectRoot, ".opencodeignore");
   if (existsSync13(ocIgnore)) {
-    copyFileSync4(ocIgnore, join21(packDir, "ignore"));
-    filesImported.push(join21(packDir, "ignore"));
+    copyFileSync4(ocIgnore, join22(packDir, "ignore"));
+    filesImported.push(join22(packDir, "ignore"));
   }
   const packJson = {
     name: "opencode-import",
@@ -3393,7 +3617,7 @@ function importFromOpenCode(projectRoot, outputPackDir) {
     targets: "*",
     features: "*"
   };
-  const dest = join21(packDir, "pack.json");
+  const dest = join22(packDir, "pack.json");
   writeFileSync8(dest, JSON.stringify(packJson, null, 2) + `
 `);
   filesImported.push(dest);
@@ -3405,7 +3629,7 @@ function importDirMd(srcDir, outDir, filesImported) {
   ensureDir(outDir);
   const files = listFiles(srcDir, { extension: ".md" });
   for (const file of files) {
-    const dest = join21(outDir, basename9(file));
+    const dest = join22(outDir, basename9(file));
     copyFileSync4(file, dest);
     filesImported.push(dest);
   }