agentsmesh 0.18.0 → 0.19.0

package/dist/engine.js

@@ -1,11 +1,11 @@
 import { z } from 'zod';
 import { stringify, parse } from 'yaml';
-import { join, basename, dirname, relative, win32, posix, resolve, extname } from 'path';
-import { readFile, rm, mkdir, readdir, stat, lstat, unlink, writeFile, rename, chmod, access, realpath } from 'fs/promises';
+import { basename, join, dirname, relative, win32, posix, sep, resolve, extname } from 'path';
+import { readFile, rm, mkdir, readdir, stat, lstat, unlink, writeFile, rename, chmod, access, realpath, mkdtemp, cp } from 'fs/promises';
 import { constants, existsSync, realpathSync, statSync, readFileSync } from 'fs';
 import { parse as parse$1 } from 'smol-toml';
 import { Buffer } from 'buffer';
-import { homedir } from 'os';
+import { homedir, tmpdir } from 'os';
 import { createHash } from 'crypto';
 import { execFile } from 'child_process';
 import { fileURLToPath, pathToFileURL, URL } from 'url';
@@ -22,86 +22,6 @@ var __export = (target31, all) => {
   for (var name in all)
     __defProp(target31, name, { get: all[name], enumerable: true });
 };
-
-// src/config/core/conversions.ts
-function usesCommandSkillProjection(target31) {
-  return Object.prototype.hasOwnProperty.call(DEFAULT_COMMANDS_TO_SKILLS, target31);
-}
-function usesAgentSkillProjection(target31) {
-  return Object.prototype.hasOwnProperty.call(DEFAULT_AGENTS_TO_SKILLS, target31);
-}
-function resolveConversionValue(value, scope) {
-  if (value === void 0) return void 0;
-  if (typeof value === "boolean") return value;
-  return value[scope];
-}
-function shouldConvertCommandsToSkills(config, target31, defaultEnabled, scope = "project") {
-  const raw = config.conversions?.commands_to_skills?.[target31];
-  const configVal = resolveConversionValue(raw, scope);
-  if (configVal !== void 0) return configVal;
-  if (usesCommandSkillProjection(target31)) return DEFAULT_COMMANDS_TO_SKILLS[target31];
-  return defaultEnabled ?? false;
-}
-function shouldConvertAgentsToSkills(config, target31, defaultEnabled, scope = "project") {
-  const raw = config.conversions?.agents_to_skills?.[target31];
-  const configVal = resolveConversionValue(raw, scope);
-  if (configVal !== void 0) return configVal;
-  if (usesAgentSkillProjection(target31)) return DEFAULT_AGENTS_TO_SKILLS[target31];
-  return defaultEnabled ?? false;
-}
-var DEFAULT_COMMANDS_TO_SKILLS, DEFAULT_AGENTS_TO_SKILLS;
-var init_conversions = __esm({
-  "src/config/core/conversions.ts"() {
-    DEFAULT_COMMANDS_TO_SKILLS = {
-      amp: true,
-      "codex-cli": true,
-      goose: true,
-      kiro: true,
-      warp: true
-    };
-    DEFAULT_AGENTS_TO_SKILLS = {
-      amp: true,
-      "gemini-cli": false,
-      // native .gemini/agents/*.md per agent-structures
-      cline: true,
-      "codex-cli": false,
-      // native .codex/agents/*.toml per agent-structures
-      windsurf: true,
-      goose: true,
-      antigravity: true,
-      continue: true,
-      warp: true
-    };
-  }
-});
-
-// src/targets/catalog/capabilities.ts
-function cap(level, flavor) {
-  return flavor !== void 0 ? { level, flavor } : { level };
-}
-function normalizeCapabilityValue(input) {
-  if (typeof input === "string") {
-    return { level: input };
-  }
-  return input;
-}
-function normalizeTargetCapabilities(caps) {
-  return {
-    rules: normalizeCapabilityValue(caps.rules),
-    additionalRules: normalizeCapabilityValue(caps.additionalRules),
-    commands: normalizeCapabilityValue(caps.commands),
-    agents: normalizeCapabilityValue(caps.agents),
-    skills: normalizeCapabilityValue(caps.skills),
-    mcp: normalizeCapabilityValue(caps.mcp),
-    hooks: normalizeCapabilityValue(caps.hooks),
-    ignore: normalizeCapabilityValue(caps.ignore),
-    permissions: normalizeCapabilityValue(caps.permissions)
-  };
-}
-var init_capabilities = __esm({
-  "src/targets/catalog/capabilities.ts"() {
-  }
-});
 function capabilityLevel(capability) {
   return typeof capability === "string" ? capability : capability.level;
 }
@@ -125,7 +45,7 @@ function validateCapabilityImplementations(descriptor31, capabilities17, ctx, pa
 function validateDescriptor(value) {
   return targetDescriptorSchema.parse(value);
 }
-var capabilityLevelSchema, capabilitiesSchema, generatorsSchema, pathResolversSchema, layoutSchema, globalSupportSchema, legacyGlobalKeys, generatorRequirements, settingsBackedFeatures, targetDescriptorSchemaBase, targetDescriptorSchema;
+var capabilityLevelSchema, capabilitiesSchema, generatorsSchema, pathResolversSchema, layoutSchema, globalSupportSchema, legacyGlobalKeys, generatorRequirements, settingsBackedFeatures, conversionDefaultsSchema, metadataSchema, targetDescriptorSchemaBase, targetDescriptorSchema;
 var init_target_descriptor_schema = __esm({
   "src/targets/catalog/target-descriptor.schema.ts"() {
     capabilityLevelSchema = z.union([
@@ -189,8 +109,19 @@ var init_target_descriptor_schema = __esm({
       { feature: "permissions", generator: "generatePermissions" }
     ];
     settingsBackedFeatures = ["mcp", "hooks", "ignore", "permissions"];
+    conversionDefaultsSchema = z.object({
+      commandsToSkills: z.boolean().optional(),
+      agentsToSkills: z.boolean().optional()
+    }).strict();
+    metadataSchema = z.object({
+      displayName: z.string().min(1),
+      category: z.enum(["cli", "ide", "agent-platform"]),
+      officialUrl: z.string().min(1),
+      shortDescription: z.string().min(1)
+    }).passthrough();
     targetDescriptorSchemaBase = z.object({
       id: z.string().regex(/^[a-z][a-z0-9-]*$/, "Target id must be lowercase with hyphens"),
+      metadata: metadataSchema,
       generators: generatorsSchema,
       capabilities: capabilitiesSchema,
       emptyImportMessage: z.string(),
@@ -198,7 +129,13 @@ var init_target_descriptor_schema = __esm({
       project: layoutSchema,
       globalSupport: globalSupportSchema.optional(),
       buildImportPaths: z.function(),
-      detectionPaths: z.array(z.string())
+      detectionPaths: z.array(z.string()),
+      excludeFromStarterInit: z.boolean().optional(),
+      conversionDefaults: conversionDefaultsSchema.optional(),
+      emitScopedSettings: z.function().optional(),
+      mergeGeneratedOutputContent: z.function().optional(),
+      postProcessHookOutputs: z.function().optional(),
+      preservesManualActivation: z.boolean().optional()
     }).passthrough();
     targetDescriptorSchema = targetDescriptorSchemaBase.superRefine((value, ctx) => {
       for (const key of legacyGlobalKeys) {
@@ -223,10 +160,15 @@ var init_target_descriptor_schema = __esm({
 
 // src/targets/catalog/registry.ts
 function builtinDescriptors() {
-  if (!_builtinDescriptors) {
-    _builtinDescriptors = new Map(BUILTIN_TARGETS.map((d) => [d.id, d]));
+  if (_builtinDescriptors) return _builtinDescriptors;
+  const defined = BUILTIN_TARGETS.filter(
+    (d) => d !== void 0 && typeof d.id === "string"
+  );
+  const map = new Map(defined.map((d) => [d.id, d]));
+  if (defined.length === BUILTIN_TARGETS.length) {
+    _builtinDescriptors = map;
   }
-  return _builtinDescriptors;
+  return map;
 }
 function registerTargetDescriptor(descriptor31) {
   const validated = validateDescriptor(descriptor31);
@@ -238,6 +180,10 @@ function getDescriptor(name) {
 function getAllDescriptors() {
   return [...descriptorRegistry.values()];
 }
+function getAllRegisteredDescriptorIds() {
+  const ids = /* @__PURE__ */ new Set([...builtinDescriptors().keys(), ...descriptorRegistry.keys()]);
+  return [...ids];
+}
 var descriptorRegistry, _builtinDescriptors;
 var init_registry = __esm({
   "src/targets/catalog/registry.ts"() {
@@ -247,6 +193,65 @@ var init_registry = __esm({
   }
 });
 
+// src/config/core/conversions.ts
+function builtinDefault(target31, key) {
+  return getDescriptor(target31)?.conversionDefaults?.[key];
+}
+function resolveConversionValue(value, scope) {
+  if (value === void 0) return void 0;
+  if (typeof value === "boolean") return value;
+  return value[scope];
+}
+function shouldConvertCommandsToSkills(config, target31, defaultEnabled, scope = "project") {
+  const raw = config.conversions?.commands_to_skills?.[target31];
+  const configVal = resolveConversionValue(raw, scope);
+  if (configVal !== void 0) return configVal;
+  const builtin = builtinDefault(target31, "commandsToSkills");
+  if (builtin !== void 0) return builtin;
+  return defaultEnabled ?? false;
+}
+function shouldConvertAgentsToSkills(config, target31, defaultEnabled, scope = "project") {
+  const raw = config.conversions?.agents_to_skills?.[target31];
+  const configVal = resolveConversionValue(raw, scope);
+  if (configVal !== void 0) return configVal;
+  const builtin = builtinDefault(target31, "agentsToSkills");
+  if (builtin !== void 0) return builtin;
+  return defaultEnabled ?? false;
+}
+var init_conversions = __esm({
+  "src/config/core/conversions.ts"() {
+    init_registry();
+  }
+});
+
+// src/targets/catalog/capabilities.ts
+function cap(level, flavor) {
+  return flavor !== void 0 ? { level, flavor } : { level };
+}
+function normalizeCapabilityValue(input) {
+  if (typeof input === "string") {
+    return { level: input };
+  }
+  return input;
+}
+function normalizeTargetCapabilities(caps) {
+  return {
+    rules: normalizeCapabilityValue(caps.rules),
+    additionalRules: normalizeCapabilityValue(caps.additionalRules),
+    commands: normalizeCapabilityValue(caps.commands),
+    agents: normalizeCapabilityValue(caps.agents),
+    skills: normalizeCapabilityValue(caps.skills),
+    mcp: normalizeCapabilityValue(caps.mcp),
+    hooks: normalizeCapabilityValue(caps.hooks),
+    ignore: normalizeCapabilityValue(caps.ignore),
+    permissions: normalizeCapabilityValue(caps.permissions)
+  };
+}
+var init_capabilities = __esm({
+  "src/targets/catalog/capabilities.ts"() {
+  }
+});
+
 // src/targets/catalog/shared-artifact-owner.ts
 function ownerTargetIdForSharedPath(path) {
   for (const descriptor31 of BUILTIN_TARGETS) {
@@ -364,6 +369,32 @@ function parseFrontmatter(content) {
   const frontmatter = yamlStr === "" ? {} : parse(yamlStr) ?? {};
   return { frontmatter, body };
 }
+function extractBody(content) {
+  if (content.indexOf("---") !== 0) return content.trim();
+  const close = content.indexOf("---", 3);
+  if (close === -1) return content.trim();
+  return content.slice(close + 3).trim();
+}
+function tryParseFrontmatter(content, filePath) {
+  try {
+    return { ok: true, value: parseFrontmatter(content) };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const wrapped = new Error(`Failed to parse frontmatter in ${filePath}: ${message}`, {
+      cause: err
+    });
+    return { ok: false, error: wrapped, bodyFallback: extractBody(content) };
+  }
+}
+function parseOrSkipFrontmatter(content, filePath, onParseError) {
+  const result = tryParseFrontmatter(content, filePath);
+  if (result.ok) return result.value;
+  if (onParseError) {
+    onParseError(result.error, filePath);
+    return null;
+  }
+  throw result.error;
+}
 function serializeFrontmatter(frontmatter, body) {
   const keys = Object.keys(frontmatter);
   if (keys.length === 0) return body;
@@ -682,7 +713,18 @@ var init_fs_text_encoding = __esm({
     EXECUTABLE_SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".sh", ".bash", ".zsh"]);
   }
 });
-async function readDirRecursive(dir, visited) {
+function shouldSkipRecursiveBranch(segments) {
+  if (segments.length > MAX_RECURSIVE_DEPTH) return true;
+  const counts = /* @__PURE__ */ new Map();
+  for (const segment of segments) {
+    const count = (counts.get(segment) ?? 0) + 1;
+    if (count >= MAX_SEGMENT_REPETITIONS) return true;
+    counts.set(segment, count);
+  }
+  return false;
+}
+async function readDirRecursive(dir, visited, branchSegments) {
+  const currentBranchSegments = branchSegments ?? [basename(dir)];
   let canonicalDir;
   try {
     canonicalDir = await realpath(dir);
@@ -708,7 +750,9 @@ async function readDirRecursive(dir, visited) {
         () => false
       );
       if (walkChild) {
-        files.push(...await readDirRecursive(full, seen));
+        const nextSegments = [...currentBranchSegments, ent.name];
+        if (shouldSkipRecursiveBranch(nextSegments)) continue;
+        files.push(...await readDirRecursive(full, seen, nextSegments));
       } else {
         files.push(full);
       }
@@ -724,9 +768,12 @@ async function readDirRecursive(dir, visited) {
     );
   }
 }
+var MAX_RECURSIVE_DEPTH, MAX_SEGMENT_REPETITIONS;
 var init_fs_traverse = __esm({
   "src/utils/filesystem/fs-traverse.ts"() {
     init_errors();
+    MAX_RECURSIVE_DEPTH = 32;
+    MAX_SEGMENT_REPETITIONS = 3;
   }
 });
 async function readFileSafe(path) {
@@ -1932,7 +1979,9 @@ function shouldRewritePathToken(fullContent, start, end, matchText, rewriteBareP
   }
   if (before === "@") return true;
   if (before === "(") {
-    return after === ")" || after === "#" || after === "?" || after === " " || after === "	";
+    if (fullContent[start - 2] === "]") {
+      return after === ")" || after === "#" || after === "?" || after === " " || after === "	";
+    }
   }
   if (!rewriteBarePathTokens) return false;
   if (isRootRelativePathToken(normalizedCandidate)) return true;
@@ -2326,6 +2375,85 @@ var init_descriptor_default_mappers = __esm({
   }
 });
 
+// src/install/importers/boilerplate-filter.ts
+function boilerplateKind(filename) {
+  const lower = filename.toLowerCase();
+  const dotIdx = lower.lastIndexOf(".");
+  const stem = dotIdx > 0 ? lower.slice(0, dotIdx) : lower;
+  return BOILERPLATE_STEMS.get(stem);
+}
+function isBoilerplate(filename) {
+  return boilerplateKind(filename) !== void 0;
+}
+function isPreservedBoilerplate(filename) {
+  return boilerplateKind(filename) === "preserved";
+}
+function isNoiseBoilerplate(filename) {
+  return boilerplateKind(filename) === "noise";
+}
+function isRepoNonContentDir(name) {
+  return NON_CONTENT_DIRS.has(name);
+}
+function isRepoNonContentFile(name) {
+  return NON_CONTENT_FILES.has(name);
+}
+var BOILERPLATE_STEMS, NON_CONTENT_DIRS, NON_CONTENT_FILES;
+var init_boilerplate_filter = __esm({
+  "src/install/importers/boilerplate-filter.ts"() {
+    BOILERPLATE_STEMS = /* @__PURE__ */ new Map([
+      // Noise — upstream-repo housekeeping with no downstream value.
+      ["contributing", "noise"],
+      ["changelog", "noise"],
+      ["changes", "noise"],
+      ["history", "noise"],
+      ["code_of_conduct", "noise"],
+      ["security", "noise"],
+      ["support", "noise"],
+      ["maintainers", "noise"],
+      ["governance", "noise"],
+      ["authors", "noise"],
+      ["contributors", "noise"],
+      ["codeowners", "noise"],
+      ["citation", "noise"],
+      ["acknowledgments", "noise"],
+      ["acknowledgements", "noise"],
+      // Preserved — installed alongside content but never treated as an entity.
+      // LICENSE family: legal attribution required by MIT/Apache/BSD/GPL.
+      ["license", "preserved"],
+      ["license-mit", "preserved"],
+      ["license-apache", "preserved"],
+      ["license-bsd", "preserved"],
+      ["license-gpl", "preserved"],
+      ["notice", "preserved"],
+      ["copying", "preserved"],
+      ["copyright", "preserved"],
+      // README: skill-specific context (overview, usage, prerequisites) that
+      // explains the skill to the downstream consumer. Filtered from entity
+      // discovery so it can never become a phantom rule/command/agent named
+      // "README", but kept as a supporting file so the docs travel with the install.
+      ["readme", "preserved"]
+    ]);
+    NON_CONTENT_DIRS = /* @__PURE__ */ new Set([
+      ".git",
+      ".github",
+      ".gitlab",
+      "node_modules",
+      ".vscode",
+      ".idea"
+    ]);
+    NON_CONTENT_FILES = /* @__PURE__ */ new Set([
+      "package.json",
+      "package-lock.json",
+      "pnpm-lock.yaml",
+      "yarn.lock",
+      ".gitignore",
+      ".gitattributes",
+      ".editorconfig",
+      ".DS_Store"
+    ]);
+  }
+});
+
 // src/targets/catalog/import-descriptor.ts
 function resolveScopedSources(paths, scope) {
   if (!paths) return [];
@@ -2359,18 +2487,32 @@ async function runSingleFile(spec, sources, projectRoot, fromTool, normalize) {
     const destPath = join(destDir, spec.canonicalRootFilename);
     const normalizeTo = (destinationFile) => normalize(content, srcPath, destinationFile);
     if (spec.map) {
-      const mapping = await spec.map({
-        absolutePath: srcPath,
-        relativePath: rel2,
-        content,
-        destDir,
-        normalizeTo
-      });
+      let mapping;
+      try {
+        mapping = await spec.map({
+          absolutePath: srcPath,
+          relativePath: rel2,
+          content,
+          destDir,
+          normalizeTo
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`\u26A0 skipping ${srcPath}: ${msg}
+`);
+        continue;
+      }
       if (!mapping) continue;
       await writeFileAtomic(mapping.destPath, mapping.content);
       return [{ fromTool, fromPath: srcPath, toPath: mapping.toPath, feature: spec.feature }];
     }
-    const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
+    const result = tryParseFrontmatter(normalizeTo(destPath), srcPath);
+    if (!result.ok) {
+      process.stderr.write(`\u26A0 skipping ${srcPath}: ${result.error.message}
+`);
+      continue;
+    }
+    const { frontmatter, body } = result.value;
     const remapped = spec.frontmatterRemap ? spec.frontmatterRemap(frontmatter) : frontmatter;
     const outFm = spec.markAsRoot ? { ...remapped, root: true } : remapped;
     const outContent = await serializeImportedRuleWithFallback(destPath, outFm, body);
@@ -2399,13 +2541,22 @@ async function runDirectory(spec, sources, projectRoot, fromTool, normalize) {
       fromTool,
       normalize,
       mapEntry: async ({ srcPath, relativePath, content, normalizeTo }) => {
-        const mapping = await mapper({
-          absolutePath: srcPath,
-          relativePath,
-          content,
-          destDir,
-          normalizeTo: (destinationFile) => normalizeTo(destinationFile)
-        });
+        if (isPreservedBoilerplate(basename(srcPath))) return null;
+        let mapping;
+        try {
+          mapping = await mapper({
+            absolutePath: srcPath,
+            relativePath,
+            content,
+            destDir,
+            normalizeTo: (destinationFile) => normalizeTo(destinationFile)
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          process.stderr.write(`\u26A0 skipping ${srcPath}: ${msg}
+`);
+          return null;
+        }
         if (!mapping) return null;
         return {
           destPath: mapping.destPath,
@@ -2546,6 +2697,7 @@ var init_descriptor_import_runner = __esm({
     init_import_metadata();
     init_import_orchestrator();
     init_descriptor_default_mappers();
+    init_boilerplate_filter();
     init_import_descriptor();
   }
 });
@@ -3423,7 +3575,7 @@ var init_crush = __esm({
 });
 
 // src/targets/cursor/constants.ts
-var CURSOR_TARGET, CURSOR_COMPAT_AGENTS, CURSOR_LEGACY_RULES, CURSOR_RULES_DIR, CURSOR_GENERAL_RULE, CURSOR_COMMANDS_DIR, CURSOR_AGENTS_DIR, CURSOR_SKILLS_DIR, CURSOR_MCP, CURSOR_HOOKS, CURSOR_SETTINGS, CURSOR_IGNORE, CURSOR_INDEXING_IGNORE, CURSOR_GLOBAL_EXPORT_DIR, CURSOR_GLOBAL_USER_RULES, CURSOR_DOT_CURSOR_AGENTS, CURSOR_GLOBAL_MCP_EXPORT, CURSOR_GLOBAL_SKILLS_DIR, CURSOR_GLOBAL_AGENTS_DIR, CURSOR_CANONICAL_RULES_DIR, CURSOR_CANONICAL_COMMANDS_DIR, CURSOR_CANONICAL_AGENTS_DIR, CURSOR_CANONICAL_SKILLS_DIR, CURSOR_CANONICAL_MCP, CURSOR_CANONICAL_PERMISSIONS, CURSOR_CANONICAL_HOOKS, CURSOR_CANONICAL_IGNORE;
+var CURSOR_TARGET, CURSOR_COMPAT_AGENTS, CURSOR_LEGACY_RULES, CURSOR_RULES_DIR, CURSOR_GENERAL_RULE, CURSOR_COMMANDS_DIR, CURSOR_AGENTS_DIR, CURSOR_SKILLS_DIR, CURSOR_MCP, CURSOR_HOOKS, CURSOR_SETTINGS, CURSOR_IGNORE, CURSOR_INDEXING_IGNORE, CURSOR_GLOBAL_EXPORT_DIR, CURSOR_GLOBAL_USER_RULES, CURSOR_DOT_CURSOR_AGENTS, CURSOR_CANONICAL_RULES_DIR, CURSOR_CANONICAL_COMMANDS_DIR, CURSOR_CANONICAL_AGENTS_DIR, CURSOR_CANONICAL_SKILLS_DIR, CURSOR_CANONICAL_MCP, CURSOR_CANONICAL_PERMISSIONS, CURSOR_CANONICAL_HOOKS, CURSOR_CANONICAL_IGNORE;
 var init_constants11 = __esm({
   "src/targets/cursor/constants.ts"() {
     CURSOR_TARGET = "cursor";
@@ -3442,9 +3594,6 @@ var init_constants11 = __esm({
     CURSOR_GLOBAL_EXPORT_DIR = ".agentsmesh-exports/cursor";
     CURSOR_GLOBAL_USER_RULES = `${CURSOR_GLOBAL_EXPORT_DIR}/user-rules.md`;
     CURSOR_DOT_CURSOR_AGENTS = ".cursor/AGENTS.md";
-    CURSOR_GLOBAL_MCP_EXPORT = CURSOR_MCP;
-    CURSOR_GLOBAL_SKILLS_DIR = CURSOR_SKILLS_DIR;
-    CURSOR_GLOBAL_AGENTS_DIR = CURSOR_AGENTS_DIR;
     CURSOR_CANONICAL_RULES_DIR = ".agentsmesh/rules";
     CURSOR_CANONICAL_COMMANDS_DIR = ".agentsmesh/commands";
     CURSOR_CANONICAL_AGENTS_DIR = ".agentsmesh/agents";
@@ -4575,7 +4724,7 @@ var init_linter2 = __esm({
 });
 
 // src/targets/amazon-q/index.ts
-var target2, project2, global, globalCapabilities, descriptor2;
+var target2, project2, globalLayout2, globalCapabilities, descriptor2;
 var init_amazon_q2 = __esm({
   "src/targets/amazon-q/index.ts"() {
     init_generator2();
@@ -4606,7 +4755,7 @@ var init_amazon_q2 = __esm({
         }
       }
     };
-    global = {
+    globalLayout2 = {
       managedOutputs: {
         dirs: [AMAZON_Q_GLOBAL_RULES_DIR],
         files: [AMAZON_Q_GLOBAL_MCP_FILE]
@@ -4669,7 +4818,7 @@ var init_amazon_q2 = __esm({
       globalSupport: {
         capabilities: globalCapabilities,
         detectionPaths: [AMAZON_Q_GLOBAL_RULES_DIR, AMAZON_Q_GLOBAL_MCP_FILE],
-        layout: global
+        layout: globalLayout2
       },
       importer: {
         rules: {
@@ -4739,13 +4888,22 @@ var init_generator3 = __esm({
 
 // src/targets/catalog/skill-mirror.ts
 function mirrorSkillsToAgents(path, skillsDir, activeTargets) {
-  if (path.startsWith(`${skillsDir}/`) && !activeTargets.includes("codex-cli")) {
+  const hasNativeWriter = activeTargets.some((id) => NATIVE_AGENTS_SKILL_WRITERS.includes(id));
+  if (path.startsWith(`${skillsDir}/`) && !hasNativeWriter) {
     return `.agents/skills/${path.slice(skillsDir.length + 1)}`;
   }
   return null;
 }
+var NATIVE_AGENTS_SKILL_WRITERS;
 var init_skill_mirror = __esm({
   "src/targets/catalog/skill-mirror.ts"() {
+    NATIVE_AGENTS_SKILL_WRITERS = [
+      "amp",
+      "antigravity",
+      "codex-cli",
+      "goose",
+      "replit-agent"
+    ];
   }
 });
 async function importAmpMcp(projectRoot, settingsPath, results) {
@@ -4887,7 +5045,7 @@ function mergeAmpSettings(existing, newContent) {
   }
   return JSON.stringify(base, null, 2);
 }
-var target3, project3, globalLayout2, capabilities2, descriptor3;
+var target3, project3, globalLayout3, capabilities2, descriptor3;
 var init_amp2 = __esm({
   "src/targets/amp/index.ts"() {
     init_command_skill();
@@ -4927,7 +5085,7 @@ var init_amp2 = __esm({
         }
       }
     };
-    globalLayout2 = {
+    globalLayout3 = {
       rootInstructionPath: AMP_GLOBAL_ROOT_FILE,
       skillDir: AMP_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -4990,7 +5148,7 @@ var init_amp2 = __esm({
       globalSupport: {
         capabilities: capabilities2,
         detectionPaths: [AMP_GLOBAL_ROOT_FILE, AMP_GLOBAL_MCP_FILE],
-        layout: globalLayout2
+        layout: globalLayout3
       },
       importer: {
         rules: {
@@ -5024,7 +5182,8 @@ var init_amp2 = __esm({
         ".agents/skills/": "consumer"
       },
       buildImportPaths: buildAmpImportPaths,
-      detectionPaths: [AMP_ROOT_FILE, AMP_MCP_FILE]
+      detectionPaths: [AMP_ROOT_FILE, AMP_MCP_FILE],
+      conversionDefaults: { commandsToSkills: true, agentsToSkills: true }
     };
   }
 });
@@ -5264,7 +5423,7 @@ var init_linter4 = __esm({
 });
 
 // src/targets/antigravity/index.ts
-var target4, project4, global2, globalCapabilities2, descriptor4;
+var target4, project4, globalLayout4, globalCapabilities2, descriptor4;
 var init_antigravity2 = __esm({
   "src/targets/antigravity/index.ts"() {
     init_capabilities();
@@ -5288,6 +5447,20 @@ var init_antigravity2 = __esm({
     project4 = {
       rootInstructionPath: ANTIGRAVITY_RULES_ROOT,
       skillDir: ".agents/skills",
+      // managedOutputs is the sole signal `cleanupStaleGeneratedOutputs` uses to
+      // decide which dirs/files to scan when reconciling post-uninstall state.
+      // Antigravity emits across three dirs:
+      //   - `.agents/rules`     (rules)
+      //   - `.agents/workflows` (commands → workflows projection)
+      //   - `.agents/skills`    (agents → skills projection + native skills)
+      // Without all three here, projected outputs from an uninstalled pack would
+      // linger in the user's project. The root rule file and (suppressed) MCP
+      // config are listed under `files` so a flip from one root style to another
+      // doesn't leave both behind.
+      managedOutputs: {
+        dirs: [ANTIGRAVITY_RULES_DIR, ANTIGRAVITY_WORKFLOWS_DIR, ANTIGRAVITY_SKILLS_DIR],
+        files: [ANTIGRAVITY_RULES_ROOT]
+      },
       rewriteGeneratedPath(path) {
         if (path === ANTIGRAVITY_MCP_CONFIG) return null;
         return path;
@@ -5304,7 +5477,7 @@ var init_antigravity2 = __esm({
         }
       }
     };
-    global2 = {
+    globalLayout4 = {
       rootInstructionPath: ANTIGRAVITY_GLOBAL_ROOT,
       renderPrimaryRootInstruction: renderAntigravityGlobalInstructions,
       skillDir: ANTIGRAVITY_GLOBAL_SKILLS_DIR,
@@ -5332,7 +5505,7 @@ var init_antigravity2 = __esm({
           return `${ANTIGRAVITY_GLOBAL_WORKFLOWS_DIR}/${name}.md`;
         },
         agentPath(name) {
-          return `${ANTIGRAVITY_SKILLS_DIR}/${projectedAgentSkillDirName(name)}/SKILL.md`;
+          return `${ANTIGRAVITY_GLOBAL_SKILLS_DIR}/${projectedAgentSkillDirName(name)}/SKILL.md`;
         }
       }
     };
@@ -5379,7 +5552,7 @@ var init_antigravity2 = __esm({
           ".gemini/antigravity/workflows",
           ".gemini/antigravity/mcp_config.json"
         ],
-        layout: global2
+        layout: globalLayout4
       },
       importer: {
         rules: {
@@ -5420,7 +5593,8 @@ var init_antigravity2 = __esm({
         ".agents/rules/",
         ".agents/skills/",
         ".agents/workflows/"
-      ]
+      ],
+      conversionDefaults: { agentsToSkills: true }
     };
   }
 });
@@ -5752,7 +5926,7 @@ function buildSettingsContent(canonical) {
   if (Object.keys(settings).length === 0) return null;
   return JSON.stringify(settings, null, 2);
 }
-var target5, project5, globalLayout3, capabilities3, globalCapabilities3, descriptor5;
+var target5, project5, globalLayout5, capabilities3, globalCapabilities3, descriptor5;
 var init_augment_code2 = __esm({
   "src/targets/augment-code/index.ts"() {
     init_generator5();
@@ -5787,7 +5961,7 @@ var init_augment_code2 = __esm({
         }
       }
     };
-    globalLayout3 = {
+    globalLayout5 = {
       skillDir: AUGMENT_CODE_GLOBAL_SKILLS_DIR,
       managedOutputs: {
         dirs: [
@@ -5873,7 +6047,7 @@ var init_augment_code2 = __esm({
           AUGMENT_CODE_GLOBAL_SKILLS_DIR,
           AUGMENT_CODE_GLOBAL_SETTINGS_FILE
         ],
-        layout: globalLayout3
+        layout: globalLayout5
       },
       emitScopedSettings(canonical) {
         const content = buildSettingsContent(canonical);
@@ -6273,6 +6447,19 @@ async function importClaudeSkills(projectRoot, results, normalize) {
     const skillDir = dirname(skillMdPath);
     const skillName = basename(skillDir);
     const destSkillDir = join(destBase, skillName);
+    const skillMdContent = await readFileSafe(skillMdPath);
+    if (skillMdContent === null) continue;
+    const normalizedSkillMd = normalize(
+      skillMdContent,
+      skillMdPath,
+      join(destSkillDir, "SKILL.md")
+    );
+    const skillMdParsed = tryParseFrontmatter(normalizedSkillMd, skillMdPath);
+    if (!skillMdParsed.ok) {
+      process.stderr.write(`\u26A0 skipping ${skillMdPath}: ${skillMdParsed.error.message}
+`);
+      continue;
+    }
     const skillFiles = await readDirRecursive(skillDir);
     for (const filePath of skillFiles) {
       const fileContent = await readFileSafe(filePath);
@@ -6281,13 +6468,12 @@ async function importClaudeSkills(projectRoot, results, normalize) {
       const destPath = join(destSkillDir, relPath);
       await mkdirp(dirname(destPath));
       const normalized = normalize(fileContent, filePath, destPath);
-      const parsed = relPath === "SKILL.md" ? parseFrontmatter(normalized) : null;
       await writeFileAtomic(
         destPath,
         relPath === "SKILL.md" ? await serializeImportedSkillWithFallback(
           destPath,
-          parsed?.frontmatter ?? {},
-          parsed?.body ?? ""
+          skillMdParsed.value.frontmatter,
+          skillMdParsed.value.body
         ) : normalized
       );
       const toPath = `${CLAUDE_CANONICAL_SKILLS_DIR}/${skillName}/${relPath}`;
@@ -6408,7 +6594,7 @@ var init_linter6 = __esm({
 });
 
 // src/targets/claude-code/index.ts
-var target6, project6, global3, globalCapabilities4, descriptor6;
+var target6, project6, globalLayout6, globalCapabilities4, descriptor6;
 var init_claude_code2 = __esm({
   "src/targets/claude-code/index.ts"() {
     init_generator6();
@@ -6452,7 +6638,7 @@ var init_claude_code2 = __esm({
         }
       }
     };
-    global3 = {
+    globalLayout6 = {
       rootInstructionPath: CLAUDE_ROOT,
       skillDir: ".claude/skills",
       renderPrimaryRootInstruction: renderClaudeGlobalPrimaryInstructions,
@@ -6531,7 +6717,7 @@ var init_claude_code2 = __esm({
           ".claude.json",
           ".agents/skills"
         ],
-        layout: global3,
+        layout: globalLayout6,
         scopeExtras: generateClaudeGlobalExtras
       },
       importer: {
@@ -7065,55 +7251,117 @@ async function findDirectorySkills(skillsDir) {
   }
   return skills;
 }
+async function importSkillsDirectory(sourceSkillsDirs, options, recognizers = []) {
+  for (const sourceDir of sourceSkillsDirs) {
+    const absSkillsDir = join(options.projectRoot, sourceDir);
+    const directorySkills = await findDirectorySkills(absSkillsDir);
+    if (directorySkills.size === 0) continue;
+    let importedAny = false;
+    for (const [skillName, skillDir] of directorySkills) {
+      const skillMdPath = join(skillDir, "SKILL.md");
+      const rawContent = await readFileSafe(skillMdPath);
+      if (rawContent === null) continue;
+      importedAny = true;
+      const { frontmatter, body: rawBody } = parseFrontmatter(rawContent);
+      const ctx = {
+        skillName,
+        skillDir,
+        skillMdPath,
+        rawContent,
+        frontmatter,
+        rawBody,
+        options
+      };
+      let handled = false;
+      for (const recognizer of recognizers) {
+        const claimed = await recognizer.recognize(ctx);
+        if (claimed) {
+          handled = true;
+          break;
+        }
+      }
+      if (!handled) {
+        await importDirectorySkill(skillName, skillDir, options);
+      }
+    }
+    if (importedAny) return;
+  }
+}
+function projectedAgentRecognizer(config) {
+  return {
+    async recognize(ctx) {
+      const projectedAgent = parseProjectedAgentSkillFrontmatter(ctx.frontmatter, ctx.skillName);
+      if (!projectedAgent) return false;
+      const { options } = ctx;
+      await removePathIfExists(
+        join(options.projectRoot, options.destCanonicalSkillsDir, ctx.skillName)
+      );
+      const destAgentsDir = join(options.projectRoot, config.canonicalAgentsDir);
+      await mkdirp(destAgentsDir);
+      const agentPath = join(destAgentsDir, `${projectedAgent.name}.md`);
+      const normalizedBody = options.normalize(ctx.rawBody, ctx.skillMdPath, agentPath);
+      await writeFileAtomic(agentPath, serializeImportedAgent(projectedAgent, normalizedBody));
+      options.results.push({
+        fromTool: options.targetName,
+        fromPath: ctx.skillMdPath,
+        toPath: `${config.canonicalAgentsDir}/${projectedAgent.name}.md`,
+        feature: "agents"
+      });
+      return true;
+    }
+  };
+}
+function commandSkillRecognizer(config) {
+  return {
+    async recognize(ctx) {
+      const command = parseCommandSkillFrontmatter(ctx.frontmatter, ctx.skillName);
+      if (!command) return false;
+      const { options } = ctx;
+      await removePathIfExists(
+        join(options.projectRoot, options.destCanonicalSkillsDir, ctx.skillName)
+      );
+      const destCommandsDir = join(options.projectRoot, config.canonicalCommandsDir);
+      await mkdirp(destCommandsDir);
+      const commandPath = join(destCommandsDir, `${command.name}.md`);
+      const normalizedBody = options.normalize(ctx.rawBody, ctx.skillMdPath, commandPath);
+      await writeFileAtomic(commandPath, serializeImportedCommand(command, normalizedBody));
+      options.results.push({
+        fromTool: options.targetName,
+        fromPath: ctx.skillMdPath,
+        toPath: `${config.canonicalCommandsDir}/${command.name}.md`,
+        feature: "commands"
+      });
+      return true;
+    }
+  };
+}
 var init_skill_import_pipeline = __esm({
   "src/targets/import/shared/skill-import-pipeline.ts"() {
     init_fs();
     init_markdown();
     init_import_metadata();
     init_reserved();
+    init_projected_agent_skill();
+    init_command_skill();
+    init_scoped_agents_import();
   }
 });
+
+// src/targets/cline/skills-adapter.ts
 async function importClineSkills(projectRoot, results, normalize, skillsRelDir = CLINE_SKILLS_DIR) {
-  const skillsDir = join(projectRoot, skillsRelDir);
-  const directorySkills = await findDirectorySkills(skillsDir);
   const options = {
     projectRoot,
-    sourceSkillsDir: skillsRelDir,
     destCanonicalSkillsDir: CLINE_CANONICAL_SKILLS_DIR,
     targetName: "cline",
     normalize,
     results
   };
-  for (const [skillName, skillDir] of directorySkills) {
-    const skillMdPath = join(skillDir, "SKILL.md");
-    const content = await readFileSafe(skillMdPath);
-    if (!content) continue;
-    const rawParsed = parseFrontmatter(content);
-    const projectedAgent = parseProjectedAgentSkillFrontmatter(rawParsed.frontmatter, skillName);
-    if (projectedAgent) {
-      const destAgentsDir = join(projectRoot, CLINE_CANONICAL_AGENTS_DIR);
-      await mkdirp(destAgentsDir);
-      const agentPath = join(destAgentsDir, `${projectedAgent.name}.md`);
-      await writeFileAtomic(
-        agentPath,
-        serializeImportedAgent(projectedAgent, normalize(rawParsed.body, skillMdPath, agentPath))
-      );
-      results.push({
-        fromTool: "cline",
-        fromPath: skillMdPath,
-        toPath: `${CLINE_CANONICAL_AGENTS_DIR}/${projectedAgent.name}.md`,
-        feature: "agents"
-      });
-      continue;
-    }
-    await importDirectorySkill(skillName, skillDir, options);
-  }
+  await importSkillsDirectory([skillsRelDir], options, [
+    projectedAgentRecognizer({ canonicalAgentsDir: CLINE_CANONICAL_AGENTS_DIR })
+  ]);
 }
 var init_skills_adapter = __esm({
   "src/targets/cline/skills-adapter.ts"() {
-    init_fs();
-    init_markdown();
-    init_projected_agent_skill();
     init_skill_import_pipeline();
     init_constants8();
   }
@@ -7259,7 +7507,7 @@ var init_lint4 = __esm({
 });
 
 // src/targets/cline/index.ts
-var target7, project7, globalLayout4, globalCapabilities5, descriptor7;
+var target7, project7, globalLayout7, globalCapabilities5, descriptor7;
 var init_cline2 = __esm({
   "src/targets/cline/index.ts"() {
     init_generator7();
@@ -7307,7 +7555,7 @@ var init_cline2 = __esm({
         }
       }
     };
-    globalLayout4 = {
+    globalLayout7 = {
       skillDir: CLINE_SKILLS_DIR,
       managedOutputs: {
         dirs: [
@@ -7399,10 +7647,11 @@ var init_cline2 = __esm({
           CLINE_MCP_SETTINGS,
           CLINE_IGNORE
         ],
-        layout: globalLayout4
+        layout: globalLayout7
       },
       buildImportPaths: buildClineImportPaths,
-      detectionPaths: [".clinerules", ".cline"]
+      detectionPaths: [".clinerules", ".cline"],
+      conversionDefaults: { agentsToSkills: true }
     };
   }
 });
@@ -7776,82 +8025,23 @@ var init_mcp_helpers = __esm({
     init_constants28();
   }
 });
+
+// src/targets/codex-cli/skills-adapter.ts
 async function importSkills(projectRoot, results, normalize) {
   const options = {
     projectRoot,
-    sourceSkillsDir: CODEX_SKILLS_DIR,
     destCanonicalSkillsDir: CODEX_CANONICAL_SKILLS_DIR,
     targetName: CODEX_TARGET,
     normalize,
     results
   };
-  for (const skillsRoot of [CODEX_SKILLS_DIR, CODEX_SKILLS_FALLBACK_DIR]) {
-    const skillsDir = join(projectRoot, skillsRoot);
-    const entries = await readdir(skillsDir, {
-      encoding: "utf8",
-      withFileTypes: true
-    }).catch(() => null);
-    if (entries === null) continue;
-    let importedAny = false;
-    for (const ent of entries) {
-      if (!ent.isDirectory() && !ent.isSymbolicLink()) continue;
-      const skillPath = join(skillsDir, ent.name);
-      const skillMdPath = join(skillPath, "SKILL.md");
-      const skillMdContent = await readFileSafe(skillMdPath);
-      if (!skillMdContent) continue;
-      importedAny = true;
-      const skillName = ent.name;
-      const destSkillPath = join(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName, "SKILL.md");
-      const normalized = normalize(skillMdContent, skillMdPath, destSkillPath);
-      const { frontmatter, body } = parseFrontmatter(normalized);
-      const command = parseCommandSkillFrontmatter(frontmatter, ent.name);
-      if (command) {
-        await removePathIfExists(join(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName));
-        const destCommandsDir = join(projectRoot, CODEX_CANONICAL_COMMANDS_DIR);
-        await mkdirp(destCommandsDir);
-        const commandPath = join(destCommandsDir, `${command.name}.md`);
-        await writeFileAtomic(
-          commandPath,
-          serializeImportedCommand(command, normalize(body, skillMdPath, commandPath))
-        );
-        results.push({
-          fromTool: CODEX_TARGET,
-          fromPath: skillMdPath,
-          toPath: `${CODEX_CANONICAL_COMMANDS_DIR}/${command.name}.md`,
-          feature: "commands"
-        });
-        continue;
-      }
-      const projectedAgent = parseProjectedAgentSkillFrontmatter(frontmatter, ent.name);
-      if (projectedAgent) {
-        await removePathIfExists(join(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName));
-        const destAgentsDir = join(projectRoot, CODEX_CANONICAL_AGENTS_DIR);
-        await mkdirp(destAgentsDir);
-        const agentPath = join(destAgentsDir, `${projectedAgent.name}.md`);
-        await writeFileAtomic(
-          agentPath,
-          serializeImportedAgent(projectedAgent, normalize(body, skillMdPath, agentPath))
-        );
-        results.push({
-          fromTool: CODEX_TARGET,
-          fromPath: skillMdPath,
-          toPath: `${CODEX_CANONICAL_AGENTS_DIR}/${projectedAgent.name}.md`,
-          feature: "agents"
-        });
-        continue;
-      }
-      await importDirectorySkill(skillName, skillPath, options);
-    }
-    if (importedAny) return;
-  }
+  await importSkillsDirectory([CODEX_SKILLS_DIR, CODEX_SKILLS_FALLBACK_DIR], options, [
+    commandSkillRecognizer({ canonicalCommandsDir: CODEX_CANONICAL_COMMANDS_DIR }),
+    projectedAgentRecognizer({ canonicalAgentsDir: CODEX_CANONICAL_AGENTS_DIR })
+  ]);
 }
 var init_skills_adapter2 = __esm({
   "src/targets/codex-cli/skills-adapter.ts"() {
-    init_fs();
-    init_markdown();
-    init_command_skill();
-    init_projected_agent_skill();
-    init_scoped_agents_import();
     init_skill_import_pipeline();
     init_constants28();
   }
@@ -8241,7 +8431,7 @@ var init_codex_rule_paths = __esm({
     init_instruction_mirror();
   }
 });
-var target8, project8, global4, globalCapabilities6, descriptor8;
+var target8, project8, globalLayout8, globalCapabilities6, descriptor8;
 var init_codex_cli2 = __esm({
   "src/targets/codex-cli/index.ts"() {
     init_generator9();
@@ -8287,7 +8477,7 @@ var init_codex_cli2 = __esm({
         }
       }
     };
-    global4 = {
+    globalLayout8 = {
       rootInstructionPath: CODEX_GLOBAL_AGENTS_MD,
       renderPrimaryRootInstruction: renderCodexGlobalInstructions,
       extraRuleOutputPaths(rule) {
@@ -8365,7 +8555,7 @@ var init_codex_cli2 = __esm({
           ".codex/rules",
           ".agents/skills"
         ],
-        layout: global4
+        layout: globalLayout8
       },
       buildImportPaths: buildCodexCliImportPaths,
       sharedArtifacts: {
@@ -8378,7 +8568,9 @@ var init_codex_cli2 = __esm({
         ".codex/config.toml",
         ".codex/agents",
         ".codex/rules"
-      ]
+      ],
+      excludeFromStarterInit: true,
+      conversionDefaults: { commandsToSkills: true, agentsToSkills: false }
     };
   }
 });
@@ -8741,7 +8933,7 @@ var init_scope_extras = __esm({
 });
 
 // src/targets/continue/index.ts
-var target9, project9, globalLayout5, globalCapabilities7, descriptor9;
+var target9, project9, globalLayout9, globalCapabilities7, descriptor9;
 var init_continue2 = __esm({
   "src/targets/continue/index.ts"() {
     init_projected_agent_skill();
@@ -8783,7 +8975,7 @@ var init_continue2 = __esm({
         }
       }
     };
-    globalLayout5 = {
+    globalLayout9 = {
       rootInstructionPath: CONTINUE_ROOT_RULE,
       outputFamilies: [
         { id: "compat-agents", kind: "additional", explicitPaths: [CONTINUE_GLOBAL_AGENTS_MD] }
@@ -8857,7 +9049,7 @@ var init_continue2 = __esm({
           ".continue/mcpServers",
           CONTINUE_SKILLS_DIR
         ],
-        layout: globalLayout5,
+        layout: globalLayout9,
         scopeExtras: generateContinueScopeExtras
       },
       importer: {
@@ -8879,7 +9071,8 @@ var init_continue2 = __esm({
         }
       },
       buildImportPaths: buildContinueImportPaths,
-      detectionPaths: [".continue/rules", ".continue/skills", ".continue/mcpServers"]
+      detectionPaths: [".continue/rules", ".continue/skills", ".continue/mcpServers"],
+      conversionDefaults: { agentsToSkills: true }
     };
   }
 });
@@ -9205,7 +9398,6 @@ async function importSkills2(projectRoot, results, normalize, skillsDirRel = COP
   const directorySkills = await findDirectorySkills(skillsDir);
   const options = {
     projectRoot,
-    sourceSkillsDir: skillsDirRel,
     destCanonicalSkillsDir: COPILOT_CANONICAL_SKILLS_DIR,
     targetName: COPILOT_TARGET,
     normalize,
@@ -9530,7 +9722,7 @@ var init_scope_extras2 = __esm({
     };
   }
 });
-var target10, project10, global5, globalCapabilities8, descriptor10;
+var target10, project10, globalLayout10, globalCapabilities8, descriptor10;
 var init_copilot2 = __esm({
   "src/targets/copilot/index.ts"() {
     init_generator11();
@@ -9584,7 +9776,7 @@ var init_copilot2 = __esm({
         }
       }
     };
-    global5 = {
+    globalLayout10 = {
       rootInstructionPath: COPILOT_GLOBAL_INSTRUCTIONS,
       renderPrimaryRootInstruction: renderCopilotGlobalInstructions,
       outputFamilies: [
@@ -9690,7 +9882,7 @@ var init_copilot2 = __esm({
           COPILOT_GLOBAL_PROMPTS_DIR,
           COPILOT_GLOBAL_AGENTS_SKILLS_DIR
         ],
-        layout: global5,
+        layout: globalLayout10,
         scopeExtras: generateCopilotGlobalExtras
       },
       importer: {
@@ -10072,7 +10264,7 @@ var init_settings = __esm({
 });
 
 // src/targets/crush/index.ts
-var target11, project11, globalLayout6, capabilities4, globalCapabilities9, descriptor11;
+var target11, project11, globalLayout11, capabilities4, globalCapabilities9, descriptor11;
 var init_crush2 = __esm({
   "src/targets/crush/index.ts"() {
     init_command_skill();
@@ -10117,7 +10309,7 @@ var init_crush2 = __esm({
         }
       }
     };
-    globalLayout6 = {
+    globalLayout11 = {
       rootInstructionPath: CRUSH_GLOBAL_ROOT_FILE,
       skillDir: CRUSH_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -10190,7 +10382,7 @@ var init_crush2 = __esm({
       globalSupport: {
         capabilities: globalCapabilities9,
         detectionPaths: [CRUSH_GLOBAL_ROOT_FILE, CRUSH_GLOBAL_CONFIG_FILE, CRUSH_GLOBAL_SKILLS_DIR],
-        layout: globalLayout6
+        layout: globalLayout11
       },
       mergeGeneratedOutputContent(existing, pending, newContent, resolvedPath) {
         const base = pending?.content ?? existing;
@@ -10737,7 +10929,6 @@ async function importSkills3(projectRoot, results, normalize, skillsRelDir = CUR
   const directorySkills = await findDirectorySkills(skillsDir);
   const options = {
     projectRoot,
-    sourceSkillsDir: skillsRelDir,
     destCanonicalSkillsDir: CURSOR_CANONICAL_SKILLS_DIR,
     targetName: "cursor",
     normalize,
@@ -10773,20 +10964,20 @@ async function hasGlobalCursorArtifacts(projectRoot) {
   const candidates = [
     join(projectRoot, CURSOR_DOT_CURSOR_AGENTS),
     join(projectRoot, CURSOR_GLOBAL_USER_RULES),
-    join(projectRoot, CURSOR_GLOBAL_MCP_EXPORT),
+    join(projectRoot, CURSOR_MCP),
     join(projectRoot, CURSOR_HOOKS),
     join(projectRoot, CURSOR_IGNORE),
-    join(projectRoot, CURSOR_GLOBAL_SKILLS_DIR),
-    join(projectRoot, CURSOR_GLOBAL_AGENTS_DIR),
+    join(projectRoot, CURSOR_SKILLS_DIR),
+    join(projectRoot, CURSOR_AGENTS_DIR),
     join(projectRoot, CURSOR_COMMANDS_DIR)
   ];
   for (const p of candidates) {
-    const stat7 = await readFileSafe(p);
-    if (stat7 !== null && stat7.trim() !== "") return true;
+    const stat8 = await readFileSafe(p);
+    if (stat8 !== null && stat8.trim() !== "") return true;
   }
-  const skillFiles = await readDirRecursive(join(projectRoot, CURSOR_GLOBAL_SKILLS_DIR));
+  const skillFiles = await readDirRecursive(join(projectRoot, CURSOR_SKILLS_DIR));
   if (skillFiles.some((f) => f.endsWith(".md"))) return true;
-  const agentFiles = await readDirRecursive(join(projectRoot, CURSOR_GLOBAL_AGENTS_DIR));
+  const agentFiles = await readDirRecursive(join(projectRoot, CURSOR_AGENTS_DIR));
   if (agentFiles.some((f) => f.endsWith(".md"))) return true;
   const commandFiles = await readDirRecursive(join(projectRoot, CURSOR_COMMANDS_DIR));
   if (commandFiles.some((f) => f.endsWith(".md"))) return true;
@@ -10843,7 +11034,7 @@ async function importGlobalDotCursorAgents(projectRoot, results, normalize) {
   });
 }
 async function importGlobalMcp(projectRoot, results) {
-  const mcpPath = join(projectRoot, CURSOR_GLOBAL_MCP_EXPORT);
+  const mcpPath = join(projectRoot, CURSOR_MCP);
   const content = await readFileSafe(mcpPath);
   if (content === null || content.trim() === "") return;
   let parsed;
@@ -10864,7 +11055,7 @@ async function importGlobalMcp(projectRoot, results) {
   });
 }
 async function importGlobalAgents(projectRoot, results, normalize) {
-  const agentsDir = join(projectRoot, CURSOR_GLOBAL_AGENTS_DIR);
+  const agentsDir = join(projectRoot, CURSOR_AGENTS_DIR);
   const destDir = join(projectRoot, CURSOR_CANONICAL_AGENTS_DIR);
   results.push(
     ...await importFileDirectory({
@@ -10913,7 +11104,7 @@ async function importFromCursorGlobalExports(projectRoot) {
   if (!rootWritten) rootWritten = await importGlobalUserRules(projectRoot, results, normalize);
   if (!rootWritten) await importGlobalDotCursorAgents(projectRoot, results, normalize);
   await importGlobalMcp(projectRoot, results);
-  await importSkills3(projectRoot, results, normalize, CURSOR_GLOBAL_SKILLS_DIR);
+  await importSkills3(projectRoot, results, normalize, CURSOR_SKILLS_DIR);
   await importGlobalAgents(projectRoot, results, normalize);
   await importGlobalCommands(projectRoot, results, normalize);
   await importSettings2(projectRoot, results);
@@ -11087,7 +11278,7 @@ var init_lint9 = __esm({
 });
 
 // src/targets/cursor/index.ts
-var target12, project12, global6, globalCapabilities10, descriptor12;
+var target12, project12, globalLayout12, globalCapabilities10, descriptor12;
 var init_cursor2 = __esm({
   "src/targets/cursor/index.ts"() {
     init_generator14();
@@ -11137,7 +11328,7 @@ var init_cursor2 = __esm({
         }
       }
     };
-    global6 = {
+    globalLayout12 = {
       rootInstructionPath: CURSOR_GENERAL_RULE,
       outputFamilies: [
         {
@@ -11146,18 +11337,13 @@ var init_cursor2 = __esm({
           explicitPaths: [CURSOR_COMPAT_AGENTS, CURSOR_DOT_CURSOR_AGENTS]
         }
       ],
-      skillDir: CURSOR_GLOBAL_SKILLS_DIR,
+      skillDir: CURSOR_SKILLS_DIR,
       managedOutputs: {
-        dirs: [
-          CURSOR_RULES_DIR,
-          CURSOR_COMMANDS_DIR,
-          CURSOR_GLOBAL_AGENTS_DIR,
-          CURSOR_GLOBAL_SKILLS_DIR
-        ],
+        dirs: [CURSOR_RULES_DIR, CURSOR_COMMANDS_DIR, CURSOR_AGENTS_DIR, CURSOR_SKILLS_DIR],
         files: [
           CURSOR_GENERAL_RULE,
           CURSOR_DOT_CURSOR_AGENTS,
-          CURSOR_GLOBAL_MCP_EXPORT,
+          CURSOR_MCP,
           CURSOR_HOOKS,
           CURSOR_IGNORE,
           CURSOR_GLOBAL_USER_RULES
@@ -11186,7 +11372,7 @@ var init_cursor2 = __esm({
           return `${CURSOR_COMMANDS_DIR}/${name}.md`;
         },
         agentPath(name, _config) {
-          return `${CURSOR_GLOBAL_AGENTS_DIR}/${name}.md`;
+          return `${CURSOR_AGENTS_DIR}/${name}.md`;
         }
       }
     };
@@ -11238,11 +11424,11 @@ var init_cursor2 = __esm({
           CURSOR_HOOKS,
           CURSOR_IGNORE,
           CURSOR_SKILLS_DIR,
-          CURSOR_GLOBAL_AGENTS_DIR,
+          CURSOR_AGENTS_DIR,
           CURSOR_COMMANDS_DIR,
           CURSOR_GLOBAL_USER_RULES
         ],
-        layout: global6
+        layout: globalLayout12
       },
       importer: {
         // Project-only declarable features. Rules/mcp/skills/settings/ignore stay
@@ -11401,7 +11587,7 @@ var init_lint10 = __esm({
 });
 
 // src/targets/deepagents-cli/index.ts
-var target13, project13, globalLayout7, capabilities5, globalCapabilities11, descriptor13;
+var target13, project13, globalLayout13, capabilities5, globalCapabilities11, descriptor13;
 var init_deepagents_cli2 = __esm({
   "src/targets/deepagents-cli/index.ts"() {
     init_command_skill();
@@ -11441,7 +11627,7 @@ var init_deepagents_cli2 = __esm({
         }
       }
     };
-    globalLayout7 = {
+    globalLayout13 = {
       rootInstructionPath: DEEPAGENTS_CLI_GLOBAL_ROOT_FILE,
       skillDir: DEEPAGENTS_CLI_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -11512,7 +11698,7 @@ var init_deepagents_cli2 = __esm({
       globalSupport: {
         capabilities: globalCapabilities11,
         detectionPaths: [DEEPAGENTS_CLI_GLOBAL_ROOT_FILE, DEEPAGENTS_CLI_GLOBAL_MCP_FILE],
-        layout: globalLayout7
+        layout: globalLayout13
       },
       importer: {
         rules: {
@@ -11734,7 +11920,7 @@ var init_lint11 = __esm({
 });
 
 // src/targets/factory-droid/index.ts
-var target14, project14, globalLayout8, capabilities6, descriptor14;
+var target14, project14, globalLayout14, capabilities6, descriptor14;
 var init_factory_droid2 = __esm({
   "src/targets/factory-droid/index.ts"() {
     init_generator16();
@@ -11773,7 +11959,7 @@ var init_factory_droid2 = __esm({
         }
       }
     };
-    globalLayout8 = {
+    globalLayout14 = {
       rootInstructionPath: FACTORY_DROID_GLOBAL_ROOT_FILE,
       skillDir: FACTORY_DROID_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -11840,7 +12026,7 @@ var init_factory_droid2 = __esm({
           FACTORY_DROID_GLOBAL_MCP_FILE,
           FACTORY_DROID_GLOBAL_DROIDS_DIR
         ],
-        layout: globalLayout8
+        layout: globalLayout14
       },
       importer: {
         rules: {
@@ -12783,7 +12969,7 @@ var init_scoped_settings_emit = __esm({
 });
 
 // src/targets/gemini-cli/index.ts
-var target15, project15, global7, globalCapabilities12, descriptor15;
+var target15, project15, globalLayout15, globalCapabilities12, descriptor15;
 var init_gemini_cli2 = __esm({
   "src/targets/gemini-cli/index.ts"() {
     init_generator18();
@@ -12853,7 +13039,7 @@ var init_gemini_cli2 = __esm({
         }
       }
     };
-    global7 = {
+    globalLayout15 = {
       rootInstructionPath: GEMINI_GLOBAL_ROOT,
       outputFamilies: [
         { id: "compat-agents", kind: "additional", explicitPaths: [GEMINI_GLOBAL_COMPAT_AGENTS] }
@@ -12964,7 +13150,7 @@ var init_gemini_cli2 = __esm({
           GEMINI_GLOBAL_SKILLS_DIR,
           GEMINI_GLOBAL_AGENTS_DIR
         ],
-        layout: global7
+        layout: globalLayout15
       },
       importer: {
         rules: {
@@ -12985,7 +13171,8 @@ var init_gemini_cli2 = __esm({
         }
       },
       buildImportPaths: buildGeminiCliImportPaths,
-      detectionPaths: ["GEMINI.md", ".gemini"]
+      detectionPaths: ["GEMINI.md", ".gemini"],
+      conversionDefaults: { agentsToSkills: false }
     };
   }
 });
@@ -13112,7 +13299,7 @@ var init_lint13 = __esm({
 });
 
 // src/targets/goose/index.ts
-var target16, project16, globalLayout9, capabilities7, descriptor16;
+var target16, project16, globalLayout16, capabilities7, descriptor16;
 var init_goose2 = __esm({
   "src/targets/goose/index.ts"() {
     init_command_skill();
@@ -13153,7 +13340,7 @@ var init_goose2 = __esm({
         }
       }
     };
-    globalLayout9 = {
+    globalLayout16 = {
       rootInstructionPath: GOOSE_GLOBAL_ROOT_FILE,
       skillDir: GOOSE_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -13163,9 +13350,6 @@ var init_goose2 = __esm({
       rewriteGeneratedPath(path) {
         if (path === GOOSE_ROOT_FILE) return GOOSE_GLOBAL_ROOT_FILE;
         if (path === GOOSE_IGNORE) return GOOSE_GLOBAL_IGNORE;
-        if (path.startsWith(`${GOOSE_SKILLS_DIR}/`)) {
-          return path;
-        }
         return path;
       },
       mirrorGlobalPath(path, activeTargets) {
@@ -13216,7 +13400,7 @@ var init_goose2 = __esm({
       globalSupport: {
         capabilities: capabilities7,
         detectionPaths: [GOOSE_GLOBAL_ROOT_FILE, GOOSE_GLOBAL_IGNORE, GOOSE_GLOBAL_SKILLS_DIR],
-        layout: globalLayout9
+        layout: globalLayout16
       },
       importer: {
         rules: {
@@ -13245,7 +13429,8 @@ var init_goose2 = __esm({
         ".agents/skills/": "consumer"
       },
       buildImportPaths: buildGooseImportPaths,
-      detectionPaths: [GOOSE_ROOT_FILE, GOOSE_IGNORE]
+      detectionPaths: [GOOSE_ROOT_FILE, GOOSE_IGNORE],
+      conversionDefaults: { commandsToSkills: true, agentsToSkills: true }
     };
   }
 });
@@ -13641,7 +13826,7 @@ var init_lint15 = __esm({
 });
 
 // src/targets/junie/index.ts
-var target18, project18, global8, globalCapabilities13, descriptor18;
+var target18, project18, globalLayout17, globalCapabilities13, descriptor18;
 var init_junie2 = __esm({
   "src/targets/junie/index.ts"() {
     init_generator21();
@@ -13681,7 +13866,7 @@ var init_junie2 = __esm({
         }
       }
     };
-    global8 = {
+    globalLayout17 = {
       rootInstructionPath: JUNIE_GLOBAL_AGENTS_MD,
       renderPrimaryRootInstruction: renderJunieGlobalInstructions,
       skillDir: JUNIE_GLOBAL_SKILLS_DIR,
@@ -13779,7 +13964,7 @@ var init_junie2 = __esm({
           JUNIE_GLOBAL_COMMANDS_DIR,
           JUNIE_GLOBAL_MCP_FILE
         ],
-        layout: global8
+        layout: globalLayout17
       },
       importer: {
         rules: {
@@ -14176,7 +14361,7 @@ var init_lint16 = __esm({
 });
 
 // src/targets/kilo-code/index.ts
-var target19, project19, globalLayout10, capabilities9, descriptor19;
+var target19, project19, globalLayout18, capabilities9, descriptor19;
 var init_kilo_code2 = __esm({
   "src/targets/kilo-code/index.ts"() {
     init_generator22();
@@ -14217,7 +14402,7 @@ var init_kilo_code2 = __esm({
         }
       }
     };
-    globalLayout10 = {
+    globalLayout18 = {
       rootInstructionPath: KILO_CODE_GLOBAL_AGENTS_MD,
       skillDir: KILO_CODE_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -14288,7 +14473,7 @@ var init_kilo_code2 = __esm({
           KILO_CODE_GLOBAL_MCP_FILE,
           KILO_CODE_GLOBAL_IGNORE
         ],
-        layout: globalLayout10
+        layout: globalLayout18
       },
       importer: {
         rules: [
@@ -14698,7 +14883,7 @@ var init_lint17 = __esm({
 });
 
 // src/targets/kiro/index.ts
-var target20, project20, global9, globalCapabilities14, descriptor20;
+var target20, project20, globalLayout19, globalCapabilities14, descriptor20;
 var init_kiro2 = __esm({
   "src/targets/kiro/index.ts"() {
     init_command_skill();
@@ -14740,7 +14925,7 @@ var init_kiro2 = __esm({
         }
       }
     };
-    global9 = {
+    globalLayout19 = {
       rootInstructionPath: KIRO_GLOBAL_STEERING_AGENTS_MD,
       skillDir: KIRO_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -14839,7 +15024,7 @@ var init_kiro2 = __esm({
           KIRO_GLOBAL_MCP_FILE,
           KIRO_GLOBAL_IGNORE
         ],
-        layout: global9
+        layout: globalLayout19
       },
       importer: {
         agents: {
@@ -14873,7 +15058,8 @@ var init_kiro2 = __esm({
         KIRO_HOOKS_DIR,
         KIRO_MCP_FILE,
         KIRO_IGNORE
-      ]
+      ],
+      conversionDefaults: { commandsToSkills: true }
     };
   }
 });
@@ -15172,7 +15358,7 @@ var init_lint18 = __esm({
 });
 
 // src/targets/opencode/index.ts
-var target21, project21, globalLayout11, capabilities10, descriptor21;
+var target21, project21, globalLayout20, capabilities10, descriptor21;
 var init_opencode2 = __esm({
   "src/targets/opencode/index.ts"() {
     init_generator24();
@@ -15212,7 +15398,7 @@ var init_opencode2 = __esm({
         }
       }
     };
-    globalLayout11 = {
+    globalLayout20 = {
       rootInstructionPath: OPENCODE_GLOBAL_AGENTS_MD,
       skillDir: OPENCODE_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -15284,7 +15470,7 @@ var init_opencode2 = __esm({
           OPENCODE_GLOBAL_SKILLS_DIR,
           OPENCODE_GLOBAL_CONFIG_FILE
         ],
-        layout: globalLayout11
+        layout: globalLayout20
       },
       importer: {
         rules: [
@@ -15477,7 +15663,7 @@ var init_lint19 = __esm({
 });
 
 // src/targets/pi-agent/index.ts
-var target22, project22, globalLayout12, capabilities11, descriptor22;
+var target22, project22, globalLayout21, capabilities11, descriptor22;
 var init_pi_agent2 = __esm({
   "src/targets/pi-agent/index.ts"() {
     init_command_skill();
@@ -15517,7 +15703,7 @@ var init_pi_agent2 = __esm({
         }
       }
     };
-    globalLayout12 = {
+    globalLayout21 = {
       rootInstructionPath: PI_AGENT_GLOBAL_ROOT_FILE,
       skillDir: PI_AGENT_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -15580,7 +15766,7 @@ var init_pi_agent2 = __esm({
       globalSupport: {
         capabilities: capabilities11,
         detectionPaths: [PI_AGENT_GLOBAL_ROOT_FILE],
-        layout: globalLayout12
+        layout: globalLayout21
       },
       importer: {
         rules: {
@@ -15726,7 +15912,7 @@ var init_linter23 = __esm({
 });
 
 // src/targets/qwen-code/index.ts
-var target23, project23, globalLayout13, capabilities12, globalCapabilities15, descriptor23;
+var target23, project23, globalLayout22, capabilities12, globalCapabilities15, descriptor23;
 var init_qwen_code2 = __esm({
   "src/targets/qwen-code/index.ts"() {
     init_generator26();
@@ -15765,7 +15951,7 @@ var init_qwen_code2 = __esm({
         }
       }
     };
-    globalLayout13 = {
+    globalLayout22 = {
       rootInstructionPath: QWEN_GLOBAL_ROOT,
       skillDir: QWEN_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -15846,7 +16032,7 @@ var init_qwen_code2 = __esm({
           QWEN_GLOBAL_AGENTS_DIR,
           QWEN_GLOBAL_SKILLS_DIR
         ],
-        layout: globalLayout13
+        layout: globalLayout22
       },
       importer: {
         rules: [
@@ -16335,7 +16521,7 @@ function computeStatus5(existing, content) {
   if (existing !== content) return "updated";
   return "unchanged";
 }
-var target25, project25, generateRooGlobalExtras, global10, globalCapabilities16, descriptor25;
+var target25, project25, generateRooGlobalExtras, globalLayout23, globalCapabilities16, descriptor25;
 var init_roo_code2 = __esm({
   "src/targets/roo-code/index.ts"() {
     init_fs();
@@ -16398,7 +16584,7 @@ var init_roo_code2 = __esm({
         }
       ];
     };
-    global10 = {
+    globalLayout23 = {
       rootInstructionPath: ROO_CODE_GLOBAL_AGENTS_MD,
       skillDir: ROO_CODE_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -16499,7 +16685,7 @@ var init_roo_code2 = __esm({
           ROO_CODE_GLOBAL_AGENTS_MD,
           ROO_CODE_GLOBAL_MODES_FILE
         ],
-        layout: global10,
+        layout: globalLayout23,
         scopeExtras: generateRooGlobalExtras
       },
       importer: {
@@ -16691,7 +16877,7 @@ var init_lint21 = __esm({
 });
 
 // src/targets/rovodev/index.ts
-var target26, project26, globalLayout14, capabilities14, globalCapabilities17, descriptor26;
+var target26, project26, globalLayout24, capabilities14, globalCapabilities17, descriptor26;
 var init_rovodev2 = __esm({
   "src/targets/rovodev/index.ts"() {
     init_command_skill();
@@ -16732,7 +16918,7 @@ var init_rovodev2 = __esm({
         }
       }
     };
-    globalLayout14 = {
+    globalLayout24 = {
       rootInstructionPath: ROVODEV_GLOBAL_ROOT_FILE,
       skillDir: ROVODEV_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -16806,7 +16992,7 @@ var init_rovodev2 = __esm({
       globalSupport: {
         capabilities: globalCapabilities17,
         detectionPaths: [ROVODEV_GLOBAL_DIR, ROVODEV_GLOBAL_ROOT_FILE, ROVODEV_GLOBAL_SKILLS_DIR],
-        layout: globalLayout14
+        layout: globalLayout24
       },
       importer: {
         rules: {
@@ -16975,7 +17161,7 @@ var init_linter27 = __esm({
 });
 
 // src/targets/trae/index.ts
-var target27, project27, global11, globalCapabilities18, descriptor27;
+var target27, project27, globalLayout25, globalCapabilities18, descriptor27;
 var init_trae2 = __esm({
   "src/targets/trae/index.ts"() {
     init_generator30();
@@ -17012,7 +17198,7 @@ var init_trae2 = __esm({
         }
       }
     };
-    global11 = {
+    globalLayout25 = {
       rootInstructionPath: TRAE_GLOBAL_ROOT_RULE,
       skillDir: TRAE_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -17095,7 +17281,7 @@ var init_trae2 = __esm({
           TRAE_GLOBAL_SKILLS_DIR,
           TRAE_GLOBAL_MCP_FILE
         ],
-        layout: global11
+        layout: globalLayout25
       },
       importer: {
         mcp: {
@@ -17242,7 +17428,7 @@ var init_lint22 = __esm({
 });
 
 // src/targets/warp/index.ts
-var target28, project28, globalLayout15, capabilities15, globalCapabilities19, descriptor28;
+var target28, project28, globalLayout26, capabilities15, globalCapabilities19, descriptor28;
 var init_warp2 = __esm({
   "src/targets/warp/index.ts"() {
     init_command_skill();
@@ -17283,7 +17469,7 @@ var init_warp2 = __esm({
         }
       }
     };
-    globalLayout15 = {
+    globalLayout26 = {
       rootInstructionPath: void 0,
       skillDir: WARP_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -17301,7 +17487,7 @@ var init_warp2 = __esm({
       },
       paths: {
         rulePath() {
-          return WARP_GLOBAL_SKILLS_DIR;
+          return null;
         },
         commandPath(name) {
           return `${WARP_GLOBAL_SKILLS_DIR}/${commandSkillDirName(name)}/SKILL.md`;
@@ -17355,7 +17541,7 @@ var init_warp2 = __esm({
       globalSupport: {
         capabilities: globalCapabilities19,
         detectionPaths: [WARP_GLOBAL_SKILLS_DIR],
-        layout: globalLayout15
+        layout: globalLayout26
       },
       importer: {
         rules: {
@@ -17379,7 +17565,8 @@ var init_warp2 = __esm({
         }
       },
       buildImportPaths: buildWarpImportPaths,
-      detectionPaths: [WARP_ROOT_FILE, WARP_LEGACY_ROOT_FILE, WARP_MCP_FILE]
+      detectionPaths: [WARP_ROOT_FILE, WARP_LEGACY_ROOT_FILE, WARP_MCP_FILE],
+      conversionDefaults: { commandsToSkills: true, agentsToSkills: true }
     };
   }
 });
@@ -17672,49 +17859,22 @@ var init_importer_workflows = __esm({
     init_constants31();
   }
 });
+
+// src/targets/windsurf/skills-adapter.ts
 async function importSkills4(projectRoot, results, normalize, skillsRelDir = WINDSURF_SKILLS_DIR) {
-  const skillsDir = join(projectRoot, skillsRelDir);
-  const directorySkills = await findDirectorySkills(skillsDir);
   const options = {
     projectRoot,
-    sourceSkillsDir: skillsRelDir,
     destCanonicalSkillsDir: WINDSURF_CANONICAL_SKILLS_DIR,
     targetName: "windsurf",
     normalize,
     results
   };
-  for (const [skillName, skillDir] of directorySkills) {
-    const skillMdPath = join(skillDir, "SKILL.md");
-    const content = await readFileSafe(skillMdPath);
-    if (!content) continue;
-    const rawParsed = parseFrontmatter(content);
-    const projectedAgent = parseProjectedAgentSkillFrontmatter(rawParsed.frontmatter, skillName);
-    if (projectedAgent) {
-      await removePathIfExists(join(projectRoot, WINDSURF_CANONICAL_SKILLS_DIR, skillName));
-      const destAgentsDir = join(projectRoot, WINDSURF_CANONICAL_AGENTS_DIR);
-      await mkdirp(destAgentsDir);
-      const agentPath = join(destAgentsDir, `${projectedAgent.name}.md`);
-      await writeFileAtomic(
-        agentPath,
-        serializeImportedAgent(projectedAgent, normalize(rawParsed.body, skillMdPath, agentPath))
-      );
-      results.push({
-        fromTool: "windsurf",
-        fromPath: skillMdPath,
-        toPath: `${WINDSURF_CANONICAL_AGENTS_DIR}/${projectedAgent.name}.md`,
-        feature: "agents"
-      });
-      continue;
-    }
-    await importDirectorySkill(skillName, skillDir, options);
-  }
+  await importSkillsDirectory([skillsRelDir], options, [
+    projectedAgentRecognizer({ canonicalAgentsDir: WINDSURF_CANONICAL_AGENTS_DIR })
+  ]);
 }
 var init_skills_adapter5 = __esm({
   "src/targets/windsurf/skills-adapter.ts"() {
-    init_fs();
-    init_markdown();
-    init_projected_agent_skill();
-    init_scoped_agents_import();
     init_skill_import_pipeline();
     init_constants31();
   }
@@ -18031,7 +18191,7 @@ function directoryScopedRuleDir2(globs) {
   if (dirs.length !== globs.length) return null;
   return dirs.every((dir) => dir === dirs[0]) ? dirs[0] : null;
 }
-var target29, project29, global12, globalCapabilities20, descriptor29;
+var target29, project29, globalLayout27, globalCapabilities20, descriptor29;
 var init_windsurf2 = __esm({
   "src/targets/windsurf/index.ts"() {
     init_generator33();
@@ -18085,7 +18245,7 @@ var init_windsurf2 = __esm({
         }
       }
     };
-    global12 = {
+    globalLayout27 = {
       rootInstructionPath: WINDSURF_GLOBAL_RULES,
       skillDir: WINDSURF_GLOBAL_SKILLS_DIR,
       managedOutputs: {
@@ -18189,10 +18349,11 @@ var init_windsurf2 = __esm({
           WINDSURF_GLOBAL_MCP_FILE,
           WINDSURF_GLOBAL_IGNORE
         ],
-        layout: global12
+        layout: globalLayout27
       },
       buildImportPaths: buildWindsurfImportPaths,
-      detectionPaths: [".windsurfrules", ".windsurf"]
+      detectionPaths: [".windsurfrules", ".windsurf"],
+      conversionDefaults: { agentsToSkills: true }
     };
   }
 });
@@ -18353,7 +18514,7 @@ function mergeZedSettings(existing, newContent) {
   }
   return JSON.stringify(base, null, 2);
 }
-var target30, project30, globalLayout16, capabilities16, globalCapabilities21, descriptor30;
+var target30, project30, globalLayout28, capabilities16, globalCapabilities21, descriptor30;
 var init_zed2 = __esm({
   "src/targets/zed/index.ts"() {
     init_generator34();
@@ -18386,7 +18547,7 @@ var init_zed2 = __esm({
         }
       }
     };
-    globalLayout16 = {
+    globalLayout28 = {
       rootInstructionPath: void 0,
       managedOutputs: {
         dirs: [],
@@ -18451,7 +18612,7 @@ var init_zed2 = __esm({
       globalSupport: {
         capabilities: globalCapabilities21,
         detectionPaths: [ZED_GLOBAL_SETTINGS_FILE],
-        layout: globalLayout16
+        layout: globalLayout28
       },
       importer: {
         rules: {
@@ -19057,6 +19218,72 @@ function rewriteGeneratedReferences(results, canonical, config, projectRoot, sco
 // src/core/reference/validate-generated-markdown-links.ts
 init_path_helpers();
 init_link_rebaser_helpers();
+
+// src/utils/output/logger.ts
+var C = {
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  reset: "\x1B[0m"
+};
+function out(text) {
+  {
+    process.stdout.write(text);
+  }
+}
+function noColor() {
+  return process.env.NO_COLOR !== void 0 && process.env.NO_COLOR !== "";
+}
+function c(code, text) {
+  return noColor() ? text : `${code}${text}${C.reset}`;
+}
+function pad(str, width) {
+  const len = [...str].length;
+  return str + " ".repeat(Math.max(0, width - len));
+}
+var logger = {
+  info(msg) {
+    out(c(C.cyan, msg) + "\n");
+  },
+  warn(msg) {
+    process.stderr.write(c(C.yellow, "\u26A0 ") + msg + "\n");
+  },
+  error(msg) {
+    process.stderr.write(c(C.red, "\u2717 ") + msg + "\n");
+  },
+  success(msg) {
+    out(c(C.green, "\u2713 ") + msg + "\n");
+  },
+  debug(msg) {
+    if (process.env.AGENTSMESH_DEBUG === "1") {
+      out(c(C.cyan, "[debug] ") + msg + "\n");
+    }
+  },
+  table(rows) {
+    if (rows.length === 0) return;
+    const cols = rows[0].length;
+    const widths = [];
+    for (let j = 0; j < cols; j++) {
+      let max = 0;
+      for (let i = 0; i < rows.length; i++) {
+        const len = [...rows[i][j]].length;
+        if (len > max) max = len;
+      }
+      widths[j] = max;
+    }
+    const border = "+" + widths.map((w) => "-".repeat(w + 2)).join("+") + "+";
+    out(border + "\n");
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      const line = "| " + row.map((cell, j) => pad(cell, widths[j])).join(" | ") + " |";
+      out(line + "\n");
+    }
+    out(border + "\n");
+  }
+};
+
+// src/core/reference/validate-generated-markdown-links.ts
 var INLINE_MD_LINK = /!?\[[^\]]*\]\(([^)]+)\)/g;
 var REF_LINK_DEF = /^\s*\[[^\]\n]+\]:\s*(?:<([^>\n]*)>|(\S+))/gm;
 function isMarkdownLikeOutput(relativePath) {
@@ -19072,7 +19299,7 @@ function parseMarkdownLinkDestination(raw) {
   if (s.startsWith("<") && s.endsWith(">")) s = s.slice(1, -1).trim();
   return s;
 }
-function shouldSkipLocalValidation(pathPart) {
+function shouldSkipLocalValidation(pathPart, projectRoot) {
   const t = pathPart.trim();
   if (!t) return true;
   if (t.startsWith("#")) return true;
@@ -19083,8 +19310,66 @@ function shouldSkipLocalValidation(pathPart) {
   if (/^ftp:/i.test(t)) return true;
   if (/^[a-zA-Z]:[\\/]/.test(t)) return false;
   if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(t)) return true;
+  if (t.startsWith("/")) {
+    const normalizedRoot = normalizeForProject(projectRoot, projectRoot);
+    const normalizedAbs = normalizeForProject(projectRoot, t);
+    if (!normalizedAbs.startsWith(`${normalizedRoot}/`) && normalizedAbs !== normalizedRoot) {
+      return true;
+    }
+  }
   return false;
 }
+function isSkillGeneratedOutput(relativePath) {
+  return /(?:^|\/)[^/]+\/skills\/[^/]+\//.test(relativePath);
+}
+var OUTPUT_DIR_TO_FEATURE = {
+  rules: "rules",
+  steering: "rules",
+  commands: "commands",
+  agents: "agents",
+  skills: "skills",
+  // factory-droid: native agent definitions land in `.factory/droids/<name>.md`.
+  // Treat the directory as the agents feature so pack-originated key matching
+  // recognizes those outputs and downgrades broken links to advisory warnings.
+  droids: "agents",
+  // copilot project layout: rules emit per-glob into `.github/instructions/`,
+  // commands into `.github/prompts/`. Map both to their canonical features so
+  // pack-originated outputs from those dirs match the same keys as their
+  // canonical counterparts.
+  instructions: "rules",
+  prompts: "commands"
+};
+var TOP_LEVEL_DIR_TO_FEATURE = {
+  ".clinerules": "rules"
+};
+var COMPOUND_MARKDOWN_SUFFIXES = [".agent.md", ".instructions.md", ".prompt.md"];
+function stripMarkdownExt(name) {
+  for (const suffix of COMPOUND_MARKDOWN_SUFFIXES) {
+    if (name.endsWith(suffix)) return name.slice(0, -suffix.length);
+  }
+  if (name.endsWith(".mdc")) return name.slice(0, -4);
+  if (name.endsWith(".md")) return name.slice(0, -3);
+  return name;
+}
+function canonicalKeyFromOutputPath(relativePath) {
+  const m = /^[^/]+\/([^/]+)\/([^/]+)/.exec(relativePath);
+  if (m) {
+    const feature = OUTPUT_DIR_TO_FEATURE[m[1] ?? ""];
+    if (feature) {
+      let name = m[2] ?? "";
+      if (feature !== "skills") name = stripMarkdownExt(name);
+      return `${feature}/${name}`;
+    }
+  }
+  const m2 = /^([^/]+)\/([^/]+)/.exec(relativePath);
+  if (m2) {
+    const feature = TOP_LEVEL_DIR_TO_FEATURE[m2[1] ?? ""];
+    if (feature) {
+      return `${feature}/${stripMarkdownExt(m2[2] ?? "")}`;
+    }
+  }
+  return null;
+}
 function pathExistsForGenerate(absolutePath, planned) {
   if (planned.has(absolutePath)) return true;
   try {
@@ -19107,7 +19392,7 @@ function resolveMarkdownLinkTargets(rawDestination, projectRoot, destinationFile
   } catch {
     decoded = pathPart;
   }
-  if (shouldSkipLocalValidation(decoded)) return [];
+  if (shouldSkipLocalValidation(decoded, projectRoot)) return [];
   let candidates = resolveProjectPath(decoded, projectRoot, destinationFileAbs);
   if (candidates.length === 0) {
     const api = pathApi(projectRoot);
@@ -19161,10 +19446,32 @@ function findBrokenMarkdownLinks(results, projectRoot) {
   }
   return broken;
 }
-function validateGeneratedMarkdownLinks(results, projectRoot) {
+function validateGeneratedMarkdownLinks(results, projectRoot, options = {}) {
   const broken = findBrokenMarkdownLinks(results, projectRoot);
   if (broken.length === 0) return;
-  const lines = broken.map(
+  const packKeys = options.packOriginatedKeys;
+  const errors = [];
+  const warnings = [];
+  for (const b of broken) {
+    const key = canonicalKeyFromOutputPath(b.generatePath);
+    const isPackOriginated = packKeys !== void 0 && key !== null && packKeys.has(key);
+    if (isSkillGeneratedOutput(b.generatePath) || isPackOriginated) {
+      warnings.push(b);
+    } else {
+      errors.push(b);
+    }
+  }
+  if (warnings.length > 0) {
+    const lines2 = warnings.map(
+      (b) => `  ${b.generatePath} (${b.target}): "${b.rawLink}" \u2192 not found`
+    );
+    logger.warn(
+      `Third-party content contains ${warnings.length} broken local link${warnings.length === 1 ? "" : "s"} (warning only; outputs from installed packs and skill subtrees are treated as advisory):
+${lines2.join("\n")}`
+    );
+  }
+  if (errors.length === 0) return;
+  const lines = errors.map(
     (b) => `  ${b.generatePath} (${b.target}): "${b.rawLink}" \u2192 not found (tried: ${b.checkedPaths.join(", ")})`
   );
   throw new Error(
@@ -19173,6 +19480,37 @@ ${lines.join("\n")}
 Fix canonical sources or generators so every local link targets an existing file or folder.`
   );
 }
+var PACK_MARKERS = [
+  `${sep}.agentsmesh${sep}packs${sep}`,
+  "/.agentsmesh/packs/"
+];
+function isUnderPacks(sourcePath) {
+  return PACK_MARKERS.some((marker) => sourcePath.includes(marker));
+}
+function buildPackOriginatedKeys(canonical) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const rule of canonical.rules) {
+    if (isUnderPacks(rule.source)) {
+      const name = rule.root ? "_root" : ruleNameFromSource(rule.source);
+      if (name) keys.add(`rules/${name}`);
+    }
+  }
+  for (const agent of canonical.agents) {
+    if (isUnderPacks(agent.source)) keys.add(`agents/${agent.name}`);
+  }
+  for (const cmd of canonical.commands) {
+    if (isUnderPacks(cmd.source)) keys.add(`commands/${cmd.name}`);
+  }
+  for (const skill of canonical.skills) {
+    if (isUnderPacks(skill.source)) keys.add(`skills/${skill.name}`);
+  }
+  return keys;
+}
+function ruleNameFromSource(source) {
+  const slash = source.replace(/\\/g, "/");
+  const base = slash.split("/").pop() ?? "";
+  return base.endsWith(".md") ? base.slice(0, -3) : base;
+}
 
 // src/core/generate/collision.ts
 init_target_ids();
@@ -19200,6 +19538,19 @@ function mergeDuplicateMetadata(preferred, other) {
 function trimmedContent(content) {
   return content.trim();
 }
+var OPTIONAL_AGENTS_BLOCKS = [
+  /<!-- agentsmesh:embedded-rules:start -->[\s\S]*?<!-- agentsmesh:embedded-rules:end -->\n*/g
+];
+function normalizeAgentsContent(content) {
+  let out2 = content;
+  for (const block of OPTIONAL_AGENTS_BLOCKS) {
+    out2 = out2.replace(block, "");
+  }
+  return out2.trim().replace(/\n{2,}/g, "\n\n");
+}
+function hasOptionalAgentsBlock(content) {
+  return /<!-- agentsmesh:embedded-rules:start -->/.test(content);
+}
 function richerAgentsResult(left, right) {
   if (!left.path.endsWith(AGENTS_SUFFIX) || left.path !== right.path) return null;
   const leftTrimmed = trimmedContent(left.content);
@@ -19207,8 +19558,15 @@ function richerAgentsResult(left, right) {
   if (!leftTrimmed || !rightTrimmed) return null;
   const leftContainsRight = leftTrimmed.includes(rightTrimmed);
   const rightContainsLeft = rightTrimmed.includes(leftTrimmed);
-  if (leftContainsRight === rightContainsLeft) return null;
-  return leftContainsRight ? left : right;
+  if (leftContainsRight !== rightContainsLeft) {
+    return leftContainsRight ? left : right;
+  }
+  if (normalizeAgentsContent(left.content) === normalizeAgentsContent(right.content)) {
+    const leftHas = hasOptionalAgentsBlock(left.content);
+    const rightHas = hasOptionalAgentsBlock(right.content);
+    if (leftHas !== rightHas) return leftHas ? left : right;
+  }
+  return null;
 }
 function richerCodexAgentsResult(left, right) {
   if (!left.path.endsWith(AGENTS_SUFFIX) || left.path !== right.path) return null;
@@ -19513,7 +19871,9 @@ async function generate(ctx) {
     targets,
     sharedPaths
   );
-  validateGeneratedMarkdownLinks(rewrittenResults, projectRoot);
+  validateGeneratedMarkdownLinks(rewrittenResults, projectRoot, {
+    packOriginatedKeys: buildPackOriginatedKeys(canonical)
+  });
   return resolveOutputCollisions(rewrittenResults.map(refreshResultStatus));
 }
 function computeSharedRootInstructionPaths(results, scope) {
@@ -19550,72 +19910,6 @@ init_errors();
 
 // src/config/core/loader.ts
 init_fs();
-
-// src/utils/output/logger.ts
-var C = {
-  green: "\x1B[32m",
-  red: "\x1B[31m",
-  yellow: "\x1B[33m",
-  cyan: "\x1B[36m",
-  reset: "\x1B[0m"
-};
-function out(text) {
-  {
-    process.stdout.write(text);
-  }
-}
-function noColor() {
-  return process.env.NO_COLOR !== void 0 && process.env.NO_COLOR !== "";
-}
-function c(code, text) {
-  return noColor() ? text : `${code}${text}${C.reset}`;
-}
-function pad(str, width) {
-  const len = [...str].length;
-  return str + " ".repeat(Math.max(0, width - len));
-}
-var logger = {
-  info(msg) {
-    out(c(C.cyan, msg) + "\n");
-  },
-  warn(msg) {
-    process.stderr.write(c(C.yellow, "\u26A0 ") + msg + "\n");
-  },
-  error(msg) {
-    process.stderr.write(c(C.red, "\u2717 ") + msg + "\n");
-  },
-  success(msg) {
-    out(c(C.green, "\u2713 ") + msg + "\n");
-  },
-  debug(msg) {
-    if (process.env.AGENTSMESH_DEBUG === "1") {
-      out(c(C.cyan, "[debug] ") + msg + "\n");
-    }
-  },
-  table(rows) {
-    if (rows.length === 0) return;
-    const cols = rows[0].length;
-    const widths = [];
-    for (let j = 0; j < cols; j++) {
-      let max = 0;
-      for (let i = 0; i < rows.length; i++) {
-        const len = [...rows[i][j]].length;
-        if (len > max) max = len;
-      }
-      widths[j] = max;
-    }
-    const border = "+" + widths.map((w) => "-".repeat(w + 2)).join("+") + "+";
-    out(border + "\n");
-    for (let i = 0; i < rows.length; i++) {
-      const row = rows[i];
-      const line = "| " + row.map((cell, j) => pad(cell, widths[j])).join(" | ") + " |";
-      out(line + "\n");
-    }
-    out(border + "\n");
-  }
-};
-
-// src/config/core/loader.ts
 init_errors();
 
 // src/config/core/schema.ts
@@ -19632,6 +19926,7 @@ var VALID_FEATURES = [
 ];
 var targetSchema = z.enum(TARGET_IDS);
 var featureSchema = z.enum(VALID_FEATURES);
+var installAsSchema = z.enum(["rules", "commands", "agents", "skills"]);
 var extendPickSchema = z.object({
   skills: z.array(z.string()).optional(),
   commands: z.array(z.string()).optional(),
@@ -19643,6 +19938,7 @@ var extendSourceSchema = z.object({
   source: z.string(),
   version: z.string().optional(),
   target: targetSchema.optional(),
+  as: installAsSchema.optional(),
   features: z.array(featureSchema),
   /** Repo-relative POSIX path for discovery (skill packs, nested .agentsmesh). */
   path: z.string().optional(),
@@ -19933,7 +20229,28 @@ async function runGit(args, cwd) {
 
 // src/config/remote/github-remote.ts
 init_fs();
-var MAX_TARBALL_BYTES = 500 * 1024 * 1024;
+var DEFAULT_MAX_TARBALL_MB = 500;
+var MIN_MAX_TARBALL_MB = 1;
+var MAX_MAX_TARBALL_MB = 4096;
+function resolveMaxTarballBytes() {
+  const raw = process.env.AGENTSMESH_MAX_TARBALL_MB;
+  if (raw === void 0 || raw === "") return DEFAULT_MAX_TARBALL_MB * 1024 * 1024;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+    console.warn(
+      `[agentsmesh] AGENTSMESH_MAX_TARBALL_MB="${raw}" is not an integer; using default ${DEFAULT_MAX_TARBALL_MB} MiB.`
+    );
+    return DEFAULT_MAX_TARBALL_MB * 1024 * 1024;
+  }
+  if (parsed < MIN_MAX_TARBALL_MB || parsed > MAX_MAX_TARBALL_MB) {
+    console.warn(
+      `[agentsmesh] AGENTSMESH_MAX_TARBALL_MB=${parsed} is outside [${MIN_MAX_TARBALL_MB}, ${MAX_MAX_TARBALL_MB}]; using default ${DEFAULT_MAX_TARBALL_MB} MiB.`
+    );
+    return DEFAULT_MAX_TARBALL_MB * 1024 * 1024;
+  }
+  return parsed * 1024 * 1024;
+}
+var MAX_TARBALL_BYTES = resolveMaxTarballBytes();
 async function readBoundedResponse(res, maxBytes) {
   const lenHeader = typeof res.headers?.get === "function" ? res.headers.get("content-length") : null;
   if (lenHeader !== null) {
@@ -20283,6 +20600,7 @@ async function resolveExtendPaths(config, configDir, options = {}) {
         resolvedPath: fetched.resolvedPath,
         features: [...ext.features],
         target: ext.target,
+        as: ext.as,
         version: fetched.version,
         path: ext.path,
         pick: ext.pick
@@ -20300,6 +20618,7 @@ async function resolveExtendPaths(config, configDir, options = {}) {
       resolvedPath,
       features: [...ext.features],
       target: ext.target,
+      as: ext.as,
       path: ext.path,
       pick: ext.pick
     });
@@ -20400,6 +20719,28 @@ function assertNoBasenameCollisions(feature, paths, stripExt) {
     seen.set(slug, p);
   }
 }
+var ALTERNATE_RESOURCE_FORMATS = /* @__PURE__ */ new Set([".toml", ".yaml", ".yml", ".json"]);
+function warnIfUnrecognizedResourceFormats(featureLabel, dir, allFiles, parsedFiles, opts = {}) {
+  if (allFiles.length === 0) return;
+  const parsed = new Set(parsedFiles);
+  const handled = opts.handledByOtherReader;
+  const formats = /* @__PURE__ */ new Set();
+  let droppedCount = 0;
+  for (const f of allFiles) {
+    if (parsed.has(f)) continue;
+    if (basename(f).startsWith(".")) continue;
+    const ext = extname(f).toLowerCase();
+    if (!ALTERNATE_RESOURCE_FORMATS.has(ext)) continue;
+    if (handled?.has(ext)) continue;
+    formats.add(ext);
+    droppedCount++;
+  }
+  if (droppedCount === 0) return;
+  const formatList = [...formats].sort().join(", ");
+  logger.warn(
+    `Skipped ${droppedCount} ${featureLabel} file(s) in ${dir} (format${formats.size === 1 ? "" : "s"}: ${formatList}). agentsmesh ${featureLabel} are parsed from .md files only.`
+  );
+}
 
 // src/canonical/features/rules.ts
 var VALID_TRIGGERS = ["always_on", "model_decision", "glob", "manual"];
@@ -20408,18 +20749,23 @@ function toStrArray(v) {
   if (typeof v === "string") return v ? [v] : [];
   return [];
 }
-async function parseRules(rulesDir) {
+async function parseRules(rulesDir, opts = {}) {
   const files = await readDirRecursive(rulesDir);
   const mdFiles = files.filter((f) => {
     if (!f.endsWith(".md")) return false;
     const name = basename(f, ".md");
     return name === "_root" || !name.startsWith("_");
   });
+  warnIfUnrecognizedResourceFormats("rules", rulesDir, files, mdFiles, {
+    handledByOtherReader: opts.handledByOtherReader
+  });
   const rules = [];
   for (const path of mdFiles) {
     const content = await readFileSafe(path);
     if (!content) continue;
-    const { frontmatter, body } = parseFrontmatter(content);
+    const parsed = parseOrSkipFrontmatter(content, path, opts.onParseError);
+    if (!parsed) continue;
+    const { frontmatter, body } = parsed;
     const name = basename(path, ".md");
     assertCanonicalName("rule", name);
     const rootFromFilename = name === "_root";
@@ -20460,15 +20806,20 @@ function toToolsArray2(v) {
   }
   return [];
 }
-async function parseCommands(commandsDir) {
+async function parseCommands(commandsDir, opts = {}) {
   const files = await readDirRecursive(commandsDir);
   const mdFiles = files.filter((f) => f.endsWith(".md") && !basename(f).startsWith("_"));
+  warnIfUnrecognizedResourceFormats("commands", commandsDir, files, mdFiles, {
+    handledByOtherReader: opts.handledByOtherReader
+  });
   assertNoBasenameCollisions("command", mdFiles, ".md");
   const commands = [];
   for (const path of mdFiles) {
     const content = await readFileSafe(path);
     if (!content) continue;
-    const { frontmatter, body } = parseFrontmatter(content);
+    const parsed = parseOrSkipFrontmatter(content, path, opts.onParseError);
+    if (!parsed) continue;
+    const { frontmatter, body } = parsed;
     const name = basename(path, ".md");
     assertCanonicalName("command", name);
     const fromCamel = toToolsArray2(frontmatter.allowedTools);
@@ -20515,15 +20866,20 @@ function toHooks2(v) {
   }
   return {};
 }
-async function parseAgents(agentsDir) {
+async function parseAgents(agentsDir, opts = {}) {
   const files = await readDirRecursive(agentsDir);
   const mdFiles = files.filter((f) => f.endsWith(".md") && !basename(f).startsWith("_"));
+  warnIfUnrecognizedResourceFormats("agents", agentsDir, files, mdFiles, {
+    handledByOtherReader: opts.handledByOtherReader
+  });
   assertNoBasenameCollisions("agent", mdFiles, ".md");
   const agents = [];
   for (const path of mdFiles) {
     const content = await readFileSafe(path);
     if (!content) continue;
-    const { frontmatter, body } = parseFrontmatter(content);
+    const parsed = parseOrSkipFrontmatter(content, path, opts.onParseError);
+    if (!parsed) continue;
+    const { frontmatter, body } = parsed;
     const name = basename(path, ".md");
     assertCanonicalName("agent", name);
     const toolsCamel = toStrArray2(frontmatter.tools);
@@ -20562,11 +20918,18 @@ async function parseAgents(agentsDir) {
 // src/canonical/features/skills.ts
 init_fs();
 init_markdown();
+init_boilerplate_filter();
 async function readContent(path) {
   const c2 = await readFileSafe(path);
   return c2 ?? "";
 }
 var SKILL_FILE = "SKILL.md";
+var DOC_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".rst", ".txt"]);
+function isMarkdownLikeDoc(name) {
+  const dot = name.lastIndexOf(".");
+  if (dot < 0) return true;
+  return DOC_EXTENSIONS.has(name.slice(dot).toLowerCase());
+}
 var EXCLUDED_DIR_PREFIXES = [".git", "node_modules"];
 function sanitizeSkillName(raw) {
   return raw.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
@@ -20581,16 +20944,20 @@ async function listSupportingFiles(skillDir) {
     const firstSegment = name.split("/")[0];
     if (EXCLUDED_DIR_PREFIXES.some((p) => firstSegment === p)) continue;
     if (name === ".DS_Store" || name.endsWith("/.DS_Store")) continue;
+    const baseName = name.includes("/") ? name.slice(name.lastIndexOf("/") + 1) : name;
+    if (isMarkdownLikeDoc(baseName) && isNoiseBoilerplate(baseName)) continue;
     const content = await readContent(absPath);
     result.push({ relativePath: name, absolutePath: absPath, content });
   }
   return result.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
 }
-async function parseSkillDirectory(skillDir) {
+async function parseSkillDirectory(skillDir, opts = {}) {
   const skillPath = join(skillDir, SKILL_FILE);
   const content = await readFileSafe(skillPath);
   if (!content) return null;
-  const { frontmatter, body } = parseFrontmatter(content);
+  const parsed = parseOrSkipFrontmatter(content, skillPath, opts.onParseError);
+  if (!parsed) return null;
+  const { frontmatter, body } = parsed;
   const supportingFiles = await listSupportingFiles(skillDir);
   const fmName = typeof frontmatter.name === "string" ? sanitizeSkillName(frontmatter.name) : "";
   const name = fmName || basename(skillDir);
@@ -20603,7 +20970,7 @@ async function parseSkillDirectory(skillDir) {
     supportingFiles
   };
 }
-async function parseSkills(skillsDir) {
+async function parseSkills(skillsDir, opts = {}) {
   let entries;
   try {
     entries = await readdir(skillsDir, { withFileTypes: true });
@@ -20619,7 +20986,9 @@ async function parseSkills(skillsDir) {
     const skillPath = join(skillDir, SKILL_FILE);
     const content = await readFileSafe(skillPath);
     if (!content) continue;
-    const { frontmatter, body } = parseFrontmatter(content);
+    const parsed = parseOrSkipFrontmatter(content, skillPath, opts.onParseError);
+    if (!parsed) continue;
+    const { frontmatter, body } = parsed;
     const supportingFiles = await listSupportingFiles(skillDir);
     skills.push({
       source: skillPath,
@@ -20824,14 +21193,14 @@ async function parseIgnore(ignorePath) {
 
 // src/canonical/load/loader.ts
 init_fs();
-async function loadCanonicalFiles(canonicalDirOrProjectRoot) {
+async function loadCanonicalFiles(canonicalDirOrProjectRoot, opts = {}) {
   const nestedCanonicalDir = join(canonicalDirOrProjectRoot, ".agentsmesh");
   const canonicalDir = await exists(nestedCanonicalDir) ? nestedCanonicalDir : canonicalDirOrProjectRoot;
   const [rules, commands, agents, skills, mcp, permissions, hooks, ignore] = await Promise.all([
-    parseRules(join(canonicalDir, "rules")),
-    parseCommands(join(canonicalDir, "commands")),
-    parseAgents(join(canonicalDir, "agents")),
-    parseSkills(join(canonicalDir, "skills")),
+    parseRules(join(canonicalDir, "rules"), opts),
+    parseCommands(join(canonicalDir, "commands"), opts),
+    parseAgents(join(canonicalDir, "agents"), opts),
+    parseSkills(join(canonicalDir, "skills"), opts),
     parseMcp(join(canonicalDir, "mcp.json")),
     parsePermissions(join(canonicalDir, "permissions.yaml")),
     parseHooks(join(canonicalDir, "hooks.yaml")),
@@ -20934,132 +21303,57 @@ function mergeIgnore(base, overlay) {
 
 // src/config/resolve/native-format-detector.ts
 init_fs();
-var TARGET_SIGNATURES = [
-  {
-    target: "claude-code",
-    paths: [
-      "CLAUDE.md",
-      ".claude/rules",
-      ".claude/commands",
-      ".claude/agents",
-      ".claude/skills",
-      ".claude/settings.json",
-      ".claudeignore"
-    ]
-  },
-  {
-    target: "cursor",
-    paths: [".cursorrules", ".cursor/rules", ".cursor", ".cursor/mcp.json"]
-  },
-  {
-    target: "copilot",
-    paths: [
-      ".github/copilot-instructions.md",
-      ".github/copilot",
-      ".github/instructions",
-      ".github/prompts",
-      ".github/skills",
-      ".github/agents",
-      ".github/hooks"
-    ]
-  },
-  {
-    target: "gemini-cli",
-    paths: ["GEMINI.md", ".gemini", ".gemini/settings.json"]
-  },
-  {
-    target: "codex-cli",
-    paths: [".codex", ".codex/config.toml", "AGENTS.md", "codex.md"]
-  },
-  {
-    target: "windsurf",
-    paths: [".windsurfrules", ".windsurf", ".windsurf/workflows"]
-  },
-  {
-    target: "cline",
-    paths: [".clinerules", ".cline"]
-  },
-  {
-    target: "continue",
-    paths: [".continue", ".continuerc.json"]
-  },
-  {
-    target: "junie",
-    paths: [".junie", ".junie/guidelines.md"]
-  },
-  {
-    target: "kiro",
-    paths: [".kiro", ".kiro/steering", ".kiro/settings/mcp.json"]
-  },
-  {
-    target: "kilo-code",
-    paths: [
-      ".kilo",
-      ".kilo/rules",
-      ".kilo/commands",
-      ".kilo/agents",
-      ".kilo/skills",
-      ".kilocodeignore",
-      ".kilocode",
-      ".kilocodemodes",
-      "kilo.jsonc",
-      "kilo.json"
-    ]
+init_builtin_targets();
+var PATH_OWNER_COUNT = (() => {
+  const map = /* @__PURE__ */ new Map();
+  for (const d of BUILTIN_TARGETS) {
+    for (const p of d.detectionPaths) {
+      map.set(p, (map.get(p) ?? 0) + 1);
+    }
   }
-];
+  return map;
+})();
+function compare(a, b) {
+  if (a.uniqueHits !== b.uniqueHits) return b.uniqueHits - a.uniqueHits;
+  if (a.sharedScore !== b.sharedScore) return b.sharedScore - a.sharedScore;
+  return a.id.localeCompare(b.id);
+}
 async function detectNativeFormat(repoPath) {
-  let bestTarget = null;
-  let bestScore = 0;
-  for (const sig of TARGET_SIGNATURES) {
-    let score = 0;
-    for (const rel2 of sig.paths) {
-      if (await exists(join(repoPath, rel2))) score++;
+  const scores = [];
+  for (const descriptor31 of BUILTIN_TARGETS) {
+    let uniqueHits = 0;
+    let sharedScore = 0;
+    for (const rel2 of descriptor31.detectionPaths) {
+      if (!await exists(join(repoPath, rel2))) continue;
+      const owners = PATH_OWNER_COUNT.get(rel2) ?? 1;
+      if (owners === 1) uniqueHits += 1;
+      else sharedScore += 1 / owners;
     }
-    if (score > bestScore) {
-      bestScore = score;
-      bestTarget = sig.target;
+    if (uniqueHits > 0 || sharedScore > 0) {
+      scores.push({ id: descriptor31.id, uniqueHits, sharedScore });
     }
   }
-  return bestScore > 0 ? bestTarget : null;
+  if (scores.length === 0) return null;
+  scores.sort(compare);
+  const winner = scores[0];
+  if (winner.uniqueHits === 0) return null;
+  return winner.id;
 }
-var KNOWN_NATIVE_PATHS = TARGET_SIGNATURES.map((sig) => sig.paths[0]).filter(
-  (p) => p !== void 0
-);
+var KNOWN_NATIVE_PATHS = BUILTIN_TARGETS.map(
+  (d) => d.detectionPaths[0]
+).filter((p) => p !== void 0);
 
 // src/canonical/extends/extend-load.ts
 init_fs();
 
 // src/canonical/extends/native-extends-importer.ts
-init_importer6();
-init_importer12();
-init_importer10();
-init_importer15();
-init_importer8();
-init_importer29();
-init_importer7();
-init_importer9();
-init_importer18();
-init_importer20();
-init_importer19();
-var NATIVE_IMPORTERS = {
-  "claude-code": importFromClaudeCode,
-  cursor: importFromCursor,
-  copilot: importFromCopilot,
-  "gemini-cli": importFromGemini,
-  "codex-cli": importFromCodex,
-  windsurf: importFromWindsurf,
-  cline: importFromCline,
-  continue: importFromContinue,
-  junie: importFromJunie,
-  kiro: importFromKiro,
-  "kilo-code": importFromKiloCode
-};
+init_registry();
 async function importNativeToCanonical(repoPath, targetName) {
-  const importFn = NATIVE_IMPORTERS[targetName];
-  if (!importFn) {
+  const descriptor31 = getDescriptor(targetName);
+  if (!descriptor31) {
     throw new Error(`No importer registered for native target: ${targetName}`);
   }
-  return importFn(repoPath);
+  return descriptor31.generators.importFrom(repoPath);
 }
 
 // src/canonical/load/skill-pack-load.ts
@@ -21079,17 +21373,176 @@ async function isSkillPackLayout(root) {
   }
   return false;
 }
-async function loadSkillsAtExtendPath(skillsRoot) {
+async function loadSkillsAtExtendPath(skillsRoot, opts = {}) {
   if (!await exists(skillsRoot)) return [];
   if (await exists(join(skillsRoot, SKILL))) {
-    const one = await parseSkillDirectory(skillsRoot);
+    const one = await parseSkillDirectory(skillsRoot, opts);
     return one ? [one] : [];
   }
-  return parseSkills(skillsRoot);
+  return parseSkills(skillsRoot, opts);
 }
 
 // src/canonical/load/load-canonical-slice.ts
 init_fs();
+init_boilerplate_filter();
+async function importAgents(agentsDir, opts = {}) {
+  const agents = await parseAgents(agentsDir, opts);
+  return agents.filter((entity) => !isBoilerplate(basename(entity.source)));
+}
+async function importCommands2(commandsDir, opts = {}) {
+  const commands = await parseCommands(commandsDir, opts);
+  return commands.filter((entity) => !isBoilerplate(basename(entity.source)));
+}
+async function importRules2(rulesDir, opts = {}) {
+  const rules = await parseRules(rulesDir, opts);
+  return rules.filter((entity) => !isBoilerplate(basename(entity.source)));
+}
+init_fs();
+init_registry();
+init_boilerplate_filter();
+function directorySpecsFor(importer, kind) {
+  const raw = importer?.[kind];
+  if (!raw) return [];
+  const specs = Array.isArray(raw) ? raw : [raw];
+  const out2 = [];
+  for (const s of specs) {
+    if (s.mode !== "directory" || !s.map || !s.extensions) continue;
+    out2.push({ extensions: s.extensions, map: s.map });
+  }
+  return out2;
+}
+function isMarkdownExtension(ext) {
+  return ext.toLowerCase().endsWith(".md");
+}
+function hasNonMdEntityMapper(targetId, kind) {
+  for (const spec of directorySpecsFor(getDescriptor(targetId)?.importer, kind)) {
+    if (spec.extensions.some((ext) => !isMarkdownExtension(ext))) return true;
+  }
+  return false;
+}
+function nonMdEntityExtensions(targetId, kind) {
+  const out2 = /* @__PURE__ */ new Set();
+  for (const spec of directorySpecsFor(getDescriptor(targetId)?.importer, kind)) {
+    for (const ext of spec.extensions) {
+      if (!isMarkdownExtension(ext)) out2.add(ext.toLowerCase());
+    }
+  }
+  return out2;
+}
+function targetsWithNonMdEntityMapper(kind) {
+  return getAllRegisteredDescriptorIds().filter((id) => hasNonMdEntityMapper(id, kind));
+}
+var CANONICAL_PARSERS = {
+  rules: parseRules,
+  commands: parseCommands,
+  agents: parseAgents
+};
+var INSTALL_IMPORTERS = {
+  rules: importRules2,
+  commands: importCommands2,
+  agents: importAgents
+};
+async function parseEntityDir(kind, dir, opts) {
+  return CANONICAL_PARSERS[kind](dir, opts);
+}
+async function importEntities(kind, dir, opts) {
+  return INSTALL_IMPORTERS[kind](dir, opts);
+}
+async function readToolNativeEntities(srcDir, targetId, kind, parseOpts = {}) {
+  const specs = directorySpecsFor(getDescriptor(targetId)?.importer, kind);
+  const allFiles = await readDirRecursive(srcDir);
+  const nonMdExtensions = /* @__PURE__ */ new Set();
+  for (const spec of specs) {
+    for (const ext of spec.extensions) {
+      if (!isMarkdownExtension(ext)) nonMdExtensions.add(ext.toLowerCase());
+    }
+  }
+  const matched = allFiles.filter(
+    (path) => [...nonMdExtensions].some((ext) => path.toLowerCase().endsWith(ext)) && !isBoilerplate(basename(path))
+  );
+  if (matched.length === 0) return { entities: [], cleanup: async () => {
+  } };
+  const stageDir = await mkdtemp(join(tmpdir(), `am-tool-${kind}-${targetId}-`));
+  const cleanup = async () => {
+    await rm(stageDir, { recursive: true, force: true });
+  };
+  try {
+    for (const absPath of matched) {
+      const content = await readFileSafe(absPath);
+      if (content === null) continue;
+      const relPath = relative(srcDir, absPath).replaceAll("\\", "/");
+      let mapping = null;
+      for (const spec of specs) {
+        const claimsExt = spec.extensions.some(
+          (e) => absPath.toLowerCase().endsWith(e.toLowerCase())
+        );
+        if (!claimsExt) continue;
+        const r = await spec.map({
+          absolutePath: absPath,
+          relativePath: relPath,
+          content,
+          destDir: stageDir,
+          normalizeTo: () => content
+        });
+        if (r) {
+          mapping = r;
+          break;
+        }
+      }
+      if (!mapping) continue;
+      await mkdirp(dirname(mapping.destPath));
+      await writeFileAtomic(mapping.destPath, mapping.content);
+    }
+    const entities = await parseEntityDir(kind, stageDir, parseOpts);
+    return { entities, cleanup };
+  } catch (err) {
+    await cleanup();
+    throw err;
+  }
+}
+async function readEntityDirWithMappers(srcDir, kind, opts = {}) {
+  const restrict = opts.restrictToTarget;
+  const targets = restrict ? hasNonMdEntityMapper(restrict, kind) ? [restrict] : [] : targetsWithNonMdEntityMapper(kind);
+  const handledExts = /* @__PURE__ */ new Set();
+  for (const id of targets) {
+    for (const ext of nonMdEntityExtensions(id, kind)) handledExts.add(ext);
+  }
+  const canonical = await importEntities(kind, srcDir, {
+    ...opts.parseOpts,
+    handledByOtherReader: handledExts.size > 0 ? handledExts : void 0
+  });
+  const cleanups = [];
+  const slugOf = (e) => basename(e.source).replace(/\.[^.]+$/, "");
+  const byKey = /* @__PURE__ */ new Map();
+  for (const e of canonical) byKey.set(slugOf(e), e);
+  for (const id of targets) {
+    const staged = await readToolNativeEntities(srcDir, id, kind, opts.parseOpts ?? {});
+    cleanups.push(staged.cleanup);
+    for (const e of staged.entities) {
+      const key = slugOf(e);
+      if (!byKey.has(key)) byKey.set(key, e);
+    }
+  }
+  const entities = [...byKey.values()].sort((a, b) => slugOf(a).localeCompare(slugOf(b)));
+  const cleanup = async () => {
+    await Promise.allSettled(cleanups.map((fn) => fn()));
+  };
+  return { entities, cleanup };
+}
+async function readCommandsDirWithMappers(srcDir, opts = {}) {
+  const result = await readEntityDirWithMappers(srcDir, "commands", opts);
+  return { commands: [...result.entities], cleanup: result.cleanup };
+}
+async function readRulesDirWithMappers(srcDir, opts = {}) {
+  const result = await readEntityDirWithMappers(srcDir, "rules", opts);
+  return { rules: [...result.entities], cleanup: result.cleanup };
+}
+async function readAgentsDirWithMappers(srcDir, opts = {}) {
+  const result = await readEntityDirWithMappers(srcDir, "agents", opts);
+  return { agents: [...result.entities], cleanup: result.cleanup };
+}
+
+// src/canonical/load/load-canonical-slice.ts
 function emptyCanonical() {
   return {
     rules: [],
@@ -21135,65 +21588,350 @@ async function normalizeSlicePath(absolutePath) {
     `Single-file install only supports .md files under rules/, commands/, or agents/. Got: ${absolutePath}`
   );
 }
-async function parseRulesAt(sliceRoot) {
-  const base = basename(sliceRoot);
-  if (base === "rules") {
-    return parseRules(sliceRoot);
-  }
-  const nested = join(sliceRoot, "rules");
-  if (await exists(nested)) {
-    return parseRules(nested);
-  }
-  return [];
+async function resolveEntityDir(sliceRoot, kindDirName) {
+  if (basename(sliceRoot) === kindDirName) return sliceRoot;
+  const nested = join(sliceRoot, kindDirName);
+  return await exists(nested) ? nested : null;
 }
-async function parseCommandsAt(sliceRoot) {
-  const base = basename(sliceRoot);
-  if (base === "commands") {
-    return parseCommands(sliceRoot);
-  }
-  const nested = join(sliceRoot, "commands");
-  if (await exists(nested)) {
-    return parseCommands(nested);
+async function parseRulesAt(sliceRoot, opts, enableTargetMappers) {
+  const noop = async () => {
+  };
+  const rulesDir = await resolveEntityDir(sliceRoot, "rules");
+  if (!rulesDir) return { rules: [], cleanup: noop };
+  if (!enableTargetMappers) {
+    return { rules: await importRules2(rulesDir, opts), cleanup: noop };
   }
-  return [];
+  const result = await readRulesDirWithMappers(rulesDir, { parseOpts: opts });
+  return { rules: [...result.rules], cleanup: result.cleanup };
 }
-async function parseAgentsAt(sliceRoot) {
-  const base = basename(sliceRoot);
-  if (base === "agents") {
-    return parseAgents(sliceRoot);
+async function parseCommandsAt(sliceRoot, opts, enableTargetMappers) {
+  const noop = async () => {
+  };
+  const commandsDir = await resolveEntityDir(sliceRoot, "commands");
+  if (!commandsDir) return { commands: [], cleanup: noop };
+  if (!enableTargetMappers) {
+    return { commands: await importCommands2(commandsDir, opts), cleanup: noop };
   }
-  const nested = join(sliceRoot, "agents");
-  if (await exists(nested)) {
-    return parseAgents(nested);
+  const result = await readCommandsDirWithMappers(commandsDir, { parseOpts: opts });
+  return { commands: [...result.commands], cleanup: result.cleanup };
+}
+async function parseAgentsAt(sliceRoot, opts, enableTargetMappers) {
+  const noop = async () => {
+  };
+  const agentsDir = await resolveEntityDir(sliceRoot, "agents");
+  if (!agentsDir) return { agents: [], cleanup: noop };
+  if (!enableTargetMappers) {
+    return { agents: await importAgents(agentsDir, opts), cleanup: noop };
   }
-  return [];
+  const result = await readAgentsDirWithMappers(agentsDir, { parseOpts: opts });
+  return { agents: [...result.agents], cleanup: result.cleanup };
 }
-async function loadSkillsForPartialSlice(sliceRoot) {
+async function loadSkillsForPartialSlice(sliceRoot, opts) {
   if (await isSkillPackLayout(sliceRoot)) {
-    return loadSkillsAtExtendPath(sliceRoot);
+    return loadSkillsAtExtendPath(sliceRoot, opts);
   }
   const nestedSkills = join(sliceRoot, "skills");
   if (await isSkillPackLayout(nestedSkills)) {
-    return loadSkillsAtExtendPath(nestedSkills);
+    return loadSkillsAtExtendPath(nestedSkills, opts);
   }
   return [];
 }
-async function loadCanonicalSliceAtPath(sliceRoot) {
+async function loadCanonicalSliceAtPath(sliceRoot, opts = {}) {
+  const noop = async () => {
+  };
   const ab = join(sliceRoot, ".agentsmesh");
   if (await exists(ab)) {
-    return loadCanonicalFiles(sliceRoot);
+    return { canonical: await loadCanonicalFiles(sliceRoot, opts), cleanup: noop };
   }
+  const enableMappers = opts.enableTargetEntityMappers ?? false;
   const partial = emptyCanonical();
-  partial.rules = await parseRulesAt(sliceRoot);
-  partial.commands = await parseCommandsAt(sliceRoot);
-  partial.agents = await parseAgentsAt(sliceRoot);
-  partial.skills = await loadSkillsForPartialSlice(sliceRoot);
+  const rulesResult = await parseRulesAt(sliceRoot, opts, enableMappers);
+  partial.rules = rulesResult.rules;
+  const commandsResult = await parseCommandsAt(sliceRoot, opts, enableMappers);
+  partial.commands = commandsResult.commands;
+  const agentsResult = await parseAgentsAt(sliceRoot, opts, enableMappers);
+  partial.agents = agentsResult.agents;
+  partial.skills = await loadSkillsForPartialSlice(sliceRoot, opts);
+  const mergedCleanup = async () => {
+    await Promise.allSettled([
+      rulesResult.cleanup(),
+      commandsResult.cleanup(),
+      agentsResult.cleanup()
+    ]);
+  };
   if (isCanonicalSliceEmpty(partial)) {
+    await mergedCleanup();
+    throw new Error(
+      `No installable resources at ${sliceRoot}. Expected .agentsmesh/, or rules/, commands/, agents/, or Anthropic-style skills (SKILL.md). Hint: pass --as commands|agents|rules|skills to force a kind for flat markdown directories.`
+    );
+  }
+  return { canonical: partial, cleanup: mergedCleanup };
+}
+
+// src/install/manual/manual-install-scope.ts
+init_fs();
+
+// src/install/source/skill-repo-filter.ts
+init_fs();
+init_markdown();
+init_boilerplate_filter();
+async function readSkillFrontmatterName(skillMdPath) {
+  const content = await readFileSafe(skillMdPath);
+  if (!content) return "";
+  const parsed = tryParseFrontmatter(content, skillMdPath);
+  if (!parsed.ok) return "";
+  const { frontmatter } = parsed.value;
+  if (typeof frontmatter.name !== "string") return "";
+  return frontmatter.name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+async function cpFilteredSkill(sourceRoot, destDir) {
+  await cp(sourceRoot, destDir, {
+    recursive: true,
+    filter: (src) => {
+      const rel2 = relative(sourceRoot, src).replace(/\\/g, "/");
+      if (rel2 === "") return true;
+      const first = rel2.split("/")[0];
+      if (isRepoNonContentDir(first)) return false;
+      if (!rel2.includes("/")) {
+        if (isNoiseBoilerplate(rel2)) return false;
+        if (isRepoNonContentFile(rel2)) return false;
+      }
+      return true;
+    }
+  });
+}
+
+// src/install/manual/manual-install-scope.ts
+init_boilerplate_filter();
+
+// src/install/manual/mdc-reader.ts
+init_markdown();
+function toStrArray3(v) {
+  if (Array.isArray(v)) return v.filter((x) => typeof x === "string");
+  if (typeof v === "string") return v ? [v] : [];
+  return [];
+}
+function normalizeCursorKeys(fm) {
+  const out2 = { ...fm };
+  const isRoot = fm.alwaysApply === true;
+  out2.root = isRoot;
+  delete out2.alwaysApply;
+  if (!isRoot) {
+    const globs = toStrArray3(fm.globs);
+    const description = typeof fm.description === "string" ? fm.description.trim() : "";
+    if (globs.length > 0) {
+      out2.trigger = "glob";
+    } else if (description.length > 0) {
+      out2.trigger = "model_decision";
+    } else {
+      out2.trigger = "manual";
+    }
+  }
+  return out2;
+}
+function normalizeWindsurfKeys(fm) {
+  const out2 = { ...fm };
+  if (out2.trigger === "always") {
+    out2.trigger = "always_on";
+  }
+  if (typeof out2.glob === "string") {
+    out2.globs = toStrArray3(out2.globs).length > 0 ? toStrArray3(out2.globs) : [out2.glob];
+    delete out2.glob;
+  }
+  return out2;
+}
+function normalizeMdcToCanonical(content) {
+  const parsed = tryParseFrontmatter(content, "<mdc>");
+  if (!parsed.ok) return parsed.bodyFallback;
+  const { frontmatter, body } = parsed.value;
+  if (Object.keys(frontmatter).length === 0 && !content.startsWith("---")) return content;
+  let normalized;
+  if ("alwaysApply" in frontmatter) {
+    normalized = normalizeCursorKeys(frontmatter);
+  } else if ("trigger" in frontmatter || "glob" in frontmatter) {
+    normalized = normalizeWindsurfKeys(frontmatter);
+  } else {
+    normalized = frontmatter;
+  }
+  return serializeFrontmatter(normalized, body.trim());
+}
+function sanitizeNameSegment(segment) {
+  return segment.toLowerCase().replace(/[^a-z0-9.-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function computeDestName(file) {
+  const isMdc = file.toLowerCase().endsWith(".mdc");
+  return isMdc ? basename(file).replace(/\.mdc$/i, ".md") : basename(file);
+}
+function namespacedName(sourceRoot, file, bareName) {
+  const rel2 = relative(sourceRoot, file).replace(/\\/g, "/");
+  const segments = rel2.split("/");
+  segments.pop();
+  if (segments.length === 0) return bareName;
+  const prefix = sanitizeNameSegment(segments[segments.length - 1]);
+  if (!prefix) return bareName;
+  return `${prefix}-${bareName}`;
+}
+
+// src/install/manual/manual-install-scope.ts
+async function createStageRoot() {
+  const stageBase = await mkdtemp(join(tmpdir(), "am-install-manual-"));
+  const discoveryRoot = join(stageBase, "repo");
+  await mkdirp(join(discoveryRoot, ".agentsmesh"));
+  return {
+    discoveryRoot,
+    cleanup: async () => {
+      await rm(stageBase, { recursive: true, force: true });
+    }
+  };
+}
+function isAcceptedFile(file, acceptMdc) {
+  const lower = file.toLowerCase();
+  if (lower.endsWith(".md")) return true;
+  if (acceptMdc && lower.endsWith(".mdc")) return true;
+  return false;
+}
+async function stageSingleFile(sourcePath, destinationDir, acceptMdc) {
+  if (!isAcceptedFile(sourcePath, acceptMdc)) {
+    throw new Error(`Manual install only supports .md files for this collection: ${sourcePath}`);
+  }
+  await mkdirp(destinationDir);
+  if (sourcePath.toLowerCase().endsWith(".mdc")) {
+    const content = await readFileSafe(sourcePath);
+    if (!content) return;
+    const destName = basename(sourcePath).replace(/\.mdc$/i, ".md");
+    await writeFile(join(destinationDir, destName), normalizeMdcToCanonical(content));
+  } else {
+    await cp(sourcePath, join(destinationDir, basename(sourcePath)));
+  }
+}
+async function stageMarkdownCollection(sourceRoot, destinationDir, acceptMdc) {
+  const info = await stat(sourceRoot);
+  if (info.isFile()) return stageSingleFile(sourceRoot, destinationDir, acceptMdc);
+  const files = (await readDirRecursive(sourceRoot)).filter(
+    (file) => isAcceptedFile(file, acceptMdc) && !isBoilerplate(basename(file))
+  );
+  if (files.length === 0) {
     throw new Error(
-      `No installable resources at ${sliceRoot}. Expected .agentsmesh/, or rules/, commands/, agents/, or Anthropic-style skills (SKILL.md).`
+      `No installable files found under ${sourceRoot} for manual install. Try a different --path to point at the directory holding *.md (or *.mdc) files, or omit --as so agentsmesh can auto-detect the layout.`
     );
   }
-  return partial;
+  const bareCounts = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const name = computeDestName(file);
+    bareCounts.set(name, (bareCounts.get(name) ?? 0) + 1);
+  }
+  const usedNames = /* @__PURE__ */ new Map();
+  await mkdirp(destinationDir);
+  for (const file of files) {
+    const bare = computeDestName(file);
+    const hasCollision = (bareCounts.get(bare) ?? 0) > 1;
+    let destName = hasCollision ? namespacedName(sourceRoot, file, bare) : bare;
+    if (usedNames.has(destName) && usedNames.get(destName) !== file) {
+      const rel2 = relative(sourceRoot, file).replace(/\\/g, "/").split("/").map(sanitizeNameSegment).filter(Boolean);
+      const ext = bare.includes(".") ? "." + bare.split(".").pop() : "";
+      const stem = rel2.join("-").replace(/\.(md|mdc)$/i, "");
+      destName = stem + ext || destName;
+    }
+    if (usedNames.has(destName)) {
+      throw new Error(
+        `Manual install could not resolve duplicate name "${destName}" under ${sourceRoot} (${usedNames.get(destName)} and ${file}).`
+      );
+    }
+    usedNames.set(destName, file);
+    const isMdc = file.toLowerCase().endsWith(".mdc");
+    if (isMdc) {
+      const content = await readFileSafe(file);
+      if (!content) continue;
+      await writeFile(join(destinationDir, destName), normalizeMdcToCanonical(content));
+    } else {
+      await cp(file, join(destinationDir, destName));
+    }
+  }
+}
+async function stagePreferredSkills(sourceRoot, destinationDir, preferredSkillNames) {
+  if (preferredSkillNames.length === 0) {
+    return false;
+  }
+  const wanted = new Set(preferredSkillNames);
+  const matches = /* @__PURE__ */ new Map();
+  for (const file of await readDirRecursive(sourceRoot)) {
+    if (!file.endsWith("/SKILL.md") && !file.endsWith("\\SKILL.md")) continue;
+    const skillDir = dirname(file);
+    const skillName = basename(skillDir);
+    if (!wanted.has(skillName)) continue;
+    const previous = matches.get(skillName);
+    if (previous && previous !== skillDir) {
+      throw new Error(
+        `Manual skill replay found duplicate skill "${skillName}" under ${sourceRoot} (${previous} and ${skillDir}).`
+      );
+    }
+    matches.set(skillName, skillDir);
+  }
+  if (matches.size !== preferredSkillNames.length) return false;
+  await mkdirp(destinationDir);
+  for (const skillName of preferredSkillNames) {
+    await cp(matches.get(skillName), join(destinationDir, skillName), { recursive: true });
+  }
+  return true;
+}
+async function stageSkills(sourceRoot, destinationDir, options = {}) {
+  const info = await stat(sourceRoot);
+  if (info.isFile()) {
+    if (basename(sourceRoot) !== "SKILL.md") {
+      throw new Error(`Manual skill install expects SKILL.md or a skill directory: ${sourceRoot}`);
+    }
+    const skillName = basename(dirname(sourceRoot));
+    const skillDir = join(destinationDir, skillName);
+    await mkdirp(skillDir);
+    await cp(dirname(sourceRoot), skillDir, { recursive: true });
+    return;
+  }
+  if (await isSkillPackLayout(sourceRoot)) {
+    if ((await stat(join(sourceRoot, "SKILL.md")).catch(() => null))?.isFile()) {
+      if (await stagePreferredSkills(sourceRoot, destinationDir, options.preferredSkillNames ?? [])) {
+        return;
+      }
+      const fmName = await readSkillFrontmatterName(join(sourceRoot, "SKILL.md"));
+      const skillName = fmName || basename(sourceRoot);
+      const skillDir = join(destinationDir, skillName);
+      await mkdirp(destinationDir);
+      await cpFilteredSkill(sourceRoot, skillDir);
+      return;
+    }
+    if (await stagePreferredSkills(sourceRoot, destinationDir, options.preferredSkillNames ?? [])) {
+      return;
+    }
+    await mkdirp(destinationDir);
+    const entries = await readDirRecursive(sourceRoot);
+    const roots = /* @__PURE__ */ new Set();
+    for (const file of entries.filter(
+      (entry) => entry.endsWith("/SKILL.md") || entry.endsWith("\\SKILL.md")
+    )) {
+      roots.add(relative(sourceRoot, dirname(file)).split(/[\\/]/)[0]);
+    }
+    for (const root of roots) {
+      await cp(join(sourceRoot, root), join(destinationDir, root), { recursive: true });
+    }
+    return;
+  }
+  throw new Error(
+    `Manual skill install expects a skill directory or skills collection at ${sourceRoot}.`
+  );
+}
+async function stageManualInstallScope(sourceRoot, as, options = {}) {
+  const staged = await createStageRoot();
+  try {
+    const destDir = join(staged.discoveryRoot, ".agentsmesh", as);
+    if (as === "skills") {
+      await stageSkills(sourceRoot, destDir, options);
+    } else {
+      await stageMarkdownCollection(sourceRoot, destDir, as === "rules");
+    }
+    return staged;
+  } catch (error) {
+    await staged.cleanup();
+    throw error;
+  }
 }
 
 // src/canonical/extends/extend-load.ts
@@ -21211,6 +21949,18 @@ function emptyCanonical2() {
 }
 async function loadCanonicalForExtend(ext) {
   const base = ext.resolvedPath;
+  if (ext.as !== void 0) {
+    const rawRoot2 = ext.path ? join(base, ext.path) : base;
+    if (!await exists(rawRoot2)) {
+      throw new Error(`Extend "${ext.name}": path does not exist: ${rawRoot2}`);
+    }
+    const staged = await stageManualInstallScope(rawRoot2, ext.as);
+    try {
+      return loadCanonicalFiles(join(staged.discoveryRoot, ".agentsmesh"));
+    } finally {
+      await staged.cleanup();
+    }
+  }
   if (!ext.path) {
     const agentsmeshDir = join(base, ".agentsmesh");
     if (!await exists(agentsmeshDir)) {
@@ -21248,7 +21998,8 @@ Expected one of: .agentsmesh/, ${KNOWN_NATIVE_PATHS.join(", ")}.`
   }
   const { sliceRoot } = await normalizeSlicePath(rawRoot);
   try {
-    return await loadCanonicalSliceAtPath(sliceRoot);
+    const { canonical } = await loadCanonicalSliceAtPath(sliceRoot);
+    return canonical;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     const wrapped = new Error(`Extend "${ext.name}": ${msg}`);
@@ -21334,7 +22085,15 @@ var packMetadataSchema = z.object({
   path: z.string().optional(),
   paths: z.array(z.string().min(1)).min(1).optional(),
   as: manualInstallAsSchema.optional(),
-  content_hash: z.string()
+  content_hash: z.string(),
+  /**
+   * SPDX identifier of the LICENSE / NOTICE / COPYING file at the pack root,
+   * or `null` when the file is missing or its text matches no known
+   * fingerprint. Detected at materialize time from the upstream bytes — never
+   * inferred from `package.json` or other secondary signals. See
+   * `src/install/license/detect-license.ts`.
+   */
+  license: z.string().nullable().optional()
 });
 
 // src/install/pack/pack-reader.ts
@@ -21585,11 +22344,7 @@ var TARGET_CATALOG = Object.fromEntries(
   ])
 );
 function getTargetCatalogEntry(id) {
-  const entry = TARGET_CATALOG[id];
-  if (!entry) {
-    throw new Error(`Unknown target: ${id}`);
-  }
-  return entry;
+  return TARGET_CATALOG[id];
 }
 
 // src/core/lint/linter.ts
@@ -21859,13 +22614,16 @@ function formatDiffSummary(summary) {
 
 // src/config/core/lock.ts
 init_fs();
+
+// src/utils/crypto/hash.ts
+init_fs_text_encoding();
 function hashContent(content) {
   return createHash("sha256").update(content, "utf8").digest("hex");
 }
 async function hashFile(path) {
   try {
-    const content = await readFile(path, "utf8");
-    return hashContent(content);
+    const bytes = await readFile(path);
+    return createHash("sha256").update(bytes).digest("hex");
   } catch (err) {
     if (err instanceof Error && "code" in err && err.code === "ENOENT") {
       return null;