prpm 2.0.1 → 2.1.0

package/dist/index.js

@@ -788,14 +788,35 @@ function normalizeFormat(sourceFormat) {
     return "zencoder";
   if (normalized.includes("replit"))
     return "replit";
+  if (normalized.includes("zed"))
+    return "zed";
   if (normalized.includes("mcp"))
     return "mcp";
   return "generic";
 }
+var CLI_SUPPORTED_FORMATS;
 var init_taxonomy_utils = __esm({
   "../converters/dist/taxonomy-utils.js"() {
     "use strict";
     init_cjs_shims();
+    CLI_SUPPORTED_FORMATS = [
+      "cursor",
+      "claude",
+      "windsurf",
+      "continue",
+      "copilot",
+      "kiro",
+      "agents.md",
+      "gemini",
+      "ruler",
+      "zed",
+      "opencode",
+      "aider",
+      "trae",
+      "replit",
+      "zencoder",
+      "droid"
+    ];
   }
 });
 
@@ -1085,11 +1106,161 @@ var init_from_claude = __esm({
   }
 });
 
+// ../converters/dist/utils/file-references.js
+function extractAtReferences(content) {
+  const atRefRegex = /@([\w\-./]+\.\w+)/g;
+  const matches = content.matchAll(atRefRegex);
+  const refs = Array.from(matches, (m) => m[1]);
+  return [...new Set(refs)];
+}
+function categorizeFile(path10) {
+  const pathLower = path10.toLowerCase();
+  if (pathLower.includes("/patterns/") || pathLower.includes("/pattern/") || pathLower.startsWith("patterns/") || pathLower.startsWith("pattern/")) {
+    return "pattern";
+  }
+  if (pathLower.includes("/examples/") || pathLower.includes("/example/") || pathLower.startsWith("examples/") || pathLower.startsWith("example/")) {
+    return "example";
+  }
+  if (pathLower.includes("/context/") || pathLower.includes("/contexts/") || pathLower.startsWith("context/") || pathLower.startsWith("contexts/")) {
+    return "context";
+  }
+  if (pathLower.includes("/config/") || pathLower.includes("/configs/") || pathLower.startsWith("config/") || pathLower.startsWith("configs/")) {
+    return "config";
+  }
+  if (pathLower.includes("/data/") || pathLower.startsWith("data/")) {
+    return "data";
+  }
+  if (pathLower.includes("/docs/") || pathLower.includes("/documentation/") || pathLower.startsWith("docs/") || pathLower.startsWith("documentation/")) {
+    return "documentation";
+  }
+  if (pathLower.endsWith(".md") && !pathLower.includes("/")) {
+    return "documentation";
+  }
+  return "other";
+}
+function detectContentType(path10) {
+  const ext = (0, import_path5.extname)(path10).toLowerCase();
+  const typeMap = {
+    ".md": "text/markdown",
+    ".txt": "text/plain",
+    ".json": "application/json",
+    ".yaml": "text/yaml",
+    ".yml": "text/yaml",
+    ".toml": "text/toml",
+    ".ts": "typescript",
+    ".tsx": "typescriptreact",
+    ".js": "javascript",
+    ".jsx": "javascriptreact",
+    ".py": "python",
+    ".rb": "ruby",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".c": "c",
+    ".cpp": "cpp",
+    ".cs": "csharp",
+    ".php": "php",
+    ".sh": "shellscript",
+    ".bash": "shellscript",
+    ".zsh": "shellscript",
+    ".html": "text/html",
+    ".css": "text/css",
+    ".scss": "scss",
+    ".sass": "sass",
+    ".xml": "text/xml",
+    ".sql": "sql"
+  };
+  return typeMap[ext] || "text/plain";
+}
+function loadReferencedFiles(references, basePath) {
+  const loaded = [];
+  const resolvedBasePath = (0, import_path5.resolve)(basePath);
+  for (const ref of references) {
+    const fullPath = (0, import_path5.resolve)((0, import_path5.join)(basePath, ref));
+    if (!fullPath.startsWith(resolvedBasePath + import_path5.sep) && fullPath !== resolvedBasePath) {
+      console.warn(`Warning: Path traversal attempt blocked: ${ref}`);
+      continue;
+    }
+    if (!(0, import_fs5.existsSync)(fullPath)) {
+      console.warn(`Warning: Referenced file not found: ${ref}`);
+      continue;
+    }
+    try {
+      const content = (0, import_fs5.readFileSync)(fullPath, "utf-8");
+      loaded.push({
+        path: ref,
+        content,
+        contentType: detectContentType(ref),
+        category: categorizeFile(ref)
+      });
+    } catch (error) {
+      console.warn(`Warning: Could not read file: ${ref}`, error);
+    }
+  }
+  return loaded;
+}
+function extractDirectories(filePaths) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const path10 of filePaths) {
+    const dir = (0, import_path5.dirname)(path10);
+    if (dir && dir !== ".") {
+      dirs.add(dir);
+      const parts = dir.split("/");
+      for (let i = 1; i < parts.length; i++) {
+        dirs.add(parts.slice(0, i).join("/"));
+      }
+    }
+  }
+  return Array.from(dirs).sort();
+}
+var import_fs5, import_path5;
+var init_file_references = __esm({
+  "../converters/dist/utils/file-references.js"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs5 = require("fs");
+    import_path5 = require("path");
+  }
+});
+
 // ../converters/dist/from-cursor.js
-function fromCursor(content, metadata, explicitSubtype) {
-  const pkg = fromClaude(content, metadata, "cursor", explicitSubtype);
+function fromCursor(content, metadata, options) {
+  const opts = typeof options === "string" ? { explicitSubtype: options } : options || {};
+  const pkg = fromClaude(content, metadata, "cursor", opts.explicitSubtype);
   pkg.format = "cursor";
   pkg.sourceFormat = "cursor";
+  if (opts.resolveFiles && opts.basePath) {
+    const fileRefs = extractAtReferences(content);
+    if (fileRefs.length > 0) {
+      try {
+        const loadedFiles = loadReferencedFiles(fileRefs, opts.basePath);
+        const fileSections = loadedFiles.map((file) => ({
+          type: "file-reference",
+          title: file.path,
+          path: file.path,
+          content: file.content,
+          contentType: file.contentType,
+          category: file.category,
+          description: `Referenced file from @${file.path}`
+        }));
+        pkg.content.sections.push(...fileSections);
+        const directories = extractDirectories(fileRefs);
+        pkg.metadata = pkg.metadata || {};
+        pkg.metadata.fileStructure = {
+          mainFile: "rule.md",
+          // Cursor typically uses single rule files
+          files: loadedFiles.map((file) => ({
+            path: file.path,
+            category: file.category,
+            description: `Referenced via @${file.path}`
+          })),
+          directories: directories.length > 0 ? directories : void 0
+        };
+      } catch (error) {
+        console.warn(`Failed to load @file references: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
   return pkg;
 }
 var init_from_cursor = __esm({
@@ -1097,6 +1268,7 @@ var init_from_cursor = __esm({
     "use strict";
     init_cjs_shims();
     init_from_claude();
+    init_file_references();
   }
 });
 
@@ -6525,20 +6697,20 @@ var require_parse_async = __commonJS({
       const index = 0;
       const blocksize = opts.blocksize || 40960;
       const parser = new TOMLParser();
-      return new Promise((resolve2, reject) => {
-        setImmediate(parseAsyncNext, index, blocksize, resolve2, reject);
+      return new Promise((resolve3, reject) => {
+        setImmediate(parseAsyncNext, index, blocksize, resolve3, reject);
       });
-      function parseAsyncNext(index2, blocksize2, resolve2, reject) {
+      function parseAsyncNext(index2, blocksize2, resolve3, reject) {
         if (index2 >= str2.length) {
           try {
-            return resolve2(parser.finish());
+            return resolve3(parser.finish());
           } catch (err) {
             return reject(prettyError(err, str2));
           }
         }
         try {
           parser.parse(str2.slice(index2, index2 + blocksize2));
-          setImmediate(parseAsyncNext, index2 + blocksize2, blocksize2, resolve2, reject);
+          setImmediate(parseAsyncNext, index2 + blocksize2, blocksize2, resolve3, reject);
         } catch (err) {
           reject(prettyError(err, str2));
         }
@@ -6565,7 +6737,7 @@ var require_parse_stream = __commonJS({
     function parseReadable(stm) {
       const parser = new TOMLParser();
       stm.setEncoding("utf8");
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         let readable;
         let ended = false;
         let errored = false;
@@ -6573,7 +6745,7 @@ var require_parse_stream = __commonJS({
           ended = true;
           if (readable) return;
           try {
-            resolve2(parser.finish());
+            resolve3(parser.finish());
           } catch (err) {
             reject(err);
           }
@@ -6968,6 +7140,74 @@ var init_from_gemini = __esm({
   }
 });
 
+// ../converters/dist/from-gemini-plugin.js
+function fromGeminiPlugin(content, metadata) {
+  const config = JSON.parse(content);
+  const sections = [];
+  const metadataSection = {
+    type: "metadata",
+    data: {
+      title: config.name || metadata.name || metadata.id,
+      description: config.description || metadata.description || "",
+      version: config.version || metadata.version,
+      author: config.author || metadata.author
+    }
+  };
+  if (config.mcpServers || config.contextFileName || config.excludeTools || config.experimentalSettings) {
+    metadataSection.data.geminiExtension = {
+      mcpServers: config.mcpServers,
+      contextFileName: config.contextFileName,
+      excludeTools: config.excludeTools,
+      experimentalSettings: config.experimentalSettings
+    };
+  }
+  sections.push(metadataSection);
+  if (config.description) {
+    sections.push({
+      type: "instructions",
+      title: "Extension Description",
+      content: config.description
+    });
+  }
+  const canonicalContent = {
+    format: "canonical",
+    version: "1.0",
+    sections
+  };
+  const pkg = {
+    ...metadata,
+    id: metadata.id,
+    name: metadata.name || config.name || metadata.id,
+    version: metadata.version || config.version,
+    author: metadata.author || config.author || "unknown",
+    description: metadata.description || config.description || "",
+    tags: metadata.tags || [],
+    format: "gemini",
+    subtype: "extension",
+    content: canonicalContent
+  };
+  if (config.mcpServers || config.contextFileName || config.excludeTools || config.experimentalSettings) {
+    pkg.metadata = {
+      ...pkg.metadata,
+      geminiExtension: {
+        mcpServers: config.mcpServers,
+        contextFileName: config.contextFileName,
+        excludeTools: config.excludeTools,
+        experimentalSettings: config.experimentalSettings
+      }
+    };
+  }
+  setTaxonomy(pkg, "gemini", "extension");
+  return pkg;
+}
+var init_from_gemini_plugin = __esm({
+  "../converters/dist/from-gemini-plugin.js"() {
+    "use strict";
+    init_cjs_shims();
+    init_taxonomy_utils();
+  }
+});
+
 // ../converters/dist/from-opencode.js
 function parseFrontmatter5(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
@@ -8312,6 +8552,34 @@ var init_from_replit = __esm({
   }
 });
 
+// ../converters/dist/from-zed.js
+function fromZed(content, metadata, explicitSubtype) {
+  const pkg = fromAgentsMd(content, metadata);
+  pkg.format = "zed";
+  pkg.sourceFormat = "zed";
+  if (explicitSubtype) {
+    pkg.subtype = explicitSubtype;
+  }
+  return pkg;
+}
+function isZedFormat(content) {
+  const trimmed = content.trim();
+  if (trimmed.startsWith("---")) {
+    return false;
+  }
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return false;
+  }
+  return true;
+}
+var init_from_zed = __esm({
+  "../converters/dist/from-zed.js"() {
+    "use strict";
+    init_cjs_shims();
+    init_from_agents_md();
+  }
+});
+
 // ../converters/dist/from-mcp-server.js
 function fromMCPServer(mcpServerJson, metadata) {
   var _a;
@@ -8432,7 +8700,8 @@ function loadSchema(format, subtype) {
       "droid:skill": "droid-skill.schema.json",
       "droid:slash-command": "droid-slash-command.schema.json",
       "droid:hook": "droid-hook.schema.json",
-      "opencode:slash-command": "opencode-slash-command.schema.json"
+      "opencode:slash-command": "opencode-slash-command.schema.json",
+      "gemini:extension": "gemini-extension.schema.json"
     };
     schemaFilename = subtypeSchemaMap[cacheKey];
   }
@@ -8459,15 +8728,15 @@ function loadSchema(format, subtype) {
     schemaFilename = schemaMap[format] || `${format}.schema.json`;
   }
   const schemaDirectories = [
-    (0, import_path5.join)(currentDirname, "..", "schemas"),
-    (0, import_path5.join)(currentDirname, "schemas")
+    (0, import_path6.join)(currentDirname, "..", "schemas"),
+    (0, import_path6.join)(currentDirname, "schemas")
   ];
   let schemaContent = null;
   let schemaPath = null;
   for (const dir of schemaDirectories) {
-    const candidate = (0, import_path5.join)(dir, schemaFilename);
+    const candidate = (0, import_path6.join)(dir, schemaFilename);
     try {
-      schemaContent = (0, import_fs5.readFileSync)(candidate, "utf-8");
+      schemaContent = (0, import_fs6.readFileSync)(candidate, "utf-8");
       schemaPath = candidate;
       break;
     } catch (error) {
@@ -8585,18 +8854,18 @@ function formatValidationErrors(result) {
   }
   return lines.join("\n");
 }
-var import_ajv, import_ajv_formats, import_fs5, import_path5, import_url, currentDirname, ajv, schemaCache;
+var import_ajv, import_ajv_formats, import_fs6, import_path6, import_url, currentDirname, ajv, schemaCache;
 var init_validation = __esm({
   "../converters/dist/validation.js"() {
     "use strict";
     init_cjs_shims();
     import_ajv = __toESM(require("ajv"), 1);
     import_ajv_formats = __toESM(require("ajv-formats"), 1);
-    import_fs5 = require("fs");
-    import_path5 = require("path");
+    import_fs6 = require("fs");
+    import_path6 = require("path");
     import_url = require("url");
     init_js_yaml();
-    currentDirname = (0, import_path5.dirname)((0, import_url.fileURLToPath)(importMetaUrl));
+    currentDirname = (0, import_path6.dirname)((0, import_url.fileURLToPath)(importMetaUrl));
     ajv = new import_ajv.default({
       allErrors: true,
       verbose: true,
@@ -8701,6 +8970,8 @@ function convertSection(section, warnings) {
       return convertPersona(section);
     case "context":
       return convertContext(section);
+    case "file-reference":
+      return convertFileReference(section, warnings);
     case "tools":
       warnings.push("Tools section skipped (Claude-specific)");
       return "";
@@ -8807,6 +9078,32 @@ function convertContext(section) {
   lines.push(section.content);
   return lines.join("\n");
 }
+function convertFileReference(section, warnings) {
+  const lines = [];
+  if (section.description) {
+    lines.push(`## ${section.title}`);
+    lines.push("");
+    lines.push(section.description);
+    lines.push("");
+  }
+  let sanitizedPath = section.path.trim();
+  if (sanitizedPath.startsWith("/") || /^[A-Z]:/i.test(sanitizedPath)) {
+    warnings.push(`Rejected absolute path: ${section.path} - converted to relative path`);
+    sanitizedPath = sanitizedPath.replace(/^\/+/, "").replace(/^[A-Z]:/i, "");
+  }
+  if (sanitizedPath.includes("../") || sanitizedPath.includes("..\\")) {
+    warnings.push(`Rejected parent traversal in path: ${section.path} - removed traversal segments`);
+    sanitizedPath = sanitizedPath.split("/").filter((seg) => seg !== "..").join("/");
+  }
+  if (/[\r\n\t]/.test(sanitizedPath)) {
+    warnings.push(`Rejected control characters in path: ${section.path}`);
+    sanitizedPath = sanitizedPath.replace(/[\r\n\t]/g, "");
+  }
+  const sanitizedCategory = (section.category || "converted package").replace(/-->/g, "--&gt;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  lines.push(`<!-- PRPM: File reference from ${sanitizedCategory} -->`);
+  lines.push(`@file ${sanitizedPath}`);
+  return lines.join("\n");
+}
 function isCursorFormat(content) {
   return content.includes("# ") && !content.includes("---\n") && // Not Claude format (has frontmatter)
   !content.includes('"systemMessage"');
@@ -10436,12 +10733,84 @@ var init_to_gemini = __esm({
   }
 });
 
+// ../converters/dist/to-gemini-plugin.js
+function toGeminiPlugin(pkg) {
+  const warnings = [];
+  let qualityScore = 100;
+  try {
+    const content = convertContent6(pkg, warnings);
+    const lossyConversion = warnings.some((w) => w.includes("not supported") || w.includes("skipped"));
+    if (lossyConversion) {
+      qualityScore -= 10;
+    }
+    return {
+      content,
+      format: "gemini",
+      warnings: warnings.length > 0 ? warnings : void 0,
+      lossyConversion,
+      qualityScore
+    };
+  } catch (error) {
+    warnings.push(`Conversion error: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      content: "",
+      format: "gemini",
+      warnings,
+      lossyConversion: true,
+      qualityScore: 0
+    };
+  }
+}
+function convertContent6(pkg, warnings) {
+  var _a, _b;
+  const metadata = pkg.content.sections.find((s) => s.type === "metadata");
+  const config = {
+    name: pkg.name,
+    version: pkg.version
+  };
+  if (pkg.description) {
+    config.description = pkg.description;
+  }
+  if (pkg.author) {
+    config.author = pkg.author;
+  }
+  const geminiData = (metadata == null ? void 0 : metadata.type) === "metadata" ? (_a = metadata.data) == null ? void 0 : _a.geminiExtension : void 0;
+  const geminiMeta = (_b = pkg.metadata) == null ? void 0 : _b.geminiExtension;
+  if (geminiData || geminiMeta) {
+    const geminiConfig = geminiData || geminiMeta;
+    if (geminiConfig == null ? void 0 : geminiConfig.mcpServers) {
+      config.mcpServers = geminiConfig.mcpServers;
+    }
+    if (geminiConfig == null ? void 0 : geminiConfig.contextFileName) {
+      config.contextFileName = geminiConfig.contextFileName;
+    }
+    if (geminiConfig == null ? void 0 : geminiConfig.excludeTools) {
+      config.excludeTools = geminiConfig.excludeTools;
+    }
+    if (geminiConfig == null ? void 0 : geminiConfig.experimentalSettings) {
+      config.experimentalSettings = geminiConfig.experimentalSettings;
+    }
+  }
+  const unsupportedSections = pkg.content.sections.filter((s) => s.type !== "metadata" && s.type !== "instructions");
+  if (unsupportedSections.length > 0) {
+    const types2 = [...new Set(unsupportedSections.map((s) => s.type))];
+    warnings.push(`Gemini extensions do not support ${types2.join(", ")} sections - these will be skipped`);
+  }
+  return JSON.stringify(config, null, 2) + "\n";
+}
+var init_to_gemini_plugin = __esm({
+  "../converters/dist/to-gemini-plugin.js"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
 // ../converters/dist/to-opencode.js
 function toOpencode(pkg) {
   const warnings = [];
   let qualityScore = 100;
   try {
-    const content = convertContent6(pkg, warnings);
+    const content = convertContent7(pkg, warnings);
     const lossyConversion = warnings.some((w) => w.includes("not supported") || w.includes("skipped"));
     if (lossyConversion) {
       qualityScore -= 10;
@@ -10464,7 +10833,7 @@ function toOpencode(pkg) {
     };
   }
 }
-function convertContent6(pkg, warnings) {
+function convertContent7(pkg, warnings) {
   const lines = [];
   const metadata = pkg.content.sections.find((s) => s.type === "metadata");
   const tools = pkg.content.sections.find((s) => s.type === "tools");
@@ -10609,7 +10978,7 @@ function toRuler(pkg, options = {}) {
       warnings.push("Hooks are not supported by Ruler");
       qualityScore -= 20;
     }
-    const content = convertContent7(pkg.content, warnings);
+    const content = convertContent8(pkg.content, warnings);
     const header = `<!-- Package: ${pkg.name} -->
 <!-- Author: ${pkg.author || "Unknown"} -->
 ${pkg.description ? `<!-- Description: ${pkg.description} -->
@@ -10645,7 +11014,7 @@ ${content}`;
     };
   }
 }
-function convertContent7(content, warnings) {
+function convertContent8(content, warnings) {
   const parts = [];
   const metadataSection = content.sections.find((s) => s.type === "metadata");
   if (metadataSection) {
@@ -10753,7 +11122,7 @@ function toDroid(pkg) {
   const warnings = [];
   let qualityScore = 100;
   try {
-    const result = convertContent8(pkg, warnings, qualityScore);
+    const result = convertContent9(pkg, warnings, qualityScore);
     const content = result.content;
     qualityScore = result.qualityScore;
     const lossyConversion = warnings.some((w) => w.includes("not supported") || w.includes("skipped"));
@@ -10778,7 +11147,7 @@ function toDroid(pkg) {
     };
   }
 }
-function convertContent8(pkg, warnings, qualityScore) {
+function convertContent9(pkg, warnings, qualityScore) {
   var _a;
   const lines = [];
   const metadata = pkg.content.sections.find((s) => s.type === "metadata");
@@ -10882,7 +11251,7 @@ function toTrae(pkg, options = {}) {
   const warnings = [];
   let qualityScore = 100;
   try {
-    const content = convertContent9(pkg, warnings);
+    const content = convertContent10(pkg, warnings);
     const lossyConversion = warnings.some((w) => w.includes("not supported") || w.includes("skipped"));
     if (lossyConversion) {
       qualityScore -= 10;
@@ -10905,7 +11274,7 @@ function toTrae(pkg, options = {}) {
     };
   }
 }
-function convertContent9(pkg, warnings) {
+function convertContent10(pkg, warnings) {
   var _a, _b, _c;
   const lines = [];
   const title = ((_a = pkg.metadata) == null ? void 0 : _a.title) || pkg.name;
@@ -11024,7 +11393,7 @@ function toAider(pkg, options = {}) {
   const warnings = [];
   let qualityScore = 100;
   try {
-    const content = convertContent10(pkg, warnings);
+    const content = convertContent11(pkg, warnings);
     const lossyConversion = warnings.some((w) => w.includes("not supported") || w.includes("skipped"));
     if (lossyConversion) {
       qualityScore -= 10;
@@ -11047,7 +11416,7 @@ function toAider(pkg, options = {}) {
     };
   }
 }
-function convertContent10(pkg, warnings) {
+function convertContent11(pkg, warnings) {
   var _a, _b, _c;
   const lines = [];
   const title = ((_a = pkg.metadata) == null ? void 0 : _a.title) || pkg.name;
@@ -11170,7 +11539,7 @@ function toZencoder(pkg, options = {}) {
     const config = options.zencoderConfig || {};
     const hasConfig = config.description || config.globs || config.alwaysApply !== void 0 || ((_a = pkg.metadata) == null ? void 0 : _a.globs) || ((_b = pkg.metadata) == null ? void 0 : _b.alwaysApply) !== void 0;
     const includeFrontmatter = config.includeFrontmatter ?? hasConfig;
-    const content = convertContent11(pkg, warnings, config);
+    const content = convertContent12(pkg, warnings, config);
     let fullContent;
     if (includeFrontmatter) {
       const frontmatter = generateFrontmatter3(pkg, config);
@@ -11243,7 +11612,7 @@ function generateFrontmatter3(pkg, config) {
   }
   return "";
 }
-function convertContent11(pkg, warnings, config) {
+function convertContent12(pkg, warnings, config) {
   var _a, _b, _c;
   const lines = [];
   const title = ((_a = pkg.metadata) == null ? void 0 : _a.title) || pkg.name;
@@ -11368,7 +11737,7 @@ function toReplit(pkg, options = {}) {
   const warnings = [];
   let qualityScore = 100;
   try {
-    const content = convertContent12(pkg, warnings);
+    const content = convertContent13(pkg, warnings);
     const lossyConversion = warnings.some((w) => w.includes("not supported") || w.includes("skipped"));
     if (lossyConversion) {
       qualityScore -= 10;
@@ -11391,7 +11760,7 @@ function toReplit(pkg, options = {}) {
     };
   }
 }
-function convertContent12(pkg, warnings) {
+function convertContent13(pkg, warnings) {
   var _a, _b, _c;
   const lines = [];
   const title = ((_a = pkg.metadata) == null ? void 0 : _a.title) || pkg.name;
@@ -11505,6 +11874,175 @@ var init_to_replit = __esm({
   }
 });
 
+// ../converters/dist/to-zed.js
+function toZed(pkg, options = {}) {
+  const warnings = [];
+  let qualityScore = 100;
+  try {
+    const fullContent = convertContent14(pkg, warnings);
+    const lossyConversion = warnings.some((w) => w.includes("not supported") || w.includes("skipped"));
+    if (lossyConversion) {
+      qualityScore -= 10;
+    }
+    return {
+      content: fullContent,
+      format: "zed",
+      warnings: warnings.length > 0 ? warnings : void 0,
+      lossyConversion,
+      qualityScore
+    };
+  } catch (error) {
+    warnings.push(`Conversion error: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      content: "",
+      format: "zed",
+      warnings,
+      lossyConversion: true,
+      qualityScore: 0
+    };
+  }
+}
+function convertContent14(pkg, warnings) {
+  var _a, _b, _c;
+  const lines = [];
+  const projectName = ((_a = pkg.metadata) == null ? void 0 : _a.title) || pkg.name;
+  lines.push(`# ${projectName}`);
+  lines.push("");
+  if (pkg.description || ((_b = pkg.metadata) == null ? void 0 : _b.description)) {
+    lines.push(pkg.description || ((_c = pkg.metadata) == null ? void 0 : _c.description) || "");
+    lines.push("");
+  }
+  for (const section of pkg.content.sections) {
+    if (section.type === "metadata" || section.type === "tools" || section.type === "persona") {
+      if (section.type === "persona") {
+        warnings.push("Persona section skipped (not supported by Zed)");
+      } else if (section.type === "tools") {
+        warnings.push("Tools section skipped (not supported by Zed)");
+      }
+      continue;
+    }
+    const sectionContent = convertSection12(section, warnings);
+    if (sectionContent) {
+      lines.push(sectionContent);
+      lines.push("");
+    }
+  }
+  return lines.join("\n").trim();
+}
+function convertSection12(section, warnings) {
+  switch (section.type) {
+    case "instructions":
+      return convertInstructions12(section);
+    case "rules":
+      return convertRules12(section);
+    case "examples":
+      return convertExamples12(section);
+    case "context":
+      return convertContext12(section);
+    case "custom":
+      if (!section.editorType) {
+        return section.content;
+      }
+      if (section.editorType === "zed") {
+        return section.content;
+      }
+      warnings.push(`Custom ${section.editorType} section skipped`);
+      return "";
+    default:
+      return "";
+  }
+}
+function convertInstructions12(section) {
+  const lines = [];
+  lines.push(`## ${section.title}`);
+  lines.push("");
+  lines.push(section.content);
+  return lines.join("\n");
+}
+function convertRules12(section) {
+  const lines = [];
+  lines.push(`## ${section.title}`);
+  lines.push("");
+  section.items.forEach((rule, index) => {
+    const prefix = section.ordered ? `${index + 1}.` : "-";
+    lines.push(`${prefix} ${rule.content}`);
+    if (rule.rationale) {
+      lines.push(`   - Rationale: ${rule.rationale}`);
+    }
+    if (rule.examples && rule.examples.length > 0) {
+      rule.examples.forEach((example) => {
+        lines.push(`   - Example: \`${example}\``);
+      });
+    }
+  });
+  return lines.join("\n");
+}
+function convertExamples12(section) {
+  const lines = [];
+  lines.push(`## ${section.title}`);
+  lines.push("");
+  section.examples.forEach((example) => {
+    if (example.good === false) {
+      lines.push(`### \u274C Avoid: ${example.description}`);
+    } else if (example.good === true) {
+      lines.push(`### \u2705 Preferred: ${example.description}`);
+    } else {
+      lines.push(`### ${example.description}`);
+    }
+    lines.push("");
+    const lang = example.language || "";
+    lines.push("```" + lang);
+    lines.push(example.code);
+    lines.push("```");
+    lines.push("");
+  });
+  return lines.join("\n");
+}
+function convertContext12(section) {
+  const lines = [];
+  lines.push(`## ${section.title}`);
+  lines.push("");
+  lines.push(section.content);
+  return lines.join("\n");
+}
+function isZedFormat2(content) {
+  const trimmed = content.trim();
+  if (trimmed.startsWith("---")) {
+    return false;
+  }
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return false;
+  }
+  return true;
+}
+function generateFilename(pkg, config) {
+  if (config == null ? void 0 : config.useAlternativeFile) {
+    switch (config.useAlternativeFile) {
+      case "cursorrules":
+        return ".cursorrules";
+      case "windsurfrules":
+        return ".windsurfrules";
+      case "clinerules":
+        return ".clinerules";
+      case "agents":
+        return "AGENTS.md";
+      case "claude":
+        return "CLAUDE.md";
+      case "gemini":
+        return "GEMINI.md";
+      default:
+        return ".rules";
+    }
+  }
+  return ".rules";
+}
+var init_to_zed = __esm({
+  "../converters/dist/to-zed.js"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
 // ../converters/dist/to-mcp-server.js
 function toMCPServer(pkg) {
   var _a, _b;
@@ -11584,17 +12122,17 @@ var init_to_mcp_server = __esm({
 });
 
 // ../converters/dist/schema-files.js
-var import_module, import_path6, schemaRequire, convertersPackagePath, convertersDir, loadSchema2, formatRegistrySchema, agentsMdSchema, canonicalSchema, claudeSchema, continueSchema, copilotSchema, cursorSchema, droidSchema, geminiMdSchema, geminiSchema, kiroSteeringSchema, opencodeSchema, rulerSchema, windsurfSchema, traeSchema, aiderSchema, zencoderSchema, replitSchema, claudeAgentSchema, claudeHookSchema, claudeSkillSchema, claudeSlashCommandSchema, cursorCommandSchema, cursorHooksSchema, droidHookSchema, droidSkillSchema, droidSlashCommandSchema, kiroAgentSchema, kiroHookSchema, opencodeSlashCommandSchema;
+var import_module, import_path7, schemaRequire, convertersPackagePath, convertersDir, loadSchema2, formatRegistrySchema, agentsMdSchema, canonicalSchema, claudeSchema, continueSchema, copilotSchema, cursorSchema, droidSchema, geminiMdSchema, geminiSchema, kiroSteeringSchema, opencodeSchema, rulerSchema, windsurfSchema, traeSchema, aiderSchema, zencoderSchema, replitSchema, zedSchema, claudeAgentSchema, claudeHookSchema, claudeSkillSchema, claudeSlashCommandSchema, cursorCommandSchema, cursorHooksSchema, droidHookSchema, droidSkillSchema, droidSlashCommandSchema, kiroAgentSchema, kiroHookSchema, opencodeSlashCommandSchema;
 var init_schema_files = __esm({
   "../converters/dist/schema-files.js"() {
     "use strict";
     init_cjs_shims();
     import_module = require("module");
-    import_path6 = require("path");
+    import_path7 = require("path");
     schemaRequire = (0, import_module.createRequire)(importMetaUrl);
     convertersPackagePath = schemaRequire.resolve("@pr-pm/converters/package.json");
-    convertersDir = (0, import_path6.dirname)(convertersPackagePath);
-    loadSchema2 = (filename) => schemaRequire((0, import_path6.join)(convertersDir, "schemas", filename));
+    convertersDir = (0, import_path7.dirname)(convertersPackagePath);
+    loadSchema2 = (filename) => schemaRequire((0, import_path7.join)(convertersDir, "schemas", filename));
     formatRegistrySchema = loadSchema2("format-registry.schema.json");
     agentsMdSchema = loadSchema2("agents-md.schema.json");
     canonicalSchema = loadSchema2("canonical.schema.json");
@@ -11613,6 +12151,7 @@ var init_schema_files = __esm({
     aiderSchema = loadSchema2("aider.schema.json");
     zencoderSchema = loadSchema2("zencoder.schema.json");
     replitSchema = loadSchema2("replit.schema.json");
+    zedSchema = loadSchema2("zed.schema.json");
     claudeAgentSchema = loadSchema2("claude-agent.schema.json");
     claudeHookSchema = loadSchema2("claude-hook.schema.json");
     claudeSkillSchema = loadSchema2("claude-skill.schema.json");
@@ -11793,13 +12332,22 @@ var init_format_registry = __esm({
         },
         gemini: {
           name: "Gemini CLI",
-          description: "Gemini CLI custom commands",
+          description: "Gemini CLI custom commands and extensions",
           documentationUrl: "https://geminicli.com",
+          rootFiles: [".gemini/extensions/*/gemini-extension.json"],
           subtypes: {
             "slash-command": {
               directory: ".gemini/commands",
               filePatterns: ["*.toml"],
               fileExtension: ".toml"
+            },
+            extension: {
+              directory: ".gemini/extensions",
+              filePatterns: ["gemini-extension.json"],
+              nested: true,
+              nestedIndicator: "gemini-extension.json",
+              usesPackageSubdirectory: true,
+              fileExtension: ".json"
             }
           }
         },
@@ -12133,13 +12681,197 @@ var init_format_registry2 = __esm({
   }
 });
 
+// ../converters/dist/utils/progressive-disclosure.js
+function loadFormatCapabilities() {
+  try {
+    const dataPath = (0, import_path8.join)(__dirname2, "format-capabilities.json");
+    const data = (0, import_fs7.readFileSync)(dataPath, "utf-8");
+    const parsed = JSON.parse(data);
+    if (!parsed || typeof parsed !== "object") {
+      throw new Error("Invalid format-capabilities.json: not an object");
+    }
+    if (!parsed.agentsMdSupport || !Array.isArray(parsed.agentsMdSupport.formats)) {
+      throw new Error("Invalid format-capabilities.json: missing agentsMdSupport.formats array");
+    }
+    if (!parsed.formats || typeof parsed.formats !== "object") {
+      throw new Error("Invalid format-capabilities.json: missing formats object");
+    }
+    return parsed;
+  } catch (error) {
+    console.error(`Failed to load format-capabilities.json: ${error instanceof Error ? error.message : String(error)}`);
+    console.error("Using minimal fallback capabilities");
+    return {
+      version: "1.0.0",
+      description: "Minimal fallback capabilities due to load error",
+      agentsMdSupport: {
+        description: "Basic agents.md support (fallback)",
+        formats: ["cursor", "copilot", "windsurf", "continue", "kiro", "droid", "opencode", "trae", "zed", "agents.md"]
+      },
+      formats: {}
+    };
+  }
+}
+function supportsAgentsMd(format) {
+  return AGENTS_MD_SUPPORTED_FORMATS.includes(format);
+}
+function formatSupportsSubtype2(format, subtype) {
+  const capabilities = FORMAT_CAPABILITIES[format];
+  if (!capabilities)
+    return false;
+  switch (subtype) {
+    case "skill":
+      return capabilities.supportsSkills || false;
+    case "plugin":
+    case "extension":
+      return capabilities.supportsPlugins || capabilities.supportsExtensions || false;
+    case "agent":
+      return capabilities.supportsAgents || false;
+    default:
+      return true;
+  }
+}
+function shouldUseMarkdownFallback(targetFormat, sourceSubtype) {
+  const capabilities = FORMAT_CAPABILITIES[targetFormat];
+  if (!capabilities) {
+    return { shouldFallback: false };
+  }
+  const supportsSubtype = formatSupportsSubtype2(targetFormat, sourceSubtype);
+  if (!supportsSubtype) {
+    return {
+      shouldFallback: true,
+      fallbackFormat: capabilities.markdownFallback,
+      reason: `${targetFormat} doesn't support ${sourceSubtype} subtype`
+    };
+  }
+  return { shouldFallback: false };
+}
+function getRecommendedFormat(targetFormat, sourceSubtype) {
+  const warnings = [];
+  const fallback = shouldUseMarkdownFallback(targetFormat, sourceSubtype);
+  if (fallback.shouldFallback) {
+    warnings.push(`Progressive disclosure: Using ${fallback.fallbackFormat} because ${fallback.reason}`);
+    return {
+      format: "markdown",
+      filename: fallback.fallbackFormat,
+      useProgressive: true,
+      warnings
+    };
+  }
+  return {
+    format: targetFormat,
+    subtype: sourceSubtype,
+    useProgressive: false,
+    warnings
+  };
+}
+function getUniversalFallback() {
+  return {
+    format: "markdown",
+    filename: "agents.md",
+    description: "Universal agent format - works with OpenAI, Gemini, Claude, and most AI systems"
+  };
+}
+function getFallbackChain(format) {
+  const chain = [];
+  const capabilities = FORMAT_CAPABILITIES[format];
+  chain.push({
+    format,
+    filename: (capabilities == null ? void 0 : capabilities.markdownFallback) || "README.md",
+    priority: 1,
+    description: `Native ${format} format`
+  });
+  if (capabilities == null ? void 0 : capabilities.markdownFallback) {
+    const fallbackFilename = capabilities.markdownFallback;
+    const formatName = capabilities.name || format;
+    chain.push({
+      format: "markdown",
+      filename: fallbackFilename,
+      priority: 2,
+      description: `${formatName}-specific markdown format`
+    });
+  }
+  chain.push({
+    format: "markdown",
+    filename: "agents.md",
+    priority: 3,
+    description: "Universal agents.md format"
+  });
+  return chain;
+}
+function getConversionStrategy(targetFormat, sourceSubtype, options) {
+  const warnings = [];
+  let qualityScore = 100;
+  if (options == null ? void 0 : options.forceMarkdown) {
+    const capabilities = FORMAT_CAPABILITIES[targetFormat];
+    return {
+      primaryFormat: "markdown",
+      primaryFilename: capabilities == null ? void 0 : capabilities.markdownFallback,
+      strategy: "progressive",
+      warnings: ["Forced markdown fallback as requested"],
+      qualityScore: 80
+    };
+  }
+  if (options == null ? void 0 : options.preferUniversal) {
+    return {
+      primaryFormat: "markdown",
+      primaryFilename: "agents.md",
+      strategy: "universal",
+      warnings: ["Using universal agents.md format for maximum compatibility"],
+      qualityScore: 75
+    };
+  }
+  const recommendation = getRecommendedFormat(targetFormat, sourceSubtype);
+  if (recommendation.useProgressive) {
+    qualityScore -= 15;
+    return {
+      primaryFormat: recommendation.format,
+      primaryFilename: recommendation.filename,
+      fallbackFormat: "markdown",
+      fallbackFilename: "agents.md",
+      strategy: "progressive",
+      warnings: recommendation.warnings,
+      qualityScore
+    };
+  }
+  return {
+    primaryFormat: recommendation.format,
+    strategy: "native",
+    warnings: [],
+    qualityScore
+  };
+}
+function getAllFormatCapabilities() {
+  return capabilitiesData;
+}
+function getFormatCapability(format) {
+  return capabilitiesData.formats[format];
+}
+var import_fs7, import_path8, import_url2, __filename2, __dirname2, capabilitiesData, AGENTS_MD_SUPPORTED_FORMATS, FORMAT_CAPABILITIES;
+var init_progressive_disclosure = __esm({
+  "../converters/dist/utils/progressive-disclosure.js"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs7 = require("fs");
+    import_path8 = require("path");
+    import_url2 = require("url");
+    __filename2 = (0, import_url2.fileURLToPath)(importMetaUrl);
+    __dirname2 = (0, import_path8.dirname)(__filename2);
+    capabilitiesData = loadFormatCapabilities();
+    AGENTS_MD_SUPPORTED_FORMATS = capabilitiesData.agentsMdSupport.formats;
+    FORMAT_CAPABILITIES = capabilitiesData.formats;
+  }
+});
+
 // ../converters/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
+  AGENTS_MD_SUPPORTED_FORMATS: () => AGENTS_MD_SUPPORTED_FORMATS,
   CLAUDE_TO_CURSOR: () => CLAUDE_TO_CURSOR,
   CLAUDE_TO_KIRO: () => CLAUDE_TO_KIRO,
+  CLI_SUPPORTED_FORMATS: () => CLI_SUPPORTED_FORMATS,
   CURSOR_TO_CLAUDE: () => CURSOR_TO_CLAUDE,
   CURSOR_TO_KIRO: () => CURSOR_TO_KIRO,
+  FORMAT_CAPABILITIES: () => FORMAT_CAPABILITIES,
   KIRO_TO_CLAUDE: () => KIRO_TO_CLAUDE,
   KIRO_TO_CURSOR: () => KIRO_TO_CURSOR,
   SCRIPT_LANGUAGE_EXTENSIONS: () => SCRIPT_LANGUAGE_EXTENSIONS,
@@ -12169,7 +12901,7 @@ __export(dist_exports, {
   findFormatByRootFile: () => findFormatByRootFile,
   formatRegistry: () => formatRegistry,
   formatRegistrySchema: () => formatRegistrySchema,
-  formatSupportsSubtype: () => formatSupportsSubtype,
+  formatSupportsSubtype: () => formatSupportsSubtype2,
   formatValidationErrors: () => formatValidationErrors,
   fromAgentsMd: () => fromAgentsMd,
   fromAider: () => fromAider,
@@ -12181,6 +12913,7 @@ __export(dist_exports, {
   fromCursorHooks: () => fromCursorHooks,
   fromDroid: () => fromDroid,
   fromGemini: () => fromGemini,
+  fromGeminiPlugin: () => fromGeminiPlugin,
   fromKiro: () => fromKiro,
   fromKiroAgent: () => fromKiroAgent,
   fromMCPServer: () => fromMCPServer,
@@ -12189,26 +12922,34 @@ __export(dist_exports, {
   fromRuler: () => fromRuler,
   fromTrae: () => fromTrae,
   fromWindsurf: () => fromWindsurf,
+  fromZed: () => fromZed,
   fromZencoder: () => fromZencoder,
   geminiMdSchema: () => geminiMdSchema,
   geminiSchema: () => geminiSchema,
   generateMCPServerPackage: () => generateMCPServerPackage,
   generatePluginJson: () => generatePluginJson,
+  generateZedFilename: () => generateFilename,
+  getAllFormatCapabilities: () => getAllFormatCapabilities,
+  getConversionStrategy: () => getConversionStrategy,
   getDefaultSubtype: () => getDefaultSubtype,
   getDestinationDirectory: () => getDestinationDirectory,
+  getFallbackChain: () => getFallbackChain,
   getFileExtension: () => getFileExtension,
   getFilePatterns: () => getFilePatterns,
+  getFormatCapability: () => getFormatCapability,
   getFormatConfig: () => getFormatConfig,
   getFormatNames: () => getFormatNames,
   getFormatRegistry: () => getFormatRegistry,
   getHookMapping: () => getHookMapping,
   getNestedIndicator: () => getNestedIndicator,
   getQualityPenalty: () => getQualityPenalty,
+  getRecommendedFormat: () => getRecommendedFormat,
   getRootFiles: () => getRootFiles,
   getScanDirectory: () => getScanDirectory,
   getScriptExtension: () => getScriptExtension,
   getSubtypeConfig: () => getSubtypeConfig,
   getSubtypes: () => getSubtypes,
+  getUniversalFallback: () => getUniversalFallback,
   isAgentsMdFormat: () => isAgentsMdFormat,
   isAiderFormat: () => isAiderFormat,
   isClaudeFormat: () => isClaudeFormat,
@@ -12225,6 +12966,8 @@ __export(dist_exports, {
   isValidCursorHookType: () => isValidCursorHookType,
   isValidHookMappingStrategy: () => isValidHookMappingStrategy,
   isWindsurfFormat: () => isWindsurfFormat,
+  isZedFormat: () => isZedFormat,
+  isZedFormatTo: () => isZedFormat2,
   isZencoderFormat: () => isZencoderFormat,
   kiroAgentSchema: () => kiroAgentSchema,
   kiroHookSchema: () => kiroHookSchema,
@@ -12240,6 +12983,8 @@ __export(dist_exports, {
   resolveFormatForSubtype: () => resolveFormatForSubtype,
   rulerSchema: () => rulerSchema,
   setTaxonomy: () => setTaxonomy,
+  shouldUseMarkdownFallback: () => shouldUseMarkdownFallback,
+  supportsAgentsMd: () => supportsAgentsMd,
   toAgentsMd: () => toAgentsMd,
   toAider: () => toAider,
   toClaude: () => toClaude,
@@ -12251,6 +12996,7 @@ __export(dist_exports, {
   toCursorHooks: () => toCursorHooks,
   toDroid: () => toDroid,
   toGemini: () => toGemini,
+  toGeminiPlugin: () => toGeminiPlugin,
   toKiro: () => toKiro,
   toKiroAgent: () => toKiroAgent,
   toMCPServer: () => toMCPServer,
@@ -12259,12 +13005,14 @@ __export(dist_exports, {
   toRuler: () => toRuler,
   toTrae: () => toTrae,
   toWindsurf: () => toWindsurf,
+  toZed: () => toZed,
   toZencoder: () => toZencoder,
   traeSchema: () => traeSchema,
   validateConversion: () => validateConversion,
   validateFormat: () => validateFormat,
   validateMarkdown: () => validateMarkdown,
   windsurfSchema: () => windsurfSchema,
+  zedSchema: () => zedSchema,
   zencoderSchema: () => zencoderSchema
 });
 var init_dist = __esm({
@@ -12285,6 +13033,7 @@ var init_dist = __esm({
     init_from_windsurf();
     init_from_agents_md();
     init_from_gemini();
+    init_from_gemini_plugin();
     init_from_opencode();
     init_from_ruler();
     init_from_droid();
@@ -12292,6 +13041,7 @@ var init_dist = __esm({
     init_from_aider();
     init_from_zencoder();
     init_from_replit();
+    init_from_zed();
     init_from_mcp_server();
     init_to_cursor();
     init_to_cursor_hooks();
@@ -12304,6 +13054,7 @@ var init_dist = __esm({
     init_to_windsurf();
     init_to_agents_md();
     init_to_gemini();
+    init_to_gemini_plugin();
     init_to_opencode();
     init_to_ruler();
     init_to_droid();
@@ -12311,11 +13062,13 @@ var init_dist = __esm({
     init_to_aider();
     init_to_zencoder();
     init_to_replit();
+    init_to_zed();
     init_to_mcp_server();
     init_taxonomy_utils();
     init_validation();
     init_schema_files();
     init_format_registry2();
+    init_progressive_disclosure();
   }
 });
 
@@ -12339,23 +13092,23 @@ function getDestinationDir2(format, subtype, name) {
 }
 async function ensureDirectoryExists(dirPath) {
   try {
-    await import_fs6.promises.mkdir(dirPath, { recursive: true });
+    await import_fs8.promises.mkdir(dirPath, { recursive: true });
   } catch (error) {
     throw new Error(`Failed to create directory ${dirPath}: ${error}`);
   }
 }
 async function saveFile(filePath, content) {
   try {
-    const dir = import_path7.default.dirname(filePath);
+    const dir = import_path9.default.dirname(filePath);
     await ensureDirectoryExists(dir);
-    await import_fs6.promises.writeFile(filePath, content, "utf-8");
+    await import_fs8.promises.writeFile(filePath, content, "utf-8");
   } catch (error) {
     throw new Error(`Failed to save file ${filePath}: ${error}`);
   }
 }
 async function fileExists(filePath) {
   try {
-    await import_fs6.promises.access(filePath);
+    await import_fs8.promises.access(filePath);
     return true;
   } catch {
     return false;
@@ -12363,7 +13116,7 @@ async function fileExists(filePath) {
 }
 async function directoryExists(dirPath) {
   try {
-    const stats = await import_fs6.promises.stat(dirPath);
+    const stats = await import_fs8.promises.stat(dirPath);
     return stats.isDirectory();
   } catch {
     return false;
@@ -12418,13 +13171,13 @@ function stripAuthorNamespace2(packageId) {
   const parts = packageId.split("/");
   return parts[parts.length - 1];
 }
-var import_fs6, import_path7;
+var import_fs8, import_path9;
 var init_filesystem = __esm({
   "src/core/filesystem.ts"() {
     "use strict";
     init_cjs_shims();
-    import_fs6 = require("fs");
-    import_path7 = __toESM(require("path"));
+    import_fs8 = require("fs");
+    import_path9 = __toESM(require("path"));
     init_dist();
   }
 });
@@ -12444,17 +13197,33 @@ function generateSkillXML(entry) {
   const resourceType = entry.resourceType || "skill";
   const tag = resourceType === "agent" ? "agent" : "skill";
   const mainFile = entry.mainFile || (resourceType === "agent" ? "AGENT.md" : "SKILL.md");
-  const fullPath = import_path8.default.join(entry.skillPath, mainFile);
-  return `<${tag}>
+  const fullPath = import_path10.default.join(entry.skillPath, mainFile);
+  const activation = entry.eager ? "eager" : "lazy";
+  return `<${tag} activation="${activation}">
 <name>${escapeXML(entry.name)}</name>
 <description>${escapeXML(entry.description)}</description>
 <path>${escapeXML(fullPath)}</path>
 </${tag}>`;
 }
-function generateSkillsSystemHeader() {
+function generateEagerSkillsSystemHeader() {
   return `<!-- PRPM_MANIFEST_START -->
 
-<skills_system priority="1">
+<skills_system priority="0">
+<usage>
+MANDATORY: You MUST load and apply these skills at the START of every session.
+Do not wait for relevance - these are always active.
+
+How to use eager skills:
+- Load each skill immediately using Bash("cat <path>")
+- These skills apply to ALL work in this project
+- Do NOT skip or defer loading these skills
+</usage>
+
+<eager_skills>`;
+}
+function generateSkillsSystemHeader(includeManifestStart = true) {
+  const prefix = includeManifestStart ? "<!-- PRPM_MANIFEST_START -->\n\n" : "";
+  return `${prefix}<skills_system priority="1">
 <usage>
 When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
 
@@ -12514,7 +13283,7 @@ async function readAgentsMdManifest(agentsPath = "AGENTS.md") {
       afterManifest: ""
     };
   }
-  const content = await import_fs7.promises.readFile(agentsPath, "utf-8");
+  const content = await import_fs9.promises.readFile(agentsPath, "utf-8");
   let manifestStart = "<!-- PRPM_MANIFEST_START -->";
   let manifestEnd = "<!-- PRPM_MANIFEST_END -->";
   let startIdx = content.indexOf(manifestStart);
@@ -12557,22 +13326,56 @@ async function addSkillToManifest(entry, agentsPath = "AGENTS.md") {
   updatedResources.push(entry);
   const skills = updatedResources.filter((r) => (r.resourceType || "skill") === "skill");
   const agents = updatedResources.filter((r) => r.resourceType === "agent");
-  const skillsXML = skills.map((s) => generateSkillXML(s)).join("\n\n");
-  const agentsXML = agents.length > 0 ? agents.map((a) => generateSkillXML(a)).join("\n\n") : void 0;
+  const eagerSkills = skills.filter((s) => s.eager === true);
+  const lazySkills = skills.filter((s) => s.eager !== true);
+  const eagerAgents = agents.filter((a) => a.eager === true);
+  const lazyAgents = agents.filter((a) => a.eager !== true);
   let newContent = "";
   if (!beforeManifest.trim() && !afterManifest.trim()) {
     newContent = "";
   } else {
     newContent = beforeManifest;
   }
-  const hasAgents = agents.length > 0;
-  newContent += generateSkillsSystemHeader();
-  newContent += "\n\n";
-  newContent += skillsXML;
-  newContent += "\n\n";
-  newContent += generateManifestFooter(hasAgents, agentsXML);
+  const hasEagerContent = eagerSkills.length > 0 || eagerAgents.length > 0;
+  const hasLazyContent = lazySkills.length > 0 || lazyAgents.length > 0;
+  if (hasEagerContent) {
+    if (eagerSkills.length > 0) {
+      newContent += generateEagerSkillsSystemHeader();
+      newContent += "\n\n";
+      newContent += eagerSkills.map((s) => generateSkillXML(s)).join("\n\n");
+      newContent += "\n\n</eager_skills>\n</skills_system>\n\n";
+    }
+    if (eagerAgents.length > 0) {
+      newContent += `<agents_system priority="0">
+<usage>
+MANDATORY: These agents are always available and should be used proactively.
+Do not wait for explicit requests - invoke these agents when their expertise applies.
+</usage>
+
+<eager_agents>
+
+`;
+      newContent += eagerAgents.map((a) => generateSkillXML(a)).join("\n\n");
+      newContent += "\n\n</eager_agents>\n</agents_system>\n\n";
+    }
+  }
+  if (hasLazyContent) {
+    if (lazySkills.length > 0) {
+      newContent += generateSkillsSystemHeader(!hasEagerContent);
+      newContent += "\n\n";
+      newContent += lazySkills.map((s) => generateSkillXML(s)).join("\n\n");
+      newContent += "\n\n</available_skills>\n</skills_system>";
+    }
+    if (lazyAgents.length > 0) {
+      newContent += "\n\n" + generateAgentsSystemHeader();
+      newContent += "\n\n";
+      newContent += lazyAgents.map((a) => generateSkillXML(a)).join("\n\n");
+      newContent += "\n\n</available_agents>\n</agents_system>";
+    }
+  }
+  newContent += "\n\n<!-- PRPM_MANIFEST_END -->";
   newContent += afterManifest;
-  await import_fs7.promises.writeFile(agentsPath, newContent.trim() + "\n", "utf-8");
+  await import_fs9.promises.writeFile(agentsPath, newContent.trim() + "\n", "utf-8");
 }
 async function removeSkillFromManifest(skillName, agentsPath = "AGENTS.md") {
   const { beforeManifest, manifest, afterManifest } = await readAgentsMdManifest(agentsPath);
@@ -12584,9 +13387,9 @@ async function removeSkillFromManifest(skillName, agentsPath = "AGENTS.md") {
   if (updatedResources.length === 0) {
     const newContent2 = (beforeManifest + afterManifest).trim();
     if (newContent2) {
-      await import_fs7.promises.writeFile(agentsPath, newContent2 + "\n", "utf-8");
+      await import_fs9.promises.writeFile(agentsPath, newContent2 + "\n", "utf-8");
     } else {
-      await import_fs7.promises.unlink(agentsPath);
+      await import_fs9.promises.unlink(agentsPath);
     }
     return;
   }
@@ -12602,14 +13405,14 @@ async function removeSkillFromManifest(skillName, agentsPath = "AGENTS.md") {
   newContent += "\n\n";
   newContent += generateManifestFooter(hasAgents, agentsXML);
   newContent += afterManifest;
-  await import_fs7.promises.writeFile(agentsPath, newContent.trim() + "\n", "utf-8");
+  await import_fs9.promises.writeFile(agentsPath, newContent.trim() + "\n", "utf-8");
 }
 function parseSkillsFromManifest(manifestXML) {
   const resources = [];
-  const skillFormatRegex = /<skill>\s*<name>([^<]+)<\/name>\s*<description>([^<]+)<\/description>\s*<path>([^<]+)<\/path>\s*<\/skill>/g;
+  const skillFormatWithAttrRegex = /<skill(?:\s+activation="(eager|lazy)")?\s*>\s*<name>([^<]+)<\/name>\s*<description>([^<]+)<\/description>\s*<path>([^<]+)<\/path>\s*<\/skill>/g;
   let match;
-  while ((match = skillFormatRegex.exec(manifestXML)) !== null) {
-    const [, name, description, fullPath] = match;
+  while ((match = skillFormatWithAttrRegex.exec(manifestXML)) !== null) {
+    const [, activation, name, description, fullPath] = match;
     const pathParts = fullPath.trim().split("/");
     const mainFile = pathParts[pathParts.length - 1];
     const dir = pathParts.slice(0, -1).join("/");
@@ -12618,12 +13421,13 @@ function parseSkillsFromManifest(manifestXML) {
       description: unescapeXML(description.trim()),
       skillPath: dir,
       mainFile,
-      resourceType: "skill"
+      resourceType: "skill",
+      eager: activation === "eager"
     });
   }
-  const agentFormatRegex = /<agent>\s*<name>([^<]+)<\/name>\s*<description>([^<]+)<\/description>\s*<path>([^<]+)<\/path>\s*<\/agent>/g;
-  while ((match = agentFormatRegex.exec(manifestXML)) !== null) {
-    const [, name, description, fullPath] = match;
+  const agentFormatWithAttrRegex = /<agent(?:\s+activation="(eager|lazy)")?\s*>\s*<name>([^<]+)<\/name>\s*<description>([^<]+)<\/description>\s*<path>([^<]+)<\/path>\s*<\/agent>/g;
+  while ((match = agentFormatWithAttrRegex.exec(manifestXML)) !== null) {
+    const [, activation, name, description, fullPath] = match;
     const pathParts = fullPath.trim().split("/");
     const mainFile = pathParts[pathParts.length - 1];
     const dir = pathParts.slice(0, -1).join("/");
@@ -12632,7 +13436,8 @@ function parseSkillsFromManifest(manifestXML) {
       description: unescapeXML(description.trim()),
       skillPath: dir,
       mainFile,
-      resourceType: "agent"
+      resourceType: "agent",
+      eager: activation === "eager"
     });
   }
   if (resources.length === 0) {
@@ -12647,7 +13452,9 @@ function parseSkillsFromManifest(manifestXML) {
         description: unescapeXML(description.trim()),
         skillPath: dir,
         mainFile,
-        resourceType: "skill"
+        resourceType: "skill",
+        eager: false
+        // Legacy format defaults to lazy
       });
     }
   }
@@ -12659,13 +13466,13 @@ function escapeXML(str2) {
 function unescapeXML(str2) {
   return str2.replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
 }
-var import_fs7, import_path8;
+var import_fs9, import_path10;
 var init_agents_md_progressive = __esm({
   "src/core/agents-md-progressive.ts"() {
     "use strict";
     init_cjs_shims();
-    import_fs7 = require("fs");
-    import_path8 = __toESM(require("path"));
+    import_fs9 = require("fs");
+    import_path10 = __toESM(require("path"));
     init_filesystem();
   }
 });
@@ -12673,27 +13480,27 @@ var init_agents_md_progressive = __esm({
 // src/core/mcp.ts
 function getMCPConfigPath(global2 = false, projectDir = process.cwd()) {
   if (global2) {
-    return (0, import_path9.join)((0, import_os3.homedir)(), ".claude", "settings.json");
+    return (0, import_path11.join)((0, import_os3.homedir)(), ".claude", "settings.json");
   }
-  return (0, import_path9.join)(projectDir, ".mcp.json");
+  return (0, import_path11.join)(projectDir, ".mcp.json");
 }
 function readMCPConfig(configPath) {
-  if (!(0, import_fs8.existsSync)(configPath)) {
+  if (!(0, import_fs10.existsSync)(configPath)) {
     return { mcpServers: {} };
   }
   try {
-    const content = (0, import_fs8.readFileSync)(configPath, "utf-8");
+    const content = (0, import_fs10.readFileSync)(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     return { mcpServers: {} };
   }
 }
 function writeMCPConfig(configPath, config) {
-  const dir = (0, import_path9.dirname)(configPath);
-  if (!(0, import_fs8.existsSync)(dir)) {
-    (0, import_fs8.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path11.dirname)(configPath);
+  if (!(0, import_fs10.existsSync)(dir)) {
+    (0, import_fs10.mkdirSync)(dir, { recursive: true });
   }
-  (0, import_fs8.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n");
+  (0, import_fs10.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n");
 }
 function mergeMCPServers(servers, global2 = false, projectDir = process.cwd()) {
   const result = {
@@ -12733,7 +13540,7 @@ function removeMCPServers(servers, global2 = false, projectDir = process.cwd())
     return result;
   }
   const configPath = getMCPConfigPath(global2, projectDir);
-  if (!(0, import_fs8.existsSync)(configPath)) {
+  if (!(0, import_fs10.existsSync)(configPath)) {
     return result;
   }
   const config = readMCPConfig(configPath);
@@ -12776,13 +13583,13 @@ function sortObject(obj) {
   }
   return sorted;
 }
-var import_fs8, import_path9, import_os3;
+var import_fs10, import_path11, import_os3;
 var init_mcp = __esm({
   "src/core/mcp.ts"() {
     "use strict";
     init_cjs_shims();
-    import_fs8 = require("fs");
-    import_path9 = require("path");
+    import_fs10 = require("fs");
+    import_path11 = require("path");
     import_os3 = require("os");
   }
 });
@@ -14814,6 +15621,9 @@ async function handleCollectionInstall(collectionSpec, options) {
         if (options.format) {
           installOptions.as = options.format;
         }
+        if (options.eager !== void 0) {
+          installOptions.eager = options.eager;
+        }
         if (pkg.format === "claude" && pkg.subtype === "hook") {
           hasClaudeHooks = true;
         }
@@ -15083,6 +15893,7 @@ function getPackageIcon2(format, subtype) {
     "workflow": "\u{1F504}",
     "template": "\u{1F4C4}",
     "plugin": "\u{1F50C}",
+    "extension": "\u{1F4E6}",
     "server": "\u{1F5A5}\uFE0F"
   };
   const formatIcons = {
@@ -15101,6 +15912,7 @@ function getPackageIcon2(format, subtype) {
     "aider": "\u{1F91D}",
     "zencoder": "\u26A1",
     "replit": "\u{1F52E}",
+    "zed": "\u26A1",
     "mcp": "\u{1F517}",
     "agents.md": "\u{1F4DD}",
     "ruler": "\u{1F4CF}",
@@ -15125,6 +15937,7 @@ function getPackageLabel2(format, subtype) {
     "aider": "Aider",
     "zencoder": "Zencoder",
     "replit": "Replit",
+    "zed": "Zed",
     "mcp": "MCP",
     "agents.md": "Agents.md",
     "ruler": "Ruler",
@@ -15143,6 +15956,7 @@ function getPackageLabel2(format, subtype) {
     "workflow": "Workflow",
     "template": "Template",
     "plugin": "Plugin",
+    "extension": "Extension",
     "server": "Server"
   };
   const formatLabel = formatLabels[format];
@@ -15156,7 +15970,7 @@ function findMainFile(files, format, subtype) {
   const nestedIndicator = getNestedIndicator(format, subtype);
   if (nestedIndicator) {
     const match = files.find((f) => {
-      const filename = import_path11.default.basename(f.name);
+      const filename = import_path13.default.basename(f.name);
       return filename.toLowerCase() === nestedIndicator.toLowerCase();
     });
     if (match) return match;
@@ -15165,7 +15979,7 @@ function findMainFile(files, format, subtype) {
   if (filePatterns) {
     for (const pattern of filePatterns) {
       for (const file of files) {
-        const filename = import_path11.default.basename(file.name);
+        const filename = import_path13.default.basename(file.name);
         if (pattern.startsWith("*")) {
           const extension = pattern.slice(1);
           if (filename.endsWith(extension)) {
@@ -15196,7 +16010,7 @@ function findMainFile(files, format, subtype) {
   ];
   for (const pattern of fallbackPatterns) {
     for (const file of files) {
-      const filename = import_path11.default.basename(file.name);
+      const filename = import_path13.default.basename(file.name);
       if (filename.toLowerCase() === pattern.toLowerCase()) {
         return file;
       }
@@ -15220,7 +16034,8 @@ async function handleInstall(packageSpec, options) {
       return await handleCollectionInstall(collectionId, {
         format: options.as,
         skipOptional: false,
-        dryRun: false
+        dryRun: false,
+        eager: options.eager
       });
     }
     let packageId;
@@ -15455,7 +16270,11 @@ This could indicate:
             canonicalPkg = fromAgentsMd(sourceContent, metadata);
             break;
           case "gemini":
-            canonicalPkg = fromGemini(sourceContent, metadata);
+            if (pkg.subtype === "extension") {
+              canonicalPkg = fromGeminiPlugin(sourceContent, metadata);
+            } else {
+              canonicalPkg = fromGemini(sourceContent, metadata);
+            }
             break;
           default:
             throw new CLIError(`Unsupported source format for conversion: ${pkg.format}`);
@@ -15506,9 +16325,17 @@ This could indicate:
             convertedContent = agentsResult.content;
             break;
           case "gemini":
+            if (effectiveSubtype === "extension") {
+              const geminiPluginResult = toGeminiPlugin(canonicalPkg);
+              convertedContent = geminiPluginResult.content;
+            } else {
+              const geminiResult = toGemini(canonicalPkg);
+              convertedContent = geminiResult.content;
+            }
+            break;
           case "gemini.md":
-            const geminiResult = toGemini(canonicalPkg);
-            convertedContent = geminiResult.content;
+            const geminiMdResult = toAgentsMd(canonicalPkg);
+            convertedContent = geminiMdResult.content;
             break;
           case "ruler":
             convertedContent = toRuler(canonicalPkg).content;
@@ -15584,7 +16411,7 @@ This could indicate:
       if (agentFiles.length > 0) {
         await import_promises2.default.mkdir(".claude/agents", { recursive: true });
         for (const file of agentFiles) {
-          const filename = import_path11.default.basename(file.name);
+          const filename = import_path13.default.basename(file.name);
           const destFile = `.claude/agents/${filename}`;
           await saveFile(destFile, file.content);
           installedFiles.push(destFile);
@@ -15598,7 +16425,7 @@ This could indicate:
         for (const file of skillFiles) {
           const relativePath = file.name.replace(/^skills\//, "");
           const destFile = `.claude/skills/${relativePath}`;
-          const destFileDir = import_path11.default.dirname(destFile);
+          const destFileDir = import_path13.default.dirname(destFile);
           await import_promises2.default.mkdir(destFileDir, { recursive: true });
           await saveFile(destFile, file.content);
           installedFiles.push(destFile);
@@ -15611,7 +16438,7 @@ This could indicate:
       if (commandFiles.length > 0) {
         await import_promises2.default.mkdir(".claude/commands", { recursive: true });
         for (const file of commandFiles) {
-          const filename = import_path11.default.basename(file.name);
+          const filename = import_path13.default.basename(file.name);
           const destFile = `.claude/commands/${filename}`;
           await saveFile(destFile, file.content);
           installedFiles.push(destFile);
@@ -15687,7 +16514,7 @@ This could indicate:
       destDir = getDestinationDir2(effectiveFormat, effectiveSubtype, pkg.name);
       if (locationOverride && effectiveFormat === "cursor") {
         const relativeDestDir = destDir.startsWith("./") ? destDir.slice(2) : destDir;
-        destDir = import_path11.default.join(locationOverride, relativeDestDir);
+        destDir = import_path13.default.join(locationOverride, relativeDestDir);
         console.log(`   \u{1F4C1} Installing Cursor package to custom location: ${destDir}`);
       }
       let mainFile = extractedFiles[0].content;
@@ -15715,7 +16542,7 @@ This could indicate:
           const manifestFilename = getManifestFilename(effectiveFormat);
           let targetPath = manifestFilename;
           if (locationOverride) {
-            targetPath = import_path11.default.join(locationOverride, `${manifestFilename.replace(".md", ".override.md")}`);
+            targetPath = import_path13.default.join(locationOverride, `${manifestFilename.replace(".md", ".override.md")}`);
             console.log(`   \u{1F4C1} Installing to custom location: ${targetPath}`);
           }
           destPath = targetPath;
@@ -15826,7 +16653,7 @@ This could indicate:
       destDir = getDestinationDir2(effectiveFormat, effectiveSubtype, pkg.name);
       if (locationOverride && effectiveFormat === "cursor") {
         const relativeDestDir = destDir.startsWith("./") ? destDir.slice(2) : destDir;
-        destDir = import_path11.default.join(locationOverride, relativeDestDir);
+        destDir = import_path13.default.join(locationOverride, relativeDestDir);
         console.log(`   \u{1F4C1} Installing Cursor package to custom location: ${destDir}`);
       }
       const packageName = stripAuthorNamespace2(packageId);
@@ -15918,15 +16745,23 @@ ${afterFrontmatter}`;
       const resourceName = stripAuthorNamespace2(packageId);
       const resourceType = effectiveSubtype;
       const mainFile = resourceType === "agent" ? "AGENT.md" : "SKILL.md";
+      let resolvedEager;
+      if (options.eager !== void 0) {
+        resolvedEager = options.eager;
+      } else if (pkg.eager !== void 0) {
+        resolvedEager = pkg.eager;
+      }
       const manifestEntry = {
         name: resourceName,
         description: pkg.description || `${pkg.name} ${resourceType}`,
         skillPath: destDir,
         mainFile,
-        resourceType
+        resourceType,
+        eager: resolvedEager
       };
       await addSkillToManifest(manifestEntry, manifestPath);
-      console.log(`   \u2713 Added ${resourceType} to ${manifestPath} manifest`);
+      const eagerLabel = resolvedEager ? " (eager)" : "";
+      console.log(`   \u2713 Added ${resourceType}${eagerLabel} to ${manifestPath} manifest`);
       progressiveDisclosureMetadata = {
         mode: "progressive",
         resourceDir: destDir,
@@ -15935,7 +16770,8 @@ ${afterFrontmatter}`;
         resourceType,
         // Legacy fields for backward compatibility
         skillsDir: destDir,
-        skillName: resourceName
+        skillName: resourceName,
+        eager: resolvedEager
       };
     }
     const updatedLockfile = lockfile || createLockfile();
@@ -15970,11 +16806,17 @@ ${afterFrontmatter}`;
     console.log(`   \u{1F512} Lock file updated`);
     if (progressiveDisclosureMetadata && !options.noAppend) {
       const manifestFile = progressiveDisclosureMetadata.manifestPath;
+      const isEager = progressiveDisclosureMetadata.eager;
       console.log(`
 \u{1F393} Skill installed with progressive disclosure`);
       console.log(`   \u{1F4DD} Skill added to ${manifestFile} manifest`);
-      console.log(`   \u{1F4A1} The skill is available but not loaded into context by default`);
-      console.log(`   \u26A1 Your AI agent will activate this skill automatically when relevant based on its description`);
+      if (isEager) {
+        console.log(`   \u{1F525} This skill will be loaded at the START of every session (eager mode)`);
+        console.log(`   \u26A1 Your AI agent will always apply this skill - no activation needed`);
+      } else {
+        console.log(`   \u{1F4A1} The skill is available but not loaded into context by default`);
+        console.log(`   \u26A1 Your AI agent will activate this skill automatically when relevant based on its description`);
+      }
     }
     if (pluginMetadata) {
       console.log(`
@@ -16013,9 +16855,9 @@ ${afterFrontmatter}`;
   }
 }
 function isPathSafe(targetDir, filePath) {
-  const resolvedPath = import_path11.default.resolve(targetDir, filePath);
-  const resolvedTarget = import_path11.default.resolve(targetDir);
-  return resolvedPath.startsWith(resolvedTarget + import_path11.default.sep) || resolvedPath === resolvedTarget;
+  const resolvedPath = import_path13.default.resolve(targetDir, filePath);
+  const resolvedTarget = import_path13.default.resolve(targetDir);
+  return resolvedPath.startsWith(resolvedTarget + import_path13.default.sep) || resolvedPath === resolvedTarget;
 }
 function hasUnsafePathPatterns(filePath) {
   if (filePath.includes("..")) return true;
@@ -16027,19 +16869,19 @@ function hasUnsafePathPatterns(filePath) {
 async function extractTarball(tarball, packageId) {
   let decompressed;
   try {
-    decompressed = await new Promise((resolve2, reject) => {
+    decompressed = await new Promise((resolve3, reject) => {
       import_zlib.default.gunzip(tarball, (err, result) => {
         if (err) {
           reject(new Error(`Failed to decompress tarball: ${err.message}`));
           return;
         }
-        resolve2(result);
+        resolve3(result);
       });
     });
   } catch (error) {
     throw new CLIError(`Package decompression failed: ${error.message}`);
   }
-  const tmpDir = await import_promises2.default.mkdtemp(import_path11.default.join(import_os4.default.tmpdir(), "prpm-"));
+  const tmpDir = await import_promises2.default.mkdtemp(import_path13.default.join(import_os4.default.tmpdir(), "prpm-"));
   const cleanup = async () => {
     try {
       await import_promises2.default.rm(tmpDir, { recursive: true, force: true });
@@ -16109,7 +16951,7 @@ async function collectExtractedFiles(rootDir, excludedNames, fs14) {
     if (!currentDir) continue;
     const entries = await fs14.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = import_path11.default.join(currentDir, entry.name);
+      const fullPath = import_path13.default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         dirs.push(fullPath);
         continue;
@@ -16121,7 +16963,7 @@ async function collectExtractedFiles(rootDir, excludedNames, fs14) {
         continue;
       }
       const content = await fs14.readFile(fullPath, "utf-8");
-      const relativePath = import_path11.default.relative(rootDir, fullPath).split(import_path11.default.sep).join("/");
+      const relativePath = import_path13.default.relative(rootDir, fullPath).split(import_path13.default.sep).join("/");
       files.push({
         name: relativePath,
         content
@@ -16155,11 +16997,11 @@ async function installFromLockfile(options) {
         console.log(`  Installing ${displayName}...`);
         let locationOverride = options.location;
         if (!locationOverride && lockEntry.format === "agents.md" && lockEntry.installedPath) {
-          const baseName = import_path11.default.basename(lockEntry.installedPath);
+          const baseName = import_path13.default.basename(lockEntry.installedPath);
           if (baseName === "AGENTS.override.md") {
-            locationOverride = import_path11.default.dirname(lockEntry.installedPath);
+            locationOverride = import_path13.default.dirname(lockEntry.installedPath);
           } else if (baseName !== "AGENTS.md") {
-            locationOverride = import_path11.default.dirname(lockEntry.installedPath);
+            locationOverride = import_path13.default.dirname(lockEntry.installedPath);
           }
         }
         const manifestFile = (_a = lockEntry.progressiveDisclosure) == null ? void 0 : _a.manifestPath;
@@ -16203,7 +17045,7 @@ async function installFromLockfile(options) {
 }
 function createInstallCommand() {
   const command = new import_commander11.Command("install");
-  command.description("Install a package from the registry, or install all packages from prpm.lock if no package specified").argument("[package]", "Package to install (e.g., react-rules or react-rules@1.2.0). If omitted, installs all packages from prpm.lock").option("--version <version>", "Specific version to install").option("--as <format>", `Convert and install in specific format (${import_types.FORMATS.join(", ")})`).option("--format <format>", "Alias for --as").option("--location <path>", "Custom location for installed files (Agents.md or nested Cursor rules)").option("--subtype <subtype>", "Specify subtype when converting (skill, agent, rule, etc.)").option("--hook-mapping <strategy>", "Hook mapping strategy: auto (default), strict, skip", "auto").option("--frozen-lockfile", "Fail if lock file needs to be updated (for CI)").option("--no-append", "Skip adding skill to manifest file (skill files only)").option("--manifest-file <filename>", "Custom manifest filename for progressive disclosure").action(async (packageSpec, options) => {
+  command.description("Install a package from the registry, or install all packages from prpm.lock if no package specified").argument("[package]", "Package to install (e.g., react-rules or react-rules@1.2.0). If omitted, installs all packages from prpm.lock").option("--version <version>", "Specific version to install").option("--as <format>", `Convert and install in specific format (${import_types.FORMATS.join(", ")})`).option("--format <format>", "Alias for --as").option("--location <path>", "Custom location for installed files (Agents.md or nested Cursor rules)").option("--subtype <subtype>", "Specify subtype when converting (skill, agent, rule, etc.)").option("--hook-mapping <strategy>", "Hook mapping strategy: auto (default), strict, skip", "auto").option("--frozen-lockfile", "Fail if lock file needs to be updated (for CI)").option("--no-append", "Skip adding skill to manifest file (skill files only)").option("--manifest-file <filename>", "Custom manifest filename for progressive disclosure").option("--eager", "Force skill/agent to always activate (not on-demand)").option("--lazy", "Use default on-demand activation (overrides package eager setting)").action(async (packageSpec, options) => {
     const convertTo = options.format || options.as;
     const validFormats = import_types.FORMATS;
     if (convertTo && !validFormats.includes(convertTo)) {
@@ -16235,6 +17077,7 @@ Valid strategies: ${VALID_HOOK_MAPPING_STRATEGIES.join(", ")}`
       });
       return;
     }
+    const eager = options.eager ? true : options.lazy ? false : void 0;
     await handleInstall(packageSpec, {
       version: options.version,
       as: convertTo,
@@ -16243,12 +17086,13 @@ Valid strategies: ${VALID_HOOK_MAPPING_STRATEGIES.join(", ")}`
       location: options.location,
       noAppend: options.noAppend,
       manifestFile: options.manifestFile,
-      hookMapping: options.hookMapping
+      hookMapping: options.hookMapping,
+      eager
     });
   });
   return command;
 }
-var import_commander11, import_chalk, import_registry_client5, import_stream, import_promises, tar, import_path11, import_zlib, import_promises2, import_os4, import_semver;
+var import_commander11, import_chalk, import_registry_client5, import_stream, import_promises, tar, import_path13, import_zlib, import_promises2, import_os4, import_semver;
 var init_install = __esm({
   "src/commands/install.ts"() {
     "use strict";
@@ -16265,7 +17109,7 @@ var init_install = __esm({
     tar = __toESM(require("tar"));
     init_errors();
     init_prompts();
-    import_path11 = __toESM(require("path"));
+    import_path13 = __toESM(require("path"));
     import_zlib = __toESM(require("zlib"));
     import_promises2 = __toESM(require("fs/promises"));
     import_os4 = __toESM(require("os"));
@@ -16304,7 +17148,7 @@ function buildScanConfigs() {
 }
 async function extractMetadata2(filePath) {
   try {
-    const content = await import_fs13.promises.readFile(filePath, "utf-8");
+    const content = await import_fs15.promises.readFile(filePath, "utf-8");
     const metadata = {};
     const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
     if (frontmatterMatch) {
@@ -16357,7 +17201,7 @@ function matchesPattern(filename, patterns) {
 }
 async function directoryExists2(dirPath) {
   try {
-    const stats = await import_fs13.promises.stat(dirPath);
+    const stats = await import_fs15.promises.stat(dirPath);
     return stats.isDirectory();
   } catch {
     return false;
@@ -16365,7 +17209,7 @@ async function directoryExists2(dirPath) {
 }
 async function fileExists2(filePath) {
   try {
-    await import_fs13.promises.access(filePath);
+    await import_fs15.promises.access(filePath);
     return true;
   } catch {
     return false;
@@ -16373,21 +17217,21 @@ async function fileExists2(filePath) {
 }
 async function scanDirectory2(config, cwd) {
   const packages = [];
-  const fullDir = import_path17.default.join(cwd, config.directory);
+  const fullDir = import_path19.default.join(cwd, config.directory);
   if (!await directoryExists2(fullDir)) {
     return packages;
   }
-  const entries = await import_fs13.promises.readdir(fullDir, { withFileTypes: true });
+  const entries = await import_fs15.promises.readdir(fullDir, { withFileTypes: true });
   if (config.nested) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const packageDir = import_path17.default.join(fullDir, entry.name);
+      const packageDir = import_path19.default.join(fullDir, entry.name);
       if (config.nestedIndicator) {
-        const indicatorPath = import_path17.default.join(packageDir, config.nestedIndicator);
+        const indicatorPath = import_path19.default.join(packageDir, config.nestedIndicator);
         if (!await fileExists2(indicatorPath)) continue;
         const packageFiles = await collectPackageFiles(packageDir, config.directory, entry.name);
         const metadata = await extractMetadata2(indicatorPath);
-        const relativePath = import_path17.default.join(config.directory, entry.name, config.nestedIndicator);
+        const relativePath = import_path19.default.join(config.directory, entry.name, config.nestedIndicator);
         packages.push({
           name: metadata.name || filenameToPackageName(entry.name),
           format: config.format,
@@ -16398,12 +17242,12 @@ async function scanDirectory2(config, cwd) {
           primaryFile: relativePath
         });
       } else {
-        const subEntries = await import_fs13.promises.readdir(packageDir, { withFileTypes: true });
+        const subEntries = await import_fs15.promises.readdir(packageDir, { withFileTypes: true });
         for (const subEntry of subEntries) {
           if (!subEntry.isFile()) continue;
           if (!matchesPattern(subEntry.name, config.patterns)) continue;
-          const filePath = import_path17.default.join(packageDir, subEntry.name);
-          const relativePath = import_path17.default.join(config.directory, entry.name, subEntry.name);
+          const filePath = import_path19.default.join(packageDir, subEntry.name);
+          const relativePath = import_path19.default.join(config.directory, entry.name, subEntry.name);
           const metadata = await extractMetadata2(filePath);
           packages.push({
             name: metadata.name || filenameToPackageName(entry.name),
@@ -16421,8 +17265,8 @@ async function scanDirectory2(config, cwd) {
     for (const entry of entries) {
       if (!entry.isFile()) continue;
       if (!matchesPattern(entry.name, config.patterns)) continue;
-      const filePath = import_path17.default.join(fullDir, entry.name);
-      const relativePath = import_path17.default.join(config.directory, entry.name);
+      const filePath = import_path19.default.join(fullDir, entry.name);
+      const relativePath = import_path19.default.join(config.directory, entry.name);
       const metadata = await extractMetadata2(filePath);
       packages.push({
         name: metadata.name || filenameToPackageName(entry.name),
@@ -16440,24 +17284,24 @@ async function scanDirectory2(config, cwd) {
 async function collectPackageFiles(packageDir, baseDir, packageName) {
   const files = [];
   async function walkDir(dir, relativeBase) {
-    const entries = await import_fs13.promises.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs15.promises.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = import_path17.default.join(dir, entry.name);
-      const relativePath = import_path17.default.join(relativeBase, entry.name);
+      const fullPath = import_path19.default.join(dir, entry.name);
+      const relativePath = import_path19.default.join(relativeBase, entry.name);
       if (entry.isDirectory()) {
         if (["node_modules", "dist", ".git", "coverage"].includes(entry.name)) {
           continue;
         }
         await walkDir(fullPath, relativePath);
       } else if (entry.isFile()) {
-        const ext = import_path17.default.extname(entry.name).toLowerCase();
+        const ext = import_path19.default.extname(entry.name).toLowerCase();
         if ([".md", ".json", ".js", ".ts", ".toml"].includes(ext)) {
           files.push(relativePath);
         }
       }
     }
   }
-  await walkDir(packageDir, import_path17.default.join(baseDir, packageName));
+  await walkDir(packageDir, import_path19.default.join(baseDir, packageName));
   return files;
 }
 function buildRootManifestFiles() {
@@ -16479,7 +17323,7 @@ async function scanForPackages(cwd = process.cwd()) {
     allPackages.push(...packages);
   }
   for (const { file, format } of ROOT_MANIFEST_FILES) {
-    const filePath = import_path17.default.join(cwd, file);
+    const filePath = import_path19.default.join(cwd, file);
     if (await fileExists2(filePath)) {
       const metadata = await extractMetadata2(filePath);
       allPackages.push({
@@ -16493,7 +17337,7 @@ async function scanForPackages(cwd = process.cwd()) {
       });
     }
   }
-  const copilotInstructionsPath = import_path17.default.join(cwd, ".github/copilot-instructions.md");
+  const copilotInstructionsPath = import_path19.default.join(cwd, ".github/copilot-instructions.md");
   if (await fileExists2(copilotInstructionsPath)) {
     const metadata = await extractMetadata2(copilotInstructionsPath);
     allPackages.push({
@@ -16508,13 +17352,13 @@ async function scanForPackages(cwd = process.cwd()) {
   }
   return allPackages;
 }
-var import_fs13, import_path17, SCAN_CONFIGS, ROOT_MANIFEST_FILES;
+var import_fs15, import_path19, SCAN_CONFIGS, ROOT_MANIFEST_FILES;
 var init_package_scanner = __esm({
   "src/core/package-scanner.ts"() {
     "use strict";
     init_cjs_shims();
-    import_fs13 = require("fs");
-    import_path17 = __toESM(require("path"));
+    import_fs15 = require("fs");
+    import_path19 = __toESM(require("path"));
     init_dist();
     SCAN_CONFIGS = buildScanConfigs();
     ROOT_MANIFEST_FILES = buildRootManifestFiles();
@@ -16524,8 +17368,8 @@ var init_package_scanner = __esm({
 // src/core/package-reconciler.ts
 async function readManifest(cwd = process.cwd()) {
   try {
-    const manifestPath = import_path18.default.join(cwd, "prpm.json");
-    const content = await import_fs14.promises.readFile(manifestPath, "utf-8");
+    const manifestPath = import_path20.default.join(cwd, "prpm.json");
+    const content = await import_fs16.promises.readFile(manifestPath, "utf-8");
     const raw = JSON.parse(content);
     if ("packages" in raw && Array.isArray(raw.packages)) {
       return {
@@ -16551,7 +17395,7 @@ async function readManifest(cwd = process.cwd()) {
 }
 async function fileExists3(filePath) {
   try {
-    await import_fs14.promises.access(filePath);
+    await import_fs16.promises.access(filePath);
     return true;
   } catch {
     return false;
@@ -16607,7 +17451,7 @@ async function reconcilePackages(detected, manifest, cwd = process.cwd()) {
     const manifestPkg = manifest[mi];
     let anyFileExists = false;
     for (const file of manifestPkg.files) {
-      const fullPath = import_path18.default.join(cwd, file);
+      const fullPath = import_path20.default.join(cwd, file);
       if (await fileExists3(fullPath)) {
         anyFileExists = true;
         break;
@@ -16676,7 +17520,7 @@ function createManifestFromDetected(packages, defaults) {
       files: pkg.files
     };
   }
-  const projectName = import_path18.default.basename(process.cwd()).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  const projectName = import_path20.default.basename(process.cwd()).toLowerCase().replace(/[^a-z0-9-]/g, "-");
   return {
     name: `${projectName}-packages`,
     version: "1.0.0",
@@ -16687,13 +17531,13 @@ function createManifestFromDetected(packages, defaults) {
     packages: packages.map(detectedToManifest)
   };
 }
-var import_fs14, import_path18;
+var import_fs16, import_path20;
 var init_package_reconciler = __esm({
   "src/core/package-reconciler.ts"() {
     "use strict";
     init_cjs_shims();
-    import_fs14 = require("fs");
-    import_path18 = __toESM(require("path"));
+    import_fs16 = require("fs");
+    import_path20 = __toESM(require("path"));
   }
 });
 
@@ -16808,12 +17652,12 @@ function getDefaultAuthor() {
 async function createExampleFiles(format, files, packageName) {
   const templates = EXAMPLE_TEMPLATES[format] || {};
   for (const file of files) {
-    const filePath = (0, import_path19.join)(process.cwd(), file);
-    const dirPath = (0, import_path19.join)(filePath, "..");
-    if (!(0, import_fs15.existsSync)(dirPath)) {
+    const filePath = (0, import_path21.join)(process.cwd(), file);
+    const dirPath = (0, import_path21.join)(filePath, "..");
+    if (!(0, import_fs17.existsSync)(dirPath)) {
       await (0, import_promises8.mkdir)(dirPath, { recursive: true });
     }
-    if ((0, import_fs15.existsSync)(filePath)) {
+    if ((0, import_fs17.existsSync)(filePath)) {
       console.log(`  Skipping ${file} (already exists)`);
       continue;
     }
@@ -16827,8 +17671,8 @@ Add your content here.
   }
 }
 async function createReadme(config) {
-  const readmePath = (0, import_path19.join)(process.cwd(), "README.md");
-  if ((0, import_fs15.existsSync)(readmePath)) {
+  const readmePath = (0, import_path21.join)(process.cwd(), "README.md");
+  if ((0, import_fs17.existsSync)(readmePath)) {
     console.log("  Skipping README.md (already exists)");
     return;
   }
@@ -16937,8 +17781,8 @@ async function reviewMissingPackage(rl, pkg, index, total) {
   return await confirm(rl, "\n  Remove from prpm.json?", true);
 }
 async function smartInit(options) {
-  const manifestPath = (0, import_path19.join)(process.cwd(), "prpm.json");
-  const hasManifest = (0, import_fs15.existsSync)(manifestPath);
+  const manifestPath = (0, import_path21.join)(process.cwd(), "prpm.json");
+  const hasManifest = (0, import_fs17.existsSync)(manifestPath);
   console.log("\nScanning for packages...\n");
   const detected = await scanForPackages();
   const existingManifest = hasManifest ? await readManifest() : null;
@@ -17088,8 +17932,8 @@ Create multi-package prpm.json with these ${detected.length} packages?` : "\nCre
   }
 }
 async function classicInit(options) {
-  const manifestPath = (0, import_path19.join)(process.cwd(), "prpm.json");
-  if ((0, import_fs15.existsSync)(manifestPath) && !options.force) {
+  const manifestPath = (0, import_path21.join)(process.cwd(), "prpm.json");
+  if ((0, import_fs17.existsSync)(manifestPath) && !options.force) {
     throw new Error(
       "prpm.json already exists. Use --force to overwrite, or run this command in a different directory."
     );
@@ -17347,7 +18191,7 @@ async function scanMode(directories, options) {
     console.log("\u{1F50D} Dry run - no changes made\n");
     return;
   }
-  const prpmJsonPath = options.output || (0, import_path19.join)(process.cwd(), "prpm.json");
+  const prpmJsonPath = options.output || (0, import_path21.join)(process.cwd(), "prpm.json");
   let manifest;
   if (options.append) {
     try {
@@ -17449,15 +18293,15 @@ function createInitCommand() {
   });
   return command;
 }
-var import_commander12, import_promises8, import_path19, import_fs15, readline4, import_process, FORMAT_EXAMPLES, EXAMPLE_TEMPLATES;
+var import_commander12, import_promises8, import_path21, import_fs17, readline4, import_process, FORMAT_EXAMPLES, EXAMPLE_TEMPLATES;
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
     init_cjs_shims();
     import_commander12 = require("commander");
     import_promises8 = require("fs/promises");
-    import_path19 = require("path");
-    import_fs15 = require("fs");
+    import_path21 = require("path");
+    import_fs17 = require("fs");
     readline4 = __toESM(require("readline/promises"));
     import_process = require("process");
     init_types();
@@ -17840,8 +18684,8 @@ Include examples if helpful.
 // src/index.ts
 init_cjs_shims();
 var import_commander29 = require("commander");
-var import_fs19 = require("fs");
-var import_path23 = require("path");
+var import_fs21 = require("fs");
+var import_path25 = require("path");
 
 // src/commands/list.ts
 init_cjs_shims();
@@ -18001,7 +18845,7 @@ var import_commander2 = require("commander");
 init_lockfile();
 init_filesystem();
 init_types();
-var import_fs9 = require("fs");
+var import_fs11 = require("fs");
 init_errors();
 init_agents_md_progressive();
 init_mcp();
@@ -18017,17 +18861,17 @@ async function promptForFormat(packageId, formats) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     rl.question("\nSelect format to uninstall (number): ", (answer) => {
       rl.close();
       const choice = parseInt(answer.trim(), 10);
       if (choice > 0 && choice <= formats.length) {
-        resolve2(formats[choice - 1]);
+        resolve3(formats[choice - 1]);
       } else if (choice === formats.length + 1) {
-        resolve2("all");
+        resolve3("all");
       } else {
         console.log("Invalid choice, uninstalling all formats");
-        resolve2("all");
+        resolve3("all");
       }
     });
   });
@@ -18107,7 +18951,7 @@ async function handleUninstall(name, options = {}) {
         let filesRemoved = 0;
         for (const filePath of files) {
           try {
-            await import_fs9.promises.unlink(filePath);
+            await import_fs11.promises.unlink(filePath);
             filesRemoved++;
             console.log(`   \u{1F5D1}\uFE0F  Deleted: ${filePath}`);
           } catch (error) {
@@ -18136,7 +18980,7 @@ async function handleUninstall(name, options = {}) {
       if (pkg.format === "claude" && pkg.subtype === "hook" && pkg.hookMetadata) {
         const settingsPath = pkg.installedPath || ".claude/settings.json";
         try {
-          const settingsContent = await import_fs9.promises.readFile(settingsPath, "utf-8");
+          const settingsContent = await import_fs11.promises.readFile(settingsPath, "utf-8");
           const settings = JSON.parse(settingsContent);
           if (settings.hooks) {
             let removedCount = 0;
@@ -18153,7 +18997,7 @@ async function handleUninstall(name, options = {}) {
                 }
               }
             }
-            await import_fs9.promises.writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+            await import_fs11.promises.writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
             console.log(`   \u{1FA9D} Removed ${removedCount} hook(s) from ${settingsPath}`);
           }
         } catch (error) {
@@ -18178,12 +19022,12 @@ async function handleUninstall(name, options = {}) {
         throw new CLIError(`Cannot uninstall ${name}: installation path unknown`, 1);
       }
       try {
-        const stats = await import_fs9.promises.stat(targetPath);
+        const stats = await import_fs11.promises.stat(targetPath);
         if (stats.isDirectory()) {
-          await import_fs9.promises.rm(targetPath, { recursive: true, force: true });
+          await import_fs11.promises.rm(targetPath, { recursive: true, force: true });
           console.log(`   \u{1F5D1}\uFE0F  Deleted directory: ${targetPath}`);
         } else if (stats.isFile()) {
-          await import_fs9.promises.unlink(targetPath);
+          await import_fs11.promises.unlink(targetPath);
           console.log(`   \u{1F5D1}\uFE0F  Deleted file: ${targetPath}`);
         }
       } catch (error) {
@@ -18212,17 +19056,17 @@ function createUninstallCommand() {
 // src/commands/index.ts
 init_cjs_shims();
 var import_commander3 = require("commander");
-var import_fs10 = require("fs");
-var import_path10 = __toESM(require("path"));
+var import_fs12 = require("fs");
+var import_path12 = __toESM(require("path"));
 init_lockfile();
 init_filesystem();
 init_errors();
 async function scanDirectory(dirPath, format, subtype) {
   try {
-    const files = await import_fs10.promises.readdir(dirPath, { withFileTypes: true });
+    const files = await import_fs12.promises.readdir(dirPath, { withFileTypes: true });
     const results = [];
     for (const file of files) {
-      const fullPath = import_path10.default.join(dirPath, file.name);
+      const fullPath = import_path12.default.join(dirPath, file.name);
       if (file.isFile()) {
         const id = generateId(file.name);
         results.push({
@@ -18235,11 +19079,11 @@ async function scanDirectory(dirPath, format, subtype) {
         const isCursorAgent = format === "cursor" && subtype === "agent";
         if (isClaudeType || isCursorAgent) {
           try {
-            const subFiles = await import_fs10.promises.readdir(fullPath, { withFileTypes: true });
+            const subFiles = await import_fs12.promises.readdir(fullPath, { withFileTypes: true });
             for (const subFile of subFiles) {
               const isValidFile = subFile.isFile() && (subFile.name === "SKILL.md" || subFile.name === "AGENT.md" || subFile.name === "skill.md" || subFile.name === "agent.md");
               if (isValidFile) {
-                const subFilePath = import_path10.default.join(fullPath, subFile.name);
+                const subFilePath = import_path12.default.join(fullPath, subFile.name);
                 const id = file.name;
                 results.push({
                   filePath: subFilePath,
@@ -18301,7 +19145,7 @@ async function handleIndex(options = {}) {
             id: file.id,
             version: "0.0.0",
             // Local files don't have versions
-            tarballUrl: `file://${import_path10.default.resolve(file.filePath)}`,
+            tarballUrl: `file://${import_path12.default.resolve(file.filePath)}`,
             format: dir.format,
             subtype: dir.subtype
           });
@@ -18427,7 +19271,7 @@ function createTestCommand() {
       console.log("\u{1F4C8} Check your PostHog dashboard for the event: prpm_test");
       console.log("\u{1F517} Dashboard: https://app.posthog.com");
       console.log("\u23F0 Note: Events may take 1-2 minutes to appear in the dashboard");
-      await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+      await new Promise((resolve3) => setTimeout(resolve3, 3e3));
       const stats = await telemetry.getStats();
       console.log(`\u{1F4CA} Total events now: ${stats.totalEvents}`);
       console.log("\n\u{1F50D} Troubleshooting tips:");
@@ -18561,6 +19405,7 @@ function getPackageIcon(format, subtype) {
     "workflow": "\u{1F504}",
     "template": "\u{1F4C4}",
     "plugin": "\u{1F50C}",
+    "extension": "\u{1F4E6}",
     "server": "\u{1F5A5}\uFE0F"
   };
   const formatIcons = {
@@ -18579,6 +19424,7 @@ function getPackageIcon(format, subtype) {
     "aider": "\u{1F91D}",
     "zencoder": "\u26A1",
     "replit": "\u{1F52E}",
+    "zed": "\u26A1",
     "mcp": "\u{1F517}",
     "agents.md": "\u{1F4DD}",
     "ruler": "\u{1F4CF}",
@@ -18603,6 +19449,7 @@ function getPackageLabel(format, subtype) {
     "aider": "Aider",
     "zencoder": "Zencoder",
     "replit": "Replit",
+    "zed": "Zed",
     "mcp": "MCP",
     "agents.md": "Agents.md",
     "ruler": "Ruler",
@@ -18621,6 +19468,7 @@ function getPackageLabel(format, subtype) {
     "workflow": "Workflow",
     "template": "Template",
     "plugin": "Plugin",
+    "extension": "Extension",
     "server": "Server"
   };
   const formatLabel = formatLabels[format];
@@ -18666,14 +19514,14 @@ function displayResults(packages, total, page, limit) {
   console.log("\u2500".repeat(80));
 }
 function promptUser() {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const rl = readline2.createInterface({
       input: process.stdin,
       output: process.stdout
     });
     rl.question("", (answer) => {
       rl.close();
-      resolve2(answer.trim().toLowerCase());
+      resolve3(answer.trim().toLowerCase());
     });
   });
 }
@@ -18710,7 +19558,7 @@ async function handlePagination(query, options, client, searchOptions, initialRe
         console.clear();
       } else {
         console.log("\n\u274C Already on last page");
-        await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+        await new Promise((resolve3) => setTimeout(resolve3, 1e3));
         console.clear();
       }
       continue;
@@ -18723,7 +19571,7 @@ async function handlePagination(query, options, client, searchOptions, initialRe
         console.clear();
       } else {
         console.log("\n\u274C Already on first page");
-        await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+        await new Promise((resolve3) => setTimeout(resolve3, 1e3));
         console.clear();
       }
       continue;
@@ -18733,7 +19581,7 @@ async function handlePagination(query, options, client, searchOptions, initialRe
       console.log(`
 \u{1F310} Opening: ${url}`);
       console.log("   (Copy and paste this URL into your browser)\n");
-      await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+      await new Promise((resolve3) => setTimeout(resolve3, 2e3));
       console.clear();
       continue;
     }
@@ -18744,12 +19592,12 @@ async function handlePagination(query, options, client, searchOptions, initialRe
 \u{1F4E6} To install: \x1B[36mprpm install ${pkg.name}\x1B[0m`);
       console.log(`   More info: \x1B[36mprpm info ${pkg.name}\x1B[0m
 `);
-      await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+      await new Promise((resolve3) => setTimeout(resolve3, 2e3));
       console.clear();
       continue;
     }
     console.log("\n\u274C Invalid option. Try again.");
-    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    await new Promise((resolve3) => setTimeout(resolve3, 1e3));
     console.clear();
   }
 }
@@ -19132,8 +19980,8 @@ init_install();
 init_cjs_shims();
 var import_commander13 = require("commander");
 var import_promises9 = require("fs/promises");
-var import_path20 = require("path");
-var import_fs16 = require("fs");
+var import_path22 = require("path");
+var import_fs18 = require("fs");
 var import_registry_client6 = require("@pr-pm/registry-client");
 init_user_config();
 init_telemetry();
@@ -19142,8 +19990,8 @@ init_errors();
 // src/utils/license-extractor.ts
 init_cjs_shims();
 var import_promises3 = require("fs/promises");
-var import_path12 = require("path");
-var import_fs11 = require("fs");
+var import_path14 = require("path");
+var import_fs13 = require("fs");
 var LICENSE_FILE_PATTERNS = [
   "LICENSE",
   "LICENSE.md",
@@ -19192,9 +20040,9 @@ function generateLicenseUrl(repositoryUrl, fileName) {
 async function extractLicenseInfo(repositoryUrl) {
   const cwd = process.cwd();
   for (const fileName of LICENSE_FILE_PATTERNS) {
-    const filePath = (0, import_path12.join)(cwd, fileName);
+    const filePath = (0, import_path14.join)(cwd, fileName);
     try {
-      await (0, import_promises3.access)(filePath, import_fs11.constants.R_OK);
+      await (0, import_promises3.access)(filePath, import_fs13.constants.R_OK);
       const text = await (0, import_promises3.readFile)(filePath, "utf-8");
       const type2 = detectLicenseType(text);
       const url = generateLicenseUrl(repositoryUrl, fileName);
@@ -19228,7 +20076,7 @@ function validateLicenseInfo(licenseInfo, packageName) {
 // src/utils/snippet-extractor.ts
 init_cjs_shims();
 var import_promises4 = require("fs/promises");
-var import_path13 = require("path");
+var import_path15 = require("path");
 var MAX_SNIPPET_LENGTH = 2e3;
 async function extractSnippet(manifest) {
   const cwd = process.cwd();
@@ -19244,7 +20092,7 @@ async function extractSnippet(manifest) {
       const firstFile = manifest.files[0];
       fileName = typeof firstFile === "string" ? firstFile : firstFile.path;
     }
-    const fullPath = (0, import_path13.join)(cwd, fileName);
+    const fullPath = (0, import_path15.join)(cwd, fileName);
     const stats = await (0, import_promises4.stat)(fullPath);
     if (stats.isDirectory()) {
       console.warn(`\u26A0\uFE0F  Skipping snippet extraction: "${fullPath}" is a directory`);
@@ -19505,7 +20353,7 @@ async function validatePackageFiles(manifest) {
 // src/utils/manifest-loader.ts
 init_cjs_shims();
 var import_promises6 = require("fs/promises");
-var import_path15 = require("path");
+var import_path17 = require("path");
 
 // src/core/marketplace-converter.ts
 init_cjs_shims();
@@ -19671,19 +20519,19 @@ function validateMarketplaceJson(data) {
 init_cjs_shims();
 var import_ajv2 = __toESM(require("ajv"));
 var import_ajv_formats2 = __toESM(require("ajv-formats"));
-var import_fs12 = require("fs");
-var import_path14 = require("path");
+var import_fs14 = require("fs");
+var import_path16 = require("path");
 var schema2;
 var schemaCandidates = [
   // Source file layout (src/core → ../../schemas)
-  (0, import_path14.join)(__dirname, "../../schemas/prpm-manifest.schema.json"),
+  (0, import_path16.join)(__dirname, "../../schemas/prpm-manifest.schema.json"),
   // Bundled layout (dist/index.js → ../schemas)
-  (0, import_path14.join)(__dirname, "../schemas/prpm-manifest.schema.json")
+  (0, import_path16.join)(__dirname, "../schemas/prpm-manifest.schema.json")
 ];
 for (const candidate of schemaCandidates) {
   try {
-    if ((0, import_fs12.existsSync)(candidate)) {
-      schema2 = JSON.parse((0, import_fs12.readFileSync)(candidate, "utf-8"));
+    if ((0, import_fs14.existsSync)(candidate)) {
+      schema2 = JSON.parse((0, import_fs14.readFileSync)(candidate, "utf-8"));
       break;
     }
   } catch {
@@ -19737,7 +20585,7 @@ function getManifestSchema() {
 
 // src/utils/manifest-loader.ts
 async function findAndLoadManifests() {
-  const prpmJsonPath = (0, import_path15.join)(process.cwd(), "prpm.json");
+  const prpmJsonPath = (0, import_path17.join)(process.cwd(), "prpm.json");
   let prpmJsonExists = false;
   try {
     const content = await (0, import_promises6.readFile)(prpmJsonPath, "utf-8");
@@ -19798,7 +20646,7 @@ async function findAndLoadManifests() {
       throw error;
     }
   }
-  const marketplaceJsonPath = (0, import_path15.join)(
+  const marketplaceJsonPath = (0, import_path17.join)(
     process.cwd(),
     ".claude",
     "marketplace.json"
@@ -19818,7 +20666,7 @@ async function findAndLoadManifests() {
     return { manifests, collections: [], source: ".claude/marketplace.json" };
   } catch (error) {
   }
-  const marketplaceJsonPluginPath = (0, import_path15.join)(
+  const marketplaceJsonPluginPath = (0, import_path17.join)(
     process.cwd(),
     ".claude-plugin",
     "marketplace.json"
@@ -19968,13 +20816,13 @@ function getSafePackageName(manifest, userInfo, fallbackName) {
 // src/utils/tarball-creator.ts
 init_cjs_shims();
 var import_promises7 = require("fs/promises");
-var import_path16 = require("path");
+var import_path18 = require("path");
 var tar2 = __toESM(require("tar"));
 var import_os5 = require("os");
 var import_crypto2 = require("crypto");
 async function createTarball(manifest) {
-  const tmpDir = (0, import_path16.join)((0, import_os5.tmpdir)(), `prpm-${(0, import_crypto2.randomBytes)(8).toString("hex")}`);
-  const tarballPath = (0, import_path16.join)(tmpDir, "package.tar.gz");
+  const tmpDir = (0, import_path18.join)((0, import_os5.tmpdir)(), `prpm-${(0, import_crypto2.randomBytes)(8).toString("hex")}`);
+  const tarballPath = (0, import_path18.join)(tmpDir, "package.tar.gz");
   try {
     await (0, import_promises7.mkdir)(tmpDir, { recursive: true });
     const filePaths = normalizeFilePaths2(manifest.files);
@@ -20103,22 +20951,22 @@ async function handlePublish(options) {
       throw new CLIError('\u274C Not logged in. Run "prpm login" first.', 1);
     }
     console.log("\u{1F4E6} Publishing package...\n");
-    const prpmJsonPath = (0, import_path20.join)(process.cwd(), "prpm.json");
-    const marketplaceJsonPath = (0, import_path20.join)(
+    const prpmJsonPath = (0, import_path22.join)(process.cwd(), "prpm.json");
+    const marketplaceJsonPath = (0, import_path22.join)(
       process.cwd(),
       ".claude",
       "marketplace.json"
     );
-    const marketplaceJsonPluginPath = (0, import_path20.join)(
+    const marketplaceJsonPluginPath = (0, import_path22.join)(
       process.cwd(),
       ".claude-plugin",
       "marketplace.json"
     );
-    const hasManifest = (0, import_fs16.existsSync)(prpmJsonPath) || (0, import_fs16.existsSync)(marketplaceJsonPath) || (0, import_fs16.existsSync)(marketplaceJsonPluginPath);
+    const hasManifest = (0, import_fs18.existsSync)(prpmJsonPath) || (0, import_fs18.existsSync)(marketplaceJsonPath) || (0, import_fs18.existsSync)(marketplaceJsonPluginPath);
     if (!hasManifest) {
       console.log("No prpm.json found. Let's create one first.\n");
       await smartInit({});
-      if (!(0, import_fs16.existsSync)(prpmJsonPath)) {
+      if (!(0, import_fs18.existsSync)(prpmJsonPath)) {
         throw new CLIError(
           "No prpm.json was created. Cannot publish without a manifest.",
           1
@@ -20130,7 +20978,7 @@ async function handlePublish(options) {
     const { manifests, collections, source } = await findAndLoadManifests();
     if (source === "prpm.json (multi-package)" || source === "prpm.json") {
       try {
-        const prpmJsonPath2 = (0, import_path20.join)(process.cwd(), "prpm.json");
+        const prpmJsonPath2 = (0, import_path22.join)(process.cwd(), "prpm.json");
         const prpmContent = await (0, import_promises9.readFile)(prpmJsonPath2, "utf-8");
         const prpmManifest = JSON.parse(prpmContent);
         if (prpmManifest.scripts) {
@@ -20222,7 +21070,7 @@ async function handlePublish(options) {
     const BATCH_DELAY_MS = options.dryRun || process.env.NODE_ENV === "test" ? 0 : parseInt(process.env.PRPM_BATCH_DELAY_MS || "2000");
     const MAX_RETRIES = parseInt(process.env.PRPM_MAX_RETRIES || "3");
     const RETRY_DELAY_MS = options.dryRun || process.env.NODE_ENV === "test" ? 0 : parseInt(process.env.PRPM_RETRY_DELAY_MS || "5000");
-    const delay = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+    const delay = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
     const isRetriableError = (error2) => {
       return error2.includes("Service Unavailable") || error2.includes("Bad Gateway") || error2.includes("at capacity") || error2.includes("502") || error2.includes("503") || error2.includes("ECONNRESET") || error2.includes("ETIMEDOUT");
     };
@@ -20789,7 +21637,7 @@ async function pollForAuthentication(registryUrl, userId) {
       }
     } catch (error) {
     }
-    await new Promise((resolve2) => setTimeout(resolve2, 5e3));
+    await new Promise((resolve3) => setTimeout(resolve3, 5e3));
     attempts++;
   }
   throw new Error("Authentication timeout - please try again");
@@ -21479,9 +22327,9 @@ function createReadline() {
   });
 }
 function prompt2(rl, question) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     rl.question(question, (answer) => {
-      resolve2(answer);
+      resolve3(answer);
     });
   });
 }
@@ -22207,7 +23055,7 @@ async function pollForSubscription(initialStatus, maxAttempts = 60, intervalMs =
   console.log("\n\u23F3 Waiting for subscription confirmation...");
   console.log("   (This may take a minute. Press Ctrl+C to cancel)");
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
+    await new Promise((resolve3) => setTimeout(resolve3, intervalMs));
     try {
       const status = await getSubscriptionStatus();
       if (status.prpm_plus_status === "active" && initialStatus !== "active") {
@@ -22386,7 +23234,7 @@ async function pollForPurchase(initialBalance, maxAttempts = 60, intervalMs = 2e
   console.log("\n\u23F3 Waiting for purchase confirmation...");
   console.log("   (This may take a minute. Press Ctrl+C to cancel)");
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
+    await new Promise((resolve3) => setTimeout(resolve3, intervalMs));
     try {
       const status = await getBalance();
       if (status.balance > initialBalance) {
@@ -22655,60 +23503,77 @@ function createStarredCommand() {
 init_cjs_shims();
 var import_commander27 = require("commander");
 var import_promises10 = require("fs/promises");
-var import_path21 = require("path");
-var import_fs17 = require("fs");
+var import_path23 = require("path");
+var import_fs19 = require("fs");
 var import_readline = require("readline");
 var import_chalk2 = __toESM(require_source());
 init_errors();
 init_dist();
 function getDefaultPath(format, filename, subtype, customName) {
-  const baseName = customName || (0, import_path21.basename)(filename, (0, import_path21.extname)(filename));
+  const baseName = customName || (0, import_path23.basename)(filename, (0, import_path23.extname)(filename));
   switch (format) {
     case "cursor":
       if (subtype === "slash-command") {
-        return (0, import_path21.join)(process.cwd(), ".cursor", "commands", `${baseName}.md`);
+        return (0, import_path23.join)(process.cwd(), ".cursor", "commands", `${baseName}.md`);
       }
       if (subtype === "hook") {
-        return (0, import_path21.join)(process.cwd(), ".cursor", "hooks", "hooks.json");
+        return (0, import_path23.join)(process.cwd(), ".cursor", "hooks", "hooks.json");
       }
-      return (0, import_path21.join)(process.cwd(), ".cursor", "rules", `${baseName}.mdc`);
+      return (0, import_path23.join)(process.cwd(), ".cursor", "rules", `${baseName}.mdc`);
     case "claude":
       if (subtype === "skill") {
-        return (0, import_path21.join)(process.cwd(), ".claude", "skills", baseName, "SKILL.md");
+        return (0, import_path23.join)(process.cwd(), ".claude", "skills", baseName, "SKILL.md");
       } else if (subtype === "slash-command") {
-        return (0, import_path21.join)(process.cwd(), ".claude", "commands", `${baseName}.md`);
+        return (0, import_path23.join)(process.cwd(), ".claude", "commands", `${baseName}.md`);
       } else {
-        return (0, import_path21.join)(process.cwd(), ".claude", "agents", `${baseName}.md`);
+        return (0, import_path23.join)(process.cwd(), ".claude", "agents", `${baseName}.md`);
       }
     case "windsurf":
-      return (0, import_path21.join)(process.cwd(), ".windsurf", "rules", `${baseName}.md`);
+      return (0, import_path23.join)(process.cwd(), ".windsurf", "rules", `${baseName}.md`);
     case "kiro":
       if (subtype === "hook") {
-        return (0, import_path21.join)(process.cwd(), ".kiro", "hooks", `${baseName}.kiro.hook`);
+        return (0, import_path23.join)(process.cwd(), ".kiro", "hooks", `${baseName}.kiro.hook`);
       }
       if (subtype === "agent") {
-        return (0, import_path21.join)(process.cwd(), ".kiro", "agents", `${baseName}.json`);
+        return (0, import_path23.join)(process.cwd(), ".kiro", "agents", `${baseName}.json`);
       }
-      return (0, import_path21.join)(process.cwd(), ".kiro", "steering", `${baseName}.md`);
+      return (0, import_path23.join)(process.cwd(), ".kiro", "steering", `${baseName}.md`);
     case "copilot":
-      return (0, import_path21.join)(process.cwd(), ".github", "instructions", `${baseName}.instructions.md`);
+      return (0, import_path23.join)(process.cwd(), ".github", "instructions", `${baseName}.instructions.md`);
     case "continue":
       if (subtype === "slash-command" || subtype === "prompt") {
-        return (0, import_path21.join)(process.cwd(), ".continue", "prompts", `${baseName}.md`);
+        return (0, import_path23.join)(process.cwd(), ".continue", "prompts", `${baseName}.md`);
       }
-      return (0, import_path21.join)(process.cwd(), ".continue", "rules", `${baseName}.md`);
+      return (0, import_path23.join)(process.cwd(), ".continue", "rules", `${baseName}.md`);
     case "agents.md":
-      return (0, import_path21.join)(process.cwd(), "agents.md");
+      return (0, import_path23.join)(process.cwd(), "agents.md");
     case "gemini":
-      return (0, import_path21.join)(process.cwd(), ".gemini", "commands", `${baseName}.toml`);
+      return (0, import_path23.join)(process.cwd(), ".gemini", "commands", `${baseName}.toml`);
     case "ruler":
-      return (0, import_path21.join)(process.cwd(), ".ruler", `${baseName}.md`);
+      return (0, import_path23.join)(process.cwd(), ".ruler", `${baseName}.md`);
+    case "zed":
+      if (subtype === "slash-command") {
+        return (0, import_path23.join)(process.cwd(), ".zed", "slash_commands", `${baseName}.md`);
+      }
+      return (0, import_path23.join)(process.cwd(), ".zed", "extensions", `${baseName}.json`);
+    case "opencode":
+      return (0, import_path23.join)(process.cwd(), ".opencode", `${baseName}.md`);
+    case "aider":
+      return (0, import_path23.join)(process.cwd(), ".aider", `${baseName}.md`);
+    case "trae":
+      return (0, import_path23.join)(process.cwd(), ".trae", "rules", `${baseName}.md`);
+    case "replit":
+      return (0, import_path23.join)(process.cwd(), ".replit", `${baseName}.md`);
+    case "zencoder":
+      return (0, import_path23.join)(process.cwd(), ".zencoder", `${baseName}.md`);
+    case "droid":
+      return (0, import_path23.join)(process.cwd(), ".factory", `${baseName}.md`);
     default:
       throw new CLIError(`Unknown format: ${format}`);
   }
 }
 function detectFormat(content, filepath) {
-  const ext = (0, import_path21.extname)(filepath).toLowerCase();
+  const ext = (0, import_path23.extname)(filepath).toLowerCase();
   if (ext === ".mdc" || filepath.includes(".cursor/rules") || filepath.includes(".cursor/commands")) {
     return "cursor";
   }
@@ -22730,15 +23595,21 @@ function detectFormat(content, filepath) {
   if (filepath.includes(".continue/rules") || filepath.includes(".continue/prompts") || filepath.includes(".continuerules")) {
     return "continue";
   }
-  if ((0, import_path21.basename)(filepath) === "agents.md") {
+  if ((0, import_path23.basename)(filepath) === "agents.md") {
     return "agents.md";
   }
+  if ((0, import_path23.basename)(filepath) === "gemini-extension.json" || filepath.includes(".gemini/extensions")) {
+    return "gemini-extension";
+  }
   if (ext === ".toml" || filepath.includes(".gemini/commands")) {
     return "gemini";
   }
   if (filepath.includes(".ruler/")) {
     return "ruler";
   }
+  if (filepath.includes(".zed/extensions") || filepath.includes(".zed/slash_commands")) {
+    return "zed";
+  }
   if (isCursorHooksFormat(content)) return "cursor-hooks";
   if (isClaudeFormat(content)) {
     if (content.includes("type: skill")) return "claude-skill";
@@ -22753,6 +23624,7 @@ function detectFormat(content, filepath) {
   if (isContinueFormat(content)) return "continue";
   if (isAgentsMdFormat(content)) return "agents.md";
   if (isRulerFormat(content)) return "ruler";
+  if (isZedFormat(content)) return "zed";
   return null;
 }
 async function confirmOverwrite(filepath) {
@@ -22760,12 +23632,12 @@ async function confirmOverwrite(filepath) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     rl.question(
       import_chalk2.default.yellow(`File ${filepath} already exists. Overwrite? (y/N): `),
       (answer) => {
         rl.close();
-        resolve2(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+        resolve3(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
       }
     );
   });
@@ -22790,6 +23662,7 @@ async function handleConvert(sourcePath, options) {
       console.log(import_chalk2.default.dim("  - GitHub Copilot instructions"));
       console.log(import_chalk2.default.dim("  - Continue rules (.continue/rules/*.md)"));
       console.log(import_chalk2.default.dim("  - agents.md format"));
+      console.log(import_chalk2.default.dim("  - Zed extensions (.zed/extensions/*)"));
       throw new CLIError("Unsupported source format");
     }
     console.log(import_chalk2.default.green(`\u2713 Detected source format: ${sourceFormat}`));
@@ -22804,7 +23677,14 @@ async function handleConvert(sourcePath, options) {
     let canonicalPkg;
     switch (sourceFormat.toLowerCase()) {
       case "cursor":
-        canonicalPkg = fromCursor(content, metadata);
+        const hasFileReferences = /@[\w\-\/\.]+\.[\w]+/m.test(content);
+        if (hasFileReferences) {
+          console.log(import_chalk2.default.dim("\u{1F4C1} Detected @file references - resolving linked files..."));
+        }
+        canonicalPkg = fromCursor(content, metadata, {
+          resolveFiles: hasFileReferences,
+          basePath: hasFileReferences ? (0, import_path23.dirname)(sourcePath) : void 0
+        });
         break;
       case "cursor-hooks":
         canonicalPkg = fromCursorHooks(content, metadata);
@@ -22835,6 +23715,9 @@ async function handleConvert(sourcePath, options) {
       case "agents.md":
         canonicalPkg = fromAgentsMd(content, metadata);
         break;
+      case "gemini-extension":
+        canonicalPkg = fromGeminiPlugin(content, metadata);
+        break;
       case "gemini":
         canonicalPkg = fromGemini(content, metadata);
         break;
@@ -22842,6 +23725,27 @@ async function handleConvert(sourcePath, options) {
         const rulerResult = fromRuler(content);
         canonicalPkg = JSON.parse(rulerResult.content);
         break;
+      case "zed":
+        canonicalPkg = fromZed(content, metadata);
+        break;
+      case "opencode":
+        canonicalPkg = fromOpencode(content, metadata);
+        break;
+      case "aider":
+        canonicalPkg = fromAider(content, metadata);
+        break;
+      case "trae":
+        canonicalPkg = fromTrae(content, metadata);
+        break;
+      case "replit":
+        canonicalPkg = fromReplit(content, metadata);
+        break;
+      case "zencoder":
+        canonicalPkg = fromZencoder(content, metadata);
+        break;
+      case "droid":
+        canonicalPkg = fromDroid(content, metadata);
+        break;
       default:
         throw new CLIError(`Unsupported source format: ${sourceFormat}`);
     }
@@ -22885,11 +23789,36 @@ async function handleConvert(sourcePath, options) {
         result = toAgentsMd(canonicalPkg);
         break;
       case "gemini":
-        result = toGemini(canonicalPkg);
+        if (canonicalPkg.subtype === "extension" || options.subtype === "extension") {
+          result = toGeminiPlugin(canonicalPkg);
+        } else {
+          result = toGemini(canonicalPkg);
+        }
         break;
       case "ruler":
         result = toRuler(canonicalPkg);
         break;
+      case "zed":
+        result = toZed(canonicalPkg);
+        break;
+      case "opencode":
+        result = toOpencode(canonicalPkg);
+        break;
+      case "aider":
+        result = toAider(canonicalPkg);
+        break;
+      case "trae":
+        result = toTrae(canonicalPkg);
+        break;
+      case "replit":
+        result = toReplit(canonicalPkg);
+        break;
+      case "zencoder":
+        result = toZencoder(canonicalPkg);
+        break;
+      case "droid":
+        result = toDroid(canonicalPkg);
+        break;
       default:
         throw new CLIError(`Unsupported target format: ${options.to}`);
     }
@@ -22898,14 +23827,14 @@ async function handleConvert(sourcePath, options) {
     }
     console.log(import_chalk2.default.green(`\u2713 Converted from ${sourceFormat} to ${options.to}`));
     const outputPath = options.output || getDefaultPath(options.to, sourcePath, options.subtype, options.name);
-    if ((0, import_fs17.existsSync)(outputPath) && !options.yes) {
+    if ((0, import_fs19.existsSync)(outputPath) && !options.yes) {
       const shouldOverwrite = await confirmOverwrite(outputPath);
       if (!shouldOverwrite) {
         console.log(import_chalk2.default.yellow("\n\u2716 Conversion cancelled"));
         return;
       }
     }
-    const outputDir = (0, import_path21.dirname)(outputPath);
+    const outputDir = (0, import_path23.dirname)(outputPath);
     await (0, import_promises10.mkdir)(outputDir, { recursive: true });
     console.log(import_chalk2.default.dim("Writing converted file..."));
     await (0, import_promises10.writeFile)(outputPath, result.content, "utf-8");
@@ -22923,6 +23852,8 @@ async function handleConvert(sourcePath, options) {
       console.log(import_chalk2.default.dim("\u{1F4A1} Gemini will automatically load commands from .gemini/commands/"));
     } else if (options.to === "ruler") {
       console.log(import_chalk2.default.dim("\u{1F4A1} Ruler will automatically load and distribute rules from .ruler/"));
+    } else if (options.to === "zed") {
+      console.log(import_chalk2.default.dim("\u{1F4A1} Zed will automatically load extensions from .zed/extensions/"));
     }
   } catch (error) {
     console.log(import_chalk2.default.red("\u2716 Conversion failed"));
@@ -22930,17 +23861,16 @@ async function handleConvert(sourcePath, options) {
   }
 }
 function createConvertCommand() {
-  const command = new import_commander27.Command("convert").description("Convert AI prompt files between formats").argument("<source>", "Source file path to convert").option("-t, --to <format>", "Target format (cursor, claude, windsurf, kiro, copilot, continue, agents.md, gemini, ruler)").option("-s, --subtype <subtype>", "Target subtype (agent, skill, slash-command, rule, hook, prompt, etc.)").option("-o, --output <path>", "Output path (defaults to format-specific location)").option("-n, --name <name>", 'Custom output filename (without extension, e.g., "my-rule")').option("--hook-mapping <strategy>", "Hook mapping strategy: auto (default), strict, skip", "auto").option("-y, --yes", "Skip confirmation prompts").action(async (source, options) => {
+  const command = new import_commander27.Command("convert").description("Convert AI prompt files between formats").argument("<source>", "Source file path to convert").option("-t, --to <format>", `Target format (${CLI_SUPPORTED_FORMATS.join(", ")})`).option("-s, --subtype <subtype>", "Target subtype (agent, skill, slash-command, rule, hook, prompt, etc.)").option("-o, --output <path>", "Output path (defaults to format-specific location)").option("-n, --name <name>", 'Custom output filename (without extension, e.g., "my-rule")').option("--hook-mapping <strategy>", "Hook mapping strategy: auto (default), strict, skip", "auto").option("-y, --yes", "Skip confirmation prompts").action(async (source, options) => {
     try {
       if (!options.to) {
         throw new CLIError("Target format is required. Use --to <format>");
       }
-      const validFormats = ["cursor", "claude", "windsurf", "kiro", "copilot", "continue", "agents.md", "gemini", "ruler"];
-      if (!validFormats.includes(options.to)) {
+      if (!CLI_SUPPORTED_FORMATS.includes(options.to)) {
         throw new CLIError(
           `Invalid format: ${options.to}
 
-Valid formats: ${validFormats.join(", ")}
+Valid formats: ${CLI_SUPPORTED_FORMATS.join(", ")}
 
 \u{1F4A1} For Cursor hooks, use: --to cursor --subtype hook`
         );
@@ -22981,8 +23911,8 @@ Valid subtypes: ${validSubtypes.join(", ")}`
 // src/commands/export.ts
 init_cjs_shims();
 var import_commander28 = require("commander");
-var import_fs18 = require("fs");
-var import_path22 = require("path");
+var import_fs20 = require("fs");
+var import_path24 = require("path");
 var import_chalk3 = __toESM(require_source());
 init_errors();
 init_lockfile();
@@ -22998,17 +23928,17 @@ async function exportToRuler(options) {
   }
   console.log(import_chalk3.default.green(`\u2713 Found ${packages.length} installed package${packages.length === 1 ? "" : "s"}`));
   console.log();
-  const outputDir = options.output || (0, import_path22.join)(process.cwd(), ".ruler");
+  const outputDir = options.output || (0, import_path24.join)(process.cwd(), ".ruler");
   let rulerExists = false;
   try {
-    await import_fs18.promises.access(outputDir);
+    await import_fs20.promises.access(outputDir);
     rulerExists = true;
   } catch {
   }
   if (!rulerExists) {
     console.log(import_chalk3.default.yellow(`\u26A0 ${outputDir} directory not found`));
     console.log(import_chalk3.default.dim("Creating .ruler directory..."));
-    await import_fs18.promises.mkdir(outputDir, { recursive: true });
+    await import_fs20.promises.mkdir(outputDir, { recursive: true });
     console.log(import_chalk3.default.green(`\u2713 Created ${outputDir}/`));
     console.log();
   }
@@ -23022,11 +23952,11 @@ async function exportToRuler(options) {
       continue;
     }
     try {
-      const content = await import_fs18.promises.readFile(pkg.installedPath, "utf-8");
+      const content = await import_fs20.promises.readFile(pkg.installedPath, "utf-8");
       const rulerContent = createRulerFormat(pkg.id, pkg.version, content, pkg.format, pkg.subtype);
       const rulerFilename = `${packageName}.md`;
-      const rulerPath = (0, import_path22.join)(outputDir, rulerFilename);
-      await import_fs18.promises.writeFile(rulerPath, rulerContent, "utf-8");
+      const rulerPath = (0, import_path24.join)(outputDir, rulerFilename);
+      await import_fs20.promises.writeFile(rulerPath, rulerContent, "utf-8");
       console.log(import_chalk3.default.green(`\u2713 Exported ${pkg.id} \u2192 ${rulerFilename}`));
       exportedCount++;
     } catch (error) {
@@ -23065,9 +23995,9 @@ function createRulerFormat(packageId, version, content, format, subtype) {
   return frontmatter + contentWithoutFrontmatter;
 }
 async function ensureRulerConfig(rulerDir) {
-  const configPath = (0, import_path22.join)((0, import_path22.dirname)(rulerDir), "ruler.toml");
+  const configPath = (0, import_path24.join)((0, import_path24.dirname)(rulerDir), "ruler.toml");
   try {
-    await import_fs18.promises.access(configPath);
+    await import_fs20.promises.access(configPath);
     console.log(import_chalk3.default.dim("\u2139 ruler.toml already exists (not modified)"));
   } catch {
     const basicConfig = `# Ruler Configuration
@@ -23093,7 +24023,7 @@ async function ensureRulerConfig(rulerDir) {
 # [agents.github-copilot]
 # enabled = false
 `;
-    await import_fs18.promises.writeFile(configPath, basicConfig, "utf-8");
+    await import_fs20.promises.writeFile(configPath, basicConfig, "utf-8");
     console.log(import_chalk3.default.green(`\u2713 Created ruler.toml configuration template`));
   }
 }
@@ -23163,8 +24093,8 @@ init_telemetry();
 init_errors();
 function getVersion() {
   try {
-    const packageJsonPath = (0, import_path23.join)(__dirname, "../package.json");
-    const packageJson = JSON.parse((0, import_fs19.readFileSync)(packageJsonPath, "utf-8"));
+    const packageJsonPath = (0, import_path25.join)(__dirname, "../package.json");
+    const packageJson = JSON.parse((0, import_fs21.readFileSync)(packageJsonPath, "utf-8"));
     return packageJson.version || "0.0.0";
   } catch {
     return "0.0.0";