agentsmesh 0.2.8 → 0.2.9

package/dist/cli.js

@@ -247,7 +247,7 @@ function handleError(err, options) {
 }
 
 // src/cli/commands/generate.ts
-import { join as join54, resolve as resolve4, sep } from "path";
+import { join as join55, resolve as resolve4, sep } from "path";
 
 // src/config/core/loader.ts
 import { parse as parseYaml } from "yaml";
@@ -359,7 +359,8 @@ var TARGET_IDS = [
   "cline",
   "codex-cli",
   "windsurf",
-  "antigravity"
+  "antigravity",
+  "roo-code"
 ];
 function isBuiltinTargetId(value) {
   return TARGET_IDS.includes(value);
@@ -524,7 +525,7 @@ async function loadConfigFromDir(startDir) {
 }
 
 // src/canonical/extends/extends.ts
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 
 // src/config/resolve/resolver.ts
 import { mkdir as mkdir4, rm as rm4 } from "fs/promises";
@@ -1464,7 +1465,7 @@ function mergeIgnore(base, overlay) {
 }
 
 // src/canonical/extends/extend-load.ts
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 
 // src/config/resolve/native-format-detector.ts
 import { join as join10 } from "path";
@@ -1542,11 +1543,11 @@ var KNOWN_NATIVE_PATHS = TARGET_SIGNATURES.map((sig) => sig.paths[0]).filter(
 );
 
 // src/targets/claude-code/importer.ts
-import { join as join40, basename as basename25, relative as relative17, dirname as dirname18 } from "path";
+import { join as join41, basename as basename26, relative as relative17, dirname as dirname18 } from "path";
 
 // src/core/reference/import-rewriter.ts
 import { existsSync as existsSync2, realpathSync as realpathSync3 } from "fs";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 import { normalize as normalizePath } from "path";
 
 // src/config/core/conversions.ts
@@ -1561,22 +1562,22 @@ var DEFAULT_AGENTS_TO_SKILLS = {
   // native .codex/agents/*.toml per agent-structures
   windsurf: true
 };
-function hasOwnTarget(map, target11) {
-  return Object.prototype.hasOwnProperty.call(map, target11);
+function hasOwnTarget(map, target12) {
+  return Object.prototype.hasOwnProperty.call(map, target12);
 }
-function usesCommandSkillProjection(target11) {
-  return hasOwnTarget(DEFAULT_COMMANDS_TO_SKILLS, target11);
+function usesCommandSkillProjection(target12) {
+  return hasOwnTarget(DEFAULT_COMMANDS_TO_SKILLS, target12);
 }
-function usesAgentSkillProjection(target11) {
-  return hasOwnTarget(DEFAULT_AGENTS_TO_SKILLS, target11);
+function usesAgentSkillProjection(target12) {
+  return hasOwnTarget(DEFAULT_AGENTS_TO_SKILLS, target12);
 }
-function shouldConvertCommandsToSkills(config, target11) {
-  if (!usesCommandSkillProjection(target11)) return false;
-  return config.conversions?.commands_to_skills?.[target11] ?? DEFAULT_COMMANDS_TO_SKILLS[target11];
+function shouldConvertCommandsToSkills(config, target12) {
+  if (!usesCommandSkillProjection(target12)) return false;
+  return config.conversions?.commands_to_skills?.[target12] ?? DEFAULT_COMMANDS_TO_SKILLS[target12];
 }
-function shouldConvertAgentsToSkills(config, target11) {
-  if (!usesAgentSkillProjection(target11)) return false;
-  return config.conversions?.agents_to_skills?.[target11] ?? DEFAULT_AGENTS_TO_SKILLS[target11];
+function shouldConvertAgentsToSkills(config, target12) {
+  if (!usesAgentSkillProjection(target12)) return false;
+  return config.conversions?.agents_to_skills?.[target12] ?? DEFAULT_AGENTS_TO_SKILLS[target12];
 }
 
 // src/targets/claude-code/constants.ts
@@ -1873,6 +1874,22 @@ var JUNIE_CANONICAL_AGENTS_DIR = ".agentsmesh/agents";
 var JUNIE_CANONICAL_MCP = ".agentsmesh/mcp.json";
 var JUNIE_CANONICAL_IGNORE = ".agentsmesh/ignore";
 
+// src/targets/roo-code/constants.ts
+var ROO_CODE_TARGET = "roo-code";
+var ROO_CODE_DIR = ".roo";
+var ROO_CODE_ROOT_RULE = `${ROO_CODE_DIR}/rules/00-root.md`;
+var ROO_CODE_ROOT_RULE_FALLBACK = ".roorules";
+var ROO_CODE_RULES_DIR = `${ROO_CODE_DIR}/rules`;
+var ROO_CODE_COMMANDS_DIR = `${ROO_CODE_DIR}/commands`;
+var ROO_CODE_SKILLS_DIR = `${ROO_CODE_DIR}/skills`;
+var ROO_CODE_MCP_FILE = `${ROO_CODE_DIR}/mcp.json`;
+var ROO_CODE_IGNORE = ".rooignore";
+var ROO_CODE_CANONICAL_ROOT_RULE = ".agentsmesh/rules/_root.md";
+var ROO_CODE_CANONICAL_RULES_DIR = ".agentsmesh/rules";
+var ROO_CODE_CANONICAL_COMMANDS_DIR = ".agentsmesh/commands";
+var ROO_CODE_CANONICAL_MCP = ".agentsmesh/mcp.json";
+var ROO_CODE_CANONICAL_IGNORE = ".agentsmesh/ignore";
+
 // src/targets/antigravity/constants.ts
 var ANTIGRAVITY_TARGET = "antigravity";
 var ANTIGRAVITY_DIR = ".agents";
@@ -2107,7 +2124,8 @@ var SCOPED_AGENTS_SKIP_DIRS = /* @__PURE__ */ new Set([
   ".gemini",
   ".github",
   ".junie",
-  ".windsurf"
+  ".windsurf",
+  ".roo"
 ]);
 async function addScopedAgentsMappings(refs, projectRoot) {
   const files = await listFiles(projectRoot, ".");
@@ -2303,6 +2321,27 @@ async function buildAntigravityImportPaths(refs, projectRoot) {
     addSkillLikeMapping(refs, rel(projectRoot, absPath), ANTIGRAVITY_SKILLS_DIR);
   }
 }
+async function buildRooCodeImportPaths(refs, projectRoot) {
+  refs.set(ROO_CODE_ROOT_RULE, `${AB_RULES2}/_root.md`);
+  refs.set(ROO_CODE_ROOT_RULE_FALLBACK, `${AB_RULES2}/_root.md`);
+  for (const absPath of await listFiles(projectRoot, ROO_CODE_RULES_DIR)) {
+    const relPath = rel(projectRoot, absPath);
+    if (relPath === ROO_CODE_ROOT_RULE) continue;
+    addSimpleFileMapping(refs, relPath, AB_RULES2, ".md");
+  }
+  for (const absPath of await listFiles(projectRoot, ".roo")) {
+    const relPath = rel(projectRoot, absPath);
+    if (/^\.roo\/rules-[^/]+\/.+\.md$/.test(relPath)) {
+      addSimpleFileMapping(refs, relPath, AB_RULES2, ".md");
+    }
+  }
+  for (const absPath of await listFiles(projectRoot, ROO_CODE_COMMANDS_DIR)) {
+    addSimpleFileMapping(refs, rel(projectRoot, absPath), AB_COMMANDS2, ".md");
+  }
+  for (const absPath of await listFiles(projectRoot, ROO_CODE_SKILLS_DIR)) {
+    addSkillLikeMapping(refs, rel(projectRoot, absPath), ROO_CODE_SKILLS_DIR);
+  }
+}
 
 // src/targets/claude-code/index.ts
 var target = {
@@ -5772,7 +5811,7 @@ function summarizeRule(rule) {
     scopes.push(`Enforced in \`${CODEX_RULES_DIR}/${ruleSlug4(rule.source)}.rules\`.`);
   }
   if (rule.targets.length > 0) {
-    scopes.push(`Targeted to ${rule.targets.map((target11) => `\`${target11}\``).join(", ")}.`);
+    scopes.push(`Targeted to ${rule.targets.map((target12) => `\`${target12}\``).join(", ")}.`);
   }
   return scopes.join(" ");
 }
@@ -7221,6 +7260,323 @@ var descriptor10 = {
   ]
 };
 
+// src/targets/roo-code/generator.ts
+import { basename as basename25 } from "path";
+function generateRules11(canonical) {
+  const outputs = [];
+  const root = canonical.rules.find((rule) => rule.root);
+  if (root) {
+    outputs.push({
+      path: ROO_CODE_ROOT_RULE,
+      content: root.body.trim() || ""
+    });
+  }
+  for (const rule of canonical.rules) {
+    if (rule.root) continue;
+    if (rule.targets.length > 0 && !rule.targets.includes(ROO_CODE_TARGET)) continue;
+    const slug = basename25(rule.source, ".md");
+    outputs.push({
+      path: `${ROO_CODE_RULES_DIR}/${slug}.md`,
+      content: rule.body.trim() || ""
+    });
+  }
+  return outputs;
+}
+function generateCommands8(canonical) {
+  return canonical.commands.map((command) => {
+    const frontmatter = {};
+    if (command.description) frontmatter.description = command.description;
+    return {
+      path: `${ROO_CODE_COMMANDS_DIR}/${command.name}.md`,
+      content: serializeFrontmatter(frontmatter, command.body.trim() || "")
+    };
+  });
+}
+function generateMcp8(canonical) {
+  if (!canonical.mcp || Object.keys(canonical.mcp.mcpServers).length === 0) return [];
+  return [
+    {
+      path: ROO_CODE_MCP_FILE,
+      content: JSON.stringify({ mcpServers: canonical.mcp.mcpServers }, null, 2)
+    }
+  ];
+}
+function generateIgnore7(canonical) {
+  if (canonical.ignore.length === 0) return [];
+  return [{ path: ROO_CODE_IGNORE, content: canonical.ignore.join("\n") }];
+}
+function generateSkills11(canonical) {
+  return generateEmbeddedSkills(canonical, ROO_CODE_SKILLS_DIR);
+}
+
+// src/targets/roo-code/importer.ts
+import { readdir as readdir9 } from "fs/promises";
+import { join as join37 } from "path";
+function readMcpServers3(content) {
+  const parsed = JSON.parse(content);
+  const rawServers = parsed.mcpServers;
+  if (!rawServers || typeof rawServers !== "object" || Array.isArray(rawServers)) return {};
+  const servers = {};
+  for (const [name, value] of Object.entries(rawServers)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const server = value;
+    if (typeof server.command === "string") {
+      servers[name] = {
+        type: typeof server.type === "string" ? server.type : "stdio",
+        command: server.command,
+        args: toStringArray4(server.args),
+        env: toStringRecord(server.env),
+        description: typeof server.description === "string" ? server.description : void 0
+      };
+      continue;
+    }
+    if (typeof server.url === "string") {
+      servers[name] = {
+        type: typeof server.type === "string" ? server.type : "http",
+        url: server.url,
+        headers: toStringRecord(server.headers),
+        env: toStringRecord(server.env),
+        description: typeof server.description === "string" ? server.description : void 0
+      };
+    }
+  }
+  return servers;
+}
+async function importRootRule2(projectRoot, results, normalize) {
+  const destPath = join37(projectRoot, ROO_CODE_CANONICAL_ROOT_RULE);
+  const sources = [ROO_CODE_ROOT_RULE, ROO_CODE_ROOT_RULE_FALLBACK];
+  for (const relPath of sources) {
+    const srcPath = join37(projectRoot, relPath);
+    const content = await readFileSafe(srcPath);
+    if (content === null) continue;
+    const { frontmatter, body } = parseFrontmatter(normalize(content, srcPath, destPath));
+    const output = await serializeImportedRuleWithFallback(
+      destPath,
+      {
+        root: true,
+        description: typeof frontmatter.description === "string" ? frontmatter.description : void 0,
+        globs: Array.isArray(frontmatter.globs) ? frontmatter.globs : void 0
+      },
+      body
+    );
+    await writeFileAtomic(destPath, output);
+    results.push({
+      fromTool: ROO_CODE_TARGET,
+      fromPath: srcPath,
+      toPath: ROO_CODE_CANONICAL_ROOT_RULE,
+      feature: "rules"
+    });
+    return;
+  }
+}
+async function importNonRootRules3(projectRoot, results, normalize) {
+  const srcDir = join37(projectRoot, ROO_CODE_RULES_DIR);
+  const destDir = join37(projectRoot, ROO_CODE_CANONICAL_RULES_DIR);
+  const rootRuleName = "00-root.md";
+  results.push(
+    ...await importFileDirectory({
+      srcDir,
+      destDir,
+      extensions: [".md"],
+      fromTool: ROO_CODE_TARGET,
+      normalize,
+      mapEntry: async ({ relativePath, normalizeTo }) => {
+        if (relativePath === rootRuleName) return null;
+        const destPath = join37(destDir, relativePath);
+        const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
+        const output = await serializeImportedRuleWithFallback(
+          destPath,
+          {
+            root: false,
+            description: typeof frontmatter.description === "string" ? frontmatter.description : void 0,
+            globs: Array.isArray(frontmatter.globs) ? frontmatter.globs : void 0
+          },
+          body
+        );
+        return {
+          destPath,
+          toPath: `${ROO_CODE_CANONICAL_RULES_DIR}/${relativePath}`,
+          feature: "rules",
+          content: output
+        };
+      }
+    })
+  );
+}
+async function importPerModeRules(projectRoot, results, normalize) {
+  const rooDir = join37(projectRoot, ROO_CODE_DIR);
+  let entries;
+  try {
+    entries = await readdir9(rooDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const modeRuleDirs = entries.filter((e) => e.isDirectory() && e.name.startsWith("rules-")).map((e) => e.name);
+  for (const dirName of modeRuleDirs) {
+    const srcDir = join37(rooDir, dirName);
+    const destDir = join37(projectRoot, ROO_CODE_CANONICAL_RULES_DIR);
+    results.push(
+      ...await importFileDirectory({
+        srcDir,
+        destDir,
+        extensions: [".md"],
+        fromTool: ROO_CODE_TARGET,
+        normalize,
+        mapEntry: async ({ relativePath, normalizeTo }) => {
+          const destPath = join37(destDir, relativePath);
+          const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
+          const output = await serializeImportedRuleWithFallback(
+            destPath,
+            {
+              root: false,
+              description: typeof frontmatter.description === "string" ? frontmatter.description : void 0,
+              globs: Array.isArray(frontmatter.globs) ? frontmatter.globs : void 0
+            },
+            body
+          );
+          return {
+            destPath,
+            toPath: `${ROO_CODE_CANONICAL_RULES_DIR}/${relativePath}`,
+            feature: "rules",
+            content: output
+          };
+        }
+      })
+    );
+  }
+}
+async function importCommands5(projectRoot, results, normalize) {
+  const srcDir = join37(projectRoot, ROO_CODE_COMMANDS_DIR);
+  const destDir = join37(projectRoot, ROO_CODE_CANONICAL_COMMANDS_DIR);
+  results.push(
+    ...await importFileDirectory({
+      srcDir,
+      destDir,
+      extensions: [".md"],
+      fromTool: ROO_CODE_TARGET,
+      normalize,
+      mapEntry: async ({ relativePath, normalizeTo }) => {
+        const destPath = join37(destDir, relativePath);
+        const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
+        const output = await serializeImportedCommandWithFallback(
+          destPath,
+          {
+            hasDescription: true,
+            description: typeof frontmatter.description === "string" ? frontmatter.description : void 0,
+            hasAllowedTools: false,
+            allowedTools: []
+          },
+          body
+        );
+        return {
+          destPath,
+          toPath: `${ROO_CODE_CANONICAL_COMMANDS_DIR}/${relativePath}`,
+          feature: "commands",
+          content: output
+        };
+      }
+    })
+  );
+}
+async function importMcp6(projectRoot, results) {
+  const srcPath = join37(projectRoot, ROO_CODE_MCP_FILE);
+  const content = await readFileSafe(srcPath);
+  if (content === null) return;
+  const servers = readMcpServers3(content);
+  if (Object.keys(servers).length === 0) return;
+  await writeFileAtomic(
+    join37(projectRoot, ROO_CODE_CANONICAL_MCP),
+    JSON.stringify({ mcpServers: servers }, null, 2)
+  );
+  results.push({
+    fromTool: ROO_CODE_TARGET,
+    fromPath: srcPath,
+    toPath: ROO_CODE_CANONICAL_MCP,
+    feature: "mcp"
+  });
+}
+async function importIgnore3(projectRoot, results) {
+  const srcPath = join37(projectRoot, ROO_CODE_IGNORE);
+  const content = await readFileSafe(srcPath);
+  if (content === null) return;
+  await writeFileAtomic(join37(projectRoot, ROO_CODE_CANONICAL_IGNORE), content.trimEnd());
+  results.push({
+    fromTool: ROO_CODE_TARGET,
+    fromPath: srcPath,
+    toPath: ROO_CODE_CANONICAL_IGNORE,
+    feature: "ignore"
+  });
+}
+async function importFromRooCode(projectRoot) {
+  const results = [];
+  const normalize = await createImportReferenceNormalizer(ROO_CODE_TARGET, projectRoot);
+  await importRootRule2(projectRoot, results, normalize);
+  await importNonRootRules3(projectRoot, results, normalize);
+  await importPerModeRules(projectRoot, results, normalize);
+  await importCommands5(projectRoot, results, normalize);
+  await importEmbeddedSkills(projectRoot, ROO_CODE_SKILLS_DIR, ROO_CODE_TARGET, results, normalize);
+  await importMcp6(projectRoot, results);
+  await importIgnore3(projectRoot, results);
+  return results;
+}
+
+// src/targets/roo-code/linter.ts
+function lintRules11(canonical, projectRoot, projectFiles) {
+  return validateRules(canonical, projectRoot, projectFiles).map((diagnostic) => ({
+    ...diagnostic,
+    target: ROO_CODE_TARGET
+  }));
+}
+
+// src/targets/roo-code/index.ts
+var target11 = {
+  name: "roo-code",
+  primaryRootInstructionPath: ROO_CODE_ROOT_RULE,
+  generateRules: generateRules11,
+  generateCommands: generateCommands8,
+  generateSkills: generateSkills11,
+  generateMcp: generateMcp8,
+  generateIgnore: generateIgnore7,
+  importFrom: importFromRooCode
+};
+var descriptor11 = {
+  id: "roo-code",
+  generators: target11,
+  capabilities: {
+    rules: "native",
+    commands: "native",
+    agents: "none",
+    skills: "native",
+    mcp: "native",
+    hooks: "none",
+    ignore: "native",
+    permissions: "none"
+  },
+  emptyImportMessage: "No Roo Code config found (.roo/rules, .roo/commands, .roo/skills, .roo/mcp.json, .rooignore, or .roorules).",
+  lintRules: lintRules11,
+  skillDir: ".roo/skills",
+  paths: {
+    rulePath(slug, _rule) {
+      return `${ROO_CODE_RULES_DIR}/${slug}.md`;
+    },
+    commandPath(name, _config) {
+      return `${ROO_CODE_COMMANDS_DIR}/${name}.md`;
+    },
+    agentPath(_name, _config) {
+      return null;
+    }
+  },
+  buildImportPaths: buildRooCodeImportPaths,
+  detectionPaths: [
+    ".roo/rules",
+    ".roo/commands",
+    ".roo/skills",
+    ".roo/mcp.json",
+    ".rooignore",
+    ".roorules"
+  ]
+};
+
 // src/targets/catalog/builtin-targets.ts
 var BUILTIN_TARGETS = [
   descriptor,
@@ -7232,39 +7588,40 @@ var BUILTIN_TARGETS = [
   descriptor7,
   descriptor8,
   descriptor9,
-  descriptor10
+  descriptor10,
+  descriptor11
 ];
-function getBuiltinTargetDefinition(target11) {
-  return BUILTIN_TARGETS.find((candidate) => candidate.id === target11);
+function getBuiltinTargetDefinition(target12) {
+  return BUILTIN_TARGETS.find((candidate) => candidate.id === target12);
 }
-function getTargetSkillDir(target11) {
-  return getBuiltinTargetDefinition(target11)?.skillDir;
+function getTargetSkillDir(target12) {
+  return getBuiltinTargetDefinition(target12)?.skillDir;
 }
-function getEffectiveTargetSupportLevel(target11, feature, config) {
-  const definition = getBuiltinTargetDefinition(target11);
+function getEffectiveTargetSupportLevel(target12, feature, config) {
+  const definition = getBuiltinTargetDefinition(target12);
   const baseLevel = definition?.capabilities[feature] ?? "none";
   if (baseLevel !== "embedded") return baseLevel;
-  if (feature === "commands" && target11 === "codex-cli") {
-    return shouldConvertCommandsToSkills(config, target11) ? "embedded" : "none";
+  if (feature === "commands" && target12 === "codex-cli") {
+    return shouldConvertCommandsToSkills(config, target12) ? "embedded" : "none";
   }
-  if (feature === "agents" && (target11 === "cline" || target11 === "windsurf")) {
-    return shouldConvertAgentsToSkills(config, target11) ? "embedded" : "none";
+  if (feature === "agents" && (target12 === "cline" || target12 === "windsurf")) {
+    return shouldConvertAgentsToSkills(config, target12) ? "embedded" : "none";
   }
   return baseLevel;
 }
-function resolveTargetFeatureGenerator(target11, feature, config) {
-  const generators = getBuiltinTargetDefinition(target11)?.generators;
+function resolveTargetFeatureGenerator(target12, feature, config) {
+  const generators = getBuiltinTargetDefinition(target12)?.generators;
   if (!generators) return void 0;
   switch (feature) {
     case "rules":
       return generators.generateRules;
     case "commands":
-      if (target11 === "codex-cli" && config && !shouldConvertCommandsToSkills(config, target11)) {
+      if (target12 === "codex-cli" && config && !shouldConvertCommandsToSkills(config, target12)) {
         return void 0;
       }
       return generators.generateWorkflows ?? generators.generateCommands;
     case "agents":
-      if (config && (target11 === "cline" || target11 === "windsurf") && !shouldConvertAgentsToSkills(config, target11)) {
+      if (config && (target12 === "cline" || target12 === "windsurf") && !shouldConvertAgentsToSkills(config, target12)) {
         return void 0;
       }
       return generators.generateAgents;
@@ -7284,9 +7641,9 @@ function resolveTargetFeatureGenerator(target11, feature, config) {
 }
 
 // src/core/reference/import-map.ts
-async function buildImportReferenceMap(target11, projectRoot) {
+async function buildImportReferenceMap(target12, projectRoot) {
   const refs = /* @__PURE__ */ new Map();
-  const def = getBuiltinTargetDefinition(target11);
+  const def = getBuiltinTargetDefinition(target12);
   if (def) {
     await def.buildImportPaths(refs, projectRoot);
   }
@@ -7342,7 +7699,8 @@ var ROOT_RELATIVE_PREFIXES = [
   ".clinerules/",
   ".cline/",
   ".agents/",
-  ".windsurf/"
+  ".windsurf/",
+  ".roo/"
 ];
 var NON_REWRITABLE_BARE_FILES = /* @__PURE__ */ new Set([
   "AGENTS.md",
@@ -7359,7 +7717,7 @@ var EXTERNAL_REF_PATTERNS = [
   /\/\/[A-Za-z0-9][\w.-]*\.[A-Za-z]{2,}[^\s<>()\]]*/g
 ];
 var FENCED_CODE_BLOCK = /^(?:```|~~~)[^\n]*\n[\s\S]*?^(?:```|~~~)/gm;
-var PATH_TOKEN = /(?:\.\.[\\/]|\.\/|\.\\|\/[A-Za-z0-9._-]|[A-Za-z]:[\\/][A-Za-z0-9._-]|\.agentsmesh[\\/]|\.claude[\\/]|\.cursor[\\/]|\.github[\\/]|\.continue[\\/]|\.junie[\\/]|\.gemini[\\/]|\.clinerules[\\/]|\.cline[\\/]|\.agents[\\/]|\.windsurf[\\/]|(?:[A-Za-z0-9._-]+[\\/])+|[A-Za-z0-9._-]+\.[A-Za-z0-9._-]+)[A-Za-z0-9._@%+~:\\/-]*/g;
+var PATH_TOKEN = /(?:\.\.[\\/]|\.\/|\.\\|\/[A-Za-z0-9._-]|[A-Za-z]:[\\/][A-Za-z0-9._-]|\.agentsmesh[\\/]|\.claude[\\/]|\.cursor[\\/]|\.github[\\/]|\.continue[\\/]|\.junie[\\/]|\.gemini[\\/]|\.clinerules[\\/]|\.cline[\\/]|\.agents[\\/]|\.windsurf[\\/]|\.roo[\\/]|(?:[A-Za-z0-9._-]+[\\/])+|[A-Za-z0-9._-]+\.[A-Za-z0-9._-]+)[A-Za-z0-9._@%+~:\\/-]*/g;
 var LINE_NUMBER_SUFFIX = /(?::(\d+)){1,2}$/;
 function resolveProjectPath(token, projectRoot, sourceFile) {
   const api = pathApi(projectRoot);
@@ -7506,7 +7864,8 @@ var IMPORT_REFERENCE_TARGETS = [
   "gemini-cli",
   "cline",
   "codex-cli",
-  "windsurf"
+  "windsurf",
+  "roo-code"
 ];
 function pathVariants(path) {
   const variants = [normalizePath(path)];
@@ -7521,9 +7880,9 @@ function pathVariants(path) {
   }
   return variants;
 }
-async function createImportReferenceNormalizer(target11, projectRoot) {
+async function createImportReferenceNormalizer(target12, projectRoot) {
   const refs = /* @__PURE__ */ new Map();
-  const targets = Array.from(/* @__PURE__ */ new Set([target11, ...IMPORT_REFERENCE_TARGETS]));
+  const targets = Array.from(/* @__PURE__ */ new Set([target12, ...IMPORT_REFERENCE_TARGETS]));
   for (const candidate of targets) {
     const candidateRefs = await buildImportReferenceMap(candidate, projectRoot);
     for (const [targetPath, canonicalPath] of candidateRefs.entries()) {
@@ -7532,8 +7891,8 @@ async function createImportReferenceNormalizer(target11, projectRoot) {
   }
   const artifactMap = /* @__PURE__ */ new Map();
   for (const [targetPath, canonicalPath] of refs.entries()) {
-    const canonicalAbsPath = normalizePath(join37(projectRoot, canonicalPath));
-    for (const variant of pathVariants(join37(projectRoot, targetPath))) {
+    const canonicalAbsPath = normalizePath(join38(projectRoot, canonicalPath));
+    for (const variant of pathVariants(join38(projectRoot, targetPath))) {
       artifactMap.set(variant, canonicalAbsPath);
     }
   }
@@ -7548,9 +7907,9 @@ async function createImportReferenceNormalizer(target11, projectRoot) {
 }
 
 // src/targets/claude-code/importer-mappers.ts
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 async function mapClaudeRuleFile(relativePath, destDir, normalizeTo) {
-  const destPath = join38(destDir, relativePath);
+  const destPath = join39(destDir, relativePath);
   const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
   return {
     destPath,
@@ -7564,7 +7923,7 @@ async function mapClaudeRuleFile(relativePath, destDir, normalizeTo) {
   };
 }
 async function mapClaudeMarkdownFile(relativePath, destDir, feature, normalizeTo) {
-  const destPath = join38(destDir, relativePath);
+  const destPath = join39(destDir, relativePath);
   const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
   const basePath = feature === "commands" ? CLAUDE_CANONICAL_COMMANDS_DIR : CLAUDE_CANONICAL_AGENTS_DIR;
   return {
@@ -7588,7 +7947,7 @@ async function mapClaudeMarkdownFile(relativePath, destDir, feature, normalizeTo
 }
 
 // src/targets/claude-code/settings-helpers.ts
-import { join as join39, dirname as dirname17 } from "path";
+import { join as join40, dirname as dirname17 } from "path";
 import { stringify as yamlStringify5 } from "yaml";
 function claudeHooksToCanonical(hooks) {
   const result = {};
@@ -7615,7 +7974,7 @@ function claudeHooksToCanonical(hooks) {
   return result;
 }
 async function importMcpJson(projectRoot, results) {
-  const mcpPath = join39(projectRoot, CLAUDE_MCP_JSON);
+  const mcpPath = join40(projectRoot, CLAUDE_MCP_JSON);
   const content = await readFileSafe(mcpPath);
   if (content === null) return;
   let parsed;
@@ -7626,7 +7985,7 @@ async function importMcpJson(projectRoot, results) {
   }
   if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
     const mcpContent = JSON.stringify({ mcpServers: parsed.mcpServers }, null, 2);
-    const destPath = join39(projectRoot, CLAUDE_CANONICAL_MCP);
+    const destPath = join40(projectRoot, CLAUDE_CANONICAL_MCP);
     await mkdirp(dirname17(destPath));
     await writeFileAtomic(destPath, mcpContent);
     results.push({
@@ -7638,7 +7997,7 @@ async function importMcpJson(projectRoot, results) {
   }
 }
 async function importSettings2(projectRoot, results) {
-  const settingsPath = join39(projectRoot, CLAUDE_SETTINGS);
+  const settingsPath = join40(projectRoot, CLAUDE_SETTINGS);
   const content = await readFileSafe(settingsPath);
   if (!content) return;
   let settings;
@@ -7650,7 +8009,7 @@ async function importSettings2(projectRoot, results) {
   const alreadyImportedMcp = results.some((r) => r.feature === "mcp");
   if (!alreadyImportedMcp && settings.mcpServers && typeof settings.mcpServers === "object") {
     const mcpContent = JSON.stringify({ mcpServers: settings.mcpServers }, null, 2);
-    const destPath = join39(projectRoot, CLAUDE_CANONICAL_MCP);
+    const destPath = join40(projectRoot, CLAUDE_CANONICAL_MCP);
     await mkdirp(dirname17(destPath));
     await writeFileAtomic(destPath, mcpContent);
     results.push({
@@ -7667,7 +8026,7 @@ async function importSettings2(projectRoot, results) {
     const deny = Array.isArray(perms.deny) ? perms.deny.filter((s) => typeof s === "string") : [];
     if (allow.length > 0 || deny.length > 0) {
       const permContent = yamlStringify5({ allow, deny });
-      const destPath = join39(projectRoot, CLAUDE_CANONICAL_PERMISSIONS);
+      const destPath = join40(projectRoot, CLAUDE_CANONICAL_PERMISSIONS);
       await mkdirp(dirname17(destPath));
       await writeFileAtomic(destPath, permContent);
       results.push({
@@ -7683,7 +8042,7 @@ async function importSettings2(projectRoot, results) {
     const canonicalHooks = claudeHooksToCanonical(rawHooks);
     if (Object.keys(canonicalHooks).length > 0) {
       const hooksContent = yamlStringify5(canonicalHooks);
-      const destPath = join39(projectRoot, CLAUDE_CANONICAL_HOOKS);
+      const destPath = join40(projectRoot, CLAUDE_CANONICAL_HOOKS);
       await mkdirp(dirname17(destPath));
       await writeFileAtomic(destPath, hooksContent);
       results.push({
@@ -7701,25 +8060,25 @@ async function importFromClaudeCode(projectRoot) {
   const results = [];
   const normalize = await createImportReferenceNormalizer("claude-code", projectRoot);
   await importRules5(projectRoot, results, normalize);
-  await importCommands5(projectRoot, results, normalize);
+  await importCommands6(projectRoot, results, normalize);
   await importAgents5(projectRoot, results, normalize);
   await importSkills5(projectRoot, results, normalize);
   await importMcpJson(projectRoot, results);
   await importSettings2(projectRoot, results);
-  await importIgnore3(projectRoot, results);
+  await importIgnore4(projectRoot, results);
   return results;
 }
 async function importRules5(projectRoot, results, normalize) {
-  const destDir = join40(projectRoot, CLAUDE_CANONICAL_RULES_DIR);
-  const primaryClaudePath = join40(projectRoot, CLAUDE_ROOT);
+  const destDir = join41(projectRoot, CLAUDE_CANONICAL_RULES_DIR);
+  const primaryClaudePath = join41(projectRoot, CLAUDE_ROOT);
   const primaryContent = await readFileSafe(primaryClaudePath);
-  const legacyClaudePath = join40(projectRoot, CLAUDE_LEGACY_ROOT);
+  const legacyClaudePath = join41(projectRoot, CLAUDE_LEGACY_ROOT);
   const legacyContent = primaryContent === null ? await readFileSafe(legacyClaudePath) : null;
   const claudeContent = primaryContent ?? legacyContent;
   const claudePath = primaryContent !== null ? primaryClaudePath : legacyClaudePath;
   if (claudeContent !== null) {
     await mkdirp(destDir);
-    const destPath = join40(destDir, "_root.md");
+    const destPath = join41(destDir, "_root.md");
     const { frontmatter, body } = parseFrontmatter(normalize(claudeContent, claudePath, destPath));
     const hasRoot = frontmatter.root === true;
     const outFm = hasRoot ? frontmatter : { ...frontmatter, root: true };
@@ -7732,7 +8091,7 @@ async function importRules5(projectRoot, results, normalize) {
       feature: "rules"
     });
   }
-  const rulesDir = join40(projectRoot, CLAUDE_RULES_DIR);
+  const rulesDir = join41(projectRoot, CLAUDE_RULES_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: rulesDir,
@@ -7744,9 +8103,9 @@ async function importRules5(projectRoot, results, normalize) {
     })
   );
 }
-async function importCommands5(projectRoot, results, normalize) {
-  const destDir = join40(projectRoot, CLAUDE_CANONICAL_COMMANDS_DIR);
-  const commandsDir = join40(projectRoot, CLAUDE_COMMANDS_DIR);
+async function importCommands6(projectRoot, results, normalize) {
+  const destDir = join41(projectRoot, CLAUDE_CANONICAL_COMMANDS_DIR);
+  const commandsDir = join41(projectRoot, CLAUDE_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: commandsDir,
@@ -7759,8 +8118,8 @@ async function importCommands5(projectRoot, results, normalize) {
   );
 }
 async function importAgents5(projectRoot, results, normalize) {
-  const destDir = join40(projectRoot, CLAUDE_CANONICAL_AGENTS_DIR);
-  const agentsDir = join40(projectRoot, CLAUDE_AGENTS_DIR);
+  const destDir = join41(projectRoot, CLAUDE_CANONICAL_AGENTS_DIR);
+  const agentsDir = join41(projectRoot, CLAUDE_AGENTS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: agentsDir,
@@ -7773,20 +8132,20 @@ async function importAgents5(projectRoot, results, normalize) {
   );
 }
 async function importSkills5(projectRoot, results, normalize) {
-  const skillsBaseDir = join40(projectRoot, CLAUDE_SKILLS_DIR);
-  const destBase = join40(projectRoot, CLAUDE_CANONICAL_SKILLS_DIR);
+  const skillsBaseDir = join41(projectRoot, CLAUDE_SKILLS_DIR);
+  const destBase = join41(projectRoot, CLAUDE_CANONICAL_SKILLS_DIR);
   const allFiles = await readDirRecursive(skillsBaseDir);
   const skillMdFiles = allFiles.filter((f) => f.endsWith("SKILL.md"));
   for (const skillMdPath of skillMdFiles) {
     const skillDir = dirname18(skillMdPath);
-    const skillName = basename25(skillDir);
-    const destSkillDir = join40(destBase, skillName);
+    const skillName = basename26(skillDir);
+    const destSkillDir = join41(destBase, skillName);
     const skillFiles = await readDirRecursive(skillDir);
     for (const filePath of skillFiles) {
       const fileContent = await readFileSafe(filePath);
       if (fileContent === null) continue;
       const relPath = relative17(skillDir, filePath);
-      const destPath = join40(destSkillDir, relPath);
+      const destPath = join41(destSkillDir, relPath);
       await mkdirp(dirname18(destPath));
       const normalized = normalize(fileContent, filePath, destPath);
       const parsed = relPath === "SKILL.md" ? parseFrontmatter(normalized) : null;
@@ -7808,11 +8167,11 @@ async function importSkills5(projectRoot, results, normalize) {
     }
   }
 }
-async function importIgnore3(projectRoot, results) {
-  const ignorePath = join40(projectRoot, CLAUDE_IGNORE);
+async function importIgnore4(projectRoot, results) {
+  const ignorePath = join41(projectRoot, CLAUDE_IGNORE);
   const content = await readFileSafe(ignorePath);
   if (content === null) return;
-  const destPath = join40(projectRoot, CLAUDE_CANONICAL_IGNORE);
+  const destPath = join41(projectRoot, CLAUDE_CANONICAL_IGNORE);
   await mkdirp(dirname18(destPath));
   await writeFileAtomic(destPath, content);
   results.push({
@@ -7844,17 +8203,17 @@ async function importNativeToCanonical(repoPath, targetName) {
 }
 
 // src/canonical/load/skill-pack-load.ts
-import { join as join41 } from "path";
-import { readdir as readdir9 } from "fs/promises";
+import { join as join42 } from "path";
+import { readdir as readdir10 } from "fs/promises";
 var SKILL = "SKILL.md";
 async function isSkillPackLayout(root) {
   if (!await exists(root)) return false;
-  if (await exists(join41(root, SKILL))) return true;
+  if (await exists(join42(root, SKILL))) return true;
   try {
-    const ents = await readdir9(root, { withFileTypes: true });
+    const ents = await readdir10(root, { withFileTypes: true });
     for (const e of ents) {
       if (!e.isDirectory() || e.name.startsWith(".")) continue;
-      if (await exists(join41(root, e.name, SKILL))) return true;
+      if (await exists(join42(root, e.name, SKILL))) return true;
     }
   } catch {
     return false;
@@ -7863,7 +8222,7 @@ async function isSkillPackLayout(root) {
 }
 async function loadSkillsAtExtendPath(skillsRoot) {
   if (!await exists(skillsRoot)) return [];
-  if (await exists(join41(skillsRoot, SKILL))) {
+  if (await exists(join42(skillsRoot, SKILL))) {
     const one = await parseSkillDirectory(skillsRoot);
     return one ? [one] : [];
   }
@@ -7871,7 +8230,7 @@ async function loadSkillsAtExtendPath(skillsRoot) {
 }
 
 // src/canonical/load/load-canonical-slice.ts
-import { basename as basename26, dirname as dirname19, join as join42 } from "path";
+import { basename as basename27, dirname as dirname19, join as join43 } from "path";
 import { stat as stat4 } from "fs/promises";
 function emptyCanonical() {
   return {
@@ -7902,8 +8261,8 @@ async function normalizeSlicePath(absolutePath) {
     );
   }
   const parent = dirname19(absolutePath);
-  const parentBase = basename26(parent);
-  const fileBase = basename26(absolutePath);
+  const parentBase = basename27(parent);
+  const fileBase = basename27(absolutePath);
   const slug = fileBase.replace(/\.md$/i, "");
   if (parentBase === "rules") {
     return { sliceRoot: parent, implicitPick: { rules: [slug] } };
@@ -7919,33 +8278,33 @@ async function normalizeSlicePath(absolutePath) {
   );
 }
 async function parseRulesAt(sliceRoot) {
-  const base = basename26(sliceRoot);
+  const base = basename27(sliceRoot);
   if (base === "rules") {
     return parseRules(sliceRoot);
   }
-  const nested = join42(sliceRoot, "rules");
+  const nested = join43(sliceRoot, "rules");
   if (await exists(nested)) {
     return parseRules(nested);
   }
   return [];
 }
 async function parseCommandsAt(sliceRoot) {
-  const base = basename26(sliceRoot);
+  const base = basename27(sliceRoot);
   if (base === "commands") {
     return parseCommands(sliceRoot);
   }
-  const nested = join42(sliceRoot, "commands");
+  const nested = join43(sliceRoot, "commands");
   if (await exists(nested)) {
     return parseCommands(nested);
   }
   return [];
 }
 async function parseAgentsAt(sliceRoot) {
-  const base = basename26(sliceRoot);
+  const base = basename27(sliceRoot);
   if (base === "agents") {
     return parseAgents(sliceRoot);
   }
-  const nested = join42(sliceRoot, "agents");
+  const nested = join43(sliceRoot, "agents");
   if (await exists(nested)) {
     return parseAgents(nested);
   }
@@ -7955,14 +8314,14 @@ async function loadSkillsForPartialSlice(sliceRoot) {
   if (await isSkillPackLayout(sliceRoot)) {
     return loadSkillsAtExtendPath(sliceRoot);
   }
-  const nestedSkills = join42(sliceRoot, "skills");
+  const nestedSkills = join43(sliceRoot, "skills");
   if (await isSkillPackLayout(nestedSkills)) {
     return loadSkillsAtExtendPath(nestedSkills);
   }
   return [];
 }
 async function loadCanonicalSliceAtPath(sliceRoot) {
-  const ab = join42(sliceRoot, ".agentsmesh");
+  const ab = join43(sliceRoot, ".agentsmesh");
   if (await exists(ab)) {
     return loadCanonicalFiles(sliceRoot);
   }
@@ -7995,7 +8354,7 @@ function emptyCanonical2() {
 async function loadCanonicalForExtend(ext) {
   const base = ext.resolvedPath;
   if (!ext.path) {
-    const agentsmeshDir = join43(base, ".agentsmesh");
+    const agentsmeshDir = join44(base, ".agentsmesh");
     if (!await exists(agentsmeshDir)) {
       if (await isSkillPackLayout(base)) {
         const skills = await loadSkillsAtExtendPath(base);
@@ -8015,12 +8374,12 @@ Expected one of: .agentsmesh/, ${KNOWN_NATIVE_PATHS.join(", ")}.`
     }
     return loadCanonicalFiles(base);
   }
-  const rawRoot = join43(base, ext.path);
+  const rawRoot = join44(base, ext.path);
   if (!await exists(rawRoot)) {
     throw new Error(`Extend "${ext.name}": path does not exist: ${rawRoot}`);
   }
   if (ext.target) {
-    const agentsmeshDir = join43(base, ".agentsmesh");
+    const agentsmeshDir = join44(base, ".agentsmesh");
     if (!await exists(agentsmeshDir)) {
       logger.info(
         `[agentsmesh] Extend "${ext.name}": path "${ext.path}" with target "${ext.target}" \u2014 importing at extend root, then loading canonical.`
@@ -8041,7 +8400,7 @@ Expected one of: .agentsmesh/, ${KNOWN_NATIVE_PATHS.join(", ")}.`
 }
 
 // src/canonical/extends/extend-pick.ts
-import { basename as basename27 } from "path";
+import { basename as basename28 } from "path";
 function applyExtendPick(canonical, features, pick, extendName) {
   if (!pick) return canonical;
   let next = { ...canonical };
@@ -8084,7 +8443,7 @@ function applyExtendPick(canonical, features, pick, extendName) {
   if (pick.rules?.length && features.includes("rules")) {
     const wanted = new Set(pick.rules);
     const prev = next.rules;
-    const stem = (src) => basename27(src).replace(/\.md$/i, "");
+    const stem = (src) => basename28(src).replace(/\.md$/i, "");
     next = {
       ...next,
       rules: prev.filter((r) => wanted.has(stem(r.source)))
@@ -8101,11 +8460,11 @@ function applyExtendPick(canonical, features, pick, extendName) {
 }
 
 // src/canonical/load/pack-load.ts
-import { join as join45 } from "path";
+import { join as join46 } from "path";
 
 // src/install/pack/pack-reader.ts
-import { join as join44 } from "path";
-import { readdir as readdir10 } from "fs/promises";
+import { join as join45 } from "path";
+import { readdir as readdir11 } from "fs/promises";
 import { parse as parseYaml5 } from "yaml";
 
 // src/install/pack/pack-schema.ts
@@ -8151,7 +8510,7 @@ function sameFeatures(a, b) {
   return a.length === b.length && [...a].sort().every((feature, index) => feature === [...b].sort()[index]);
 }
 async function readPackMetadata(packDir) {
-  const metaPath = join44(packDir, "pack.yaml");
+  const metaPath = join45(packDir, "pack.yaml");
   const content = await readFileSafe(metaPath);
   if (content === null) return null;
   try {
@@ -8166,13 +8525,13 @@ async function findExistingPack(packsDir, source, scope) {
   const requestedIdentity = sourceIdentity(source);
   let entries;
   try {
-    entries = await readdir10(packsDir, { withFileTypes: true });
+    entries = await readdir11(packsDir, { withFileTypes: true });
   } catch {
     return null;
   }
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const packDir = join44(packsDir, entry.name);
+    const packDir = join45(packsDir, entry.name);
     const meta = await readPackMetadata(packDir);
     if (meta && sourceIdentity(meta.source) === requestedIdentity && meta.target === scope.target && meta.as === scope.as && sameFeatures(meta.features, scope.features)) {
       return { meta, packDir, name: meta.name };
@@ -8184,14 +8543,14 @@ async function listPacks(packsDir) {
   if (!await exists(packsDir)) return [];
   let entries;
   try {
-    entries = await readdir10(packsDir, { withFileTypes: true });
+    entries = await readdir11(packsDir, { withFileTypes: true });
   } catch {
     return [];
   }
   const result = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const packDir = join44(packsDir, entry.name);
+    const packDir = join45(packsDir, entry.name);
     const meta = await readPackMetadata(packDir);
     if (meta) {
       result.push({ meta, packDir, name: meta.name });
@@ -8215,19 +8574,19 @@ function emptyCanonical3() {
 }
 async function loadPackCanonical(packDir) {
   const [rules, commands, agents, skills, mcp, permissions, hooks, ignore] = await Promise.all([
-    parseRules(join45(packDir, "rules")),
-    parseCommands(join45(packDir, "commands")),
-    parseAgents(join45(packDir, "agents")),
-    parseSkills(join45(packDir, "skills")),
-    parseMcp(join45(packDir, "mcp.json")),
-    parsePermissions(join45(packDir, "permissions.yaml")),
-    parseHooks(join45(packDir, "hooks.yaml")),
-    parseIgnore(join45(packDir, "ignore"))
+    parseRules(join46(packDir, "rules")),
+    parseCommands(join46(packDir, "commands")),
+    parseAgents(join46(packDir, "agents")),
+    parseSkills(join46(packDir, "skills")),
+    parseMcp(join46(packDir, "mcp.json")),
+    parsePermissions(join46(packDir, "permissions.yaml")),
+    parseHooks(join46(packDir, "hooks.yaml")),
+    parseIgnore(join46(packDir, "ignore"))
   ]);
   return { ...emptyCanonical3(), rules, commands, agents, skills, mcp, permissions, hooks, ignore };
 }
 async function loadPacksCanonical(abDir) {
-  const packsDir = join45(abDir, "packs");
+  const packsDir = join46(abDir, "packs");
   const packs = await listPacks(packsDir);
   let merged = emptyCanonical3();
   for (const { meta, packDir } of packs) {
@@ -8289,7 +8648,7 @@ async function loadCanonicalWithExtends(config, configDir, options = {}) {
     const picked = applyExtendPick(filtered, ext.features, ext.pick, ext.name);
     merged = mergeCanonicalFiles(merged, picked);
   }
-  const packsCanonical = await loadPacksCanonical(join46(configDir, ".agentsmesh"));
+  const packsCanonical = await loadPacksCanonical(join47(configDir, ".agentsmesh"));
   merged = mergeCanonicalFiles(merged, packsCanonical);
   const localCanonical = await loadCanonicalFiles(configDir);
   merged = mergeCanonicalFiles(merged, localCanonical);
@@ -8298,7 +8657,7 @@ async function loadCanonicalWithExtends(config, configDir, options = {}) {
 
 // src/config/core/lock.ts
 import { parse as parseYaml6, stringify as stringifyYaml3 } from "yaml";
-import { join as join47, relative as relative18 } from "path";
+import { join as join48, relative as relative18 } from "path";
 
 // src/utils/crypto/hash.ts
 import { createHash } from "crypto";
@@ -8345,7 +8704,7 @@ var FEATURE_PATTERNS = {
   ignore: (path) => path === "ignore"
 };
 async function readLock(abDir) {
-  const lockPath = join47(abDir, LOCK_FILENAME);
+  const lockPath = join48(abDir, LOCK_FILENAME);
   const content = await readFileSafe(lockPath);
   if (content === null) return null;
   try {
@@ -8364,7 +8723,7 @@ async function readLock(abDir) {
   }
 }
 async function writeLock(abDir, lock) {
-  const lockPath = join47(abDir, LOCK_FILENAME);
+  const lockPath = join48(abDir, LOCK_FILENAME);
   const raw = {
     generated_at: lock.generatedAt,
     generated_by: lock.generatedBy,
@@ -8418,7 +8777,7 @@ async function buildExtendChecksums(resolvedExtends) {
       result[ext.name] = ext.version;
       continue;
     }
-    const abDir = join47(ext.resolvedPath, ".agentsmesh");
+    const abDir = join48(ext.resolvedPath, ".agentsmesh");
     const checksums = await buildChecksums(abDir);
     const fingerprint = Object.keys(checksums).sort().map((p) => `${p}:${checksums[p]}`).join("\n");
     const h = hashContent(fingerprint);
@@ -8429,7 +8788,7 @@ async function buildExtendChecksums(resolvedExtends) {
 }
 
 // src/core/reference/map.ts
-import { basename as basename29 } from "path";
+import { basename as basename30 } from "path";
 
 // src/core/reference/map-directories.ts
 import { posix as posix2 } from "path";
@@ -8448,29 +8807,29 @@ function addSkillDirectoryMappings(refs, canonicalPath, targetPath) {
 }
 
 // src/core/reference/map-targets.ts
-import { basename as basename28 } from "path";
+import { basename as basename29 } from "path";
 var SKILL_DIRS = Object.fromEntries(
-  TARGET_IDS.map((target11) => [target11, getTargetSkillDir(target11)]).filter(
+  TARGET_IDS.map((target12) => [target12, getTargetSkillDir(target12)]).filter(
     (entry) => typeof entry[1] === "string"
   )
 );
-function ruleTargetPath(target11, rule) {
-  const def = getBuiltinTargetDefinition(target11);
+function ruleTargetPath(target12, rule) {
+  const def = getBuiltinTargetDefinition(target12);
   if (!def) return null;
   if (rule.root) {
     return def.generators.primaryRootInstructionPath ?? null;
   }
-  if (rule.targets.length > 0 && !rule.targets.includes(target11)) return null;
-  const slug = basename28(rule.source, ".md");
+  if (rule.targets.length > 0 && !rule.targets.includes(target12)) return null;
+  const slug = basename29(rule.source, ".md");
   return def.paths.rulePath(slug, rule);
 }
-function commandTargetPath(target11, name, config) {
-  const def = getBuiltinTargetDefinition(target11);
+function commandTargetPath(target12, name, config) {
+  const def = getBuiltinTargetDefinition(target12);
   if (!def) return null;
   return def.paths.commandPath(name, config);
 }
-function agentTargetPath(target11, name, config) {
-  const def = getBuiltinTargetDefinition(target11);
+function agentTargetPath(target12, name, config) {
+  const def = getBuiltinTargetDefinition(target12);
   if (!def) return null;
   return def.paths.agentPath(name, config);
 }
@@ -8480,21 +8839,21 @@ function addDirectoryMapping3(refs, from, to) {
   refs.set(from, to);
   refs.set(`${from}/`, `${to}/`);
 }
-function buildReferenceMap(target11, canonical, config) {
+function buildReferenceMap(target12, canonical, config) {
   const refs = /* @__PURE__ */ new Map();
   for (const rule of canonical.rules) {
-    const path = ruleTargetPath(target11, rule);
-    if (path) refs.set(`.agentsmesh/rules/${basename29(rule.source)}`, path);
+    const path = ruleTargetPath(target12, rule);
+    if (path) refs.set(`.agentsmesh/rules/${basename30(rule.source)}`, path);
   }
   for (const command of canonical.commands) {
-    const path = commandTargetPath(target11, command.name, config);
+    const path = commandTargetPath(target12, command.name, config);
     if (path) refs.set(`.agentsmesh/commands/${command.name}.md`, path);
   }
   for (const agent of canonical.agents) {
-    const path = agentTargetPath(target11, agent.name, config);
+    const path = agentTargetPath(target12, agent.name, config);
     if (path) refs.set(`.agentsmesh/agents/${agent.name}.md`, path);
   }
-  const skillDir = SKILL_DIRS[target11];
+  const skillDir = SKILL_DIRS[target12];
   if (!skillDir) return refs;
   for (const skill of canonical.skills) {
     addDirectoryMapping3(refs, `.agentsmesh/skills/${skill.name}`, `${skillDir}/${skill.name}`);
@@ -8530,14 +8889,14 @@ function isGeminiAgents(result) {
 function isCompatibilityAgents(result) {
   return isCursorAgents(result) || isGeminiAgents(result);
 }
-function reverseReferenceMap(target11, canonical, config, cache) {
-  const cached = cache.get(target11);
+function reverseReferenceMap(target12, canonical, config, cache) {
+  const cached = cache.get(target12);
   if (cached) return cached;
   const reversed = /* @__PURE__ */ new Map();
-  for (const [canonicalPath, targetPath] of buildReferenceMap(target11, canonical, config)) {
+  for (const [canonicalPath, targetPath] of buildReferenceMap(target12, canonical, config)) {
     if (!reversed.has(targetPath)) reversed.set(targetPath, canonicalPath);
   }
-  cache.set(target11, reversed);
+  cache.set(target12, reversed);
   return reversed;
 }
 function normalizeContent(content, refs) {
@@ -8569,11 +8928,11 @@ function preferEquivalentCodexAgents(results, canonical, config) {
   return results.filter((result) => {
     if (isCursorAgents(result)) {
       const targets = overlapTargetsByPath.get(result.path);
-      if (targets && [...targets].some((target11) => target11 !== "cursor")) return false;
+      if (targets && [...targets].some((target12) => target12 !== "cursor")) return false;
     }
     if (isGeminiAgents(result)) {
       const targets = overlapTargetsByPath.get(result.path);
-      if (targets && [...targets].some((target11) => target11 !== "cursor" && target11 !== "gemini-cli")) {
+      if (targets && [...targets].some((target12) => target12 !== "cursor" && target12 !== "gemini-cli")) {
         return false;
       }
     }
@@ -8591,10 +8950,10 @@ function preferEquivalentCodexAgents(results, canonical, config) {
 
 // src/core/reference/rewriter.ts
 import { existsSync as existsSync3 } from "fs";
-import { dirname as dirname21, join as join49 } from "path";
+import { dirname as dirname21, join as join50 } from "path";
 
 // src/core/reference/output-source-map.ts
-import { dirname as dirname20, join as join48, normalize as normalizePath2 } from "path";
+import { dirname as dirname20, join as join49, normalize as normalizePath2 } from "path";
 function canonicalRulePath(rule) {
   return `.agentsmesh/rules/${rule.source.split("/").pop()}`;
 }
@@ -8617,17 +8976,17 @@ function copilotInstructionsPath(rule) {
   const slug = rule.source.split("/").pop().replace(/\.md$/, "");
   return `.github/instructions/${slug}.instructions.md`;
 }
-function ruleOutputPaths(target11, rule, refs) {
+function ruleOutputPaths(target12, rule, refs) {
   const paths = [];
   const targetPath = refs.get(canonicalRulePath(rule));
   if (targetPath) paths.push(targetPath);
-  if (target11 === "copilot" && !rule.root && rule.globs.length > 0) {
+  if (target12 === "copilot" && !rule.root && rule.globs.length > 0) {
     paths.push(copilotInstructionsPath(rule));
   }
-  if ((target11 === "cline" || target11 === "cursor") && rule.root) {
+  if ((target12 === "cline" || target12 === "cursor") && rule.root) {
     paths.push("AGENTS.md");
   }
-  if (target11 === "windsurf") {
+  if (target12 === "windsurf") {
     if (rule.root) {
       paths.push("AGENTS.md");
     } else {
@@ -8635,10 +8994,10 @@ function ruleOutputPaths(target11, rule, refs) {
       if (dir) paths.push(`${dir}/AGENTS.md`);
     }
   }
-  if (target11 === "gemini-cli") {
+  if (target12 === "gemini-cli") {
     paths.push(GEMINI_COMPAT_AGENTS);
   }
-  if (target11 === "codex-cli") {
+  if (target12 === "codex-cli") {
     if (!rule.root && rule.codexEmit === "execution") {
       const slug = rule.source.split("/").pop().replace(/\.md$/, "");
       paths.push(`${CODEX_RULES_DIR}/${slug}.rules`);
@@ -8646,46 +9005,46 @@ function ruleOutputPaths(target11, rule, refs) {
   }
   return paths;
 }
-function addPackSkillPaths(refs, target11, canonical, projectRoot) {
-  const skillDir = SKILL_DIRS[target11];
+function addPackSkillPaths(refs, target12, canonical, projectRoot) {
+  const skillDir = SKILL_DIRS[target12];
   if (!skillDir) return;
-  const packsPrefix = join48(projectRoot, ".agentsmesh", "packs");
+  const packsPrefix = join49(projectRoot, ".agentsmesh", "packs");
   for (const skill of canonical.skills) {
     const skillSourceDir = dirname20(skill.source);
     if (!skillSourceDir.startsWith(packsPrefix)) continue;
-    const targetSkillDir = normalizePath2(join48(projectRoot, skillDir, skill.name));
+    const targetSkillDir = normalizePath2(join49(projectRoot, skillDir, skill.name));
     refs.set(normalizePath2(skillSourceDir), targetSkillDir);
-    refs.set(normalizePath2(skill.source), normalizePath2(join48(targetSkillDir, "SKILL.md")));
+    refs.set(normalizePath2(skill.source), normalizePath2(join49(targetSkillDir, "SKILL.md")));
     for (const file of skill.supportingFiles) {
-      const targetFilePath = normalizePath2(join48(targetSkillDir, file.relativePath));
+      const targetFilePath = normalizePath2(join49(targetSkillDir, file.relativePath));
       refs.set(normalizePath2(file.absolutePath), targetFilePath);
     }
   }
 }
-function buildArtifactPathMap(target11, canonical, config, projectRoot, destinationPath) {
+function buildArtifactPathMap(target12, canonical, config, projectRoot, destinationPath) {
   const refs = new Map(
-    [...buildReferenceMap(target11, canonical, config)].map(([canonicalPath, targetPath]) => [
-      normalizePath2(join48(projectRoot, canonicalPath)),
-      normalizePath2(join48(projectRoot, targetPath))
+    [...buildReferenceMap(target12, canonical, config)].map(([canonicalPath, targetPath]) => [
+      normalizePath2(join49(projectRoot, canonicalPath)),
+      normalizePath2(join49(projectRoot, targetPath))
     ])
   );
-  if (target11 === "copilot" && destinationPath?.startsWith(".github/instructions/")) {
+  if (target12 === "copilot" && destinationPath?.startsWith(".github/instructions/")) {
     for (const rule of canonical.rules) {
       if (rule.root || rule.globs.length === 0) continue;
       refs.set(
-        normalizePath2(join48(projectRoot, canonicalRulePath(rule))),
-        normalizePath2(join48(projectRoot, copilotInstructionsPath(rule)))
+        normalizePath2(join49(projectRoot, canonicalRulePath(rule))),
+        normalizePath2(join49(projectRoot, copilotInstructionsPath(rule)))
       );
     }
   }
-  addPackSkillPaths(refs, target11, canonical, projectRoot);
+  addPackSkillPaths(refs, target12, canonical, projectRoot);
   return refs;
 }
-function buildOutputSourceMap(target11, canonical, config) {
-  const refs = buildReferenceMap(target11, canonical, config);
+function buildOutputSourceMap(target12, canonical, config) {
+  const refs = buildReferenceMap(target12, canonical, config);
   const sourceMap = /* @__PURE__ */ new Map();
   for (const rule of canonical.rules) {
-    for (const targetPath of ruleOutputPaths(target11, rule, refs)) {
+    for (const targetPath of ruleOutputPaths(target12, rule, refs)) {
       sourceMap.set(targetPath, rule.source);
     }
   }
@@ -8713,7 +9072,7 @@ function buildOutputSourceMap(target11, canonical, config) {
 function collectPlannedPaths(projectRoot, results) {
   const planned = /* @__PURE__ */ new Set();
   for (const result of results) {
-    const absolutePath = join49(projectRoot, result.path);
+    const absolutePath = join50(projectRoot, result.path);
     planned.add(absolutePath);
     let current = dirname21(absolutePath);
     while (current.startsWith(projectRoot) && !planned.has(current)) {
@@ -8755,7 +9114,7 @@ function rewriteGeneratedReferences(results, canonical, config, projectRoot) {
       content: result.content,
       projectRoot,
       sourceFile,
-      destinationFile: join49(projectRoot, result.path),
+      destinationFile: join50(projectRoot, result.path),
       translatePath: (absolutePath) => artifactMap.get(absolutePath) ?? absolutePath,
       pathExists: (absolutePath) => plannedPaths.has(absolutePath) || existsSync3(absolutePath)
     });
@@ -8806,7 +9165,7 @@ function refreshResultStatus(result) {
 }
 
 // src/core/generate/feature-loop.ts
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 function computeStatus(existing, content) {
   if (existing === null) return "created";
   if (existing !== content) return "updated";
@@ -8814,13 +9173,13 @@ function computeStatus(existing, content) {
 }
 async function generateFeature(results, targets, canonical, projectRoot, enabled, getGen) {
   if (!enabled) return;
-  for (const target11 of targets) {
-    const gen = getGen(target11);
+  for (const target12 of targets) {
+    const gen = getGen(target12);
     if (!gen) continue;
     for (const out of gen(canonical)) {
-      const existing = await readFileSafe(join50(projectRoot, out.path));
+      const existing = await readFileSafe(join51(projectRoot, out.path));
       results.push({
-        target: target11,
+        target: target12,
         path: out.path,
         content: out.content,
         currentContent: existing ?? void 0,
@@ -8838,8 +9197,8 @@ function getDescriptor(name) {
   return descriptorRegistry.get(name) ?? builtinDescriptors.get(name);
 }
 function getTarget(name) {
-  const descriptor11 = getDescriptor(name);
-  if (descriptor11) return descriptor11.generators;
+  const descriptor12 = getDescriptor(name);
+  if (descriptor12) return descriptor12.generators;
   const legacy = legacyRegistry.get(name);
   if (legacy) return legacy;
   throw new Error(`Unknown target: ${name}`);
@@ -8863,10 +9222,10 @@ function decoratePrimaryRootInstructions(results) {
 }
 
 // src/core/generate/optional-features.ts
-import { join as join52 } from "path";
+import { join as join53 } from "path";
 
 // src/targets/copilot/hook-assets.ts
-import { join as join51, relative as relative19 } from "path";
+import { join as join52, relative as relative19 } from "path";
 var SCRIPT_PREFIX_RE = /^(?<prefix>\s*(?:(?:bash|sh|zsh)\s+)?)["']?(?<path>(?:\.\.\/|\.\/|[^/\s"'`]+\/)[^\s"'`]+)["']?(?<suffix>(?:\s.*)?)$/;
 function safePhaseName(phase) {
   return phase.replace(/[^a-zA-Z0-9]/g, "-").toLowerCase();
@@ -8887,7 +9246,7 @@ async function buildAssetOutput(projectRoot, command) {
   const match = command.match(SCRIPT_PREFIX_RE);
   const sourceToken = match?.groups?.["path"];
   if (!sourceToken) return null;
-  const sourcePath = join51(projectRoot, sourceToken);
+  const sourcePath = join52(projectRoot, sourceToken);
   const assetContent = await readFileSafe(sourcePath);
   if (assetContent === null) return null;
   const repoRelative = toRepoRelative(projectRoot, sourcePath);
@@ -8975,14 +9334,14 @@ function mergeGeminiSettingsJson(existing, newContent) {
 
 // src/core/generate/optional-features.ts
 async function generatePermissionsFeature(results, targets, canonical, projectRoot) {
-  for (const target11 of targets) {
-    const gen = resolveTargetFeatureGenerator(target11, "permissions");
+  for (const target12 of targets) {
+    const gen = resolveTargetFeatureGenerator(target12, "permissions");
     if (!gen) continue;
     for (const out of gen(canonical)) {
-      const existing = await readFileSafe(join52(projectRoot, out.path));
+      const existing = await readFileSafe(join53(projectRoot, out.path));
       const content = existing !== null && SETTINGS_JSON_PATHS.includes(out.path) ? mergeSettingsJson(existing, out.content) : out.content;
       results.push({
-        target: target11,
+        target: target12,
         path: out.path,
         content,
         currentContent: existing ?? void 0,
@@ -8992,15 +9351,15 @@ async function generatePermissionsFeature(results, targets, canonical, projectRo
   }
 }
 async function generateHooksFeature(results, targets, canonical, projectRoot) {
-  for (const target11 of targets) {
-    const gen = resolveTargetFeatureGenerator(target11, "hooks");
+  for (const target12 of targets) {
+    const gen = resolveTargetFeatureGenerator(target12, "hooks");
     if (!gen) continue;
-    const outputs = target11 === "copilot" ? await addHookScriptAssets(projectRoot, canonical, gen(canonical)) : gen(canonical);
+    const outputs = target12 === "copilot" ? await addHookScriptAssets(projectRoot, canonical, gen(canonical)) : gen(canonical);
     for (const out of outputs) {
-      const existing = await readFileSafe(join52(projectRoot, out.path));
+      const existing = await readFileSafe(join53(projectRoot, out.path));
       let content = out.content;
       if (SETTINGS_JSON_PATHS.includes(out.path)) {
-        const pendingIdx = results.findIndex((r) => r.path === out.path && r.target === target11);
+        const pendingIdx = results.findIndex((r) => r.path === out.path && r.target === target12);
         const pendingResult = pendingIdx >= 0 ? results[pendingIdx] : void 0;
         const base = pendingResult?.content ?? existing;
         if (base !== null) {
@@ -9011,7 +9370,7 @@ async function generateHooksFeature(results, targets, canonical, projectRoot) {
         }
       }
       results.push({
-        target: target11,
+        target: target12,
         path: out.path,
         content,
         currentContent: existing ?? void 0,
@@ -9021,17 +9380,17 @@ async function generateHooksFeature(results, targets, canonical, projectRoot) {
   }
 }
 async function generateGeminiSettingsFeature(results, targets, canonical, projectRoot) {
-  for (const target11 of targets) {
-    if (target11 !== "gemini-cli") continue;
-    const gen = resolveTargetFeatureGenerator(target11, "settings");
+  for (const target12 of targets) {
+    if (target12 !== "gemini-cli") continue;
+    const gen = resolveTargetFeatureGenerator(target12, "settings");
     if (!gen) continue;
     const outputs = gen(canonical);
     if (outputs.length === 0) continue;
     for (const out of outputs) {
-      const existing = await readFileSafe(join52(projectRoot, out.path));
+      const existing = await readFileSafe(join53(projectRoot, out.path));
       const content = existing !== null && out.path === GEMINI_SETTINGS ? mergeGeminiSettingsJson(existing, out.content) : out.content;
       results.push({
-        target: target11,
+        target: target12,
         path: out.path,
         content,
         currentContent: existing ?? void 0,
@@ -9060,7 +9419,7 @@ async function generate(ctx) {
     canonical,
     projectRoot,
     hasRules,
-    (target11) => resolveTargetFeatureGenerator(target11, "rules", config)
+    (target12) => resolveTargetFeatureGenerator(target12, "rules", config)
   );
   await generateFeature(
     results,
@@ -9068,7 +9427,7 @@ async function generate(ctx) {
     canonical,
     projectRoot,
     hasCommands,
-    (target11) => resolveTargetFeatureGenerator(target11, "commands", config)
+    (target12) => resolveTargetFeatureGenerator(target12, "commands", config)
   );
   await generateFeature(
     results,
@@ -9076,7 +9435,7 @@ async function generate(ctx) {
     canonical,
     projectRoot,
     hasAgents,
-    (target11) => resolveTargetFeatureGenerator(target11, "agents", config)
+    (target12) => resolveTargetFeatureGenerator(target12, "agents", config)
   );
   await generateFeature(
     results,
@@ -9084,7 +9443,7 @@ async function generate(ctx) {
     canonical,
     projectRoot,
     hasSkills,
-    (target11) => resolveTargetFeatureGenerator(target11, "skills", config)
+    (target12) => resolveTargetFeatureGenerator(target12, "skills", config)
   );
   await generateFeature(
     results,
@@ -9092,7 +9451,7 @@ async function generate(ctx) {
     canonical,
     projectRoot,
     hasMcp,
-    (target11) => resolveTargetFeatureGenerator(target11, "mcp", config)
+    (target12) => resolveTargetFeatureGenerator(target12, "mcp", config)
   );
   if (hasPermissions) await generatePermissionsFeature(results, targets, canonical, projectRoot);
   if (hasHooks) await generateHooksFeature(results, targets, canonical, projectRoot);
@@ -9102,7 +9461,7 @@ async function generate(ctx) {
     canonical,
     projectRoot,
     hasIgnore,
-    (target11) => resolveTargetFeatureGenerator(target11, "ignore", config)
+    (target12) => resolveTargetFeatureGenerator(target12, "ignore", config)
   );
   if (hasMcp || hasIgnore || hasHooks || hasAgents) {
     await generateGeminiSettingsFeature(results, targets, canonical, projectRoot);
@@ -9113,8 +9472,8 @@ async function generate(ctx) {
 }
 
 // src/core/generate/stale-cleanup.ts
-import { readdir as readdir11, rm as rm6 } from "fs/promises";
-import { join as join53, relative as relative20 } from "path";
+import { readdir as readdir12, rm as rm6 } from "fs/promises";
+import { join as join54, relative as relative20 } from "path";
 var TARGET_MANAGED_OUTPUTS = {
   "claude-code": {
     dirs: [".claude/agents", ".claude/commands", ".claude/rules", ".claude/skills"],
@@ -9177,10 +9536,10 @@ var TARGET_MANAGED_OUTPUTS = {
   }
 };
 async function listFiles2(root, base = root) {
-  const entries = await readdir11(root, { withFileTypes: true });
+  const entries = await readdir12(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const abs = join53(root, entry.name);
+    const abs = join54(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFiles2(abs, base));
       continue;
@@ -9191,18 +9550,18 @@ async function listFiles2(root, base = root) {
 }
 async function removeIfStale(projectRoot, relPath, expected) {
   if (expected.has(relPath)) return;
-  const abs = join53(projectRoot, relPath);
+  const abs = join54(projectRoot, relPath);
   if (await exists(abs)) await rm6(abs, { recursive: true, force: true });
 }
 async function cleanupStaleGeneratedOutputs(args) {
   const expected = new Set(args.expectedPaths);
   const stale = /* @__PURE__ */ new Set();
-  for (const target11 of args.targets) {
-    const managed = TARGET_MANAGED_OUTPUTS[target11];
+  for (const target12 of args.targets) {
+    const managed = TARGET_MANAGED_OUTPUTS[target12];
     if (!managed) continue;
     for (const file of managed.files) stale.add(file);
     for (const dir of managed.dirs) {
-      const absDir = join53(args.projectRoot, dir);
+      const absDir = join54(args.projectRoot, dir);
       if (!await exists(absDir)) continue;
       for (const file of await listFiles2(absDir)) {
         stale.add(`${dir}/${file}`.replace(/\/+/g, "/"));
@@ -9215,17 +9574,17 @@ async function cleanupStaleGeneratedOutputs(args) {
 }
 
 // src/core/matrix/matrix.ts
-import { basename as basename30 } from "path";
+import { basename as basename31 } from "path";
 
 // src/targets/catalog/target-catalog.ts
 var TARGET_CATALOG = Object.fromEntries(
-  BUILTIN_TARGETS.map((target11) => [
-    target11.id,
+  BUILTIN_TARGETS.map((target12) => [
+    target12.id,
     {
-      importFrom: target11.generators.importFrom,
-      emptyImportMessage: target11.emptyImportMessage,
-      lintRules: target11.lintRules,
-      capabilities: target11.capabilities
+      importFrom: target12.generators.importFrom,
+      emptyImportMessage: target12.emptyImportMessage,
+      lintRules: target12.lintRules,
+      capabilities: target12.capabilities
     }
   ])
 );
@@ -9252,7 +9611,7 @@ var SUPPORT_MATRIX = Object.fromEntries(
   FEATURE_IDS.map((feature) => [
     feature,
     Object.fromEntries(
-      TARGET_IDS.map((target11) => [target11, TARGET_CATALOG[target11].capabilities[feature]])
+      TARGET_IDS.map((target12) => [target12, TARGET_CATALOG[target12].capabilities[feature]])
     )
   ])
 );
@@ -9358,13 +9717,13 @@ function formatMatrix(rows, targets) {
 function formatVerboseDetails(canonical) {
   const lines = [];
   if (canonical.rules.length > 0) {
-    lines.push(`rules: ${canonical.rules.map((r) => basename30(r.source)).join(", ")}`);
+    lines.push(`rules: ${canonical.rules.map((r) => basename31(r.source)).join(", ")}`);
   }
   if (canonical.commands.length > 0) {
-    lines.push(`commands: ${canonical.commands.map((c2) => basename30(c2.source)).join(", ")}`);
+    lines.push(`commands: ${canonical.commands.map((c2) => basename31(c2.source)).join(", ")}`);
   }
   if (canonical.agents.length > 0) {
-    lines.push(`agents: ${canonical.agents.map((a) => basename30(a.source)).join(", ")}`);
+    lines.push(`agents: ${canonical.agents.map((a) => basename31(a.source)).join(", ")}`);
   }
   if (canonical.skills.length > 0) {
     lines.push(`skills: ${canonical.skills.map((s) => s.name).join(", ")}`);
@@ -9416,11 +9775,11 @@ async function runMatrix(flags, projectRoot) {
 }
 
 // src/cli/commands/generate.ts
-function ensurePathInsideRoot(rootDir, relativePath, target11) {
+function ensurePathInsideRoot(rootDir, relativePath, target12) {
   const rootAbs = resolve4(rootDir);
   const outputAbs = resolve4(rootDir, relativePath);
   if (outputAbs === rootAbs || outputAbs.startsWith(`${rootAbs}${sep}`)) return outputAbs;
-  throw new Error(`Unsafe generated output path for ${target11}: ${relativePath}`);
+  throw new Error(`Unsafe generated output path for ${target12}: ${relativePath}`);
 }
 async function runGenerate(flags, projectRoot, options = {}) {
   if (flags.features !== void 0) {
@@ -9436,7 +9795,7 @@ async function runGenerate(flags, projectRoot, options = {}) {
   const { config, configDir } = await loadConfigFromDir(root);
   const lockFeatures = config.collaboration?.lock_features ?? [];
   if (config.collaboration?.strategy === "lock" && !force && lockFeatures.length > 0) {
-    const abDir = join54(configDir, ".agentsmesh");
+    const abDir = join55(configDir, ".agentsmesh");
     const existingLock = await readLock(abDir);
     if (existingLock !== null) {
       const currentChecksums = await buildChecksums(abDir);
@@ -9472,10 +9831,10 @@ async function runGenerate(flags, projectRoot, options = {}) {
       return 0;
     }
     if (!dryRun) {
-      const abDir = join54(configDir, ".agentsmesh");
+      const abDir = join55(configDir, ".agentsmesh");
       const checksums = await buildChecksums(abDir);
       const extendChecksums = resolvedExtends.length > 0 ? await buildExtendChecksums(resolvedExtends) : {};
-      const packChecksums = await buildPackChecksums(join54(abDir, "packs"));
+      const packChecksums = await buildPackChecksums(join55(abDir, "packs"));
       const generatedBy = process.env["USER"] ?? process.env["USERNAME"] ?? "unknown";
       await writeLock(abDir, {
         generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -9486,7 +9845,7 @@ async function runGenerate(flags, projectRoot, options = {}) {
         packs: packChecksums
       });
       try {
-        await ensureCacheSymlink(getCacheDir(), join54(configDir, ".agentsmeshcache"));
+        await ensureCacheSymlink(getCacheDir(), join55(configDir, ".agentsmeshcache"));
       } catch (err) {
         logger.warn(
           `Could not create .agentsmeshcache symlink: ${err instanceof Error ? err.message : String(err)}`
@@ -9533,10 +9892,10 @@ async function runGenerate(flags, projectRoot, options = {}) {
     } else {
       logger.info(`Nothing changed. (${unchanged} unchanged)`);
     }
-    const abDir = join54(configDir, ".agentsmesh");
+    const abDir = join55(configDir, ".agentsmesh");
     const checksums = await buildChecksums(abDir);
     const extendChecksums = resolvedExtends.length > 0 ? await buildExtendChecksums(resolvedExtends) : {};
-    const packChecksums = await buildPackChecksums(join54(abDir, "packs"));
+    const packChecksums = await buildPackChecksums(join55(abDir, "packs"));
     const generatedBy = process.env["USER"] ?? process.env["USERNAME"] ?? "unknown";
     await writeLock(abDir, {
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -9547,7 +9906,7 @@ async function runGenerate(flags, projectRoot, options = {}) {
       packs: packChecksums
     });
     try {
-      await ensureCacheSymlink(getCacheDir(), join54(configDir, ".agentsmeshcache"));
+      await ensureCacheSymlink(getCacheDir(), join55(configDir, ".agentsmeshcache"));
     } catch (err) {
       logger.warn(
         `Could not create .agentsmeshcache symlink: ${err instanceof Error ? err.message : String(err)}`
@@ -9561,7 +9920,7 @@ async function runGenerate(flags, projectRoot, options = {}) {
 }
 
 // src/cli/commands/init.ts
-import { join as join56 } from "path";
+import { join as join57 } from "path";
 
 // src/cli/commands/init-templates.ts
 var ALL_TARGETS = [
@@ -9717,7 +10076,7 @@ var LOCAL_TEMPLATE = `# Personal overrides \u2014 NOT committed to git
 `;
 
 // src/cli/commands/init-detect.ts
-import { join as join55 } from "path";
+import { join as join56 } from "path";
 var TOOL_INDICATORS = BUILTIN_TARGETS.map((d) => ({
   id: d.id,
   paths: [...d.detectionPaths]
@@ -9726,7 +10085,7 @@ async function detectExistingConfigs(projectRoot) {
   const found = [];
   for (const { id, paths } of TOOL_INDICATORS) {
     for (const p of paths) {
-      const full = join55(projectRoot, p);
+      const full = join56(projectRoot, p);
       if (await exists(full)) {
         found.push(id);
         break;
@@ -9744,7 +10103,7 @@ var IMPORTERS = Object.fromEntries(
   BUILTIN_TARGETS.map((d) => [d.id, (root) => d.generators.importFrom(root)])
 );
 async function appendToGitignore(projectRoot) {
-  const gitignorePath = join56(projectRoot, ".gitignore");
+  const gitignorePath = join57(projectRoot, ".gitignore");
   const current = await readFileSafe(gitignorePath) ?? "";
   const lines = new Set(current.split("\n").map((s) => s.trim()));
   const toAdd = GITIGNORE_ENTRIES.filter((e) => !lines.has(e));
@@ -9753,7 +10112,7 @@ async function appendToGitignore(projectRoot) {
   await writeFileAtomic(gitignorePath, current + suffix + toAdd.join("\n") + "\n");
 }
 async function writeScaffold(projectRoot) {
-  const ab = (rel2) => join56(projectRoot, ".agentsmesh", rel2);
+  const ab = (rel2) => join57(projectRoot, ".agentsmesh", rel2);
   await mkdirp(ab("rules"));
   await writeFileAtomic(ab("rules/_root.md"), TEMPLATE_ROOT_RULE);
   logger.success("Created .agentsmesh/rules/_root.md");
@@ -9778,7 +10137,7 @@ async function writeScaffold(projectRoot) {
   logger.success("Created .agentsmesh/ignore");
 }
 async function runInit(projectRoot, options = {}) {
-  const configPath = join56(projectRoot, CONFIG_FILENAME2);
+  const configPath = join57(projectRoot, CONFIG_FILENAME2);
   if (await exists(configPath)) {
     throw new Error(`Already initialized. ${CONFIG_FILENAME2} exists. Remove it first to re-init.`);
   }
@@ -9815,7 +10174,7 @@ async function runInit(projectRoot, options = {}) {
     await writeFileAtomic(configPath, buildConfig([]));
     logger.success(`Created ${CONFIG_FILENAME2}`);
   }
-  const localPath = join56(projectRoot, LOCAL_CONFIG_FILENAME2);
+  const localPath = join57(projectRoot, LOCAL_CONFIG_FILENAME2);
   await writeFileAtomic(localPath, LOCAL_TEMPLATE);
   logger.success(`Created ${LOCAL_CONFIG_FILENAME2}`);
   await appendToGitignore(projectRoot);
@@ -9834,10 +10193,10 @@ async function runImport(flags, projectRoot) {
   if (!isBuiltinTargetId(normalized)) {
     throw new Error(`Unknown --from "${from}". Supported: ${TARGET_IDS.join(", ")}.`);
   }
-  const target11 = getTargetCatalogEntry(normalized);
-  const results = await target11.importFrom(root);
+  const target12 = getTargetCatalogEntry(normalized);
+  const results = await target12.importFrom(root);
   if (results.length === 0) {
-    logger.info(target11.emptyImportMessage);
+    logger.info(target12.emptyImportMessage);
     return;
   }
   for (const r of results) {
@@ -9922,56 +10281,56 @@ async function runDiff(flags, projectRoot) {
 import { relative as relative22 } from "path";
 
 // src/core/lint/commands.ts
-function lintCommands(canonical, target11) {
+function lintCommands(canonical, target12) {
   if (canonical.commands.length === 0) return [];
   return canonical.commands.flatMap((command) => {
-    if (target11 === "copilot" && command.allowedTools.length > 0) {
+    if (target12 === "copilot" && command.allowedTools.length > 0) {
       return [
         {
           level: "warning",
           file: command.source,
-          target: target11,
+          target: target12,
           message: "Copilot prompt files do not enforce canonical allowed-tools natively."
         }
       ];
     }
-    if (target11 === "cursor" && (command.description.length > 0 || command.allowedTools.length > 0)) {
+    if (target12 === "cursor" && (command.description.length > 0 || command.allowedTools.length > 0)) {
       return [
         {
           level: "warning",
           file: command.source,
-          target: target11,
+          target: target12,
           message: "Cursor command files are plain Markdown; command description and allowed-tools metadata are not projected."
         }
       ];
     }
-    if (target11 === "gemini-cli" && command.allowedTools.length > 0) {
+    if (target12 === "gemini-cli" && command.allowedTools.length > 0) {
       return [
         {
           level: "warning",
           file: command.source,
-          target: target11,
+          target: target12,
           message: "Gemini TOML command files do not project canonical allowed-tools metadata."
         }
       ];
     }
-    if (target11 === "continue" && command.allowedTools.length > 0) {
+    if (target12 === "continue" && command.allowedTools.length > 0) {
       return [
         {
           level: "warning",
           file: command.source,
-          target: target11,
+          target: target12,
           message: "Continue invokable prompt rules do not natively enforce canonical allowed-tools metadata."
         }
       ];
     }
-    if (["cline", "windsurf"].includes(target11) && (command.description.length > 0 || command.allowedTools.length > 0)) {
+    if (["cline", "windsurf"].includes(target12) && (command.description.length > 0 || command.allowedTools.length > 0)) {
       return [
         {
           level: "warning",
           file: command.source,
-          target: target11,
-          message: `${target11} workflow files are plain Markdown; command description and allowed-tools metadata are not projected.`
+          target: target12,
+          message: `${target12} workflow files are plain Markdown; command description and allowed-tools metadata are not projected.`
         }
       ];
     }
@@ -9980,48 +10339,48 @@ function lintCommands(canonical, target11) {
 }
 
 // src/core/lint/mcp.ts
-function lintMcp(canonical, target11) {
+function lintMcp(canonical, target12) {
   if (!canonical.mcp || Object.keys(canonical.mcp.mcpServers).length === 0) return [];
   const diagnostics = [];
   for (const [name, server] of Object.entries(canonical.mcp.mcpServers)) {
-    if (target11 === "cursor" && usesCursorSensitiveInterpolation(server)) {
+    if (target12 === "cursor" && usesCursorSensitiveInterpolation(server)) {
       diagnostics.push({
         level: "warning",
         file: ".agentsmesh/mcp.json",
-        target: target11,
+        target: target12,
         message: `MCP server "${name}" uses env vars or URL/header interpolation; Cursor handling may differ from canonical MCP.`
       });
     }
-    if (target11 === "codex-cli" && typeof server.description === "string" && server.description) {
+    if (target12 === "codex-cli" && typeof server.description === "string" && server.description) {
       diagnostics.push({
         level: "warning",
         file: ".agentsmesh/mcp.json",
-        target: target11,
+        target: target12,
         message: `MCP server "${name}" has a description, but codex-cli does not project MCP descriptions into .codex/config.toml.`
       });
     }
-    if (target11 === "codex-cli" && isUrlMcpServer(server)) {
+    if (target12 === "codex-cli" && isUrlMcpServer(server)) {
       diagnostics.push({
         level: "warning",
         file: ".agentsmesh/mcp.json",
-        target: target11,
+        target: target12,
         message: `MCP server "${name}" uses ${server.type} transport; codex-cli only generates stdio MCP servers.`
       });
     }
-    if (target11 === "junie" && isUrlMcpServer(server)) {
+    if (target12 === "junie" && isUrlMcpServer(server)) {
       diagnostics.push({
         level: "warning",
         file: ".agentsmesh/mcp.json",
-        target: target11,
+        target: target12,
         message: `MCP server "${name}" uses ${server.type} transport; Junie project mcp.json currently documents stdio MCP servers only.`
       });
     }
   }
-  if (target11 === "windsurf") {
+  if (target12 === "windsurf") {
     diagnostics.push({
       level: "warning",
       file: ".agentsmesh/mcp.json",
-      target: target11,
+      target: target12,
       message: "Windsurf MCP is partial; generated .windsurf/mcp_config.example.json is a reference artifact and may require manual setup."
     });
   }
@@ -10029,39 +10388,39 @@ function lintMcp(canonical, target11) {
 }
 
 // src/core/lint/permissions.ts
-function lintPermissions(canonical, target11) {
+function lintPermissions(canonical, target12) {
   if (!canonical.permissions) return [];
-  if (target11 !== "cursor") return [];
+  if (target12 !== "cursor") return [];
   const hasEntries = canonical.permissions.allow.length > 0 || canonical.permissions.deny.length > 0;
   if (!hasEntries) return [];
   return [
     {
       level: "warning",
       file: ".agentsmesh/permissions.yaml",
-      target: target11,
+      target: target12,
       message: "Cursor permissions are partial; tool-level allow/deny may lose fidelity."
     }
   ];
 }
 
 // src/core/lint/hooks.ts
-function lintHooks(canonical, target11) {
+function lintHooks(canonical, target12) {
   if (!canonical.hooks || Object.keys(canonical.hooks).length === 0) return [];
-  if (target11 === "gemini-cli") {
+  if (target12 === "gemini-cli") {
     const supported = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse", "Notification"]);
     return Object.keys(canonical.hooks).filter((event) => !supported.has(event)).map((event) => ({
       level: "warning",
       file: ".agentsmesh/hooks.yaml",
-      target: target11,
+      target: target12,
       message: `${event} is not supported by gemini-cli; only PreToolUse, PostToolUse, and Notification are projected.`
     }));
   }
-  if (target11 === "copilot") {
+  if (target12 === "copilot") {
     const supported = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse", "Notification", "UserPromptSubmit"]);
     return Object.keys(canonical.hooks).filter((event) => !supported.has(event)).map((event) => ({
       level: "warning",
       file: ".agentsmesh/hooks.yaml",
-      target: target11,
+      target: target12,
       message: `${event} is not supported by Copilot hooks; only PreToolUse, PostToolUse, Notification, and UserPromptSubmit are projected.`
     }));
   }
@@ -10087,22 +10446,22 @@ async function runLint(config, canonical, projectRoot, targetFilter) {
   const hasHooks = config.features.includes("hooks");
   const diagnostics = [];
   const projectFiles = await getProjectFiles(projectRoot);
-  for (const target11 of targets) {
-    const linter = isBuiltinTargetId(target11) ? getTargetCatalogEntry(target11).lintRules : null;
+  for (const target12 of targets) {
+    const linter = isBuiltinTargetId(target12) ? getTargetCatalogEntry(target12).lintRules : null;
     if (hasRules && linter) {
       diagnostics.push(...linter(canonical, projectRoot, projectFiles));
     }
     if (hasCommands) {
-      diagnostics.push(...lintCommands(canonical, target11));
+      diagnostics.push(...lintCommands(canonical, target12));
     }
     if (hasMcp) {
-      diagnostics.push(...lintMcp(canonical, target11));
+      diagnostics.push(...lintMcp(canonical, target12));
     }
     if (hasPermissions) {
-      diagnostics.push(...lintPermissions(canonical, target11));
+      diagnostics.push(...lintPermissions(canonical, target12));
     }
     if (hasHooks) {
-      diagnostics.push(...lintHooks(canonical, target11));
+      diagnostics.push(...lintHooks(canonical, target12));
     }
   }
   const hasErrors = diagnostics.some((d) => d.level === "error");
@@ -10142,7 +10501,7 @@ async function runLintCmd(flags, projectRoot) {
 }
 
 // src/cli/commands/watch.ts
-import { join as join57, relative as relative23 } from "path";
+import { join as join58, relative as relative23 } from "path";
 import chokidar from "chokidar";
 var DEBOUNCE_MS = 300;
 function normalizeWatchPath(path) {
@@ -10169,9 +10528,9 @@ async function runWatch(flags, projectRoot) {
   const root = projectRoot ?? process.cwd();
   const { configDir } = await loadConfigFromDir(root);
   const paths = [
-    join57(configDir, ".agentsmesh"),
-    join57(configDir, "agentsmesh.yaml"),
-    join57(configDir, "agentsmesh.local.yaml")
+    join58(configDir, ".agentsmesh"),
+    join58(configDir, "agentsmesh.yaml"),
+    join58(configDir, "agentsmesh.local.yaml")
   ];
   let debounceTimer = null;
   let lastFingerprint = null;
@@ -10257,12 +10616,12 @@ async function runWatch(flags, projectRoot) {
 }
 
 // src/cli/commands/check.ts
-import { join as join58 } from "path";
+import { join as join59 } from "path";
 async function runCheck(flags, projectRoot) {
   void flags;
   const root = projectRoot ?? process.cwd();
   const { config, configDir } = await loadConfigFromDir(root);
-  const abDir = join58(configDir, ".agentsmesh");
+  const abDir = join59(configDir, ".agentsmesh");
   const lock = await readLock(abDir);
   if (lock === null) {
     logger.error("Not initialized for collaboration. Run 'agentsmesh generate' first.");
@@ -10332,14 +10691,14 @@ async function runCheck(flags, projectRoot) {
 }
 
 // src/cli/commands/merge.ts
-import { join as join60 } from "path";
+import { join as join61 } from "path";
 
 // src/core/merger.ts
-import { dirname as dirname22, join as join59 } from "path";
+import { dirname as dirname22, join as join60 } from "path";
 var LOCK_FILENAME2 = ".lock";
 var CONFLICT_MARKER = "<<<<<<<";
 async function hasLockConflict(abDir) {
-  const lockPath = join59(abDir, LOCK_FILENAME2);
+  const lockPath = join60(abDir, LOCK_FILENAME2);
   const content = await readFileSafe(lockPath);
   if (content === null) return false;
   return content.includes(CONFLICT_MARKER);
@@ -10353,7 +10712,7 @@ async function resolveLockConflict(abDir, libVersion, config) {
   const configDir = dirname22(abDir);
   const resolvedExtends = config ? await resolveExtendPaths(config, configDir) : [];
   const extendChecksums = resolvedExtends.length > 0 ? await buildExtendChecksums(resolvedExtends) : {};
-  const packChecksums = await buildPackChecksums(join59(abDir, "packs"));
+  const packChecksums = await buildPackChecksums(join60(abDir, "packs"));
   const generatedBy = process.env["USER"] ?? process.env["USERNAME"] ?? "unknown";
   await writeLock(abDir, {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10370,7 +10729,7 @@ async function runMerge(flags, projectRoot) {
   void flags;
   const root = projectRoot ?? process.cwd();
   const { config, configDir } = await loadConfigFromDir(root);
-  const abDir = join60(configDir, ".agentsmesh");
+  const abDir = join61(configDir, ".agentsmesh");
   const hasConflict = await hasLockConflict(abDir);
   if (!hasConflict) {
     logger.info("No conflicts to resolve.");
@@ -10381,7 +10740,7 @@ async function runMerge(flags, projectRoot) {
 }
 
 // src/install/run/run-install.ts
-import { join as join74 } from "path";
+import { join as join75 } from "path";
 
 // src/install/source/git-pin.ts
 import { execFile as execFile2 } from "child_process";
@@ -10515,7 +10874,7 @@ async function confirm(message) {
 }
 
 // src/install/core/validate-resources.ts
-import { basename as basename31 } from "path";
+import { basename as basename32 } from "path";
 function validateSkill(skill) {
   if (!skill.description.trim()) {
     return { skill, ok: false, reason: "missing description in frontmatter" };
@@ -10541,7 +10900,7 @@ function validateAgent(agent) {
   return { agent, ok: true };
 }
 function ruleSlug6(rule) {
-  return basename31(rule.source).replace(/\.md$/i, "");
+  return basename32(rule.source).replace(/\.md$/i, "");
 }
 
 // src/install/core/pool-resolution.ts
@@ -11035,7 +11394,7 @@ function ensureInstallSelection(args) {
 }
 
 // src/install/core/install-extend-entry.ts
-import { join as join61 } from "path";
+import { join as join62 } from "path";
 
 // src/install/core/merge-extend-entry.ts
 function assertExtendNameAvailable(extendsList, entry) {
@@ -11124,7 +11483,7 @@ async function writeInstallAsExtend(args) {
 ${JSON.stringify(entry, null, 2)}`);
     return;
   }
-  const configPath = join61(configDir, "agentsmesh.yaml");
+  const configPath = join62(configDir, "agentsmesh.yaml");
   await writeAgentsmeshWithNewExtend(configPath, config, entry);
   logger.success(`Wrote extends entry "${entry.name}" to agentsmesh.yaml.`);
 }
@@ -11141,11 +11500,11 @@ function toNewExtendEntry(args) {
 }
 
 // src/install/run/run-install-pack.ts
-import { join as join65 } from "path";
+import { join as join66 } from "path";
 import { rename as rename4 } from "fs/promises";
 
 // src/install/pack/pack-writer.ts
-import { join as join62, basename as basename32, dirname as dirname23 } from "path";
+import { join as join63, basename as basename33, dirname as dirname23 } from "path";
 import { rm as rm7, rename as rename3, mkdir as mkdir5, copyFile as copyFile2 } from "fs/promises";
 import { stringify as yamlStringify6 } from "yaml";
 
@@ -11171,41 +11530,41 @@ async function hashPackContent(packDir) {
 // src/install/pack/pack-writer.ts
 async function writeRules(canonical, packDir) {
   if (canonical.rules.length === 0) return;
-  const rulesDir = join62(packDir, "rules");
+  const rulesDir = join63(packDir, "rules");
   await mkdirp(rulesDir);
   for (const rule of canonical.rules) {
-    const dest = join62(rulesDir, basename32(rule.source));
+    const dest = join63(rulesDir, basename33(rule.source));
     await copyFile2(rule.source, dest);
   }
 }
 async function writeCommands(canonical, packDir) {
   if (canonical.commands.length === 0) return;
-  const dir = join62(packDir, "commands");
+  const dir = join63(packDir, "commands");
   await mkdirp(dir);
   for (const cmd of canonical.commands) {
-    const dest = join62(dir, basename32(cmd.source));
+    const dest = join63(dir, basename33(cmd.source));
     await copyFile2(cmd.source, dest);
   }
 }
 async function writeAgents(canonical, packDir) {
   if (canonical.agents.length === 0) return;
-  const dir = join62(packDir, "agents");
+  const dir = join63(packDir, "agents");
   await mkdirp(dir);
   for (const agent of canonical.agents) {
-    const dest = join62(dir, basename32(agent.source));
+    const dest = join63(dir, basename33(agent.source));
     await copyFile2(agent.source, dest);
   }
 }
 async function writeSkills(canonical, packDir) {
   if (canonical.skills.length === 0) return;
-  const skillsDir = join62(packDir, "skills");
+  const skillsDir = join63(packDir, "skills");
   await mkdirp(skillsDir);
   for (const skill of canonical.skills) {
-    const skillDestDir = join62(skillsDir, skill.name);
+    const skillDestDir = join63(skillsDir, skill.name);
     await mkdirp(skillDestDir);
-    await copyFile2(skill.source, join62(skillDestDir, "SKILL.md"));
+    await copyFile2(skill.source, join63(skillDestDir, "SKILL.md"));
     for (const sf of skill.supportingFiles) {
-      const destPath = join62(skillDestDir, sf.relativePath);
+      const destPath = join63(skillDestDir, sf.relativePath);
       await mkdirp(dirname23(destPath));
       await copyFile2(sf.absolutePath, destPath);
     }
@@ -11213,23 +11572,23 @@ async function writeSkills(canonical, packDir) {
 }
 async function writeSettings(canonical, packDir) {
   if (canonical.mcp !== null) {
-    await writeFileAtomic(join62(packDir, "mcp.json"), `${JSON.stringify(canonical.mcp, null, 2)}
+    await writeFileAtomic(join63(packDir, "mcp.json"), `${JSON.stringify(canonical.mcp, null, 2)}
 `);
   }
   if (canonical.permissions !== null) {
-    await writeFileAtomic(join62(packDir, "permissions.yaml"), yamlStringify6(canonical.permissions));
+    await writeFileAtomic(join63(packDir, "permissions.yaml"), yamlStringify6(canonical.permissions));
   }
   if (canonical.hooks !== null) {
-    await writeFileAtomic(join62(packDir, "hooks.yaml"), yamlStringify6(canonical.hooks));
+    await writeFileAtomic(join63(packDir, "hooks.yaml"), yamlStringify6(canonical.hooks));
   }
   if (canonical.ignore.length > 0) {
-    await writeFileAtomic(join62(packDir, "ignore"), `${canonical.ignore.join("\n")}
+    await writeFileAtomic(join63(packDir, "ignore"), `${canonical.ignore.join("\n")}
 `);
   }
 }
 async function materializePack(packsDir, packName, canonical, metadataInput) {
-  const tmpDir = join62(packsDir, `${packName}.tmp`);
-  const finalDir = join62(packsDir, packName);
+  const tmpDir = join63(packsDir, `${packName}.tmp`);
+  const finalDir = join63(packsDir, packName);
   if (await exists(tmpDir)) {
     await rm7(tmpDir, { recursive: true, force: true });
   }
@@ -11241,7 +11600,7 @@ async function materializePack(packsDir, packName, canonical, metadataInput) {
   await writeSettings(canonical, tmpDir);
   const contentHash = await hashPackContent(tmpDir);
   const metadata = { ...metadataInput, content_hash: contentHash };
-  await writeFileAtomic(join62(tmpDir, "pack.yaml"), yamlStringify6(metadata));
+  await writeFileAtomic(join63(tmpDir, "pack.yaml"), yamlStringify6(metadata));
   if (await exists(finalDir)) {
     await rm7(finalDir, { recursive: true, force: true });
   }
@@ -11251,7 +11610,7 @@ async function materializePack(packsDir, packName, canonical, metadataInput) {
 }
 
 // src/install/pack/pack-merge.ts
-import { join as join63, basename as basename33, dirname as dirname24 } from "path";
+import { join as join64, basename as basename34, dirname as dirname24 } from "path";
 import { copyFile as copyFile3 } from "fs/promises";
 import { stringify as yamlStringify7 } from "yaml";
 function union(a, b) {
@@ -11282,38 +11641,38 @@ function mergePick2(existing, newFeatures, newPick) {
 }
 async function mergeRules(canonical, packDir) {
   if (canonical.rules.length === 0) return;
-  const dir = join63(packDir, "rules");
+  const dir = join64(packDir, "rules");
   await mkdirp(dir);
   for (const rule of canonical.rules) {
-    await copyFile3(rule.source, join63(dir, basename33(rule.source)));
+    await copyFile3(rule.source, join64(dir, basename34(rule.source)));
   }
 }
 async function mergeCommands(canonical, packDir) {
   if (canonical.commands.length === 0) return;
-  const dir = join63(packDir, "commands");
+  const dir = join64(packDir, "commands");
   await mkdirp(dir);
   for (const cmd of canonical.commands) {
-    await copyFile3(cmd.source, join63(dir, basename33(cmd.source)));
+    await copyFile3(cmd.source, join64(dir, basename34(cmd.source)));
   }
 }
 async function mergeAgents(canonical, packDir) {
   if (canonical.agents.length === 0) return;
-  const dir = join63(packDir, "agents");
+  const dir = join64(packDir, "agents");
   await mkdirp(dir);
   for (const agent of canonical.agents) {
-    await copyFile3(agent.source, join63(dir, basename33(agent.source)));
+    await copyFile3(agent.source, join64(dir, basename34(agent.source)));
   }
 }
 async function mergeSkills(canonical, packDir) {
   if (canonical.skills.length === 0) return;
-  const skillsDir = join63(packDir, "skills");
+  const skillsDir = join64(packDir, "skills");
   await mkdirp(skillsDir);
   for (const skill of canonical.skills) {
-    const destDir = join63(skillsDir, skill.name);
+    const destDir = join64(skillsDir, skill.name);
     await mkdirp(destDir);
-    await copyFile3(skill.source, join63(destDir, "SKILL.md"));
+    await copyFile3(skill.source, join64(destDir, "SKILL.md"));
     for (const sf of skill.supportingFiles) {
-      const destPath = join63(destDir, sf.relativePath);
+      const destPath = join64(destDir, sf.relativePath);
       await mkdirp(dirname24(destPath));
       await copyFile3(sf.absolutePath, destPath);
     }
@@ -11321,17 +11680,17 @@ async function mergeSkills(canonical, packDir) {
 }
 async function mergeSettings(canonical, packDir) {
   if (canonical.mcp !== null) {
-    await writeFileAtomic(join63(packDir, "mcp.json"), `${JSON.stringify(canonical.mcp, null, 2)}
+    await writeFileAtomic(join64(packDir, "mcp.json"), `${JSON.stringify(canonical.mcp, null, 2)}
 `);
   }
   if (canonical.permissions !== null) {
-    await writeFileAtomic(join63(packDir, "permissions.yaml"), yamlStringify7(canonical.permissions));
+    await writeFileAtomic(join64(packDir, "permissions.yaml"), yamlStringify7(canonical.permissions));
   }
   if (canonical.hooks !== null) {
-    await writeFileAtomic(join63(packDir, "hooks.yaml"), yamlStringify7(canonical.hooks));
+    await writeFileAtomic(join64(packDir, "hooks.yaml"), yamlStringify7(canonical.hooks));
   }
   if (canonical.ignore.length > 0) {
-    await writeFileAtomic(join63(packDir, "ignore"), `${canonical.ignore.join("\n")}
+    await writeFileAtomic(join64(packDir, "ignore"), `${canonical.ignore.join("\n")}
 `);
   }
 }
@@ -11358,12 +11717,12 @@ async function mergeIntoPack(packDir, existingMeta, newCanonical, newFeatures, n
     updated_at: updatedAt,
     content_hash: contentHash
   };
-  await writeFileAtomic(join63(packDir, "pack.yaml"), yamlStringify7(updatedMeta));
+  await writeFileAtomic(join64(packDir, "pack.yaml"), yamlStringify7(updatedMeta));
   return updatedMeta;
 }
 
 // src/install/core/install-manifest.ts
-import { join as join64 } from "path";
+import { join as join65 } from "path";
 import { parse as parseYaml8, stringify as yamlStringify8 } from "yaml";
 import { z as z4 } from "zod";
 var installManifestEntrySchema = z4.object({
@@ -11389,7 +11748,7 @@ function sameInstallIdentity(a, b) {
   return a.source === b.source && a.target === b.target && a.as === b.as && sameFeatures2(a.features, b.features);
 }
 function manifestPath(configDir) {
-  return join64(configDir, ".agentsmesh", "installs.yaml");
+  return join65(configDir, ".agentsmesh", "installs.yaml");
 }
 async function readInstallManifest(configDir) {
   const content = await readFileSafe(manifestPath(configDir));
@@ -11462,7 +11821,7 @@ async function installAsPack(args) {
     manualAs,
     renameExistingPack
   } = args;
-  const packsDir = join65(configDir, ".agentsmesh", "packs");
+  const packsDir = join66(configDir, ".agentsmesh", "packs");
   const selectedCanonical = applySelection(narrowed, selected);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const parsedTarget = yamlTarget !== void 0 ? targetSchema.parse(yamlTarget) : void 0;
@@ -11480,7 +11839,7 @@ async function installAsPack(args) {
     let packDir = existingPack.packDir;
     let packMeta = existingPack.meta;
     if (renameExistingPack && existingPack.name !== packName) {
-      const nextDir = join65(packsDir, packName);
+      const nextDir = join66(packsDir, packName);
       if (await exists(nextDir)) {
         throw new Error(
           `Auto-generated pack name "${packName}" collides with an existing incompatible pack. Use --name to choose a different pack name.`
@@ -11511,7 +11870,7 @@ async function installAsPack(args) {
     persistedPaths = mergedMeta.paths;
     logger.success(`Updated pack "${mergedMeta.name}" in .agentsmesh/packs/.`);
   } else {
-    const collidingMeta = await readPackMetadata(join65(packsDir, packName));
+    const collidingMeta = await readPackMetadata(join66(packsDir, packName));
     if (collidingMeta) {
       throw new Error(
         `Auto-generated pack name "${packName}" collides with an existing incompatible pack. Use --name to choose a different pack name.`
@@ -11553,7 +11912,7 @@ async function installAsPack(args) {
 }
 
 // src/install/run/install-sync.ts
-import { join as join66 } from "path";
+import { join as join67 } from "path";
 async function syncInstalledPacks(args) {
   const installs = await readInstallManifest(args.configDir);
   if (installs.length === 0) {
@@ -11562,7 +11921,7 @@ async function syncInstalledPacks(args) {
   }
   const missing = [];
   for (const entry of installs) {
-    const packDir = join66(args.configDir, ".agentsmesh", "packs", entry.name);
+    const packDir = join67(args.configDir, ".agentsmesh", "packs", entry.name);
     if (!await exists(packDir)) {
       missing.push(entry);
     }
@@ -11740,7 +12099,7 @@ function narrowDiscoveredForInstallScope(canonical, options) {
 }
 
 // src/install/manual/manual-install-scope.ts
-import { basename as basename34, dirname as dirname25, join as join67, relative as relative27 } from "path";
+import { basename as basename35, dirname as dirname25, join as join68, relative as relative27 } from "path";
 import { cp as cp2, mkdtemp, stat as stat5, rm as rm8 } from "fs/promises";
 import { tmpdir } from "os";
 
@@ -11800,9 +12159,9 @@ async function cpFilteredSkill(sourceRoot, destDir) {
 
 // src/install/manual/manual-install-scope.ts
 async function createStageRoot() {
-  const stageBase = await mkdtemp(join67(tmpdir(), "am-install-manual-"));
-  const discoveryRoot = join67(stageBase, "repo");
-  await mkdirp(join67(discoveryRoot, ".agentsmesh"));
+  const stageBase = await mkdtemp(join68(tmpdir(), "am-install-manual-"));
+  const discoveryRoot = join68(stageBase, "repo");
+  await mkdirp(join68(discoveryRoot, ".agentsmesh"));
   return {
     discoveryRoot,
     cleanup: async () => {
@@ -11817,7 +12176,7 @@ async function stageMarkdownCollection(sourceRoot, destinationDir) {
       throw new Error(`Manual install only supports .md files for this collection: ${sourceRoot}`);
     }
     await mkdirp(destinationDir);
-    await cp2(sourceRoot, join67(destinationDir, basename34(sourceRoot)));
+    await cp2(sourceRoot, join68(destinationDir, basename35(sourceRoot)));
     return;
   }
   const files = (await readDirRecursive(sourceRoot)).filter(
@@ -11829,7 +12188,7 @@ async function stageMarkdownCollection(sourceRoot, destinationDir) {
   const usedNames = /* @__PURE__ */ new Map();
   await mkdirp(destinationDir);
   for (const file of files) {
-    const name = basename34(file);
+    const name = basename35(file);
     const previous = usedNames.get(name);
     if (previous) {
       throw new Error(
@@ -11837,7 +12196,7 @@ async function stageMarkdownCollection(sourceRoot, destinationDir) {
       );
     }
     usedNames.set(name, file);
-    await cp2(file, join67(destinationDir, name));
+    await cp2(file, join68(destinationDir, name));
   }
 }
 async function stagePreferredSkills(sourceRoot, destinationDir, preferredSkillNames) {
@@ -11849,7 +12208,7 @@ async function stagePreferredSkills(sourceRoot, destinationDir, preferredSkillNa
   for (const file of await readDirRecursive(sourceRoot)) {
     if (!file.endsWith("/SKILL.md") && !file.endsWith("\\SKILL.md")) continue;
     const skillDir = dirname25(file);
-    const skillName = basename34(skillDir);
+    const skillName = basename35(skillDir);
     if (!wanted.has(skillName)) continue;
     const previous = matches.get(skillName);
     if (previous && previous !== skillDir) {
@@ -11862,30 +12221,30 @@ async function stagePreferredSkills(sourceRoot, destinationDir, preferredSkillNa
   if (matches.size !== preferredSkillNames.length) return false;
   await mkdirp(destinationDir);
   for (const skillName of preferredSkillNames) {
-    await cp2(matches.get(skillName), join67(destinationDir, skillName), { recursive: true });
+    await cp2(matches.get(skillName), join68(destinationDir, skillName), { recursive: true });
   }
   return true;
 }
 async function stageSkills(sourceRoot, destinationDir, options = {}) {
   const info = await stat5(sourceRoot);
   if (info.isFile()) {
-    if (basename34(sourceRoot) !== "SKILL.md") {
+    if (basename35(sourceRoot) !== "SKILL.md") {
       throw new Error(`Manual skill install expects SKILL.md or a skill directory: ${sourceRoot}`);
     }
-    const skillName = basename34(dirname25(sourceRoot));
-    const skillDir = join67(destinationDir, skillName);
+    const skillName = basename35(dirname25(sourceRoot));
+    const skillDir = join68(destinationDir, skillName);
     await mkdirp(skillDir);
     await cp2(dirname25(sourceRoot), skillDir, { recursive: true });
     return;
   }
   if (await isSkillPackLayout(sourceRoot)) {
-    if ((await stat5(join67(sourceRoot, "SKILL.md")).catch(() => null))?.isFile()) {
+    if ((await stat5(join68(sourceRoot, "SKILL.md")).catch(() => null))?.isFile()) {
       if (await stagePreferredSkills(sourceRoot, destinationDir, options.preferredSkillNames ?? [])) {
         return;
       }
-      const fmName = await readSkillFrontmatterName(join67(sourceRoot, "SKILL.md"));
-      const skillName = fmName || basename34(sourceRoot);
-      const skillDir = join67(destinationDir, skillName);
+      const fmName = await readSkillFrontmatterName(join68(sourceRoot, "SKILL.md"));
+      const skillName = fmName || basename35(sourceRoot);
+      const skillDir = join68(destinationDir, skillName);
       await mkdirp(destinationDir);
       await cpFilteredSkill(sourceRoot, skillDir);
       return;
@@ -11902,7 +12261,7 @@ async function stageSkills(sourceRoot, destinationDir, options = {}) {
       roots.add(relative27(sourceRoot, dirname25(file)).split(/[\\/]/)[0]);
     }
     for (const root of roots) {
-      await cp2(join67(sourceRoot, root), join67(destinationDir, root), { recursive: true });
+      await cp2(join68(sourceRoot, root), join68(destinationDir, root), { recursive: true });
     }
     return;
   }
@@ -11913,7 +12272,7 @@ async function stageSkills(sourceRoot, destinationDir, options = {}) {
 async function stageManualInstallScope(sourceRoot, as, options = {}) {
   const staged = await createStageRoot();
   try {
-    const destDir = join67(staged.discoveryRoot, ".agentsmesh", as);
+    const destDir = join68(staged.discoveryRoot, ".agentsmesh", as);
     if (as === "skills") {
       await stageSkills(sourceRoot, destDir, options);
     } else {
@@ -11947,7 +12306,7 @@ async function resolveManualDiscoveredForInstall(sourceRoot, explicitAs, explici
 }
 
 // src/install/core/prepare-install-discovery.ts
-import { join as join72 } from "path";
+import { join as join73 } from "path";
 
 // src/install/native/native-path-pick.ts
 var PATH_PREFIX_TO_TARGET = [
@@ -11985,14 +12344,14 @@ function norm(p) {
 function targetHintFromNativePath(pathInRepoPosix) {
   const p = norm(pathInRepoPosix);
   const sorted = [...PATH_PREFIX_TO_TARGET].sort((a, b) => b.prefix.length - a.prefix.length);
-  for (const { prefix, target: target11 } of sorted) {
-    if (p === prefix || p.startsWith(`${prefix}/`)) return target11;
+  for (const { prefix, target: target12 } of sorted) {
+    if (p === prefix || p.startsWith(`${prefix}/`)) return target12;
   }
   return void 0;
 }
-function pathSupportsNativePick(pathInRepoPosix, target11) {
+function pathSupportsNativePick(pathInRepoPosix, target12) {
   const hint = targetHintFromNativePath(pathInRepoPosix);
-  return hint === target11;
+  return hint === target12;
 }
 function validateTargetMatchesPath(explicitTarget, pathInRepoPosix) {
   if (!explicitTarget || !pathInRepoPosix) return;
@@ -12008,13 +12367,13 @@ function extendPickHasArrays(p) {
 }
 
 // src/install/native/native-path-pick-infer.ts
-import { basename as basename37, join as join70 } from "path";
+import { basename as basename38, join as join71 } from "path";
 
 // src/install/native/gemini-install-commands.ts
-import { join as join68, relative as relative28 } from "path";
+import { join as join69, relative as relative28 } from "path";
 async function inferGeminiCommandNamesFromFiles(repoRoot, pathInRepoPosix) {
-  const commandsRoot = join68(repoRoot, ...GEMINI_COMMANDS_DIR.split("/"));
-  const scanDir = join68(repoRoot, ...pathInRepoPosix.split("/"));
+  const commandsRoot = join69(repoRoot, ...GEMINI_COMMANDS_DIR.split("/"));
+  const scanDir = join69(repoRoot, ...pathInRepoPosix.split("/"));
   const files = await readDirRecursive(scanDir);
   const names = [];
   for (const f of files) {
@@ -12029,32 +12388,32 @@ async function inferGeminiCommandNamesFromFiles(repoRoot, pathInRepoPosix) {
 }
 
 // src/install/native/native-skill-scan.ts
-import { basename as basename35, dirname as dirname26, relative as relative29 } from "path";
+import { basename as basename36, dirname as dirname26, relative as relative29 } from "path";
 async function skillNamesFromNativeSkillDir(scanRoot) {
   const files = await readDirRecursive(scanRoot);
   const names = /* @__PURE__ */ new Set();
   for (const f of files) {
-    if (basename35(f) === "SKILL.md") {
-      names.add(basename35(dirname26(f)));
+    if (basename36(f) === "SKILL.md") {
+      names.add(basename36(dirname26(f)));
       continue;
     }
     const rel2 = relative29(scanRoot, f).replace(/\\/g, "/");
     if (!rel2.includes("/") && f.toLowerCase().endsWith(".md")) {
-      names.add(basename35(f, ".md"));
+      names.add(basename36(f, ".md"));
     }
   }
   return [...names].filter(Boolean).sort();
 }
 
 // src/install/native/native-path-pick-infer-copilot.ts
-import { basename as basename36, join as join69 } from "path";
+import { basename as basename37, join as join70 } from "path";
 async function inferCopilotPickFromPath(repoRoot, posixPath) {
-  const scan = join69(repoRoot, ...posixPath.split("/"));
+  const scan = join70(repoRoot, ...posixPath.split("/"));
   if (posixPath.startsWith(COPILOT_PROMPTS_DIR)) {
     const files = await readDirRecursive(scan);
     const commands = [
       ...new Set(
-        files.filter((f) => f.toLowerCase().endsWith(".prompt.md")).map((f) => basename36(f, ".prompt.md"))
+        files.filter((f) => f.toLowerCase().endsWith(".prompt.md")).map((f) => basename37(f, ".prompt.md"))
       )
     ].sort();
     return commands.length ? { commands } : {};
@@ -12063,7 +12422,7 @@ async function inferCopilotPickFromPath(repoRoot, posixPath) {
     const files = await readDirRecursive(scan);
     const rules = [
       ...new Set(
-        files.filter((f) => f.includes(".instructions.md")).map((f) => basename36(f).replace(/\.instructions\.md$/i, ""))
+        files.filter((f) => f.includes(".instructions.md")).map((f) => basename37(f).replace(/\.instructions\.md$/i, ""))
       )
     ].sort();
     return rules.length ? { rules } : {};
@@ -12072,10 +12431,10 @@ async function inferCopilotPickFromPath(repoRoot, posixPath) {
     const files = await readDirRecursive(scan);
     const names = /* @__PURE__ */ new Set();
     for (const f of files) {
-      const b = basename36(f);
+      const b = basename37(f);
       if (b.toLowerCase().endsWith(".instructions.md"))
         names.add(b.replace(/\.instructions\.md$/i, ""));
-      else if (b.toLowerCase().endsWith(".md")) names.add(basename36(f, ".md"));
+      else if (b.toLowerCase().endsWith(".md")) names.add(basename37(f, ".md"));
     }
     const rules = [...names].sort();
     return rules.length ? { rules } : {};
@@ -12088,7 +12447,7 @@ async function inferCopilotPickFromPath(repoRoot, posixPath) {
     const files = await readDirRecursive(scan);
     const agents = [
       ...new Set(
-        files.filter((f) => f.toLowerCase().endsWith(".agent.md")).map((f) => basename36(f, ".agent.md"))
+        files.filter((f) => f.toLowerCase().endsWith(".agent.md")).map((f) => basename37(f, ".agent.md"))
       )
     ].sort();
     return agents.length ? { agents } : {};
@@ -12101,20 +12460,20 @@ async function mdNames(dir, ext) {
   const files = await readDirRecursive(dir);
   const e = ext.toLowerCase();
   return [
-    ...new Set(files.filter((f) => f.toLowerCase().endsWith(e)).map((f) => basename37(f, ext)))
+    ...new Set(files.filter((f) => f.toLowerCase().endsWith(e)).map((f) => basename38(f, ext)))
   ].sort();
 }
-async function inferImplicitPickFromNativePath(repoRoot, pathInRepoPosix, target11) {
+async function inferImplicitPickFromNativePath(repoRoot, pathInRepoPosix, target12) {
   const posixPath = pathInRepoPosix.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
-  const scan = join70(repoRoot, ...posixPath.split("/"));
-  if (target11 === "gemini-cli") {
+  const scan = join71(repoRoot, ...posixPath.split("/"));
+  if (target12 === "gemini-cli") {
     if (posixPath === GEMINI_COMMANDS_DIR || posixPath.startsWith(`${GEMINI_COMMANDS_DIR}/`)) {
       const commands = await inferGeminiCommandNamesFromFiles(repoRoot, posixPath);
       return commands.length ? { commands } : {};
     }
     return {};
   }
-  if (target11 === "claude-code") {
+  if (target12 === "claude-code") {
     if (posixPath.startsWith(".claude/commands")) {
       const commands = await mdNames(scan, ".md");
       return commands.length ? { commands } : {};
@@ -12134,7 +12493,7 @@ async function inferImplicitPickFromNativePath(repoRoot, pathInRepoPosix, target
     }
     return {};
   }
-  if (target11 === "cursor") {
+  if (target12 === "cursor") {
     if (posixPath.startsWith(".cursor/rules")) {
       const rules = await mdNames(scan, ".mdc");
       return rules.length ? { rules } : {};
@@ -12153,14 +12512,14 @@ async function inferImplicitPickFromNativePath(repoRoot, pathInRepoPosix, target
     }
     return {};
   }
-  if (target11 === "copilot") {
+  if (target12 === "copilot") {
     return inferCopilotPickFromPath(repoRoot, posixPath);
   }
-  if (target11 === "windsurf" && posixPath.startsWith(".windsurf/rules")) {
+  if (target12 === "windsurf" && posixPath.startsWith(".windsurf/rules")) {
     const rules = await mdNames(scan, ".md");
     return rules.length ? { rules } : {};
   }
-  if (target11 === "cline") {
+  if (target12 === "cline") {
     if (posixPath.startsWith(CLINE_SKILLS_DIR)) {
       const skills = await skillNamesFromNativeSkillDir(scan);
       return skills.length ? { skills } : {};
@@ -12171,7 +12530,7 @@ async function inferImplicitPickFromNativePath(repoRoot, pathInRepoPosix, target
     }
     return {};
   }
-  if (target11 === "continue") {
+  if (target12 === "continue") {
     if (posixPath.startsWith(".continue/rules")) {
       const rules = await mdNames(scan, ".md");
       return rules.length ? { rules } : {};
@@ -12186,7 +12545,7 @@ async function inferImplicitPickFromNativePath(repoRoot, pathInRepoPosix, target
     }
     return {};
   }
-  if (target11 === "junie") {
+  if (target12 === "junie") {
     if (posixPath.startsWith(".junie/commands")) {
       const commands = await mdNames(scan, ".md");
       return commands.length ? { commands } : {};
@@ -12205,11 +12564,11 @@ async function inferImplicitPickFromNativePath(repoRoot, pathInRepoPosix, target
     }
     return {};
   }
-  if (target11 === "codex-cli" && posixPath.startsWith(".codex")) {
+  if (target12 === "codex-cli" && posixPath.startsWith(".codex")) {
     const files = await readDirRecursive(scan);
     const rules = [
       ...new Set(
-        files.filter((f) => f.toLowerCase().endsWith(".md")).map((f) => basename37(f, ".md"))
+        files.filter((f) => f.toLowerCase().endsWith(".md")).map((f) => basename38(f, ".md"))
       )
     ].sort();
     return rules.length ? { rules } : {};
@@ -12221,7 +12580,7 @@ function isImplicitPickEmpty(p) {
 }
 
 // src/install/native/native-install-scope.ts
-import { basename as basename38, join as join71, relative as relative30 } from "path";
+import { basename as basename39, join as join72, relative as relative30 } from "path";
 import { cp as cp3, mkdtemp as mkdtemp2, rm as rm9 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 function normalizePath3(path) {
@@ -12232,14 +12591,14 @@ function overlapsPath(requested, imported) {
   const b = normalizePath3(imported);
   return a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
 }
-function addUnique(target11, value) {
-  const next = target11 ?? [];
+function addUnique(target12, value) {
+  const next = target12 ?? [];
   if (!next.includes(value)) next.push(value);
   return next;
 }
 async function makeStageRoot(repoRoot) {
-  const stageBase = await mkdtemp2(join71(tmpdir2(), "am-install-native-"));
-  const stageRoot = join71(stageBase, "repo");
+  const stageBase = await mkdtemp2(join72(tmpdir2(), "am-install-native-"));
+  const stageRoot = join72(stageBase, "repo");
   const cleanup = async () => {
     await rm9(stageBase, { recursive: true, force: true });
   };
@@ -12257,13 +12616,13 @@ function buildPickFromResults(results, stageRoot) {
     if (result.feature === "rules" && result.toPath.startsWith(".agentsmesh/rules/")) {
       pick = {
         ...pick,
-        rules: addUnique(pick?.rules, basename38(result.toPath, ".md"))
+        rules: addUnique(pick?.rules, basename39(result.toPath, ".md"))
       };
       continue;
     }
     if (result.feature === "commands" && result.toPath.startsWith(".agentsmesh/commands/")) {
       const rel2 = normalizePath3(
-        relative30(join71(stageRoot, ".agentsmesh", "commands"), join71(stageRoot, result.toPath))
+        relative30(join72(stageRoot, ".agentsmesh", "commands"), join72(stageRoot, result.toPath))
       );
       pick = {
         ...pick,
@@ -12277,13 +12636,13 @@ function buildPickFromResults(results, stageRoot) {
     if (result.feature === "agents" && result.toPath.startsWith(".agentsmesh/agents/")) {
       pick = {
         ...pick,
-        agents: addUnique(pick?.agents, basename38(result.toPath, ".md"))
+        agents: addUnique(pick?.agents, basename39(result.toPath, ".md"))
       };
       continue;
     }
     if (result.feature === "skills" && result.toPath.startsWith(".agentsmesh/skills/")) {
       const rel2 = normalizePath3(
-        relative30(join71(stageRoot, ".agentsmesh", "skills"), join71(stageRoot, result.toPath))
+        relative30(join72(stageRoot, ".agentsmesh", "skills"), join72(stageRoot, result.toPath))
       );
       const skillName = rel2.split("/")[0];
       if (skillName) {
@@ -12298,12 +12657,12 @@ function buildPickFromResults(results, stageRoot) {
   const hasAny = (pick.rules?.length ?? 0) + (pick.commands?.length ?? 0) + (pick.agents?.length ?? 0) + (pick.skills?.length ?? 0) > 0;
   return hasAny ? pick : void 0;
 }
-function scopeImportedResults(pathInRepoPosix, stageRoot, results, target11) {
-  const requestedPath = join71(stageRoot, ...normalizePath3(pathInRepoPosix).split("/"));
+function scopeImportedResults(pathInRepoPosix, stageRoot, results, target12) {
+  const requestedPath = join72(stageRoot, ...normalizePath3(pathInRepoPosix).split("/"));
   const filtered = results.filter((result) => overlapsPath(requestedPath, result.fromPath));
   if (filtered.length === 0) {
     throw new Error(
-      `No installable native resources found under "${pathInRepoPosix}" for target "${target11}".`
+      `No installable native resources found under "${pathInRepoPosix}" for target "${target12}".`
     );
   }
   return {
@@ -12311,23 +12670,23 @@ function scopeImportedResults(pathInRepoPosix, stageRoot, results, target11) {
     pick: buildPickFromResults(filtered, stageRoot)
   };
 }
-async function stageImportedNativeRepo(repoRoot, target11) {
+async function stageImportedNativeRepo(repoRoot, target12) {
   const { stageRoot, cleanup } = await makeStageRoot(repoRoot);
   try {
-    const results = await importNativeToCanonical(stageRoot, target11);
+    const results = await importNativeToCanonical(stageRoot, target12);
     return { stageRoot, results, cleanup };
   } catch (error) {
     await cleanup();
     throw error;
   }
 }
-async function stageNativeInstallScope(repoRoot, pathInRepoPosix, target11) {
-  const staged = await stageImportedNativeRepo(repoRoot, target11);
+async function stageNativeInstallScope(repoRoot, pathInRepoPosix, target12) {
+  const staged = await stageImportedNativeRepo(repoRoot, target12);
   try {
     return {
       stageRoot: staged.stageRoot,
       cleanup: staged.cleanup,
-      ...scopeImportedResults(pathInRepoPosix, staged.stageRoot, staged.results, target11)
+      ...scopeImportedResults(pathInRepoPosix, staged.stageRoot, staged.results, target12)
     };
   } catch (error) {
     await staged.cleanup();
@@ -12343,7 +12702,7 @@ async function prepareInstallDiscovery(repoRoot, contentRoot, pathInRepo, option
   }
   const posixPath = pathInRepo.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
   validateTargetMatchesPath(explicitTarget, posixPath);
-  const agentsmeshAtRoot = join72(repoRoot, ".agentsmesh");
+  const agentsmeshAtRoot = join73(repoRoot, ".agentsmesh");
   const hasAbRoot = await exists(agentsmeshAtRoot);
   const pathHint = posixPath ? targetHintFromNativePath(posixPath) : void 0;
   const detectedTarget = !hasAbRoot && !explicitTarget ? await detectNativeFormat(repoRoot) ?? void 0 : void 0;
@@ -12368,7 +12727,7 @@ async function prepareInstallDiscovery(repoRoot, contentRoot, pathInRepo, option
     }
     const staged = await stageImportedNativeRepo(repoRoot, effectiveTarget);
     return {
-      discoveryRoot: posixPath ? join72(staged.stageRoot, posixPath) : staged.stageRoot,
+      discoveryRoot: posixPath ? join73(staged.stageRoot, posixPath) : staged.stageRoot,
       yamlTarget: effectiveTarget,
       importHappened: true,
       cleanup: staged.cleanup
@@ -12471,13 +12830,13 @@ function applyReplayInstallScope(narrowed, discoveredFeatures, replay) {
 }
 
 // src/install/manual/manual-install-persistence.ts
-import { basename as basename39, dirname as dirname27, join as join73 } from "path";
+import { basename as basename40, dirname as dirname27, join as join74 } from "path";
 import { stat as stat6 } from "fs/promises";
 function trimDot(pathInRepo) {
   return pathInRepo === "." || pathInRepo === "" ? void 0 : pathInRepo;
 }
 function markdownPick(as, pathValue) {
-  const name = basename39(pathValue).replace(/\.md$/i, "");
+  const name = basename40(pathValue).replace(/\.md$/i, "");
   if (as === "agents") return { agents: [name] };
   if (as === "commands") return { commands: [name] };
   return { rules: [name] };
@@ -12495,23 +12854,23 @@ async function resolveManualInstallPersistence(args) {
     };
   }
   if (args.as === "skills") {
-    if (info.isFile() && basename39(args.contentRoot) === "SKILL.md") {
+    if (info.isFile() && basename40(args.contentRoot) === "SKILL.md") {
       const skillDir = normalizedPath ? dirname27(normalizedPath) : dirname27(args.contentRoot);
       return {
         pathInRepo: trimDot(dirname27(skillDir)),
-        pick: { skills: [basename39(skillDir)] }
+        pick: { skills: [basename40(skillDir)] }
       };
     }
     if (info.isDirectory()) {
-      const skillDir = normalizedPath || basename39(args.contentRoot);
-      const skillFile = join73(args.contentRoot.replace(/\/+$/g, ""), "SKILL.md");
+      const skillDir = normalizedPath || basename40(args.contentRoot);
+      const skillFile = join74(args.contentRoot.replace(/\/+$/g, ""), "SKILL.md");
       try {
         const skillStat = await stat6(skillFile);
         if (skillStat.isFile()) {
           const fmName = await readSkillFrontmatterName(skillFile);
           return {
             pathInRepo: trimDot(dirname27(skillDir)),
-            pick: { skills: [fmName || basename39(skillDir)] }
+            pick: { skills: [fmName || basename40(skillDir)] }
           };
         }
       } catch {
@@ -12579,7 +12938,7 @@ async function runInstall(flags, args, projectRoot, replay) {
     sourceArg
   );
   const pathInRepo = parsed.pathInRepo.replace(/^\/+|\/+$/g, "");
-  const contentRoot = pathInRepo ? join74(resolvedPath, pathInRepo) : resolvedPath;
+  const contentRoot = pathInRepo ? join75(resolvedPath, pathInRepo) : resolvedPath;
   if (!await exists(contentRoot)) {
     throw new Error(`Install path does not exist: ${contentRoot}`);
   }