agentpacks 0.9.0 → 1.0.0

package/dist/index.js

@@ -12,6 +12,7 @@ var TARGET_IDS = [
   "cursor",
   "claudecode",
   "codexcli",
+  "mistralvibe",
   "geminicli",
   "copilot",
   "agentsmd",
@@ -352,6 +353,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 = [];
@@ -375,6 +378,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 === "*")
@@ -1518,7 +1574,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);
       }
     }
@@ -1773,12 +1829,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);
       }
@@ -2078,7 +2130,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);
       }
     }
@@ -2208,7 +2260,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);
       }
     }
@@ -2216,12 +2268,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",
@@ -2233,49 +2441,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);
       }
@@ -2284,14 +2492,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(`
 `) + `
 `;
@@ -2330,11 +2538,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",
@@ -2347,81 +2555,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);
       }
@@ -2431,14 +2639,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);
@@ -2450,7 +2658,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);
@@ -2458,7 +2666,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);
 }
@@ -2477,16 +2685,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);
@@ -2494,13 +2702,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);
@@ -2508,7 +2716,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);
       }
@@ -2517,7 +2725,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
         });
@@ -2526,7 +2734,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(`
 `) + `
 `);
@@ -2538,7 +2746,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);
       }
@@ -2650,6 +2858,7 @@ var TARGETS = [
   new CursorTarget,
   new ClaudeCodeTarget,
   new CodexCliTarget,
+  new MistralVibeTarget,
   new GeminiCliTarget,
   new CopilotTarget,
   new AgentsMdTarget,
@@ -2682,12 +2891,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
@@ -2718,7 +2927,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) {
@@ -2731,13 +2940,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) {
@@ -2746,29 +2955,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) {
@@ -2779,7 +2985,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);
     }
@@ -2787,9 +2993,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);
@@ -2798,14 +3004,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);
@@ -2830,10 +3036,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)) {
@@ -2844,79 +3050,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",
@@ -2928,14 +3140,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;
   }
@@ -2949,7 +3161,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],
@@ -2967,9 +3179,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)) {
@@ -2980,11 +3192,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) {
@@ -3000,64 +3212,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 };
@@ -3086,7 +3304,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);
@@ -3094,12 +3312,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 {
@@ -3109,12 +3327,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",
@@ -3124,21 +3342,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");
@@ -3146,7 +3364,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);
@@ -3166,7 +3384,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);
@@ -3175,11 +3393,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: "",
@@ -3188,45 +3406,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 = [
@@ -3238,18 +3462,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);
@@ -3258,10 +3482,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",
@@ -3273,7 +3497,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);
@@ -3285,14 +3509,14 @@ 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);
   }
 }
 
 // src/cli/export-cmd.ts
-import { resolve as resolve20 } from "path";
+import { resolve as resolve21 } from "path";
 import chalk from "chalk";
 function runExport(projectRoot, options) {
   const config = loadWorkspaceConfig(projectRoot);
@@ -3311,7 +3535,7 @@ function runExport(projectRoot, options) {
     console.log(chalk.red(`Pack "${options.pack}" not found.`));
     return;
   }
-  const outputDir = resolve20(projectRoot, options.output ?? "dist/cursor-plugins");
+  const outputDir = resolve21(projectRoot, options.output ?? "dist/cursor-plugins");
   switch (options.format) {
     case "cursor-plugin": {
       let totalFiles = 0;
@@ -3799,10 +4023,10 @@ class RegistryApiError extends Error {
 
 // src/utils/credentials.ts
 import { existsSync as existsSync16, readFileSync as readFileSync16, writeFileSync as writeFileSync9, mkdirSync as mkdirSync5 } from "fs";
-import { join as join22, dirname as dirname2 } from "path";
+import { join as join23, dirname as dirname2 } from "path";
 import { homedir } from "os";
-var CONFIG_DIR = join22(homedir(), ".config", "agentpacks");
-var CREDENTIALS_FILE = join22(CONFIG_DIR, "credentials.json");
+var CONFIG_DIR = join23(homedir(), ".config", "agentpacks");
+var CREDENTIALS_FILE = join23(CONFIG_DIR, "credentials.json");
 function loadCredentials() {
   if (!existsSync16(CREDENTIALS_FILE)) {
     return { registryUrl: "https://registry.agentpacks.dev" };
@@ -3891,16 +4115,16 @@ function formatBytes(bytes) {
 
 // src/cli/init.ts
 import { existsSync as existsSync17, copyFileSync as copyFileSync5, writeFileSync as writeFileSync10 } from "fs";
-import { resolve as resolve21, join as join23 } from "path";
+import { resolve as resolve22, join as join24 } from "path";
 import chalk5 from "chalk";
 function runInit(projectRoot) {
-  const configPath = resolve21(projectRoot, "agentpacks.jsonc");
-  const packsDir = resolve21(projectRoot, "packs", "default");
+  const configPath = resolve22(projectRoot, "agentpacks.jsonc");
+  const packsDir = resolve22(projectRoot, "packs", "default");
   if (existsSync17(configPath)) {
     console.log(chalk5.yellow("agentpacks.jsonc already exists. Skipping config creation."));
   } else {
-    const templateDir = resolve21(import.meta.dirname, "..", "..", "templates");
-    const templateConfig = resolve21(templateDir, "workspace", "agentpacks.jsonc");
+    const templateDir = resolve22(import.meta.dirname, "..", "..", "templates");
+    const templateConfig = resolve22(templateDir, "workspace", "agentpacks.jsonc");
     if (existsSync17(templateConfig)) {
       copyFileSync5(templateConfig, configPath);
     } else {
@@ -3931,10 +4155,10 @@ function runInit(projectRoot) {
     console.log(chalk5.yellow("packs/default/ already exists. Skipping pack scaffold."));
   } else {
     ensureDir(packsDir);
-    ensureDir(join23(packsDir, "rules"));
-    ensureDir(join23(packsDir, "commands"));
-    ensureDir(join23(packsDir, "agents"));
-    ensureDir(join23(packsDir, "skills"));
+    ensureDir(join24(packsDir, "rules"));
+    ensureDir(join24(packsDir, "commands"));
+    ensureDir(join24(packsDir, "agents"));
+    ensureDir(join24(packsDir, "skills"));
     const packJson = {
       name: "default",
       version: "1.0.0",
@@ -3945,11 +4169,11 @@ function runInit(projectRoot) {
       targets: "*",
       features: "*"
     };
-    writeFileSync10(join23(packsDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
+    writeFileSync10(join24(packsDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
 `);
-    const templateRule = resolve21(import.meta.dirname, "..", "..", "templates", "pack", "rules", "overview.md");
+    const templateRule = resolve22(import.meta.dirname, "..", "..", "templates", "pack", "rules", "overview.md");
     if (existsSync17(templateRule)) {
-      copyFileSync5(templateRule, join23(packsDir, "rules", "overview.md"));
+      copyFileSync5(templateRule, join24(packsDir, "rules", "overview.md"));
     }
     console.log(chalk5.green("Created packs/default/ with scaffold"));
   }
@@ -3963,12 +4187,12 @@ Next steps:`), `
 // src/utils/tarball.ts
 import { execSync as execSync2 } from "child_process";
 import { readFileSync as readFileSync17, existsSync as existsSync18, mkdirSync as mkdirSync6, rmSync as rmSync2 } from "fs";
-import { join as join24, resolve as resolve22 } from "path";
+import { join as join25, resolve as resolve23 } from "path";
 import { createHash as createHash2 } from "crypto";
 import { tmpdir } from "os";
 async function createTarball(packDir) {
-  const absDir = resolve22(packDir);
-  const tmpFile = join24(tmpdir(), `agentpacks-${Date.now()}.tgz`);
+  const absDir = resolve23(packDir);
+  const tmpFile = join25(tmpdir(), `agentpacks-${Date.now()}.tgz`);
   try {
     execSync2(`tar -czf "${tmpFile}" -C "${absDir}" .`, {
       stdio: "pipe"
@@ -3983,7 +4207,7 @@ async function createTarball(packDir) {
 }
 async function extractTarball(data, targetDir) {
   mkdirSync6(targetDir, { recursive: true });
-  const tmpFile = join24(tmpdir(), `agentpacks-${Date.now()}.tgz`);
+  const tmpFile = join25(tmpdir(), `agentpacks-${Date.now()}.tgz`);
   try {
     const buffer = Buffer.from(data);
     const { writeFileSync: writeFileSync11 } = await import("fs");
@@ -4004,7 +4228,7 @@ function computeTarballIntegrity(data) {
 
 // src/sources/registry.ts
 import { existsSync as existsSync19, mkdirSync as mkdirSync7, readdirSync as readdirSync3, rmSync as rmSync3 } from "fs";
-import { resolve as resolve23, join as join25 } from "path";
+import { resolve as resolve24, join as join26 } from "path";
 async function installRegistrySource(projectRoot, source, lockfile, options = {}) {
   const parsed = parseRegistrySourceRef(source);
   const sourceKey = registrySourceKey(parsed);
@@ -4033,8 +4257,8 @@ async function installRegistrySource(projectRoot, source, lockfile, options = {}
       throw new Error(`Integrity mismatch for ${parsed.packName}@${targetVersion}. ` + `Expected ${expectedIntegrity}, got ${localIntegrity}.`);
     }
   }
-  const curatedDir = resolve23(projectRoot, ".agentpacks", ".curated");
-  const packOutDir = resolve23(curatedDir, parsed.packName);
+  const curatedDir = resolve24(projectRoot, ".agentpacks", ".curated");
+  const packOutDir = resolve24(curatedDir, parsed.packName);
   if (existsSync19(packOutDir)) {
     rmSync3(packOutDir, { recursive: true, force: true });
   }
@@ -4071,7 +4295,7 @@ function buildClientConfig(registryUrl) {
 function collectFiles2(dir, out) {
   const entries = readdirSync3(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const full = join25(dir, entry.name);
+    const full = join26(dir, entry.name);
     if (entry.isDirectory()) {
       collectFiles2(full, out);
     } else {
@@ -4186,9 +4410,9 @@ async function runLogin(options) {
 
 // src/cli/models-explain.ts
 import chalk8 from "chalk";
-import { resolve as resolve24 } from "path";
+import { resolve as resolve25 } from "path";
 function runModelsExplain(options) {
-  const projectRoot = resolve24(options.config ?? ".");
+  const projectRoot = resolve25(options.config ?? ".");
   const config = loadWorkspaceConfig(projectRoot);
   const loader = new PackLoader(projectRoot, config);
   const { packs } = loader.loadAll();
@@ -4320,19 +4544,19 @@ function matchTaskToRouting(task, routing) {
 
 // src/cli/pack/create.ts
 import { existsSync as existsSync20, writeFileSync as writeFileSync11 } from "fs";
-import { resolve as resolve25, join as join26 } from "path";
+import { resolve as resolve26, join as join27 } from "path";
 import chalk9 from "chalk";
 function runPackCreate(projectRoot, name) {
-  const packDir = resolve25(projectRoot, "packs", name);
+  const packDir = resolve26(projectRoot, "packs", name);
   if (existsSync20(packDir)) {
     console.log(chalk9.red(`Pack "${name}" already exists at packs/${name}/`));
     return;
   }
   ensureDir(packDir);
-  ensureDir(join26(packDir, "rules"));
-  ensureDir(join26(packDir, "commands"));
-  ensureDir(join26(packDir, "agents"));
-  ensureDir(join26(packDir, "skills"));
+  ensureDir(join27(packDir, "rules"));
+  ensureDir(join27(packDir, "commands"));
+  ensureDir(join27(packDir, "agents"));
+  ensureDir(join27(packDir, "skills"));
   const packJson = {
     name,
     version: "1.0.0",
@@ -4343,20 +4567,20 @@ function runPackCreate(projectRoot, name) {
     targets: "*",
     features: "*"
   };
-  writeFileSync11(join26(packDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
+  writeFileSync11(join27(packDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
 `);
   console.log(chalk9.green(`Created pack "${name}" at packs/${name}/`));
   console.log(chalk9.dim("  Add rules, commands, agents, skills, hooks, plugins, mcp.json, or ignore files."));
-  console.log(chalk9.dim(`  Then add "${join26("./packs", name)}" to packs[] in agentpacks.jsonc.`));
+  console.log(chalk9.dim(`  Then add "${join27("./packs", name)}" to packs[] in agentpacks.jsonc.`));
 }
 
 // src/cli/pack/enable.ts
 import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, existsSync as existsSync21 } from "fs";
-import { resolve as resolve26 } from "path";
+import { resolve as resolve27 } from "path";
 import chalk10 from "chalk";
 var CONFIG_FILENAME = "agentpacks.jsonc";
 function readConfigRaw(projectRoot) {
-  const filepath = resolve26(projectRoot, CONFIG_FILENAME);
+  const filepath = resolve27(projectRoot, CONFIG_FILENAME);
   if (!existsSync21(filepath)) {
     throw new Error(`No ${CONFIG_FILENAME} found. Run 'agentpacks init' first.`);
   }
@@ -4392,7 +4616,7 @@ function runPackDisable(projectRoot, packName) {
   }
   list.push(packName);
   const updated = writeDisabled(raw, list, match);
-  const filepath = resolve26(projectRoot, CONFIG_FILENAME);
+  const filepath = resolve27(projectRoot, CONFIG_FILENAME);
   writeFileSync12(filepath, updated);
   console.log(chalk10.green(`Disabled pack "${packName}".`));
   console.log(chalk10.dim("Run 'agentpacks generate' to regenerate configs."));
@@ -4406,7 +4630,7 @@ function runPackEnable(projectRoot, packName) {
   }
   const newList = list.filter((n) => n !== packName);
   const updated = writeDisabled(raw, newList, match);
-  const filepath = resolve26(projectRoot, CONFIG_FILENAME);
+  const filepath = resolve27(projectRoot, CONFIG_FILENAME);
   writeFileSync12(filepath, updated);
   console.log(chalk10.green(`Enabled pack "${packName}".`));
   console.log(chalk10.dim("Run 'agentpacks generate' to regenerate configs."));
@@ -4466,7 +4690,7 @@ function runPackList(projectRoot) {
 
 // src/cli/pack/validate.ts
 import { existsSync as existsSync22 } from "fs";
-import { resolve as resolve27, join as join27 } from "path";
+import { resolve as resolve28, join as join28, basename as basename10 } from "path";
 import chalk12 from "chalk";
 function runPackValidate(projectRoot) {
   const config = loadWorkspaceConfig(projectRoot);
@@ -4480,7 +4704,7 @@ Validating pack: ${packRef}`));
       hasErrors = true;
       continue;
     }
-    const packJsonPath = resolve27(packDir, "pack.json");
+    const packJsonPath = resolve28(packDir, "pack.json");
     if (!existsSync22(packJsonPath)) {
       console.log(chalk12.yellow("  warn: No pack.json found. Name will be inferred from directory."));
     } else {
@@ -4495,14 +4719,30 @@ Validating pack: ${packRef}`));
     }
     const subdirs = ["rules", "commands", "agents", "skills"];
     for (const sub of subdirs) {
-      const subDir = join27(packDir, sub);
+      const subDir = join28(packDir, sub);
       if (existsSync22(subDir)) {
         if (sub === "skills") {
           const skillDirs = listDirs(subDir);
           for (const skillDir of skillDirs) {
-            const skillMd = join27(skillDir, "SKILL.md");
+            const skillName = basename10(skillDir);
+            const skillMd = join28(skillDir, "SKILL.md");
             if (!existsSync22(skillMd)) {
-              console.log(chalk12.yellow(`  warn: skills/${skillDir.split("/").pop()} missing SKILL.md`));
+              console.log(chalk12.yellow(`  warn: skills/${skillName} missing SKILL.md`));
+              continue;
+            }
+            try {
+              const parsed = parseSkillFile(skillMd, skillDir, "__validation__");
+              const skillErrors = validateAgentSkillsFrontmatter(parsed);
+              for (const err of skillErrors) {
+                console.log(chalk12.red(`  ERROR skills/${skillName}/SKILL.md: ${err}`));
+              }
+              if (skillErrors.length > 0) {
+                hasErrors = true;
+              }
+            } catch (err) {
+              const message = err instanceof Error ? err.message : String(err);
+              console.log(chalk12.red(`  ERROR skills/${skillName}/SKILL.md: failed to parse (${message})`));
+              hasErrors = true;
             }
           }
           console.log(chalk12.green(`  ${sub}/: ${skillDirs.length} skill(s)`));
@@ -4514,15 +4754,15 @@ Validating pack: ${packRef}`));
     }
     const optionalFiles = ["mcp.json", "ignore", ".aiignore"];
     for (const file of optionalFiles) {
-      if (existsSync22(join27(packDir, file))) {
+      if (existsSync22(join28(packDir, file))) {
         console.log(chalk12.green(`  ${file}: present`));
       }
     }
-    const hooksJson = join27(packDir, "hooks", "hooks.json");
+    const hooksJson = join28(packDir, "hooks", "hooks.json");
     if (existsSync22(hooksJson)) {
       console.log(chalk12.green("  hooks/hooks.json: present"));
     }
-    const pluginsDir = join27(packDir, "plugins");
+    const pluginsDir = join28(packDir, "plugins");
     if (existsSync22(pluginsDir)) {
       const pluginFiles = [
         ...listFiles(pluginsDir, { extension: ".ts" }),
@@ -4530,7 +4770,7 @@ Validating pack: ${packRef}`));
       ];
       console.log(chalk12.green(`  plugins/: ${pluginFiles.length} file(s)`));
     }
-    const modelsJsonPath = join27(packDir, "models.json");
+    const modelsJsonPath = join28(packDir, "models.json");
     if (existsSync22(modelsJsonPath)) {
       try {
         const parsed = parseModels(packDir, "validate");
@@ -4561,13 +4801,13 @@ Validating pack: ${packRef}`));
 }
 function resolvePackDir(projectRoot, packRef) {
   if (packRef.startsWith("./") || packRef.startsWith("../")) {
-    return resolve27(projectRoot, packRef);
+    return resolve28(projectRoot, packRef);
   }
-  return resolve27(projectRoot, packRef);
+  return resolve28(projectRoot, packRef);
 }
 
 // src/cli/publish.ts
-import { resolve as resolve28 } from "path";
+import { resolve as resolve29 } from "path";
 import { existsSync as existsSync23 } from "fs";
 import chalk13 from "chalk";
 async function runPublish(projectRoot, options) {
@@ -4576,8 +4816,8 @@ async function runPublish(projectRoot, options) {
     console.log(chalk13.red("Not authenticated. Run `agentpacks login` first."));
     process.exit(1);
   }
-  const packDir = resolve28(projectRoot);
-  const packJsonPath = resolve28(packDir, "pack.json");
+  const packDir = resolve29(projectRoot);
+  const packJsonPath = resolve29(packDir, "pack.json");
   if (!existsSync23(packJsonPath)) {
     console.log(chalk13.red("No pack.json found. Are you in a pack directory?"));
     process.exit(1);
@@ -4662,23 +4902,23 @@ async function runSearch(query, options) {
 
 // src/index.ts
 import { Command } from "commander";
-import { resolve as resolve29 } from "path";
+import { resolve as resolve30 } from "path";
 var program = new Command;
 program.name("agentpacks").description("Composable AI agent configuration manager. Pack-based rules, commands, skills, hooks, and MCP sync across OpenCode, Cursor, Claude Code, Codex, Gemini, Copilot, and more.").version("0.1.0");
 program.command("init").description("Initialize agentpacks in the current project").action(() => {
-  runInit(resolve29("."));
+  runInit(resolve30("."));
 });
 program.command("generate").description("Generate tool configs from active packs").option("-t, --targets <targets>", "Comma-separated target IDs or '*' for all").option("-f, --features <features>", "Comma-separated feature IDs or '*' for all").option("--dry-run", "Preview changes without writing files").option("--diff", "Show diff of what would change").option("-v, --verbose", "Enable verbose logging").action((options) => {
-  runGenerate(resolve29("."), options);
+  runGenerate(resolve30("."), options);
 });
 program.command("install").description("Install remote packs (git, npm) into local cache").option("--update", "Re-resolve all refs (ignore lockfile)").option("--frozen", "Fail if lockfile is missing or incomplete").option("-v, --verbose", "Enable verbose logging").action(async (options) => {
-  await runInstall(resolve29("."), options);
+  await runInstall(resolve30("."), options);
 });
 program.command("export").description("Export packs to target-native format (e.g. Cursor plugin)").requiredOption("--format <format>", "Export format (cursor-plugin)").option("-o, --output <dir>", "Output directory").option("--pack <name>", "Export a specific pack only").option("-v, --verbose", "Enable verbose logging").action((options) => {
-  runExport(resolve29("."), options);
+  runExport(resolve30("."), options);
 });
 program.command("import").description("Import from existing tool configurations").requiredOption("--from <source>", "Import source (rulesync)").option("-o, --output <dir>", "Output pack directory").action((options) => {
-  runImport(resolve29("."), options);
+  runImport(resolve30("."), options);
 });
 program.command("search [query]").description("Search for packs in the registry").option("--tags <tags>", "Filter by tags (comma-separated)").option("--targets <targets>", "Filter by targets (comma-separated)").option("--sort <sort>", "Sort by: downloads, updated, name, weekly").option("-l, --limit <limit>", "Max results to show").option("-v, --verbose", "Show additional details").action(async (query, options) => {
   await runSearch(query ?? "", options);
@@ -4687,7 +4927,7 @@ program.command("info <pack>").description("Show detailed pack information from
   await runInfo(packName);
 });
 program.command("publish").description("Publish a pack to the registry").option("-v, --verbose", "Enable verbose logging").action(async (options) => {
-  await runPublish(resolve29("."), options);
+  await runPublish(resolve30("."), options);
 });
 program.command("login").description("Authenticate with the agentpacks registry").option("--token <token>", "API token").option("--registry <url>", "Registry URL").action(async (options) => {
   await runLogin(options);
@@ -4698,18 +4938,18 @@ modelsCmd.command("explain").description("Explain model profile and routing reso
 });
 var packCmd = program.command("pack").description("Manage packs");
 packCmd.command("create <name>").description("Create a new pack scaffold").action((name) => {
-  runPackCreate(resolve29("."), name);
+  runPackCreate(resolve30("."), name);
 });
 packCmd.command("list").description("List all configured packs and their status").action(() => {
-  runPackList(resolve29("."));
+  runPackList(resolve30("."));
 });
 packCmd.command("validate").description("Validate all configured packs").action(() => {
-  runPackValidate(resolve29("."));
+  runPackValidate(resolve30("."));
 });
 packCmd.command("enable <name>").description("Enable a previously disabled pack").action((name) => {
-  runPackEnable(resolve29("."), name);
+  runPackEnable(resolve30("."), name);
 });
 packCmd.command("disable <name>").description("Disable a pack without removing it").action((name) => {
-  runPackDisable(resolve29("."), name);
+  runPackDisable(resolve30("."), name);
 });
 program.parse();