agentsmesh 0.2.1 → 0.2.3

package/dist/cli.js

@@ -406,6 +406,7 @@ import { normalize as normalizePath } from "path";
 import { basename as basename2 } from "path";
 
 // src/targets/junie/constants.ts
+var JUNIE_TARGET = "junie";
 var JUNIE_DIR = ".junie";
 var JUNIE_GUIDELINES = `${JUNIE_DIR}/guidelines.md`;
 var JUNIE_CI_GUIDELINES = `${JUNIE_DIR}/ci-guidelines.md`;
@@ -418,6 +419,12 @@ var JUNIE_RULES_DIR = `${JUNIE_DIR}/rules`;
 var JUNIE_COMMANDS_DIR = `${JUNIE_DIR}/commands`;
 var JUNIE_AGENTS_DIR = `${JUNIE_DIR}/agents`;
 var JUNIE_IGNORE = ".aiignore";
+var JUNIE_CANONICAL_ROOT_RULE = ".agentsmesh/rules/_root.md";
+var JUNIE_CANONICAL_RULES_DIR = ".agentsmesh/rules";
+var JUNIE_CANONICAL_COMMANDS_DIR = ".agentsmesh/commands";
+var JUNIE_CANONICAL_AGENTS_DIR = ".agentsmesh/agents";
+var JUNIE_CANONICAL_MCP = ".agentsmesh/mcp.json";
+var JUNIE_CANONICAL_IGNORE = ".agentsmesh/ignore";
 
 // src/core/import-reference-map-shared.ts
 import { basename, dirname as dirname3, join as join3, relative } from "path";
@@ -775,6 +782,9 @@ async function buildCodexCliImportPaths(refs, projectRoot) {
   refs.set("AGENTS.md", `${AB_RULES2}/_root.md`);
   refs.set("codex.md", `${AB_RULES2}/_root.md`);
   await addScopedAgentsMappings(refs, projectRoot);
+  for (const absPath of await listFiles(projectRoot, ".codex/instructions")) {
+    addSimpleFileMapping(refs, rel(projectRoot, absPath), AB_RULES2, ".md");
+  }
   for (const absPath of await listFiles(projectRoot, ".codex/rules")) {
     const relPath = rel(projectRoot, absPath);
     if (relPath.endsWith(".rules")) {
@@ -1107,6 +1117,69 @@ init_markdown();
 // src/targets/import-metadata.ts
 import { basename as basename3 } from "path";
 init_markdown();
+
+// src/targets/root-instruction-paragraph.ts
+var ROOT_INSTRUCTION_BODY_LEGACY = "AgentsMesh is a config sync library for AI coding tools. The only canonical source of truth is `.agentsmesh/`; files emitted into target formats such as `AGENTS.md`, `.claude/`, `.cursor/`, `.junie/`, and similar directories are generated artifacts. When making changes, edit canonical config first, then regenerate and verify the target outputs. Preserve the library's bidirectional contract: import native tool config into canonical form, generate back to target-specific layouts, and keep projected or embedded features round-trippable rather than treating them as plain text exports.";
+var ROOT_INSTRUCTION_BODY = "AgentsMesh is a config sync library for AI coding tools. The only canonical source of truth is the `.agentsmesh` directory at the project root; files emitted into target formats such as `AGENTS.md`, `.claude/`, `.cursor/`, `.junie/`, and similar directories are generated artifacts. When making changes, edit canonical config first, then regenerate and verify the target outputs. Preserve the library's bidirectional contract: import native tool config into canonical form, generate back to target-specific layouts, and keep projected or embedded features round-trippable rather than treating them as plain text exports.";
+var LEGACY_AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH = ROOT_INSTRUCTION_BODY_LEGACY;
+var LEGACY_AGENTSMESH_ROOT_INSTRUCTION_SECTION = `## Project-Specific Rules
+
+${ROOT_INSTRUCTION_BODY_LEGACY}`;
+var AGENTSMESH_CONTRACT_WITH_LEGACY_BODY = `## AgentsMesh Generation Contract
+
+${ROOT_INSTRUCTION_BODY_LEGACY}`;
+var AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH = `## AgentsMesh Generation Contract
+
+${ROOT_INSTRUCTION_BODY}`;
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function appendAgentsmeshRootInstructionParagraph(content) {
+  const trimmed = content.trim();
+  if (normalizeWhitespace(trimmed).includes(
+    normalizeWhitespace(AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH)
+  )) {
+    return trimmed;
+  }
+  if (normalizeWhitespace(trimmed).includes(
+    normalizeWhitespace(LEGACY_AGENTSMESH_ROOT_INSTRUCTION_SECTION)
+  )) {
+    return trimmed.replace(
+      LEGACY_AGENTSMESH_ROOT_INSTRUCTION_SECTION,
+      AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH
+    );
+  }
+  if (normalizeWhitespace(trimmed).includes(normalizeWhitespace(AGENTSMESH_CONTRACT_WITH_LEGACY_BODY))) {
+    return trimmed.replace(
+      AGENTSMESH_CONTRACT_WITH_LEGACY_BODY,
+      AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH
+    );
+  }
+  if (normalizeWhitespace(trimmed).includes(
+    normalizeWhitespace(LEGACY_AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH)
+  )) {
+    return trimmed.replace(
+      LEGACY_AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH,
+      AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH
+    );
+  }
+  return trimmed ? `${trimmed}
+
+${AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH}` : AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH;
+}
+function stripAgentsmeshRootInstructionParagraph(content) {
+  return content.replace(`
+
+${AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH}`, "").replace(`
+
+${AGENTSMESH_CONTRACT_WITH_LEGACY_BODY}`, "").replace(`
+
+${LEGACY_AGENTSMESH_ROOT_INSTRUCTION_SECTION}`, "").replace(`
+
+${LEGACY_AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH}`, "").trim();
+}
+
+// src/targets/import-metadata.ts
 function toStringArray3(value) {
   if (Array.isArray(value)) {
     return value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
@@ -1135,11 +1208,12 @@ function serializeCanonicalRuleFrontmatter(destinationPath, frontmatter) {
 }
 async function serializeImportedRuleWithFallback(destinationPath, importedFrontmatter, body) {
   const existingFrontmatter = await readExistingFrontmatter(destinationPath);
+  const normalizedBody = basename3(destinationPath, ".md") === "_root" ? stripAgentsmeshRootInstructionParagraph(body) : body.trim();
   const mergedFrontmatter = serializeCanonicalRuleFrontmatter(
     destinationPath,
     pruneUndefined({ ...existingFrontmatter, ...importedFrontmatter })
   );
-  return serializeFrontmatter(mergedFrontmatter, body.trim() || "");
+  return serializeFrontmatter(mergedFrontmatter, normalizedBody || "");
 }
 async function serializeImportedCommandWithFallback(destinationPath, imported, body) {
   const existingFrontmatter = await readExistingFrontmatter(destinationPath);
@@ -1191,16 +1265,35 @@ async function importFileDirectory(opts) {
 // src/targets/claude-code/importer-mappers.ts
 init_markdown();
 import { basename as basename4, join as join5 } from "path";
-var AB_RULES3 = ".agentsmesh/rules";
-var AB_COMMANDS3 = ".agentsmesh/commands";
-var AB_AGENTS3 = ".agentsmesh/agents";
+
+// src/targets/claude-code/constants.ts
+var CLAUDE_CODE_TARGET = "claude-code";
+var CLAUDE_ROOT = ".claude/CLAUDE.md";
+var CLAUDE_LEGACY_ROOT = "CLAUDE.md";
+var CLAUDE_RULES_DIR = ".claude/rules";
+var CLAUDE_COMMANDS_DIR = ".claude/commands";
+var CLAUDE_AGENTS_DIR = ".claude/agents";
+var CLAUDE_SKILLS_DIR = ".claude/skills";
+var CLAUDE_SETTINGS = ".claude/settings.json";
+var CLAUDE_IGNORE = ".claudeignore";
+var CLAUDE_MCP_JSON = ".mcp.json";
+var CLAUDE_CANONICAL_RULES_DIR = ".agentsmesh/rules";
+var CLAUDE_CANONICAL_COMMANDS_DIR = ".agentsmesh/commands";
+var CLAUDE_CANONICAL_AGENTS_DIR = ".agentsmesh/agents";
+var CLAUDE_CANONICAL_SKILLS_DIR = ".agentsmesh/skills";
+var CLAUDE_CANONICAL_MCP = ".agentsmesh/mcp.json";
+var CLAUDE_CANONICAL_PERMISSIONS = ".agentsmesh/permissions.yaml";
+var CLAUDE_CANONICAL_HOOKS = ".agentsmesh/hooks.yaml";
+var CLAUDE_CANONICAL_IGNORE = ".agentsmesh/ignore";
+
+// src/targets/claude-code/importer-mappers.ts
 async function mapClaudeRuleFile(srcPath, destDir, normalizeTo) {
   const name = basename4(srcPath, ".md");
   const destPath = join5(destDir, `${name}.md`);
   const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
   return {
     destPath,
-    toPath: `${AB_RULES3}/${name}.md`,
+    toPath: `${CLAUDE_CANONICAL_RULES_DIR}/${name}.md`,
     feature: "rules",
     content: await serializeImportedRuleWithFallback(
       destPath,
@@ -1212,7 +1305,7 @@ async function mapClaudeRuleFile(srcPath, destDir, normalizeTo) {
 function mapClaudeMarkdownFile(srcPath, destDir, feature, normalizeTo) {
   const name = basename4(srcPath, ".md");
   const destPath = join5(destDir, `${name}.md`);
-  const basePath = feature === "commands" ? AB_COMMANDS3 : AB_AGENTS3;
+  const basePath = feature === "commands" ? CLAUDE_CANONICAL_COMMANDS_DIR : CLAUDE_CANONICAL_AGENTS_DIR;
   return {
     destPath,
     toPath: `${basePath}/${name}.md`,
@@ -1248,11 +1341,6 @@ function hasHookText(entry) {
 
 // src/targets/claude-code/settings-helpers.ts
 import { stringify as yamlStringify2 } from "yaml";
-var CLAUDE_SETTINGS = ".claude/settings.json";
-var CLAUDE_MCP_JSON = ".mcp.json";
-var AB_MCP = ".agentsmesh/mcp.json";
-var AB_PERMISSIONS = ".agentsmesh/permissions.yaml";
-var AB_HOOKS = ".agentsmesh/hooks.yaml";
 function claudeHooksToCanonical(hooks) {
   const result = {};
   for (const [event, entries] of Object.entries(hooks)) {
@@ -1289,13 +1377,13 @@ async function importMcpJson(projectRoot, results) {
   }
   if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
     const mcpContent = JSON.stringify({ mcpServers: parsed.mcpServers }, null, 2);
-    const destPath = join6(projectRoot, AB_MCP);
+    const destPath = join6(projectRoot, CLAUDE_CANONICAL_MCP);
     await mkdirp(dirname5(destPath));
     await writeFileAtomic(destPath, mcpContent);
     results.push({
       fromTool: "claude-code",
       fromPath: mcpPath,
-      toPath: AB_MCP,
+      toPath: CLAUDE_CANONICAL_MCP,
       feature: "mcp"
     });
   }
@@ -1313,13 +1401,13 @@ async function importSettings(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 = join6(projectRoot, AB_MCP);
+    const destPath = join6(projectRoot, CLAUDE_CANONICAL_MCP);
     await mkdirp(dirname5(destPath));
     await writeFileAtomic(destPath, mcpContent);
     results.push({
       fromTool: "claude-code",
       fromPath: settingsPath,
-      toPath: AB_MCP,
+      toPath: CLAUDE_CANONICAL_MCP,
       feature: "mcp"
     });
   }
@@ -1330,13 +1418,13 @@ async function importSettings(projectRoot, results) {
     const deny = Array.isArray(perms.deny) ? perms.deny.filter((s) => typeof s === "string") : [];
     if (allow.length > 0 || deny.length > 0) {
       const permContent = yamlStringify2({ allow, deny });
-      const destPath = join6(projectRoot, AB_PERMISSIONS);
+      const destPath = join6(projectRoot, CLAUDE_CANONICAL_PERMISSIONS);
       await mkdirp(dirname5(destPath));
       await writeFileAtomic(destPath, permContent);
       results.push({
         fromTool: "claude-code",
         fromPath: settingsPath,
-        toPath: AB_PERMISSIONS,
+        toPath: CLAUDE_CANONICAL_PERMISSIONS,
         feature: "permissions"
       });
     }
@@ -1346,13 +1434,13 @@ async function importSettings(projectRoot, results) {
     const canonicalHooks = claudeHooksToCanonical(rawHooks);
     if (Object.keys(canonicalHooks).length > 0) {
       const hooksContent = yamlStringify2(canonicalHooks);
-      const destPath = join6(projectRoot, AB_HOOKS);
+      const destPath = join6(projectRoot, CLAUDE_CANONICAL_HOOKS);
       await mkdirp(dirname5(destPath));
       await writeFileAtomic(destPath, hooksContent);
       results.push({
         fromTool: "claude-code",
         fromPath: settingsPath,
-        toPath: AB_HOOKS,
+        toPath: CLAUDE_CANONICAL_HOOKS,
         feature: "hooks"
       });
     }
@@ -1360,18 +1448,6 @@ async function importSettings(projectRoot, results) {
 }
 
 // src/targets/claude-code/importer.ts
-var CLAUDE_MD = ".claude/CLAUDE.md";
-var CLAUDE_MD_LEGACY = "CLAUDE.md";
-var CLAUDE_RULES_DIR = ".claude/rules";
-var CLAUDE_COMMANDS_DIR = ".claude/commands";
-var CLAUDE_AGENTS_DIR = ".claude/agents";
-var CLAUDE_SKILLS_DIR = ".claude/skills";
-var CLAUDEIGNORE = ".claudeignore";
-var AB_RULES4 = ".agentsmesh/rules";
-var AB_COMMANDS4 = ".agentsmesh/commands";
-var AB_AGENTS4 = ".agentsmesh/agents";
-var AB_SKILLS2 = ".agentsmesh/skills";
-var AB_IGNORE = ".agentsmesh/ignore";
 async function importFromClaudeCode(projectRoot) {
   const results = [];
   const normalize = await createImportReferenceNormalizer("claude-code", projectRoot);
@@ -1385,10 +1461,10 @@ async function importFromClaudeCode(projectRoot) {
   return results;
 }
 async function importRules(projectRoot, results, normalize) {
-  const destDir = join7(projectRoot, AB_RULES4);
-  const primaryClaudePath = join7(projectRoot, CLAUDE_MD);
+  const destDir = join7(projectRoot, CLAUDE_CANONICAL_RULES_DIR);
+  const primaryClaudePath = join7(projectRoot, CLAUDE_ROOT);
   const primaryContent = await readFileSafe(primaryClaudePath);
-  const legacyClaudePath = join7(projectRoot, CLAUDE_MD_LEGACY);
+  const legacyClaudePath = join7(projectRoot, CLAUDE_LEGACY_ROOT);
   const legacyContent = primaryContent === null ? await readFileSafe(legacyClaudePath) : null;
   const claudeContent = primaryContent ?? legacyContent;
   const claudePath = primaryContent !== null ? primaryClaudePath : legacyClaudePath;
@@ -1403,7 +1479,7 @@ async function importRules(projectRoot, results, normalize) {
     results.push({
       fromTool: "claude-code",
       fromPath: claudePath,
-      toPath: `${AB_RULES4}/_root.md`,
+      toPath: `${CLAUDE_CANONICAL_RULES_DIR}/_root.md`,
       feature: "rules"
     });
   }
@@ -1420,7 +1496,7 @@ async function importRules(projectRoot, results, normalize) {
   );
 }
 async function importCommands(projectRoot, results, normalize) {
-  const destDir = join7(projectRoot, AB_COMMANDS4);
+  const destDir = join7(projectRoot, CLAUDE_CANONICAL_COMMANDS_DIR);
   const commandsDir = join7(projectRoot, CLAUDE_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
@@ -1434,7 +1510,7 @@ async function importCommands(projectRoot, results, normalize) {
   );
 }
 async function importAgents(projectRoot, results, normalize) {
-  const destDir = join7(projectRoot, AB_AGENTS4);
+  const destDir = join7(projectRoot, CLAUDE_CANONICAL_AGENTS_DIR);
   const agentsDir = join7(projectRoot, CLAUDE_AGENTS_DIR);
   results.push(
     ...await importFileDirectory({
@@ -1449,7 +1525,7 @@ async function importAgents(projectRoot, results, normalize) {
 }
 async function importSkills(projectRoot, results, normalize) {
   const skillsBaseDir = join7(projectRoot, CLAUDE_SKILLS_DIR);
-  const destBase = join7(projectRoot, AB_SKILLS2);
+  const destBase = join7(projectRoot, CLAUDE_CANONICAL_SKILLS_DIR);
   const allFiles = await readDirRecursive(skillsBaseDir);
   const skillMdFiles = allFiles.filter((f) => f.endsWith("SKILL.md"));
   for (const skillMdPath of skillMdFiles) {
@@ -1464,7 +1540,7 @@ async function importSkills(projectRoot, results, normalize) {
       const destPath = join7(destSkillDir, relPath);
       await mkdirp(dirname6(destPath));
       await writeFileAtomic(destPath, normalize(fileContent, filePath, destPath));
-      const toPath = `${AB_SKILLS2}/${skillName}/${relPath}`;
+      const toPath = `${CLAUDE_CANONICAL_SKILLS_DIR}/${skillName}/${relPath}`;
       results.push({
         fromTool: "claude-code",
         fromPath: filePath,
@@ -1475,16 +1551,16 @@ async function importSkills(projectRoot, results, normalize) {
   }
 }
 async function importIgnore(projectRoot, results) {
-  const ignorePath = join7(projectRoot, CLAUDEIGNORE);
+  const ignorePath = join7(projectRoot, CLAUDE_IGNORE);
   const content = await readFileSafe(ignorePath);
   if (content === null) return;
-  const destPath = join7(projectRoot, AB_IGNORE);
+  const destPath = join7(projectRoot, CLAUDE_CANONICAL_IGNORE);
   await mkdirp(dirname6(destPath));
   await writeFileAtomic(destPath, content);
   results.push({
     fromTool: "claude-code",
     fromPath: ignorePath,
-    toPath: AB_IGNORE,
+    toPath: CLAUDE_CANONICAL_IGNORE,
     feature: "ignore"
   });
 }
@@ -1525,9 +1601,23 @@ function toStringRecord(value) {
   );
 }
 
+// src/targets/cline/constants.ts
+var CLINE_TARGET = "cline";
+var CLINE_RULES_DIR = ".clinerules";
+var CLINE_IGNORE = ".clineignore";
+var CLINE_MCP_SETTINGS = ".cline/mcp_settings.json";
+var CLINE_SKILLS_DIR = ".cline/skills";
+var CLINE_WORKFLOWS_DIR = ".clinerules/workflows";
+var CLINE_AGENTS_MD = "AGENTS.md";
+var CLINE_HOOKS_DIR = ".clinerules/hooks";
+var CLINE_CANONICAL_RULES_DIR = ".agentsmesh/rules";
+var CLINE_CANONICAL_COMMANDS_DIR = ".agentsmesh/commands";
+var CLINE_CANONICAL_IGNORE = ".agentsmesh/ignore";
+var CLINE_CANONICAL_MCP = ".agentsmesh/mcp.json";
+var CLINE_CANONICAL_AGENTS_DIR = ".agentsmesh/agents";
+var CLINE_CANONICAL_SKILLS_DIR = ".agentsmesh/skills";
+
 // src/targets/cline/importer-mappers.ts
-var AGENTSMESH_RULES = ".agentsmesh/rules";
-var AGENTSMESH_COMMANDS = ".agentsmesh/commands";
 async function mapClineRuleFile(srcPath, destDir, normalizeTo) {
   if (srcPath.includes("/workflows/")) return null;
   const name = basename6(srcPath, ".md");
@@ -1545,7 +1635,7 @@ async function mapClineRuleFile(srcPath, destDir, normalizeTo) {
   });
   return {
     destPath,
-    toPath: `${AGENTSMESH_RULES}/${name}.md`,
+    toPath: `${CLINE_CANONICAL_RULES_DIR}/${name}.md`,
     feature: "rules",
     content: await serializeImportedRuleWithFallback(destPath, canonicalFm, body)
   };
@@ -1574,7 +1664,7 @@ async function mapClineWorkflowFile(srcPath, destDir, normalizeTo) {
   }
   return {
     destPath,
-    toPath: `${AGENTSMESH_COMMANDS}/${name}.md`,
+    toPath: `${CLINE_CANONICAL_COMMANDS_DIR}/${name}.md`,
     feature: "commands",
     content: await serializeImportedCommandWithFallback(
       destPath,
@@ -1589,18 +1679,8 @@ async function mapClineWorkflowFile(srcPath, destDir, normalizeTo) {
   };
 }
 
-// src/targets/cline/constants.ts
-var CLINE_RULES_DIR = ".clinerules";
-var CLINE_IGNORE = ".clineignore";
-var CLINE_MCP_SETTINGS = ".cline/mcp_settings.json";
-var CLINE_SKILLS_DIR = ".cline/skills";
-var CLINE_WORKFLOWS_DIR = ".clinerules/workflows";
-var CLINE_AGENTS_MD = "AGENTS.md";
-var CLINE_HOOKS_DIR = ".clinerules/hooks";
-
 // src/targets/cline/mcp-mapper.ts
 import { join as join9 } from "path";
-var AGENTSMESH_MCP = ".agentsmesh/mcp.json";
 function mapClineServerToCanonical(raw) {
   if (!raw || typeof raw !== "object") return null;
   const obj = raw;
@@ -1642,13 +1722,13 @@ async function importClineMcp(projectRoot, results) {
     if (Object.keys(mcpServers).length > 0) {
       await mkdirp(join9(projectRoot, ".agentsmesh"));
       await writeFileAtomic(
-        join9(projectRoot, AGENTSMESH_MCP),
+        join9(projectRoot, CLINE_CANONICAL_MCP),
         JSON.stringify({ mcpServers }, null, 2)
       );
       results.push({
-        fromTool: "cline",
+        fromTool: CLINE_TARGET,
         fromPath: mcpPath,
-        toPath: AGENTSMESH_MCP,
+        toPath: CLINE_CANONICAL_MCP,
         feature: "mcp"
       });
     }
@@ -1659,8 +1739,6 @@ async function importClineMcp(projectRoot, results) {
 import { readdir as readdir2 } from "fs/promises";
 import { join as join10 } from "path";
 init_markdown();
-var AGENTSMESH_AGENTS = ".agentsmesh/agents";
-var AGENTSMESH_SKILLS = ".agentsmesh/skills";
 async function importClineSkills(projectRoot, results, normalize) {
   const skillsDir = join10(projectRoot, CLINE_SKILLS_DIR);
   const skillDirs = [];
@@ -1683,7 +1761,7 @@ async function importClineSkills(projectRoot, results, normalize) {
     const rawParsed = parseFrontmatter(content);
     const projectedAgent = parseProjectedAgentSkillFrontmatter(rawParsed.frontmatter, name);
     if (projectedAgent) {
-      const destAgentsDir = join10(projectRoot, AGENTSMESH_AGENTS);
+      const destAgentsDir = join10(projectRoot, CLINE_CANONICAL_AGENTS_DIR);
       await mkdirp(destAgentsDir);
       const agentPath = join10(destAgentsDir, `${projectedAgent.name}.md`);
       await writeFileAtomic(
@@ -1691,17 +1769,17 @@ async function importClineSkills(projectRoot, results, normalize) {
         serializeImportedAgent(projectedAgent, normalize(rawParsed.body, skillMdPath, agentPath))
       );
       results.push({
-        fromTool: "cline",
+        fromTool: CLINE_TARGET,
         fromPath: skillMdPath,
-        toPath: `${AGENTSMESH_AGENTS}/${projectedAgent.name}.md`,
+        toPath: `${CLINE_CANONICAL_AGENTS_DIR}/${projectedAgent.name}.md`,
         feature: "agents"
       });
       continue;
     }
-    const destSkillPath = join10(projectRoot, AGENTSMESH_SKILLS, name, "SKILL.md");
+    const destSkillPath = join10(projectRoot, CLINE_CANONICAL_SKILLS_DIR, name, "SKILL.md");
     const normalized = normalize(content, skillMdPath, destSkillPath);
     const { frontmatter, body } = parseFrontmatter(normalized);
-    const destSkillDir = join10(projectRoot, AGENTSMESH_SKILLS, name);
+    const destSkillDir = join10(projectRoot, CLINE_CANONICAL_SKILLS_DIR, name);
     await mkdirp(destSkillDir);
     const canonicalFm = {
       description: typeof frontmatter.description === "string" ? frontmatter.description : void 0
@@ -1710,9 +1788,9 @@ async function importClineSkills(projectRoot, results, normalize) {
     const skillContent = Object.keys(canonicalFm).length > 0 ? serializeFrontmatter(canonicalFm, body.trim() || "") : body.trim() || "";
     await writeFileAtomic(destSkillPath, skillContent);
     results.push({
-      fromTool: "cline",
+      fromTool: CLINE_TARGET,
       fromPath: skillMdPath,
-      toPath: `${AGENTSMESH_SKILLS}/${name}/SKILL.md`,
+      toPath: `${CLINE_CANONICAL_SKILLS_DIR}/${name}/SKILL.md`,
       feature: "skills"
     });
     const allFiles = await readDirRecursive(skillPath);
@@ -1725,9 +1803,9 @@ async function importClineSkills(projectRoot, results, normalize) {
       await mkdirp(join10(destSupportPath, ".."));
       await writeFileAtomic(destSupportPath, normalize(supportContent, absPath, destSupportPath));
       results.push({
-        fromTool: "cline",
+        fromTool: CLINE_TARGET,
         fromPath: absPath,
-        toPath: `${AGENTSMESH_SKILLS}/${name}/${relPath}`,
+        toPath: `${CLINE_CANONICAL_SKILLS_DIR}/${name}/${relPath}`,
         feature: "skills"
       });
     }
@@ -1735,13 +1813,10 @@ async function importClineSkills(projectRoot, results, normalize) {
 }
 
 // src/targets/cline/importer.ts
-var AGENTSMESH_RULES2 = ".agentsmesh/rules";
-var AGENTSMESH_COMMANDS2 = ".agentsmesh/commands";
-var AGENTSMESH_IGNORE = ".agentsmesh/ignore";
 async function importFromCline(projectRoot) {
   const results = [];
-  const normalize = await createImportReferenceNormalizer("cline", projectRoot);
-  const destRulesDir = join11(projectRoot, AGENTSMESH_RULES2);
+  const normalize = await createImportReferenceNormalizer(CLINE_TARGET, projectRoot);
+  const destRulesDir = join11(projectRoot, CLINE_CANONICAL_RULES_DIR);
   const clineRulesPath = join11(projectRoot, CLINE_RULES_DIR);
   const clineRulesRaw = join11(projectRoot, CLINE_RULES_DIR);
   let clineRulesIsFile = false;
@@ -1765,7 +1840,7 @@ async function importFromCline(projectRoot) {
       results.push({
         fromTool: "cline",
         fromPath: clineRulesRaw,
-        toPath: `${AGENTSMESH_RULES2}/_root.md`,
+        toPath: `${CLINE_CANONICAL_RULES_DIR}/_root.md`,
         feature: "rules"
       });
     }
@@ -1774,7 +1849,7 @@ async function importFromCline(projectRoot) {
     const rootPath = join11(clineRulesPath, "_root.md");
     const rootContent = await readFileSafe(rootPath);
     if (rootContent === null) {
-      const agentsMdPath = join11(projectRoot, "AGENTS.md");
+      const agentsMdPath = join11(projectRoot, CLINE_AGENTS_MD);
       const agentsMdContent = await readFileSafe(agentsMdPath);
       if (agentsMdContent !== null) {
         rootSourcePath = agentsMdPath;
@@ -1790,7 +1865,7 @@ async function importFromCline(projectRoot) {
         results.push({
           fromTool: "cline",
           fromPath: agentsMdPath,
-          toPath: `${AGENTSMESH_RULES2}/_root.md`,
+          toPath: `${CLINE_CANONICAL_RULES_DIR}/_root.md`,
           feature: "rules"
         });
       } else {
@@ -1811,7 +1886,7 @@ async function importFromCline(projectRoot) {
             results.push({
               fromTool: "cline",
               fromPath: first,
-              toPath: `${AGENTSMESH_RULES2}/_root.md`,
+              toPath: `${CLINE_CANONICAL_RULES_DIR}/_root.md`,
               feature: "rules"
             });
           }
@@ -1829,7 +1904,7 @@ async function importFromCline(projectRoot) {
       results.push({
         fromTool: "cline",
         fromPath: rootPath,
-        toPath: `${AGENTSMESH_RULES2}/_root.md`,
+        toPath: `${CLINE_CANONICAL_RULES_DIR}/_root.md`,
         feature: "rules"
       });
     }
@@ -1858,18 +1933,18 @@ async function importFromCline(projectRoot) {
     }
     if (patterns.length > 0) {
       await mkdirp(join11(projectRoot, ".agentsmesh"));
-      const destIgnorePath = join11(projectRoot, AGENTSMESH_IGNORE);
+      const destIgnorePath = join11(projectRoot, CLINE_CANONICAL_IGNORE);
       await writeFileAtomic(destIgnorePath, patterns.join("\n"));
       results.push({
         fromTool: "cline",
         fromPath: ignorePath,
-        toPath: AGENTSMESH_IGNORE,
+        toPath: CLINE_CANONICAL_IGNORE,
         feature: "ignore"
       });
     }
   }
   await importClineMcp(projectRoot, results);
-  const destCommandsDir = join11(projectRoot, AGENTSMESH_COMMANDS2);
+  const destCommandsDir = join11(projectRoot, CLINE_CANONICAL_COMMANDS_DIR);
   if (!clineRulesIsFile) {
     results.push(
       ...await importFileDirectory({
@@ -1893,9 +1968,31 @@ init_markdown();
 // src/targets/cursor/importer-mappers.ts
 init_markdown();
 import { basename as basename7, join as join12 } from "path";
-var AB_RULES5 = ".agentsmesh/rules";
-var AB_COMMANDS5 = ".agentsmesh/commands";
-var AB_AGENTS5 = ".agentsmesh/agents";
+
+// src/targets/cursor/constants.ts
+var CURSOR_TARGET = "cursor";
+var CURSOR_COMPAT_AGENTS = "AGENTS.md";
+var CURSOR_LEGACY_RULES = ".cursorrules";
+var CURSOR_RULES_DIR = ".cursor/rules";
+var CURSOR_GENERAL_RULE = `${CURSOR_RULES_DIR}/general.mdc`;
+var CURSOR_COMMANDS_DIR = ".cursor/commands";
+var CURSOR_AGENTS_DIR = ".cursor/agents";
+var CURSOR_SKILLS_DIR = ".cursor/skills";
+var CURSOR_MCP = ".cursor/mcp.json";
+var CURSOR_HOOKS = ".cursor/hooks.json";
+var CURSOR_SETTINGS = ".cursor/settings.json";
+var CURSOR_IGNORE = ".cursorignore";
+var CURSOR_INDEXING_IGNORE = ".cursorindexingignore";
+var CURSOR_CANONICAL_RULES_DIR = ".agentsmesh/rules";
+var CURSOR_CANONICAL_COMMANDS_DIR = ".agentsmesh/commands";
+var CURSOR_CANONICAL_AGENTS_DIR = ".agentsmesh/agents";
+var CURSOR_CANONICAL_SKILLS_DIR = ".agentsmesh/skills";
+var CURSOR_CANONICAL_MCP = ".agentsmesh/mcp.json";
+var CURSOR_CANONICAL_PERMISSIONS = ".agentsmesh/permissions.yaml";
+var CURSOR_CANONICAL_HOOKS = ".agentsmesh/hooks.yaml";
+var CURSOR_CANONICAL_IGNORE = ".agentsmesh/ignore";
+
+// src/targets/cursor/importer-mappers.ts
 async function mapCursorRuleFile(srcPath, destDir, normalizeTo, onRootRule) {
   const name = basename7(srcPath, ".mdc");
   const destPath = join12(destDir, `${name}.md`);
@@ -1906,7 +2003,7 @@ async function mapCursorRuleFile(srcPath, destDir, normalizeTo, onRootRule) {
   delete canonicalFm.alwaysApply;
   return {
     destPath,
-    toPath: `${AB_RULES5}/${name}.md`,
+    toPath: `${CURSOR_CANONICAL_RULES_DIR}/${name}.md`,
     feature: "rules",
     content: await serializeImportedRuleWithFallback(destPath, canonicalFm, body)
   };
@@ -1919,7 +2016,7 @@ async function mapCursorCommandFile(srcPath, destDir, normalizeTo) {
   const allowedTools = fromCamel.length > 0 ? fromCamel : toToolsArray(frontmatter["allowed-tools"]);
   return {
     destPath,
-    toPath: `${AB_COMMANDS5}/${name}.md`,
+    toPath: `${CURSOR_CANONICAL_COMMANDS_DIR}/${name}.md`,
     feature: "commands",
     content: await serializeImportedCommandWithFallback(
       destPath,
@@ -1938,7 +2035,7 @@ function mapCursorAgentFile(srcPath, destDir, normalizeTo) {
   const destPath = join12(destDir, `${name}.md`);
   return {
     destPath,
-    toPath: `${AB_AGENTS5}/${name}.md`,
+    toPath: `${CURSOR_CANONICAL_AGENTS_DIR}/${name}.md`,
     feature: "agents",
     content: normalizeTo(destPath)
   };
@@ -1947,13 +2044,6 @@ function mapCursorAgentFile(srcPath, destDir, normalizeTo) {
 // src/targets/cursor/settings-helpers.ts
 import { join as join13, dirname as dirname7 } from "path";
 import { stringify as yamlStringify3 } from "yaml";
-var CURSOR_SETTINGS = ".cursor/settings.json";
-var CURSOR_HOOKS = ".cursor/hooks.json";
-var CURSORIGNORE = ".cursorignore";
-var CURSORINDEXINGIGNORE = ".cursorindexingignore";
-var AB_PERMISSIONS2 = ".agentsmesh/permissions.yaml";
-var AB_HOOKS2 = ".agentsmesh/hooks.yaml";
-var AB_IGNORE2 = ".agentsmesh/ignore";
 function cursorHooksToCanonical(hooks) {
   const result = {};
   for (const [event, entries] of Object.entries(hooks)) {
@@ -1989,13 +2079,13 @@ async function importSettings2(projectRoot, results) {
         const canonical = cursorHooksToCanonical(hooksFile.hooks);
         if (Object.keys(canonical).length > 0) {
           const hooksContent = yamlStringify3(canonical);
-          const destPath = join13(projectRoot, AB_HOOKS2);
+          const destPath = join13(projectRoot, CURSOR_CANONICAL_HOOKS);
           await mkdirp(dirname7(destPath));
           await writeFileAtomic(destPath, hooksContent);
           results.push({
             fromTool: "cursor",
             fromPath: hooksJsonPath,
-            toPath: AB_HOOKS2,
+            toPath: CURSOR_CANONICAL_HOOKS,
             feature: "hooks"
           });
           hooksImportedFromHooksJson = true;
@@ -2020,13 +2110,13 @@ 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 = yamlStringify3({ allow, deny });
-      const destPath = join13(projectRoot, AB_PERMISSIONS2);
+      const destPath = join13(projectRoot, CURSOR_CANONICAL_PERMISSIONS);
       await mkdirp(dirname7(destPath));
       await writeFileAtomic(destPath, permContent);
       results.push({
         fromTool: "cursor",
         fromPath: settingsPath,
-        toPath: AB_PERMISSIONS2,
+        toPath: CURSOR_CANONICAL_PERMISSIONS,
         feature: "permissions"
       });
     }
@@ -2036,13 +2126,13 @@ async function importSettings2(projectRoot, results) {
     const canonicalHooks = cursorHooksToCanonical(rawHooks);
     if (Object.keys(canonicalHooks).length > 0) {
       const hooksContent = yamlStringify3(canonicalHooks);
-      const destPath = join13(projectRoot, AB_HOOKS2);
+      const destPath = join13(projectRoot, CURSOR_CANONICAL_HOOKS);
       await mkdirp(dirname7(destPath));
       await writeFileAtomic(destPath, hooksContent);
       results.push({
         fromTool: "cursor",
         fromPath: settingsPath,
-        toPath: AB_HOOKS2,
+        toPath: CURSOR_CANONICAL_HOOKS,
         feature: "hooks"
       });
     }
@@ -2050,8 +2140,8 @@ async function importSettings2(projectRoot, results) {
 }
 async function importIgnore2(projectRoot, results) {
   const sources = [
-    { path: join13(projectRoot, CURSORIGNORE), label: CURSORIGNORE },
-    { path: join13(projectRoot, CURSORINDEXINGIGNORE), label: CURSORINDEXINGIGNORE }
+    { path: join13(projectRoot, CURSOR_IGNORE), label: CURSOR_IGNORE },
+    { path: join13(projectRoot, CURSOR_INDEXING_IGNORE), label: CURSOR_INDEXING_IGNORE }
   ];
   const patterns = [];
   const importedFrom = [];
@@ -2067,23 +2157,21 @@ async function importIgnore2(projectRoot, results) {
     }
   }
   if (patterns.length === 0) return;
-  const destPath = join13(projectRoot, AB_IGNORE2);
+  const destPath = join13(projectRoot, CURSOR_CANONICAL_IGNORE);
   await mkdirp(dirname7(destPath));
   await writeFileAtomic(destPath, patterns.join("\n") + "\n");
   results.push({
     fromTool: "cursor",
     fromPath: join13(projectRoot, importedFrom[0]),
-    toPath: AB_IGNORE2,
+    toPath: CURSOR_CANONICAL_IGNORE,
     feature: "ignore"
   });
 }
 
 // src/targets/cursor/skills-helpers.ts
 import { join as join14, basename as basename8, dirname as dirname8, relative as relative3 } from "path";
-var CURSOR_SKILLS_DIR = ".cursor/skills";
-var AB_SKILLS3 = ".agentsmesh/skills";
 async function importSkills2(projectRoot, results, normalize) {
-  const destBase = join14(projectRoot, AB_SKILLS3);
+  const destBase = join14(projectRoot, CURSOR_CANONICAL_SKILLS_DIR);
   const skillsDir = join14(projectRoot, CURSOR_SKILLS_DIR);
   const allFiles = await readDirRecursive(skillsDir);
   const mdFiles = allFiles.filter((f) => f.endsWith(".md"));
@@ -2105,7 +2193,7 @@ async function importSkills2(projectRoot, results, normalize) {
       results.push({
         fromTool: "cursor",
         fromPath: filePath,
-        toPath: `${AB_SKILLS3}/${skillName}/${relPath}`,
+        toPath: `${CURSOR_CANONICAL_SKILLS_DIR}/${skillName}/${relPath}`,
         feature: "skills"
       });
     }
@@ -2122,23 +2210,13 @@ async function importSkills2(projectRoot, results, normalize) {
     results.push({
       fromTool: "cursor",
       fromPath: srcPath,
-      toPath: `${AB_SKILLS3}/${name}/SKILL.md`,
+      toPath: `${CURSOR_CANONICAL_SKILLS_DIR}/${name}/SKILL.md`,
       feature: "skills"
     });
   }
 }
 
 // src/targets/cursor/importer.ts
-var AGENTS_MD = "AGENTS.md";
-var CURSORRULES = ".cursorrules";
-var CURSOR_RULES_DIR = ".cursor/rules";
-var CURSOR_COMMANDS_DIR = ".cursor/commands";
-var CURSOR_AGENTS_DIR = ".cursor/agents";
-var CURSOR_MCP = ".cursor/mcp.json";
-var AB_RULES6 = ".agentsmesh/rules";
-var AB_COMMANDS6 = ".agentsmesh/commands";
-var AB_AGENTS6 = ".agentsmesh/agents";
-var AB_MCP2 = ".agentsmesh/mcp.json";
 async function importFromCursor(projectRoot) {
   const results = [];
   const normalize = await createImportReferenceNormalizer("cursor", projectRoot);
@@ -2152,9 +2230,9 @@ async function importFromCursor(projectRoot) {
   return results;
 }
 async function importRules2(projectRoot, results, normalize) {
-  const destDir = join15(projectRoot, AB_RULES6);
+  const destDir = join15(projectRoot, CURSOR_CANONICAL_RULES_DIR);
   let rootWritten = false;
-  const agentsPath = join15(projectRoot, AGENTS_MD);
+  const agentsPath = join15(projectRoot, CURSOR_COMPAT_AGENTS);
   const agentsContent = await readFileSafe(agentsPath);
   if (agentsContent !== null) {
     rootWritten = true;
@@ -2168,7 +2246,7 @@ async function importRules2(projectRoot, results, normalize) {
     results.push({
       fromTool: "cursor",
       fromPath: agentsPath,
-      toPath: `${AB_RULES6}/_root.md`,
+      toPath: `${CURSOR_CANONICAL_RULES_DIR}/_root.md`,
       feature: "rules"
     });
   }
@@ -2195,7 +2273,7 @@ async function importRules2(projectRoot, results, normalize) {
     })
   );
   if (!rootWritten) {
-    const cursorRulesPath = join15(projectRoot, CURSORRULES);
+    const cursorRulesPath = join15(projectRoot, CURSOR_LEGACY_RULES);
     const cursorRulesContent = await readFileSafe(cursorRulesPath);
     if (cursorRulesContent !== null) {
       await mkdirp(destDir);
@@ -2209,14 +2287,14 @@ async function importRules2(projectRoot, results, normalize) {
       results.push({
         fromTool: "cursor",
         fromPath: cursorRulesPath,
-        toPath: `${AB_RULES6}/_root.md`,
+        toPath: `${CURSOR_CANONICAL_RULES_DIR}/_root.md`,
         feature: "rules"
       });
     }
   }
 }
 async function importCommands2(projectRoot, results, normalize) {
-  const destDir = join15(projectRoot, AB_COMMANDS6);
+  const destDir = join15(projectRoot, CURSOR_CANONICAL_COMMANDS_DIR);
   const commandsDir = join15(projectRoot, CURSOR_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
@@ -2230,7 +2308,7 @@ async function importCommands2(projectRoot, results, normalize) {
   );
 }
 async function importAgents2(projectRoot, results, normalize) {
-  const destDir = join15(projectRoot, AB_AGENTS6);
+  const destDir = join15(projectRoot, CURSOR_CANONICAL_AGENTS_DIR);
   const agentsDir = join15(projectRoot, CURSOR_AGENTS_DIR);
   results.push(
     ...await importFileDirectory({
@@ -2254,29 +2332,43 @@ async function importMcp(projectRoot, results) {
     return;
   }
   if (!parsed || typeof parsed !== "object" || !("mcpServers" in parsed)) return;
-  const destPath = join15(projectRoot, AB_MCP2);
+  const destPath = join15(projectRoot, CURSOR_CANONICAL_MCP);
   await mkdirp(dirname9(destPath));
   await writeFileAtomic(destPath, content);
   results.push({
     fromTool: "cursor",
     fromPath: mcpPath,
-    toPath: AB_MCP2,
+    toPath: CURSOR_CANONICAL_MCP,
     feature: "mcp"
   });
 }
 
 // src/targets/codex-cli/importer.ts
-import { join as join19, relative as relative5, dirname as dirname11, basename as basename10 } from "path";
+import { join as join19, relative as relative5, dirname as dirname11, basename as basename11 } from "path";
 init_markdown();
 
 // src/targets/codex-cli/constants.ts
+var CODEX_TARGET = "codex-cli";
 var CODEX_MD = "codex.md";
-var AGENTS_MD2 = "AGENTS.md";
+var AGENTS_MD = "AGENTS.md";
 var CODEX_SKILLS_DIR = ".agents/skills";
 var CODEX_SKILLS_FALLBACK_DIR = ".codex/skills";
 var CODEX_CONFIG_TOML = ".codex/config.toml";
+var CODEX_INSTRUCTIONS_DIR = ".codex/instructions";
 var CODEX_RULES_DIR = ".codex/rules";
 var CODEX_AGENTS_DIR = ".codex/agents";
+var CODEX_CANONICAL_RULES_DIR = ".agentsmesh/rules";
+var CODEX_CANONICAL_COMMANDS_DIR = ".agentsmesh/commands";
+var CODEX_CANONICAL_AGENTS_DIR = ".agentsmesh/agents";
+var CODEX_CANONICAL_SKILLS_DIR = ".agentsmesh/skills";
+var CODEX_CANONICAL_MCP = ".agentsmesh/mcp.json";
+var CODEX_RULE_EMBED_MARKER = "am-codex-rule:v1";
+var CODEX_RULE_EMBED_JSON_PREFIX = "# am-json: ";
+var CODEX_RULE_EMBED_B64_BEGIN = "# am-body-b64-begin";
+var CODEX_RULE_EMBED_B64_END = "# am-body-b64-end";
+var CODEX_RULE_EMBED_B64_LINE = "# am64:";
+var CODEX_RULE_INDEX_START = "<!-- agentsmesh:codex-rule-index:start -->";
+var CODEX_RULE_INDEX_END = "<!-- agentsmesh:codex-rule-index:end -->";
 
 // src/targets/codex-cli/import-codex-non-root-rules.ts
 import { join as join16, basename as basename9 } from "path";
@@ -2284,18 +2376,13 @@ init_markdown();
 
 // src/targets/codex-cli/codex-rules-embed.ts
 import { Buffer as Buffer2 } from "buffer";
-var MARKER = "am-codex-rule:v1";
-var JSON_PREFIX = "# am-json: ";
-var B64_BEGIN = "# am-body-b64-begin";
-var B64_END = "# am-body-b64-end";
-var B64_LINE = "# am64:";
 function tryParseEmbeddedCanonicalFromCodexRules(content) {
-  if (!content.includes(MARKER)) return null;
-  const jsonLine = content.split("\n").find((l) => l.startsWith(JSON_PREFIX));
+  if (!content.includes(CODEX_RULE_EMBED_MARKER)) return null;
+  const jsonLine = content.split("\n").find((l) => l.startsWith(CODEX_RULE_EMBED_JSON_PREFIX));
   if (!jsonLine) return null;
   let parsed;
   try {
-    parsed = JSON.parse(jsonLine.slice(JSON_PREFIX.length));
+    parsed = JSON.parse(jsonLine.slice(CODEX_RULE_EMBED_JSON_PREFIX.length));
   } catch {
     return null;
   }
@@ -2307,16 +2394,16 @@ function tryParseEmbeddedCanonicalFromCodexRules(content) {
   let inB64 = false;
   for (const line of content.split("\n")) {
     const t = line.trimEnd();
-    if (t === B64_BEGIN) {
+    if (t === CODEX_RULE_EMBED_B64_BEGIN) {
       inB64 = true;
       continue;
     }
-    if (t === B64_END) {
+    if (t === CODEX_RULE_EMBED_B64_END) {
       inB64 = false;
       continue;
     }
-    if (inB64 && t.startsWith(B64_LINE)) {
-      chunks.push(t.slice(B64_LINE.length));
+    if (inB64 && t.startsWith(CODEX_RULE_EMBED_B64_LINE)) {
+      chunks.push(t.slice(CODEX_RULE_EMBED_B64_LINE.length));
     }
   }
   if (chunks.length === 0) return null;
@@ -2329,7 +2416,6 @@ function tryParseEmbeddedCanonicalFromCodexRules(content) {
 }
 
 // src/targets/codex-cli/import-codex-non-root-rules.ts
-var AB_RULES7 = ".agentsmesh/rules";
 async function importCodexNonRootRuleFiles(projectRoot, destDir, normalize) {
   const results = [];
   const codexRulesPath = join16(projectRoot, CODEX_RULES_DIR);
@@ -2347,9 +2433,9 @@ async function importCodexNonRootRuleFiles(projectRoot, destDir, normalize) {
       const outContent = await serializeImportedRuleWithFallback(destPath, outFm, body);
       await writeFileAtomic(destPath, outContent);
       results.push({
-        fromTool: "codex-cli",
+        fromTool: CODEX_TARGET,
         fromPath: srcPath,
-        toPath: `${AB_RULES7}/${slug}.md`,
+        toPath: `${CODEX_CANONICAL_RULES_DIR}/${slug}.md`,
         feature: "rules"
       });
     }
@@ -2386,9 +2472,9 @@ async function importCodexNonRootRuleFiles(projectRoot, destDir, normalize) {
         await writeFileAtomic(destPath, outContent);
       }
       results.push({
-        fromTool: "codex-cli",
+        fromTool: CODEX_TARGET,
         fromPath: srcPath,
-        toPath: `${AB_RULES7}/${slug}.md`,
+        toPath: `${CODEX_CANONICAL_RULES_DIR}/${slug}.md`,
         feature: "rules"
       });
     }
@@ -2397,10 +2483,76 @@ async function importCodexNonRootRuleFiles(projectRoot, destDir, normalize) {
   return results;
 }
 
+// src/targets/codex-cli/instruction-mirror.ts
+init_markdown();
+import { basename as basename10 } from "path";
+function ruleSlug(source) {
+  return basename10(source, ".md");
+}
+function codexInstructionMirrorPath(rule) {
+  return `${CODEX_INSTRUCTIONS_DIR}/${ruleSlug(rule.source)}.md`;
+}
+function serializeCodexInstructionMirror(rule) {
+  const frontmatter = {
+    root: rule.root,
+    description: rule.description || void 0,
+    globs: rule.globs.length > 0 ? rule.globs : void 0,
+    targets: rule.targets.length > 0 ? rule.targets : void 0,
+    codex_emit: rule.codexEmit || void 0,
+    codex_instruction: rule.codexInstructionVariant && rule.codexInstructionVariant !== "default" ? rule.codexInstructionVariant : void 0
+  };
+  Object.keys(frontmatter).forEach((key) => {
+    if (frontmatter[key] === void 0) delete frontmatter[key];
+  });
+  return serializeFrontmatter(frontmatter, rule.body.trim() || "");
+}
+function summarizeRule(rule) {
+  const scopes = [];
+  if (rule.root) {
+    scopes.push("Applies to the whole project.");
+  } else if (rule.globs.length > 0) {
+    scopes.push(`Applies to ${rule.globs.map((glob) => `\`${glob}\``).join(", ")}.`);
+  } else {
+    scopes.push("General guidance with no file glob restriction.");
+  }
+  if (rule.codexInstructionVariant === "override") {
+    scopes.push("Override guidance when this rule conflicts with broader instructions.");
+  }
+  if (rule.codexEmit === "execution") {
+    scopes.push(`Enforced in \`${CODEX_RULES_DIR}/${ruleSlug(rule.source)}.rules\`.`);
+  }
+  if (rule.targets.length > 0) {
+    scopes.push(`Targeted to ${rule.targets.map((target10) => `\`${target10}\``).join(", ")}.`);
+  }
+  return scopes.join(" ");
+}
+function appendCodexRuleIndex(rootBody, rules) {
+  const trimmed = rootBody.trim();
+  const additionalRules = rules.filter((rule) => !rule.root);
+  if (additionalRules.length === 0) return trimmed;
+  const entries = additionalRules.map((rule) => {
+    const label = rule.description || ruleSlug(rule.source);
+    return `- [${label}](${codexInstructionMirrorPath(rule)}): ${summarizeRule(rule)}`;
+  });
+  const section = [
+    CODEX_RULE_INDEX_START,
+    "## Additional Rule Files",
+    ...entries,
+    CODEX_RULE_INDEX_END
+  ].join("\n");
+  return trimmed ? `${trimmed}
+
+${section}` : section;
+}
+function stripCodexRuleIndex(content) {
+  const escapedStart = CODEX_RULE_INDEX_START.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const escapedEnd = CODEX_RULE_INDEX_END.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return content.replace(new RegExp(`\\n?${escapedStart}[\\s\\S]*?${escapedEnd}\\n?`, "g"), "\n").trim();
+}
+
 // src/targets/codex-cli/mcp-helpers.ts
 import { join as join17 } from "path";
 import { parse as parseToml } from "smol-toml";
-var AB_MCP3 = ".agentsmesh/mcp.json";
 function mapTomlServerToCanonical(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
   const obj = raw;
@@ -2441,11 +2593,14 @@ async function importMcp2(projectRoot, results) {
   }
   if (Object.keys(mcpServers).length === 0) return;
   await mkdirp(join17(projectRoot, ".agentsmesh"));
-  await writeFileAtomic(join17(projectRoot, AB_MCP3), JSON.stringify({ mcpServers }, null, 2));
+  await writeFileAtomic(
+    join17(projectRoot, CODEX_CANONICAL_MCP),
+    JSON.stringify({ mcpServers }, null, 2)
+  );
   results.push({
-    fromTool: "codex-cli",
+    fromTool: CODEX_TARGET,
     fromPath: configPath,
-    toPath: AB_MCP3,
+    toPath: CODEX_CANONICAL_MCP,
     feature: "mcp"
   });
 }
@@ -2469,9 +2624,6 @@ async function removePathIfExists(path) {
 }
 
 // src/targets/codex-cli/skills-helpers.ts
-var AB_COMMANDS7 = ".agentsmesh/commands";
-var AB_AGENTS7 = ".agentsmesh/agents";
-var AB_SKILLS4 = ".agentsmesh/skills";
 async function importSkills3(projectRoot, results, normalize) {
   for (const skillsRoot of [CODEX_SKILLS_DIR, CODEX_SKILLS_FALLBACK_DIR]) {
     const skillsDir = join18(projectRoot, skillsRoot);
@@ -2491,13 +2643,13 @@ async function importSkills3(projectRoot, results, normalize) {
       if (!skillMdContent) continue;
       importedAny = true;
       const skillName = ent.name;
-      const destSkillPath = join18(projectRoot, AB_SKILLS4, skillName, "SKILL.md");
+      const destSkillPath = join18(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName, "SKILL.md");
       const normalized = normalize(skillMdContent, skillMdPath, destSkillPath);
       const { frontmatter, body } = parseFrontmatter(normalized);
       const command = parseCommandSkillFrontmatter(frontmatter, ent.name);
       if (command) {
-        await removePathIfExists(join18(projectRoot, AB_SKILLS4, skillName));
-        const destCommandsDir = join18(projectRoot, AB_COMMANDS7);
+        await removePathIfExists(join18(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName));
+        const destCommandsDir = join18(projectRoot, CODEX_CANONICAL_COMMANDS_DIR);
         await mkdirp(destCommandsDir);
         const commandPath = join18(destCommandsDir, `${command.name}.md`);
         await writeFileAtomic(
@@ -2505,17 +2657,17 @@ async function importSkills3(projectRoot, results, normalize) {
           serializeImportedCommand(command, normalize(body, skillMdPath, commandPath))
         );
         results.push({
-          fromTool: "codex-cli",
+          fromTool: CODEX_TARGET,
           fromPath: skillMdPath,
-          toPath: `${AB_COMMANDS7}/${command.name}.md`,
+          toPath: `${CODEX_CANONICAL_COMMANDS_DIR}/${command.name}.md`,
           feature: "commands"
         });
         continue;
       }
       const projectedAgent = parseProjectedAgentSkillFrontmatter(frontmatter, ent.name);
       if (projectedAgent) {
-        await removePathIfExists(join18(projectRoot, AB_SKILLS4, skillName));
-        const destAgentsDir = join18(projectRoot, AB_AGENTS7);
+        await removePathIfExists(join18(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName));
+        const destAgentsDir = join18(projectRoot, CODEX_CANONICAL_AGENTS_DIR);
         await mkdirp(destAgentsDir);
         const agentPath = join18(destAgentsDir, `${projectedAgent.name}.md`);
         await writeFileAtomic(
@@ -2523,14 +2675,14 @@ async function importSkills3(projectRoot, results, normalize) {
           serializeImportedAgent(projectedAgent, normalize(body, skillMdPath, agentPath))
         );
         results.push({
-          fromTool: "codex-cli",
+          fromTool: CODEX_TARGET,
           fromPath: skillMdPath,
-          toPath: `${AB_AGENTS7}/${projectedAgent.name}.md`,
+          toPath: `${CODEX_CANONICAL_AGENTS_DIR}/${projectedAgent.name}.md`,
           feature: "agents"
         });
         continue;
       }
-      const destSkillDir = join18(projectRoot, AB_SKILLS4, skillName);
+      const destSkillDir = join18(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName);
       await mkdirp(destSkillDir);
       const canonicalFm = {
         description: typeof frontmatter.description === "string" ? frontmatter.description : void 0
@@ -2539,9 +2691,9 @@ async function importSkills3(projectRoot, results, normalize) {
       const outContent = Object.keys(canonicalFm).length > 0 ? serializeFrontmatter(canonicalFm, body.trim() || "") : body.trim() || "";
       await writeFileAtomic(destSkillPath, outContent);
       results.push({
-        fromTool: "codex-cli",
+        fromTool: CODEX_TARGET,
         fromPath: skillMdPath,
-        toPath: `${AB_SKILLS4}/${skillName}/SKILL.md`,
+        toPath: `${CODEX_CANONICAL_SKILLS_DIR}/${skillName}/SKILL.md`,
         feature: "skills"
       });
       const allFiles = await readDirRecursive(skillPath);
@@ -2554,9 +2706,9 @@ async function importSkills3(projectRoot, results, normalize) {
         await mkdirp(dirname10(destPath));
         await writeFileAtomic(destPath, normalize(fileContent, absPath, destPath));
         results.push({
-          fromTool: "codex-cli",
+          fromTool: CODEX_TARGET,
           fromPath: absPath,
-          toPath: `${AB_SKILLS4}/${skillName}/${relPath}`,
+          toPath: `${CODEX_CANONICAL_SKILLS_DIR}/${skillName}/${relPath}`,
           feature: "skills"
         });
       }
@@ -2569,10 +2721,9 @@ async function importSkills3(projectRoot, results, normalize) {
 
 // src/targets/codex-cli/importer.ts
 import { parse as parseToml2 } from "smol-toml";
-var AB_RULES8 = ".agentsmesh/rules";
 async function importFromCodex(projectRoot) {
   const results = [];
-  const normalize = await createImportReferenceNormalizer("codex-cli", projectRoot);
+  const normalize = await createImportReferenceNormalizer(CODEX_TARGET, projectRoot);
   const normalizeWindsurf = await createImportReferenceNormalizer("windsurf", projectRoot);
   await importRules3(projectRoot, results, normalize, normalizeWindsurf);
   await importSkills3(projectRoot, results, normalize);
@@ -2582,7 +2733,7 @@ async function importFromCodex(projectRoot) {
 }
 async function importAgents3(projectRoot, results, normalize) {
   const agentsPath = join19(projectRoot, CODEX_AGENTS_DIR);
-  const agentsDestDir = join19(projectRoot, ".agentsmesh/agents");
+  const agentsDestDir = join19(projectRoot, CODEX_CANONICAL_AGENTS_DIR);
   try {
     const agentFiles = await readDirRecursive(agentsPath);
     const tomlFiles = agentFiles.filter((f) => f.endsWith(".toml"));
@@ -2591,7 +2742,7 @@ async function importAgents3(projectRoot, results, normalize) {
       if (!content) continue;
       const parsed = parseToml2(content);
       if (!parsed || typeof parsed !== "object") continue;
-      const name = typeof parsed.name === "string" ? parsed.name : basename10(srcPath, ".toml");
+      const name = typeof parsed.name === "string" ? parsed.name : basename11(srcPath, ".toml");
       const description = typeof parsed.description === "string" ? parsed.description : "";
       const body = typeof parsed.developer_instructions === "string" ? parsed.developer_instructions.trim() : "";
       const model = typeof parsed.model === "string" ? parsed.model : "";
@@ -2617,9 +2768,9 @@ async function importAgents3(projectRoot, results, normalize) {
       const outContent = serializeImportedAgent(agent, normalizedBody);
       await writeFileAtomic(destPath, outContent);
       results.push({
-        fromTool: "codex-cli",
+        fromTool: CODEX_TARGET,
         fromPath: srcPath,
-        toPath: `.agentsmesh/agents/${name}.md`,
+        toPath: `${CODEX_CANONICAL_AGENTS_DIR}/${name}.md`,
         feature: "agents"
       });
     }
@@ -2628,16 +2779,17 @@ async function importAgents3(projectRoot, results, normalize) {
 }
 async function importRules3(projectRoot, results, normalize, normalizeWindsurf) {
   const codexPath = join19(projectRoot, CODEX_MD);
-  const agentsPath = join19(projectRoot, AGENTS_MD2);
+  const agentsPath = join19(projectRoot, AGENTS_MD);
   const agentsContent = await readFileSafe(agentsPath);
   const codexContent = await readFileSafe(codexPath);
   const sourcePath = agentsContent !== null ? agentsPath : codexPath;
-  const destDir = join19(projectRoot, AB_RULES8);
+  const destDir = join19(projectRoot, CODEX_CANONICAL_RULES_DIR);
   const content = agentsContent ?? codexContent;
   if (content !== null) {
     await mkdirp(destDir);
     const destPath = join19(destDir, "_root.md");
-    const normalizedContent = sourcePath === agentsPath ? normalize(normalizeWindsurf(content, sourcePath, destPath), sourcePath, destPath) : normalize(content, sourcePath, destPath);
+    const stripped = sourcePath === agentsPath ? stripCodexRuleIndex(content) : content;
+    const normalizedContent = sourcePath === agentsPath ? normalize(normalizeWindsurf(stripped, sourcePath, destPath), sourcePath, destPath) : normalize(stripped, sourcePath, destPath);
     const { frontmatter, body } = parseFrontmatter(normalizedContent);
     const outFm = frontmatter.root === true ? frontmatter : { ...frontmatter, root: true };
     const outContent = await serializeImportedRuleWithFallback(destPath, outFm, body);
@@ -2645,10 +2797,11 @@ async function importRules3(projectRoot, results, normalize, normalizeWindsurf)
     results.push({
       fromTool: "codex-cli",
       fromPath: sourcePath,
-      toPath: `${AB_RULES8}/_root.md`,
+      toPath: `${CODEX_CANONICAL_RULES_DIR}/_root.md`,
       feature: "rules"
     });
   }
+  await importInstructionMirrors(projectRoot, destDir, results, normalize);
   results.push(...await importCodexNonRootRuleFiles(projectRoot, destDir, normalize));
   results.push(
     ...await importFileDirectory({
@@ -2671,7 +2824,7 @@ async function importRules3(projectRoot, results, normalize, normalizeWindsurf)
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         return {
           destPath,
-          toPath: `${AB_RULES8}/${ruleName}.md`,
+          toPath: `${CODEX_CANONICAL_RULES_DIR}/${ruleName}.md`,
           feature: "rules",
           content: await serializeImportedRuleWithFallback(
             destPath,
@@ -2688,13 +2841,39 @@ async function importRules3(projectRoot, results, normalize, normalizeWindsurf)
     })
   );
 }
+async function importInstructionMirrors(projectRoot, destDir, results, normalize) {
+  try {
+    const files = await readDirRecursive(join19(projectRoot, CODEX_INSTRUCTIONS_DIR));
+    const instructionFiles = files.filter((file) => file.endsWith(".md"));
+    for (const srcPath of instructionFiles) {
+      const slug = basename11(srcPath, ".md");
+      if (slug === "_root") continue;
+      const content = await readFileSafe(srcPath);
+      if (!content) continue;
+      const destPath = join19(destDir, `${slug}.md`);
+      const { frontmatter, body } = parseFrontmatter(normalize(content, srcPath, destPath));
+      await mkdirp(destDir);
+      const outFm = frontmatter.root === true ? frontmatter : { ...frontmatter, root: false };
+      const outContent = await serializeImportedRuleWithFallback(destPath, outFm, body);
+      await writeFileAtomic(destPath, outContent);
+      results.push({
+        fromTool: CODEX_TARGET,
+        fromPath: srcPath,
+        toPath: `${CODEX_CANONICAL_RULES_DIR}/${slug}.md`,
+        feature: "rules"
+      });
+    }
+  } catch {
+  }
+}
 
 // src/targets/windsurf/importer.ts
-import { join as join21, basename as basename12, dirname as dirname12, relative as relative6 } from "path";
+import { join as join21, basename as basename13, dirname as dirname12, relative as relative6 } from "path";
 init_markdown();
 import { stringify as yamlStringify4 } from "yaml";
 
 // src/targets/windsurf/constants.ts
+var WINDSURF_TARGET = "windsurf";
 var WINDSURF_RULES_ROOT = ".windsurfrules";
 var WINDSURF_RULES_DIR = ".windsurf/rules";
 var WINDSURF_IGNORE = ".windsurfignore";
@@ -2705,14 +2884,18 @@ var WINDSURF_MCP_EXAMPLE_FILE = ".windsurf/mcp_config.example.json";
 var WINDSURF_MCP_CONFIG_FILE = ".windsurf/mcp_config.json";
 var WINDSURF_WORKFLOWS_DIR = ".windsurf/workflows";
 var WINDSURF_SKILLS_DIR = ".windsurf/skills";
+var WINDSURF_CANONICAL_RULES_DIR = ".agentsmesh/rules";
+var WINDSURF_CANONICAL_COMMANDS_DIR = ".agentsmesh/commands";
+var WINDSURF_CANONICAL_AGENTS_DIR = ".agentsmesh/agents";
+var WINDSURF_CANONICAL_SKILLS_DIR = ".agentsmesh/skills";
+var WINDSURF_CANONICAL_IGNORE = ".agentsmesh/ignore";
+var WINDSURF_CANONICAL_HOOKS = ".agentsmesh/hooks.yaml";
+var WINDSURF_CANONICAL_MCP = ".agentsmesh/mcp.json";
 
 // src/targets/windsurf/workflows-skills-helpers.ts
-import { join as join20, basename as basename11 } from "path";
+import { join as join20, basename as basename12 } from "path";
 import { readdir as readdir4 } from "fs/promises";
 init_markdown();
-var AGENTSMESH_COMMANDS3 = ".agentsmesh/commands";
-var AGENTSMESH_AGENTS2 = ".agentsmesh/agents";
-var AGENTSMESH_SKILLS2 = ".agentsmesh/skills";
 function toStringArray5(value) {
   if (Array.isArray(value)) {
     return value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
@@ -2726,11 +2909,11 @@ async function importWorkflows(projectRoot, results, normalize) {
   const workflowsDir = join20(projectRoot, WINDSURF_WORKFLOWS_DIR);
   const workflowFiles = await readDirRecursive(workflowsDir);
   const workflowMdFiles = workflowFiles.filter((f) => f.endsWith(".md"));
-  const destCommandsDir = join20(projectRoot, AGENTSMESH_COMMANDS3);
+  const destCommandsDir = join20(projectRoot, WINDSURF_CANONICAL_COMMANDS_DIR);
   for (const srcPath of workflowMdFiles) {
     const content = await readFileSafe(srcPath);
     if (!content) continue;
-    const name = basename11(srcPath, ".md");
+    const name = basename12(srcPath, ".md");
     await mkdirp(destCommandsDir);
     const destPath = join20(destCommandsDir, `${name}.md`);
     const normalized = normalize(content, srcPath, destPath);
@@ -2750,9 +2933,9 @@ async function importWorkflows(projectRoot, results, normalize) {
     );
     await writeFileAtomic(destPath, outContent);
     results.push({
-      fromTool: "windsurf",
+      fromTool: WINDSURF_TARGET,
       fromPath: srcPath,
-      toPath: `${AGENTSMESH_COMMANDS3}/${name}.md`,
+      toPath: `${WINDSURF_CANONICAL_COMMANDS_DIR}/${name}.md`,
       feature: "commands"
     });
   }
@@ -2770,8 +2953,8 @@ async function importSkills4(projectRoot, results, normalize) {
       const rawParsed = parseFrontmatter(skillContent);
       const projectedAgent = parseProjectedAgentSkillFrontmatter(rawParsed.frontmatter, ent.name);
       if (projectedAgent) {
-        await removePathIfExists(join20(projectRoot, AGENTSMESH_SKILLS2, ent.name));
-        const destAgentsDir = join20(projectRoot, AGENTSMESH_AGENTS2);
+        await removePathIfExists(join20(projectRoot, WINDSURF_CANONICAL_SKILLS_DIR, ent.name));
+        const destAgentsDir = join20(projectRoot, WINDSURF_CANONICAL_AGENTS_DIR);
         await mkdirp(destAgentsDir);
         const agentPath = join20(destAgentsDir, `${projectedAgent.name}.md`);
         await writeFileAtomic(
@@ -2779,22 +2962,22 @@ async function importSkills4(projectRoot, results, normalize) {
           serializeImportedAgent(projectedAgent, normalize(rawParsed.body, skillMdPath, agentPath))
         );
         results.push({
-          fromTool: "windsurf",
+          fromTool: WINDSURF_TARGET,
           fromPath: skillMdPath,
-          toPath: `${AGENTSMESH_AGENTS2}/${projectedAgent.name}.md`,
+          toPath: `${WINDSURF_CANONICAL_AGENTS_DIR}/${projectedAgent.name}.md`,
           feature: "agents"
         });
         continue;
       }
-      const destSkillDir = join20(projectRoot, AGENTSMESH_SKILLS2, ent.name);
+      const destSkillDir = join20(projectRoot, WINDSURF_CANONICAL_SKILLS_DIR, ent.name);
       const destSkillPath = join20(destSkillDir, "SKILL.md");
       const normalized = normalize(skillContent, skillMdPath, destSkillPath);
       await mkdirp(destSkillDir);
       await writeFileAtomic(destSkillPath, normalized);
       results.push({
-        fromTool: "windsurf",
+        fromTool: WINDSURF_TARGET,
         fromPath: skillMdPath,
-        toPath: `${AGENTSMESH_SKILLS2}/${ent.name}/SKILL.md`,
+        toPath: `${WINDSURF_CANONICAL_SKILLS_DIR}/${ent.name}/SKILL.md`,
         feature: "skills"
       });
       const allSkillFiles = await readDirRecursive(skillPath);
@@ -2807,9 +2990,9 @@ async function importSkills4(projectRoot, results, normalize) {
         await mkdirp(join20(destSupportPath, ".."));
         await writeFileAtomic(destSupportPath, normalize(supportContent, absPath, destSupportPath));
         results.push({
-          fromTool: "windsurf",
+          fromTool: WINDSURF_TARGET,
           fromPath: absPath,
-          toPath: `${AGENTSMESH_SKILLS2}/${ent.name}/${relPath}`,
+          toPath: `${WINDSURF_CANONICAL_SKILLS_DIR}/${ent.name}/${relPath}`,
           feature: "skills"
         });
       }
@@ -2819,15 +3002,11 @@ async function importSkills4(projectRoot, results, normalize) {
 }
 
 // src/targets/windsurf/importer.ts
-var AGENTSMESH_RULES3 = ".agentsmesh/rules";
-var AGENTSMESH_IGNORE2 = ".agentsmesh/ignore";
-var AGENTSMESH_HOOKS = ".agentsmesh/hooks.yaml";
-var AGENTSMESH_MCP2 = ".agentsmesh/mcp.json";
 async function importFromWindsurf(projectRoot) {
   const results = [];
-  const normalize = await createImportReferenceNormalizer("windsurf", projectRoot);
+  const normalize = await createImportReferenceNormalizer(WINDSURF_TARGET, projectRoot);
   const normalizeCodex = await createImportReferenceNormalizer("codex-cli", projectRoot);
-  const destRulesDir = join21(projectRoot, AGENTSMESH_RULES3);
+  const destRulesDir = join21(projectRoot, WINDSURF_CANONICAL_RULES_DIR);
   const rootPath = join21(projectRoot, WINDSURF_RULES_ROOT);
   const rootContent = await readFileSafe(rootPath);
   if (rootContent !== null) {
@@ -2839,7 +3018,7 @@ async function importFromWindsurf(projectRoot) {
     results.push({
       fromTool: "windsurf",
       fromPath: rootPath,
-      toPath: `${AGENTSMESH_RULES3}/_root.md`,
+      toPath: `${WINDSURF_CANONICAL_RULES_DIR}/_root.md`,
       feature: "rules"
     });
   }
@@ -2859,7 +3038,7 @@ async function importFromWindsurf(projectRoot) {
       results.push({
         fromTool: "windsurf",
         fromPath: agentsMdPath,
-        toPath: `${AGENTSMESH_RULES3}/_root.md`,
+        toPath: `${WINDSURF_CANONICAL_RULES_DIR}/_root.md`,
         feature: "rules"
       });
     }
@@ -2882,7 +3061,7 @@ async function importFromWindsurf(projectRoot) {
         const destPath = join21(destRulesDir, `${ruleName}.md`);
         return {
           destPath,
-          toPath: `${AGENTSMESH_RULES3}/${ruleName}.md`,
+          toPath: `${WINDSURF_CANONICAL_RULES_DIR}/${ruleName}.md`,
           feature: "rules",
           content: await serializeImportedRuleWithFallback(
             destPath,
@@ -2902,7 +3081,7 @@ async function importFromWindsurf(projectRoot) {
       fromTool: "windsurf",
       normalize,
       mapEntry: async ({ srcPath, normalizeTo }) => {
-        const name = basename12(srcPath, ".md");
+        const name = basename13(srcPath, ".md");
         if (name === "_root" && rootContent !== null) return null;
         const destPath = join21(destRulesDir, `${name}.md`);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
@@ -2913,7 +3092,7 @@ async function importFromWindsurf(projectRoot) {
         }
         return {
           destPath,
-          toPath: `${AGENTSMESH_RULES3}/${name}.md`,
+          toPath: `${WINDSURF_CANONICAL_RULES_DIR}/${name}.md`,
           feature: "rules",
           content: await serializeImportedRuleWithFallback(
             destPath,
@@ -2939,12 +3118,12 @@ async function importFromWindsurf(projectRoot) {
     }
     if (patterns.length > 0) {
       await mkdirp(join21(projectRoot, ".agentsmesh"));
-      const destIgnorePath = join21(projectRoot, AGENTSMESH_IGNORE2);
+      const destIgnorePath = join21(projectRoot, WINDSURF_CANONICAL_IGNORE);
       await writeFileAtomic(destIgnorePath, patterns.join("\n"));
       results.push({
         fromTool: "windsurf",
         fromPath: ignorePath,
-        toPath: AGENTSMESH_IGNORE2,
+        toPath: WINDSURF_CANONICAL_IGNORE,
         feature: "ignore"
       });
     }
@@ -2964,13 +3143,13 @@ async function importHooks(projectRoot, results) {
     if (!parsed.hooks || typeof parsed.hooks !== "object" || Array.isArray(parsed.hooks)) return;
     const canonical = windsurfHooksToCanonical(parsed.hooks);
     if (Object.keys(canonical).length === 0) return;
-    const destPath = join21(projectRoot, AGENTSMESH_HOOKS);
+    const destPath = join21(projectRoot, WINDSURF_CANONICAL_HOOKS);
     await mkdirp(dirname12(destPath));
     await writeFileAtomic(destPath, yamlStringify4(canonical));
     results.push({
-      fromTool: "windsurf",
+      fromTool: WINDSURF_TARGET,
       fromPath: hooksPath,
-      toPath: AGENTSMESH_HOOKS,
+      toPath: WINDSURF_CANONICAL_HOOKS,
       feature: "hooks"
     });
   } catch {
@@ -3033,13 +3212,13 @@ async function importMcp3(projectRoot, results) {
     try {
       const parsed = JSON.parse(content);
       if (!parsed.mcpServers || typeof parsed.mcpServers !== "object") continue;
-      const destPath = join21(projectRoot, AGENTSMESH_MCP2);
+      const destPath = join21(projectRoot, WINDSURF_CANONICAL_MCP);
       await mkdirp(dirname12(destPath));
       await writeFileAtomic(destPath, JSON.stringify({ mcpServers: parsed.mcpServers }, null, 2));
       results.push({
-        fromTool: "windsurf",
+        fromTool: WINDSURF_TARGET,
         fromPath: srcPath,
-        toPath: AGENTSMESH_MCP2,
+        toPath: WINDSURF_CANONICAL_MCP,
         feature: "mcp"
       });
       return;
@@ -3049,10 +3228,11 @@ async function importMcp3(projectRoot, results) {
 }
 
 // src/targets/copilot/importer.ts
-import { join as join24, basename as basename16 } from "path";
+import { join as join24, basename as basename17 } from "path";
 init_markdown();
 
 // src/targets/copilot/constants.ts
+var COPILOT_TARGET = "copilot";
 var COPILOT_INSTRUCTIONS = ".github/copilot-instructions.md";
 var COPILOT_CONTEXT_DIR = ".github/copilot";
 var COPILOT_INSTRUCTIONS_DIR = ".github/instructions";
@@ -3060,10 +3240,16 @@ var COPILOT_PROMPTS_DIR = ".github/prompts";
 var COPILOT_HOOKS_DIR = ".github/hooks";
 var COPILOT_SKILLS_DIR = ".github/skills";
 var COPILOT_AGENTS_DIR = ".github/agents";
+var COPILOT_CANONICAL_RULES_DIR = ".agentsmesh/rules";
+var COPILOT_CANONICAL_COMMANDS_DIR = ".agentsmesh/commands";
+var COPILOT_CANONICAL_AGENTS_DIR = ".agentsmesh/agents";
+var COPILOT_CANONICAL_SKILLS_DIR = ".agentsmesh/skills";
+var COPILOT_CANONICAL_HOOKS = ".agentsmesh/hooks.yaml";
+var COPILOT_LEGACY_HOOKS_DIR = ".github/copilot-hooks";
 
 // src/targets/copilot/command-prompt.ts
 init_markdown();
-import { basename as basename13 } from "path";
+import { basename as basename14 } from "path";
 function toStringArray6(value) {
   if (Array.isArray(value)) {
     return value.filter((entry) => typeof entry === "string" && entry.length > 0);
@@ -3092,7 +3278,7 @@ function serializeCommandPrompt(command) {
 }
 function parseCommandPromptFrontmatter(frontmatter, promptPath) {
   const nameFromMetadata = typeof frontmatter["x-agentsmesh-name"] === "string" ? frontmatter["x-agentsmesh-name"] : "";
-  const name = (nameFromMetadata || basename13(promptPath, ".prompt.md")).trim();
+  const name = (nameFromMetadata || basename14(promptPath, ".prompt.md")).trim();
   const allowedToolsFromMetadata = toStringArray6(frontmatter["x-agentsmesh-allowed-tools"]);
   const allowedTools = allowedToolsFromMetadata.length > 0 ? allowedToolsFromMetadata : toStringArray6(frontmatter.tools);
   return {
@@ -3112,9 +3298,8 @@ function serializeImportedCommand2(command, body) {
 }
 
 // src/targets/copilot/hook-parser.ts
-import { join as join22, dirname as dirname13, basename as basename14 } from "path";
+import { join as join22, dirname as dirname13, basename as basename15 } from "path";
 import { stringify as yamlStringify5 } from "yaml";
-var AB_HOOKS3 = ".agentsmesh/hooks.yaml";
 function mapCopilotHookEvent(event) {
   switch (event) {
     case "preToolUse":
@@ -3176,36 +3361,35 @@ async function importHooks2(projectRoot, results) {
       }
     }
   }
-  const legacyDir = join22(projectRoot, ".github", "copilot-hooks");
+  const legacyDir = join22(projectRoot, COPILOT_LEGACY_HOOKS_DIR);
   const legacyFiles = await readDirRecursive(legacyDir).catch(() => []);
   const shFiles = legacyFiles.filter(
-    (file) => dirname13(file) === legacyDir && /^[^-]+-\d+\.sh$/i.test(basename14(file))
+    (file) => dirname13(file) === legacyDir && /^[^-]+-\d+\.sh$/i.test(basename15(file))
   );
   for (const srcPath of shFiles) {
     const content = await readFileSafe(srcPath);
     if (!content) continue;
-    const name = basename14(srcPath, ".sh");
+    const name = basename15(srcPath, ".sh");
     const dashIdx = name.lastIndexOf("-");
     const phase = dashIdx > 0 ? name.slice(0, dashIdx) : name;
     if (!hooks[phase]) hooks[phase] = [];
     hooks[phase].push({ matcher: "*", command: extractWrapperCommand(content), type: "command" });
   }
   if (Object.keys(hooks).length === 0) return;
-  const destPath = join22(projectRoot, AB_HOOKS3);
+  const destPath = join22(projectRoot, COPILOT_CANONICAL_HOOKS);
   await mkdirp(dirname13(destPath));
   await writeFileAtomic(destPath, yamlStringify5(hooks));
   results.push({
-    fromTool: "copilot",
+    fromTool: COPILOT_TARGET,
     fromPath: join22(projectRoot, COPILOT_HOOKS_DIR),
-    toPath: AB_HOOKS3,
+    toPath: COPILOT_CANONICAL_HOOKS,
     feature: "hooks"
   });
 }
 
 // src/targets/copilot/agents-skills-helpers.ts
-import { join as join23, basename as basename15, dirname as dirname14 } from "path";
+import { join as join23, basename as basename16, dirname as dirname14 } from "path";
 init_markdown();
-var AB_AGENTS8 = ".agentsmesh/agents";
 async function importAgents4(projectRoot, results, normalize) {
   const agentsDir = join23(projectRoot, COPILOT_AGENTS_DIR);
   let files;
@@ -3215,11 +3399,11 @@ async function importAgents4(projectRoot, results, normalize) {
     return;
   }
   const agentFiles = files.filter((f) => f.endsWith(".agent.md"));
-  const destDir = join23(projectRoot, AB_AGENTS8);
+  const destDir = join23(projectRoot, COPILOT_CANONICAL_AGENTS_DIR);
   for (const srcPath of agentFiles) {
     const content = await readFileSafe(srcPath);
     if (!content) continue;
-    const base = basename15(srcPath, ".agent.md");
+    const base = basename16(srcPath, ".agent.md");
     await mkdirp(destDir);
     const destPath = join23(destDir, `${base}.md`);
     const { frontmatter, body } = parseFrontmatter(normalize(content, srcPath, destPath));
@@ -3237,9 +3421,9 @@ async function importAgents4(projectRoot, results, normalize) {
     const outContent = serializeFrontmatter(canonicalFm, body.trim());
     await writeFileAtomic(destPath, outContent);
     results.push({
-      fromTool: "copilot",
+      fromTool: COPILOT_TARGET,
       fromPath: srcPath,
-      toPath: `${AB_AGENTS8}/${base}.md`,
+      toPath: `${COPILOT_CANONICAL_AGENTS_DIR}/${base}.md`,
       feature: "agents"
     });
   }
@@ -3250,8 +3434,8 @@ async function importSkills5(projectRoot, results, normalize) {
   for (const skillMdPath of skillMdFiles) {
     const content = await readFileSafe(skillMdPath);
     if (!content) continue;
-    const skillName = basename15(dirname14(skillMdPath));
-    const destSkillDir = join23(projectRoot, ".agentsmesh", "skills", skillName);
+    const skillName = basename16(dirname14(skillMdPath));
+    const destSkillDir = join23(projectRoot, COPILOT_CANONICAL_SKILLS_DIR, skillName);
     const allSkillFiles = await readDirRecursive(dirname14(skillMdPath));
     for (const absPath of allSkillFiles) {
       const fileContent = await readFileSafe(absPath);
@@ -3261,9 +3445,9 @@ async function importSkills5(projectRoot, results, normalize) {
       await mkdirp(dirname14(destPath));
       await writeFileAtomic(destPath, normalize(fileContent, absPath, destPath));
       results.push({
-        fromTool: "copilot",
+        fromTool: COPILOT_TARGET,
         fromPath: absPath,
-        toPath: `.agentsmesh/skills/${skillName}/${relPath}`,
+        toPath: `${COPILOT_CANONICAL_SKILLS_DIR}/${skillName}/${relPath}`,
         feature: "skills"
       });
     }
@@ -3271,12 +3455,10 @@ async function importSkills5(projectRoot, results, normalize) {
 }
 
 // src/targets/copilot/importer.ts
-var AGENTSMESH_RULES4 = ".agentsmesh/rules";
-var AB_COMMANDS8 = ".agentsmesh/commands";
 async function importFromCopilot(projectRoot) {
   const results = [];
-  const normalize = await createImportReferenceNormalizer("copilot", projectRoot);
-  const destDir = join24(projectRoot, AGENTSMESH_RULES4);
+  const normalize = await createImportReferenceNormalizer(COPILOT_TARGET, projectRoot);
+  const destDir = join24(projectRoot, COPILOT_CANONICAL_RULES_DIR);
   const instructionsPath = join24(projectRoot, COPILOT_INSTRUCTIONS);
   const instructionsContent = await readFileSafe(instructionsPath);
   if (instructionsContent !== null) {
@@ -3292,7 +3474,7 @@ async function importFromCopilot(projectRoot) {
     results.push({
       fromTool: "copilot",
       fromPath: instructionsPath,
-      toPath: `${AGENTSMESH_RULES4}/_root.md`,
+      toPath: `${COPILOT_CANONICAL_RULES_DIR}/_root.md`,
       feature: "rules"
     });
   }
@@ -3305,7 +3487,7 @@ async function importFromCopilot(projectRoot) {
       fromTool: "copilot",
       normalize,
       mapEntry: async ({ srcPath, normalizeTo }) => {
-        const destFileName = `${basename16(srcPath, ".instructions.md")}.md`;
+        const destFileName = `${basename17(srcPath, ".instructions.md")}.md`;
         const destPath = join24(destDir, destFileName);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         const globs = toGlobsArray(frontmatter.globs);
@@ -3319,7 +3501,7 @@ async function importFromCopilot(projectRoot) {
         });
         return {
           destPath,
-          toPath: `${AGENTSMESH_RULES4}/${destFileName}`,
+          toPath: `${COPILOT_CANONICAL_RULES_DIR}/${destFileName}`,
           feature: "rules",
           content: await serializeImportedRuleWithFallback(destPath, canonicalFm, body)
         };
@@ -3335,7 +3517,7 @@ async function importFromCopilot(projectRoot) {
       fromTool: "copilot",
       normalize,
       mapEntry: async ({ srcPath, normalizeTo }) => {
-        const base = srcPath.endsWith(".instructions.md") ? basename16(srcPath, ".instructions.md") : basename16(srcPath, ".md");
+        const base = srcPath.endsWith(".instructions.md") ? basename17(srcPath, ".instructions.md") : basename17(srcPath, ".md");
         const destPath = join24(destDir, `${base}.md`);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         const globs = toGlobsArray(
@@ -3351,7 +3533,7 @@ async function importFromCopilot(projectRoot) {
         });
         return {
           destPath,
-          toPath: `${AGENTSMESH_RULES4}/${base}.md`,
+          toPath: `${COPILOT_CANONICAL_RULES_DIR}/${base}.md`,
           feature: "rules",
           content: await serializeImportedRuleWithFallback(destPath, canonicalFm, body)
         };
@@ -3366,7 +3548,7 @@ async function importFromCopilot(projectRoot) {
 }
 async function importCommands3(projectRoot, results, normalize) {
   const promptsDir = join24(projectRoot, COPILOT_PROMPTS_DIR);
-  const destDir = join24(projectRoot, AB_COMMANDS8);
+  const destDir = join24(projectRoot, COPILOT_CANONICAL_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: promptsDir,
@@ -3375,13 +3557,13 @@ async function importCommands3(projectRoot, results, normalize) {
       fromTool: "copilot",
       normalize,
       mapEntry: ({ srcPath, content }) => {
-        const previewDest = join24(destDir, `${basename16(srcPath, ".prompt.md")}.md`);
+        const previewDest = join24(destDir, `${basename17(srcPath, ".prompt.md")}.md`);
         const { frontmatter, body } = parseFrontmatter(normalize(content, srcPath, previewDest));
         const command = parseCommandPromptFrontmatter(frontmatter, srcPath);
         const destPath = join24(destDir, `${command.name}.md`);
         return {
           destPath,
-          toPath: `${AB_COMMANDS8}/${command.name}.md`,
+          toPath: `${COPILOT_CANONICAL_COMMANDS_DIR}/${command.name}.md`,
           feature: "commands",
           content: serializeImportedCommand2(command, body)
         };
@@ -3391,7 +3573,7 @@ async function importCommands3(projectRoot, results, normalize) {
 }
 
 // src/targets/continue/importer.ts
-import { basename as basename18, extname, join as join26 } from "path";
+import { basename as basename19, extname, join as join26 } from "path";
 import { parse as parseYaml } from "yaml";
 init_markdown();
 
@@ -3399,7 +3581,7 @@ init_markdown();
 import { readdir as readdir5 } from "fs/promises";
 import { dirname as dirname15, join as join25, relative as relative7 } from "path";
 init_markdown();
-var AB_SKILLS5 = ".agentsmesh/skills";
+var AB_SKILLS2 = ".agentsmesh/skills";
 function generateEmbeddedSkills(canonical, skillsDir) {
   const outputs = [];
   for (const skill of canonical.skills) {
@@ -3434,7 +3616,7 @@ async function importEmbeddedSkills(projectRoot, skillsDir, fromTool, results, n
     const sourceSkillFile = join25(sourceSkillDir, "SKILL.md");
     const sourceSkillContent = await readFileSafe(sourceSkillFile);
     if (sourceSkillContent === null) continue;
-    const destinationSkillDir = join25(projectRoot, AB_SKILLS5, entry.name);
+    const destinationSkillDir = join25(projectRoot, AB_SKILLS2, entry.name);
     const destinationSkillFile = join25(destinationSkillDir, "SKILL.md");
     const { frontmatter, body } = parseFrontmatter(
       normalize(sourceSkillContent, sourceSkillFile, destinationSkillFile)
@@ -3450,7 +3632,7 @@ async function importEmbeddedSkills(projectRoot, skillsDir, fromTool, results, n
     results.push({
       fromTool,
       fromPath: sourceSkillFile,
-      toPath: `${AB_SKILLS5}/${entry.name}/SKILL.md`,
+      toPath: `${AB_SKILLS2}/${entry.name}/SKILL.md`,
       feature: "skills"
     });
     const sourceFiles = await readDirRecursive(sourceSkillDir);
@@ -3465,7 +3647,7 @@ async function importEmbeddedSkills(projectRoot, skillsDir, fromTool, results, n
       results.push({
         fromTool,
         fromPath: sourcePath,
-        toPath: `${AB_SKILLS5}/${entry.name}/${relativePath}`,
+        toPath: `${AB_SKILLS2}/${entry.name}/${relativePath}`,
         feature: "skills"
       });
     }
@@ -3474,15 +3656,19 @@ async function importEmbeddedSkills(projectRoot, skillsDir, fromTool, results, n
 
 // src/targets/continue/command-rule.ts
 init_markdown();
-import { basename as basename17 } from "path";
+import { basename as basename18 } from "path";
 
 // src/targets/continue/constants.ts
+var CONTINUE_TARGET = "continue";
 var CONTINUE_RULES_DIR = ".continue/rules";
 var CONTINUE_PROMPTS_DIR = ".continue/prompts";
 var CONTINUE_MCP_DIR = ".continue/mcpServers";
 var CONTINUE_MCP_FILE = `${CONTINUE_MCP_DIR}/agentsmesh.json`;
 var CONTINUE_ROOT_RULE = `${CONTINUE_RULES_DIR}/_root.md`;
 var CONTINUE_SKILLS_DIR = ".continue/skills";
+var CONTINUE_CANONICAL_RULES_DIR = ".agentsmesh/rules";
+var CONTINUE_CANONICAL_COMMANDS_DIR = ".agentsmesh/commands";
+var CONTINUE_CANONICAL_MCP = ".agentsmesh/mcp.json";
 
 // src/targets/continue/command-rule.ts
 function toStringArray7(value) {
@@ -3511,7 +3697,7 @@ function serializeCommandRule(command) {
   return serializeFrontmatter(frontmatter, command.body.trim() || "");
 }
 function parseCommandRuleFrontmatter(frontmatter, filePath) {
-  const fileName = basename17(filePath, ".md");
+  const fileName = basename18(filePath, ".md");
   const fromMetadata = typeof frontmatter["x-agentsmesh-name"] === "string" ? frontmatter["x-agentsmesh-name"] : "";
   const name = (fromMetadata || fileName).trim();
   return {
@@ -3531,9 +3717,6 @@ function serializeImportedCommand3(command, body) {
 }
 
 // src/targets/continue/importer.ts
-var AB_RULES9 = ".agentsmesh/rules";
-var AB_COMMANDS9 = ".agentsmesh/commands";
-var AB_MCP4 = ".agentsmesh/mcp.json";
 function readMcpServers(content, extension) {
   const parsed = extension === ".json" ? JSON.parse(content) : parseYaml(content) ?? {};
   const rawServers = parsed.mcpServers;
@@ -3558,7 +3741,7 @@ function readMcpServers(content, extension) {
 }
 async function importFromContinue(projectRoot) {
   const results = [];
-  const normalize = await createImportReferenceNormalizer("continue", projectRoot);
+  const normalize = await createImportReferenceNormalizer(CONTINUE_TARGET, projectRoot);
   await importRules4(projectRoot, results, normalize);
   await importCommands4(projectRoot, results, normalize);
   await importEmbeddedSkills(projectRoot, CONTINUE_SKILLS_DIR, "continue", results, normalize);
@@ -3572,8 +3755,8 @@ async function importRules4(projectRoot, results, normalize) {
   for (const srcPath of files) {
     const source = await readFileSafe(srcPath);
     if (!source) continue;
-    const name = basename18(srcPath, ".md");
-    const destPath = join26(projectRoot, AB_RULES9, `${name}.md`);
+    const name = basename19(srcPath, ".md");
+    const destPath = join26(projectRoot, CONTINUE_CANONICAL_RULES_DIR, `${name}.md`);
     const { frontmatter, body } = parseFrontmatter(normalize(source, srcPath, destPath));
     const canonicalFrontmatter = {
       description: typeof frontmatter.description === "string" ? frontmatter.description : void 0,
@@ -3587,7 +3770,7 @@ async function importRules4(projectRoot, results, normalize) {
     results.push({
       fromTool: "continue",
       fromPath: srcPath,
-      toPath: `${AB_RULES9}/${name}.md`,
+      toPath: `${CONTINUE_CANONICAL_RULES_DIR}/${name}.md`,
       feature: "rules"
     });
   }
@@ -3599,12 +3782,12 @@ async function importCommands4(projectRoot, results, normalize) {
   for (const srcPath of files) {
     const source = await readFileSafe(srcPath);
     if (!source) continue;
-    const name = basename18(srcPath, ".md");
-    const destPath = join26(projectRoot, AB_COMMANDS9, `${name}.md`);
+    const name = basename19(srcPath, ".md");
+    const destPath = join26(projectRoot, CONTINUE_CANONICAL_COMMANDS_DIR, `${name}.md`);
     const { frontmatter, body } = parseFrontmatter(normalize(source, srcPath, destPath));
     const command = parseCommandRuleFrontmatter(frontmatter, srcPath);
     const commandName = command.name || name;
-    const commandPath = join26(projectRoot, AB_COMMANDS9, `${commandName}.md`);
+    const commandPath = join26(projectRoot, CONTINUE_CANONICAL_COMMANDS_DIR, `${commandName}.md`);
     const content = await serializeImportedCommandWithFallback(
       commandPath,
       {
@@ -3619,7 +3802,7 @@ async function importCommands4(projectRoot, results, normalize) {
     results.push({
       fromTool: "continue",
       fromPath: srcPath,
-      toPath: `${AB_COMMANDS9}/${commandName}.md`,
+      toPath: `${CONTINUE_CANONICAL_COMMANDS_DIR}/${commandName}.md`,
       feature: "commands"
     });
   }
@@ -3637,22 +3820,21 @@ async function importMcp4(projectRoot, results) {
     importedFrom.push(srcPath);
   }
   if (Object.keys(mergedServers).length === 0) return;
-  const destPath = join26(projectRoot, AB_MCP4);
+  const destPath = join26(projectRoot, CONTINUE_CANONICAL_MCP);
   await writeFileAtomic(destPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
   for (const fromPath of importedFrom) {
-    results.push({ fromTool: "continue", fromPath, toPath: AB_MCP4, feature: "mcp" });
+    results.push({
+      fromTool: CONTINUE_TARGET,
+      fromPath,
+      toPath: CONTINUE_CANONICAL_MCP,
+      feature: "mcp"
+    });
   }
 }
 
 // src/targets/junie/importer.ts
-import { basename as basename19, join as join27 } from "path";
+import { basename as basename20, join as join27 } from "path";
 init_markdown();
-var AB_RULE = ".agentsmesh/rules/_root.md";
-var AB_RULES_DIR = ".agentsmesh/rules";
-var AB_COMMANDS_DIR = ".agentsmesh/commands";
-var AB_AGENTS_DIR = ".agentsmesh/agents";
-var AB_MCP5 = ".agentsmesh/mcp.json";
-var AB_IGNORE3 = ".agentsmesh/ignore";
 function readMcpServers2(content) {
   const parsed = JSON.parse(content);
   const rawServers = parsed.mcpServers;
@@ -3685,7 +3867,7 @@ function readMcpServers2(content) {
 }
 async function importRules5(projectRoot, results, normalize) {
   const sources = [JUNIE_DOT_AGENTS, JUNIE_GUIDELINES, JUNIE_CI_GUIDELINES, JUNIE_AGENTS_FALLBACK];
-  const destPath = join27(projectRoot, AB_RULE);
+  const destPath = join27(projectRoot, JUNIE_CANONICAL_ROOT_RULE);
   for (const relPath of sources) {
     const srcPath = join27(projectRoot, relPath);
     const content = await readFileSafe(srcPath);
@@ -3701,13 +3883,18 @@ async function importRules5(projectRoot, results, normalize) {
       body
     );
     await writeFileAtomic(destPath, output);
-    results.push({ fromTool: "junie", fromPath: srcPath, toPath: AB_RULE, feature: "rules" });
+    results.push({
+      fromTool: JUNIE_TARGET,
+      fromPath: srcPath,
+      toPath: JUNIE_CANONICAL_ROOT_RULE,
+      feature: "rules"
+    });
     return;
   }
 }
 async function importNonRootRules(projectRoot, results, normalize) {
-  const srcDir = join27(projectRoot, ".junie/rules");
-  const destDir = join27(projectRoot, AB_RULES_DIR);
+  const srcDir = join27(projectRoot, JUNIE_RULES_DIR);
+  const destDir = join27(projectRoot, JUNIE_CANONICAL_RULES_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir,
@@ -3716,7 +3903,7 @@ async function importNonRootRules(projectRoot, results, normalize) {
       fromTool: "junie",
       normalize,
       mapEntry: async ({ srcPath, normalizeTo }) => {
-        const name = basename19(srcPath, ".md");
+        const name = basename20(srcPath, ".md");
         if (!name) return null;
         const destPath = join27(destDir, `${name}.md`);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
@@ -3731,7 +3918,7 @@ async function importNonRootRules(projectRoot, results, normalize) {
         );
         return {
           destPath,
-          toPath: `${AB_RULES_DIR}/${name}.md`,
+          toPath: `${JUNIE_CANONICAL_RULES_DIR}/${name}.md`,
           feature: "rules",
           content: output
         };
@@ -3746,14 +3933,19 @@ async function importMcp5(projectRoot, results) {
   const servers = readMcpServers2(content);
   if (Object.keys(servers).length === 0) return;
   await writeFileAtomic(
-    join27(projectRoot, AB_MCP5),
+    join27(projectRoot, JUNIE_CANONICAL_MCP),
     JSON.stringify({ mcpServers: servers }, null, 2)
   );
-  results.push({ fromTool: "junie", fromPath: srcPath, toPath: AB_MCP5, feature: "mcp" });
+  results.push({
+    fromTool: JUNIE_TARGET,
+    fromPath: srcPath,
+    toPath: JUNIE_CANONICAL_MCP,
+    feature: "mcp"
+  });
 }
 async function importCommands5(projectRoot, results, normalize) {
   const srcDir = join27(projectRoot, JUNIE_COMMANDS_DIR);
-  const destDir = join27(projectRoot, AB_COMMANDS_DIR);
+  const destDir = join27(projectRoot, JUNIE_CANONICAL_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir,
@@ -3762,7 +3954,7 @@ async function importCommands5(projectRoot, results, normalize) {
       fromTool: "junie",
       normalize,
       mapEntry: async ({ srcPath, normalizeTo }) => {
-        const name = basename19(srcPath, ".md");
+        const name = basename20(srcPath, ".md");
         if (!name) return null;
         const destPath = join27(destDir, `${name}.md`);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
@@ -3778,7 +3970,7 @@ async function importCommands5(projectRoot, results, normalize) {
         );
         return {
           destPath,
-          toPath: `${AB_COMMANDS_DIR}/${name}.md`,
+          toPath: `${JUNIE_CANONICAL_COMMANDS_DIR}/${name}.md`,
           feature: "commands",
           content: normalized
         };
@@ -3788,7 +3980,7 @@ async function importCommands5(projectRoot, results, normalize) {
 }
 async function importAgents5(projectRoot, results, normalize) {
   const srcDir = join27(projectRoot, JUNIE_AGENTS_DIR);
-  const destDir = join27(projectRoot, AB_AGENTS_DIR);
+  const destDir = join27(projectRoot, JUNIE_CANONICAL_AGENTS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir,
@@ -3797,13 +3989,13 @@ async function importAgents5(projectRoot, results, normalize) {
       fromTool: "junie",
       normalize,
       mapEntry: ({ srcPath, normalizeTo }) => {
-        const name = basename19(srcPath, ".md");
+        const name = basename20(srcPath, ".md");
         if (!name) return null;
         const destPath = join27(destDir, `${name}.md`);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         return {
           destPath,
-          toPath: `${AB_AGENTS_DIR}/${name}.md`,
+          toPath: `${JUNIE_CANONICAL_AGENTS_DIR}/${name}.md`,
           feature: "agents",
           content: serializeFrontmatter(frontmatter, body.trim() || "")
         };
@@ -3815,28 +4007,33 @@ async function importIgnore3(projectRoot, results) {
   const srcPath = join27(projectRoot, JUNIE_IGNORE);
   const content = await readFileSafe(srcPath);
   if (content === null) return;
-  await writeFileAtomic(join27(projectRoot, AB_IGNORE3), content.trimEnd());
-  results.push({ fromTool: "junie", fromPath: srcPath, toPath: AB_IGNORE3, feature: "ignore" });
+  await writeFileAtomic(join27(projectRoot, JUNIE_CANONICAL_IGNORE), content.trimEnd());
+  results.push({
+    fromTool: JUNIE_TARGET,
+    fromPath: srcPath,
+    toPath: JUNIE_CANONICAL_IGNORE,
+    feature: "ignore"
+  });
 }
 async function importFromJunie(projectRoot) {
   const results = [];
-  const normalize = await createImportReferenceNormalizer("junie", projectRoot);
+  const normalize = await createImportReferenceNormalizer(JUNIE_TARGET, projectRoot);
   await importRules5(projectRoot, results, normalize);
   await importNonRootRules(projectRoot, results, normalize);
   await importCommands5(projectRoot, results, normalize);
   await importAgents5(projectRoot, results, normalize);
-  await importEmbeddedSkills(projectRoot, JUNIE_SKILLS_DIR, "junie", results, normalize);
+  await importEmbeddedSkills(projectRoot, JUNIE_SKILLS_DIR, JUNIE_TARGET, results, normalize);
   await importMcp5(projectRoot, results);
   await importIgnore3(projectRoot, results);
   return results;
 }
 
 // src/targets/gemini-cli/importer.ts
-import { join as join31, basename as basename21, dirname as dirname16, relative as relative9 } from "path";
+import { join as join31, basename as basename22, dirname as dirname16, relative as relative9 } from "path";
 init_markdown();
 
 // src/targets/gemini-cli/importer-mappers.ts
-import { basename as basename20, join as join29, relative as relative8 } from "path";
+import { basename as basename21, join as join29, relative as relative8 } from "path";
 import { parse as parseToml4 } from "smol-toml";
 
 // src/targets/gemini-cli/format-helpers.ts
@@ -3846,6 +4043,7 @@ import { stringify as stringifyYaml } from "yaml";
 init_markdown();
 
 // src/targets/gemini-cli/constants.ts
+var GEMINI_TARGET = "gemini-cli";
 var GEMINI_ROOT = "GEMINI.md";
 var GEMINI_COMPAT_AGENTS = "AGENTS.md";
 var GEMINI_RULES_DIR = ".gemini/rules";
@@ -3858,11 +4056,16 @@ var GEMINI_SKILLS_DIR = ".gemini/skills";
 var GEMINI_AGENTS_DIR = ".gemini/agents";
 var GEMINI_SYSTEM = ".gemini/system.md";
 var GEMINI_DEFAULT_POLICIES_FILE = `${GEMINI_POLICIES_DIR}/permissions.toml`;
+var GEMINI_CANONICAL_RULES_DIR = ".agentsmesh/rules";
+var GEMINI_CANONICAL_COMMANDS_DIR = ".agentsmesh/commands";
+var GEMINI_CANONICAL_AGENTS_DIR = ".agentsmesh/agents";
+var GEMINI_CANONICAL_SKILLS_DIR = ".agentsmesh/skills";
+var GEMINI_CANONICAL_MCP = ".agentsmesh/mcp.json";
+var GEMINI_CANONICAL_HOOKS = ".agentsmesh/hooks.yaml";
+var GEMINI_CANONICAL_IGNORE = ".agentsmesh/ignore";
+var GEMINI_CANONICAL_PERMISSIONS = ".agentsmesh/permissions.yaml";
 
 // src/targets/gemini-cli/format-helpers.ts
-var AGENTSMESH_MCP3 = ".agentsmesh/mcp.json";
-var AGENTSMESH_HOOKS2 = ".agentsmesh/hooks.yaml";
-var AGENTSMESH_IGNORE3 = ".agentsmesh/ignore";
 function mapGeminiHookEvent(event) {
   switch (event) {
     case "BeforeTool":
@@ -3912,25 +4115,25 @@ async function importGeminiSettings(projectRoot, results) {
   if (!settings) return;
   const mcpServers = settings.mcpServers;
   if (mcpServers !== void 0 && typeof mcpServers === "object" && mcpServers !== null && Object.keys(mcpServers).length > 0) {
-    const mcpPath = join28(projectRoot, AGENTSMESH_MCP3);
+    const mcpPath = join28(projectRoot, GEMINI_CANONICAL_MCP);
     await mkdirp(join28(projectRoot, ".agentsmesh"));
     await writeFileAtomic(mcpPath, JSON.stringify({ mcpServers }, null, 2));
     results.push({
       fromTool: "gemini-cli",
       fromPath: settingsPath,
-      toPath: AGENTSMESH_MCP3,
+      toPath: GEMINI_CANONICAL_MCP,
       feature: "mcp"
     });
   }
   const ignorePatterns = settings.ignorePatterns;
   if (Array.isArray(ignorePatterns) && ignorePatterns.length > 0 && ignorePatterns.every((p) => typeof p === "string")) {
-    const ignorePath = join28(projectRoot, AGENTSMESH_IGNORE3);
+    const ignorePath = join28(projectRoot, GEMINI_CANONICAL_IGNORE);
     await mkdirp(join28(projectRoot, ".agentsmesh"));
     await writeFileAtomic(ignorePath, ignorePatterns.join("\n") + "\n");
     results.push({
       fromTool: "gemini-cli",
       fromPath: settingsPath,
-      toPath: AGENTSMESH_IGNORE3,
+      toPath: GEMINI_CANONICAL_IGNORE,
       feature: "ignore"
     });
   }
@@ -3967,13 +4170,13 @@ async function importGeminiSettings(projectRoot, results) {
     );
     if (mappedHooks.length > 0) {
       const hooksYaml = Object.fromEntries(mappedHooks);
-      const hooksPath = join28(projectRoot, AGENTSMESH_HOOKS2);
+      const hooksPath = join28(projectRoot, GEMINI_CANONICAL_HOOKS);
       await mkdirp(join28(projectRoot, ".agentsmesh"));
       await writeFileAtomic(hooksPath, stringifyYaml(hooksYaml, { lineWidth: 0 }).trimEnd());
       results.push({
         fromTool: "gemini-cli",
         fromPath: settingsPath,
-        toPath: AGENTSMESH_HOOKS2,
+        toPath: GEMINI_CANONICAL_HOOKS,
         feature: "hooks"
       });
     }
@@ -3986,12 +4189,12 @@ async function importGeminiIgnore(projectRoot, results) {
     const patterns = geminiIgnoreContent.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
     if (patterns.length > 0) {
       await mkdirp(join28(projectRoot, ".agentsmesh"));
-      const ignorePath = join28(projectRoot, AGENTSMESH_IGNORE3);
+      const ignorePath = join28(projectRoot, GEMINI_CANONICAL_IGNORE);
       await writeFileAtomic(ignorePath, patterns.join("\n") + "\n");
       results.push({
         fromTool: "gemini-cli",
         fromPath: geminiIgnorePath,
-        toPath: AGENTSMESH_IGNORE3,
+        toPath: GEMINI_CANONICAL_IGNORE,
         feature: "ignore"
       });
     }
@@ -3999,10 +4202,8 @@ async function importGeminiIgnore(projectRoot, results) {
 }
 
 // src/targets/gemini-cli/importer-mappers.ts
-var AGENTSMESH_RULES5 = ".agentsmesh/rules";
-var AGENTSMESH_COMMANDS4 = ".agentsmesh/commands";
 async function mapGeminiRuleFile(srcPath, destDir, normalizeTo) {
-  const destFileName = `${basename20(srcPath, ".md")}.md`;
+  const destFileName = `${basename21(srcPath, ".md")}.md`;
   const destPath = join29(destDir, destFileName);
   const { frontmatter, body } = parseFlexibleFrontmatter(normalizeTo(destPath));
   const globs = toGlobsArray(frontmatter.globs);
@@ -4016,7 +4217,7 @@ async function mapGeminiRuleFile(srcPath, destDir, normalizeTo) {
   });
   return {
     destPath,
-    toPath: `${AGENTSMESH_RULES5}/${destFileName}`,
+    toPath: `${GEMINI_CANONICAL_RULES_DIR}/${destFileName}`,
     feature: "rules",
     content: await serializeImportedRuleWithFallback(destPath, canonicalFm, body)
   };
@@ -4033,7 +4234,7 @@ async function mapGeminiCommandFile(srcPath, destDir, normalizeTo, geminiCommand
   const allowedTools = fromCamel.length > 0 ? fromCamel : fromKebab;
   return {
     destPath,
-    toPath: `${AGENTSMESH_COMMANDS4}/${name}.md`,
+    toPath: `${GEMINI_CANONICAL_COMMANDS_DIR}/${name}.md`,
     feature: "commands",
     content: await serializeImportedCommandWithFallback(
       destPath,
@@ -4063,7 +4264,6 @@ function parseTomlCommand(normalized) {
 import { parse as parseToml5 } from "smol-toml";
 import { stringify as stringifyYaml2 } from "yaml";
 import { join as join30 } from "path";
-var AB_PERMISSIONS3 = ".agentsmesh/permissions.yaml";
 function unescapeRegexLiteral(value) {
   return value.replace(/\\(.)/g, "$1");
 }
@@ -4153,28 +4353,24 @@ async function importGeminiPolicies(projectRoot) {
   }
   if (allow.length === 0 && deny.length === 0) return results;
   await mkdirp(join30(projectRoot, ".agentsmesh"));
-  const outPath = join30(projectRoot, AB_PERMISSIONS3);
+  const outPath = join30(projectRoot, GEMINI_CANONICAL_PERMISSIONS);
   const yaml = stringifyYaml2({ allow, deny });
   await writeFileAtomic(outPath, yaml.trimEnd() + "\n");
   results.push({
-    fromTool: "gemini-cli",
+    fromTool: GEMINI_TARGET,
     fromPath: join30(projectRoot, GEMINI_POLICIES_DIR),
-    toPath: AB_PERMISSIONS3,
+    toPath: GEMINI_CANONICAL_PERMISSIONS,
     feature: "permissions"
   });
   return results;
 }
 
 // src/targets/gemini-cli/importer.ts
-var AGENTSMESH_RULES6 = ".agentsmesh/rules";
-var AGENTSMESH_COMMANDS5 = ".agentsmesh/commands";
-var AGENTSMESH_AGENTS3 = ".agentsmesh/agents";
-var AGENTSMESH_SKILLS3 = ".agentsmesh/skills";
 async function importFromGemini(projectRoot) {
   const results = [];
-  const normalize = await createImportReferenceNormalizer("gemini-cli", projectRoot);
-  const rulesDir = join31(projectRoot, AGENTSMESH_RULES6);
-  const commandsDir = join31(projectRoot, AGENTSMESH_COMMANDS5);
+  const normalize = await createImportReferenceNormalizer(GEMINI_TARGET, projectRoot);
+  const rulesDir = join31(projectRoot, GEMINI_CANONICAL_RULES_DIR);
+  const commandsDir = join31(projectRoot, GEMINI_CANONICAL_COMMANDS_DIR);
   const geminiRootPath = join31(projectRoot, GEMINI_ROOT);
   const compatAgentsRootPath = join31(projectRoot, GEMINI_COMPAT_AGENTS);
   const compatInnerRootPath = join31(projectRoot, GEMINI_COMPAT_INNER_ROOT);
@@ -4204,7 +4400,7 @@ async function importFromGemini(projectRoot) {
     results.push({
       fromTool: "gemini-cli",
       fromPath: rootSourcePath,
-      toPath: `${AGENTSMESH_RULES6}/_root.md`,
+      toPath: `${GEMINI_CANONICAL_RULES_DIR}/_root.md`,
       feature: "rules"
     });
   }
@@ -4232,15 +4428,15 @@ async function importFromGemini(projectRoot) {
   );
   const geminiSkillsPath = join31(projectRoot, GEMINI_SKILLS_DIR);
   const skillDirs = await readDirRecursive(geminiSkillsPath);
-  const skillMdFiles = skillDirs.filter((f) => basename21(f) === "SKILL.md");
+  const skillMdFiles = skillDirs.filter((f) => basename22(f) === "SKILL.md");
   for (const srcPath of skillMdFiles) {
     const content = await readFileSafe(srcPath);
     if (!content) continue;
-    const skillName = basename21(srcPath.slice(0, -"/SKILL.md".length));
+    const skillName = basename22(srcPath.slice(0, -"/SKILL.md".length));
     const rawParsed = parseFrontmatter(content);
     const projectedAgent = parseProjectedAgentSkillFrontmatter(rawParsed.frontmatter, skillName);
     if (projectedAgent) {
-      const agentsDir = join31(projectRoot, AGENTSMESH_AGENTS3);
+      const agentsDir = join31(projectRoot, GEMINI_CANONICAL_AGENTS_DIR);
       await mkdirp(agentsDir);
       const agentPath = join31(agentsDir, `${projectedAgent.name}.md`);
       await writeFileAtomic(
@@ -4250,20 +4446,20 @@ async function importFromGemini(projectRoot) {
       results.push({
         fromTool: "gemini-cli",
         fromPath: srcPath,
-        toPath: `${AGENTSMESH_AGENTS3}/${projectedAgent.name}.md`,
+        toPath: `${GEMINI_CANONICAL_AGENTS_DIR}/${projectedAgent.name}.md`,
         feature: "agents"
       });
       continue;
     }
-    const destPath = join31(projectRoot, AGENTSMESH_SKILLS3, skillName, "SKILL.md");
+    const destPath = join31(projectRoot, GEMINI_CANONICAL_SKILLS_DIR, skillName, "SKILL.md");
     const normalized = normalize(content, srcPath, destPath);
-    const skillDir = join31(projectRoot, AGENTSMESH_SKILLS3, skillName);
+    const skillDir = join31(projectRoot, GEMINI_CANONICAL_SKILLS_DIR, skillName);
     await mkdirp(skillDir);
     await writeFileAtomic(destPath, normalized);
     results.push({
       fromTool: "gemini-cli",
       fromPath: srcPath,
-      toPath: `${AGENTSMESH_SKILLS3}/${skillName}/SKILL.md`,
+      toPath: `${GEMINI_CANONICAL_SKILLS_DIR}/${skillName}/SKILL.md`,
       feature: "skills"
     });
     const allSkillFiles = await readDirRecursive(dirname16(srcPath));
@@ -4278,7 +4474,7 @@ async function importFromGemini(projectRoot) {
       results.push({
         fromTool: "gemini-cli",
         fromPath: absPath,
-        toPath: `${AGENTSMESH_SKILLS3}/${skillName}/${relPath}`,
+        toPath: `${GEMINI_CANONICAL_SKILLS_DIR}/${skillName}/${relPath}`,
         feature: "skills"
       });
     }
@@ -4292,8 +4488,8 @@ async function importFromGemini(projectRoot) {
       const content = await readFileSafe(srcPath);
       if (!content) continue;
       const { frontmatter, body } = parseFrontmatter(content);
-      const name = typeof frontmatter.name === "string" ? frontmatter.name : basename21(srcPath, ".md");
-      const agentsDir = join31(projectRoot, AGENTSMESH_AGENTS3);
+      const name = typeof frontmatter.name === "string" ? frontmatter.name : basename22(srcPath, ".md");
+      const agentsDir = join31(projectRoot, GEMINI_CANONICAL_AGENTS_DIR);
       await mkdirp(agentsDir);
       const destPath = join31(agentsDir, `${name}.md`);
       const normalizedBody = normalize(body, srcPath, destPath);
@@ -4312,7 +4508,7 @@ async function importFromGemini(projectRoot) {
       results.push({
         fromTool: "gemini-cli",
         fromPath: srcPath,
-        toPath: `${AGENTSMESH_AGENTS3}/${name}.md`,
+        toPath: `${GEMINI_CANONICAL_AGENTS_DIR}/${name}.md`,
         feature: "agents"
       });
     }
@@ -4444,24 +4640,21 @@ function validateRules(canonical, projectRoot, projectFiles) {
 }
 
 // src/targets/claude-code/linter.ts
-var TARGET = "claude-code";
 function lintRules(canonical, _projectRoot, projectFiles) {
   const diags = validateRules(canonical, _projectRoot, projectFiles);
-  return diags.map((d) => ({ ...d, target: TARGET }));
+  return diags.map((d) => ({ ...d, target: CLAUDE_CODE_TARGET }));
 }
 
 // src/targets/cursor/linter.ts
-var TARGET2 = "cursor";
 function lintRules2(canonical, _projectRoot, projectFiles) {
   const diags = validateRules(canonical, _projectRoot, projectFiles);
-  return diags.map((d) => ({ ...d, target: TARGET2 }));
+  return diags.map((d) => ({ ...d, target: CURSOR_TARGET }));
 }
 
 // src/targets/copilot/linter.ts
-var TARGET3 = "copilot";
 function lintRules3(canonical, projectRoot, projectFiles) {
   const diags = validateRules(canonical, projectRoot, projectFiles);
-  const targetDiags = diags.map((d) => ({ ...d, target: TARGET3 }));
+  const targetDiags = diags.map((d) => ({ ...d, target: COPILOT_TARGET }));
   const nonRootWithoutGlobs = canonical.rules.filter(
     (rule) => !rule.root && rule.globs.length === 0
   );
@@ -4470,47 +4663,42 @@ function lintRules3(canonical, projectRoot, projectFiles) {
     ...nonRootWithoutGlobs.map((rule) => ({
       level: "warning",
       file: rule.source,
-      target: TARGET3,
+      target: COPILOT_TARGET,
       message: "Copilot path-specific instructions require applyTo globs; non-root rules without globs are not generated."
     }))
   ];
 }
 
 // src/targets/continue/linter.ts
-var TARGET4 = "continue";
 function lintRules4(canonical, projectRoot, projectFiles) {
   return validateRules(canonical, projectRoot, projectFiles).map((diagnostic) => ({
     ...diagnostic,
-    target: TARGET4
+    target: CONTINUE_TARGET
   }));
 }
 
 // src/targets/junie/linter.ts
-var TARGET5 = "junie";
 function lintRules5(canonical, projectRoot, projectFiles) {
   return validateRules(canonical, projectRoot, projectFiles).map((diagnostic) => ({
     ...diagnostic,
-    target: TARGET5
+    target: JUNIE_TARGET
   }));
 }
 
 // src/targets/gemini-cli/linter.ts
-var TARGET6 = "gemini-cli";
 function lintRules6(canonical, projectRoot, projectFiles) {
   const diags = validateRules(canonical, projectRoot, projectFiles);
-  return diags.map((d) => ({ ...d, target: TARGET6 }));
+  return diags.map((d) => ({ ...d, target: GEMINI_TARGET }));
 }
 
 // src/targets/cline/linter.ts
-var TARGET7 = "cline";
 function lintRules7(canonical, projectRoot, projectFiles) {
   const diags = validateRules(canonical, projectRoot, projectFiles);
-  return diags.map((d) => ({ ...d, target: TARGET7 }));
+  return diags.map((d) => ({ ...d, target: CLINE_TARGET }));
 }
 
 // src/targets/codex-cli/linter.ts
 import { relative as relative11 } from "path";
-var TARGET8 = "codex-cli";
 function lintRules8(canonical, projectRoot, _projectFiles) {
   const { rules } = canonical;
   if (rules.length === 0) return [];
@@ -4520,7 +4708,7 @@ function lintRules8(canonical, projectRoot, _projectFiles) {
       {
         level: "warning",
         file: relative11(projectRoot, rules[0].source),
-        target: TARGET8,
+        target: CODEX_TARGET,
         message: "Codex needs a root rule to generate AGENTS.md. Add root: true to a rule."
       }
     ];
@@ -4530,7 +4718,6 @@ function lintRules8(canonical, projectRoot, _projectFiles) {
 
 // src/targets/windsurf/linter.ts
 import { relative as relative12 } from "path";
-var TARGET9 = "windsurf";
 function lintRules9(canonical, projectRoot, _projectFiles) {
   const diags = [];
   const { rules } = canonical;
@@ -4540,7 +4727,7 @@ function lintRules9(canonical, projectRoot, _projectFiles) {
       diags.push({
         level: "warning",
         file: relative12(projectRoot, rules[0].source),
-        target: TARGET9,
+        target: WINDSURF_TARGET,
         message: "Windsurf needs a root rule to generate AGENTS.md. Add root: true to a rule."
       });
     }
@@ -4552,7 +4739,7 @@ function lintRules9(canonical, projectRoot, _projectFiles) {
     diags.push({
       level: "warning",
       file: ".agentsmesh",
-      target: TARGET9,
+      target: WINDSURF_TARGET,
       message: `Windsurf cannot project these features yet: ${unsupported.join(", ")}.`
     });
   }
@@ -5304,7 +5491,7 @@ async function resolveExtendPaths(config, configDir, options = {}) {
 import { join as join38 } from "path";
 
 // src/canonical/rules.ts
-import { basename as basename22 } from "path";
+import { basename as basename23 } from "path";
 init_markdown();
 var VALID_TRIGGERS = ["always_on", "model_decision", "glob", "manual"];
 function toStrArray(v) {
@@ -5320,7 +5507,7 @@ async function parseRules(rulesDir) {
     const content = await readFileSafe(path);
     if (!content) continue;
     const { frontmatter, body } = parseFrontmatter(content);
-    const name = basename22(path, ".md");
+    const name = basename23(path, ".md");
     const rootFromFilename = name === "_root";
     const rootFromFm = frontmatter.root === true;
     const triggerRaw = frontmatter.trigger;
@@ -5345,7 +5532,7 @@ async function parseRules(rulesDir) {
 }
 
 // src/canonical/commands.ts
-import { basename as basename23 } from "path";
+import { basename as basename24 } from "path";
 init_markdown();
 function toToolsArray2(v) {
   if (Array.isArray(v)) {
@@ -5364,7 +5551,7 @@ async function parseCommands(commandsDir) {
     const content = await readFileSafe(path);
     if (!content) continue;
     const { frontmatter, body } = parseFrontmatter(content);
-    const name = basename23(path, ".md");
+    const name = basename24(path, ".md");
     const fromCamel = toToolsArray2(frontmatter.allowedTools);
     const fromKebab = toToolsArray2(frontmatter["allowed-tools"]);
     const allowedTools = fromCamel.length > 0 ? fromCamel : fromKebab;
@@ -5380,7 +5567,7 @@ async function parseCommands(commandsDir) {
 }
 
 // src/canonical/agents.ts
-import { basename as basename24 } from "path";
+import { basename as basename25 } from "path";
 init_markdown();
 function toStrArray2(v) {
   if (Array.isArray(v)) {
@@ -5413,7 +5600,7 @@ async function parseAgents(agentsDir) {
     const content = await readFileSafe(path);
     if (!content) continue;
     const { frontmatter, body } = parseFrontmatter(content);
-    const name = basename24(path, ".md");
+    const name = basename25(path, ".md");
     const toolsCamel = toStrArray2(frontmatter.tools);
     const toolsKebab = toStrArray2(frontmatter["tools"]);
     const tools = toolsCamel.length > 0 ? toolsCamel : toolsKebab;
@@ -5447,7 +5634,7 @@ async function parseAgents(agentsDir) {
 }
 
 // src/canonical/skills.ts
-import { basename as basename25, join as join37 } from "path";
+import { basename as basename26, join as join37 } from "path";
 import { readdir as readdir8 } from "fs/promises";
 init_markdown();
 async function readContent(path) {
@@ -5455,6 +5642,10 @@ async function readContent(path) {
   return c2 ?? "";
 }
 var SKILL_FILE = "SKILL.md";
+var EXCLUDED_DIR_PREFIXES = [".git", "node_modules"];
+function sanitizeSkillName(raw) {
+  return raw.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
 async function listSupportingFiles(skillDir) {
   const files = await readDirRecursive(skillDir);
   const result = [];
@@ -5462,6 +5653,9 @@ async function listSupportingFiles(skillDir) {
     const raw = absPath.slice(skillDir.length + 1);
     const name = raw.replace(/\\/g, "/");
     if (name === SKILL_FILE || name.endsWith(`/${SKILL_FILE}`)) continue;
+    const firstSegment = name.split("/")[0];
+    if (EXCLUDED_DIR_PREFIXES.some((p) => firstSegment === p)) continue;
+    if (name === ".DS_Store" || name.endsWith("/.DS_Store")) continue;
     const content = await readContent(absPath);
     result.push({ relativePath: name, absolutePath: absPath, content });
   }
@@ -5473,9 +5667,10 @@ async function parseSkillDirectory(skillDir) {
   if (!content) return null;
   const { frontmatter, body } = parseFrontmatter(content);
   const supportingFiles = await listSupportingFiles(skillDir);
+  const fmName = typeof frontmatter.name === "string" ? sanitizeSkillName(frontmatter.name) : "";
   return {
     source: skillPath,
-    name: basename25(skillDir),
+    name: fmName || basename26(skillDir),
     description: typeof frontmatter.description === "string" ? frontmatter.description : "",
     body,
     supportingFiles
@@ -5672,14 +5867,14 @@ async function loadCanonicalFiles(projectRoot) {
 }
 
 // src/canonical/merge.ts
-import { basename as basename26 } from "path";
-function ruleSlug(r) {
-  return basename26(r.source, ".md");
+import { basename as basename27 } from "path";
+function ruleSlug2(r) {
+  return basename27(r.source, ".md");
 }
 function mergeCanonicalFiles(base, overlay) {
-  const baseRuleMap = new Map(base.rules.map((r) => [ruleSlug(r), r]));
+  const baseRuleMap = new Map(base.rules.map((r) => [ruleSlug2(r), r]));
   for (const r of overlay.rules) {
-    baseRuleMap.set(ruleSlug(r), r);
+    baseRuleMap.set(ruleSlug2(r), r);
   }
   const baseCmdMap = new Map(base.commands.map((c2) => [c2.name, c2]));
   for (const c2 of overlay.commands) {
@@ -5882,7 +6077,7 @@ async function loadSkillsAtExtendPath(skillsRoot) {
 }
 
 // src/canonical/load-canonical-slice.ts
-import { basename as basename27, dirname as dirname18, join as join41 } from "path";
+import { basename as basename28, dirname as dirname18, join as join41 } from "path";
 import { stat as stat4 } from "fs/promises";
 function emptyCanonical() {
   return {
@@ -5913,8 +6108,8 @@ async function normalizeSlicePath(absolutePath) {
     );
   }
   const parent = dirname18(absolutePath);
-  const parentBase = basename27(parent);
-  const fileBase = basename27(absolutePath);
+  const parentBase = basename28(parent);
+  const fileBase = basename28(absolutePath);
   const slug = fileBase.replace(/\.md$/i, "");
   if (parentBase === "rules") {
     return { sliceRoot: parent, implicitPick: { rules: [slug] } };
@@ -5930,7 +6125,7 @@ async function normalizeSlicePath(absolutePath) {
   );
 }
 async function parseRulesAt(sliceRoot) {
-  const base = basename27(sliceRoot);
+  const base = basename28(sliceRoot);
   if (base === "rules") {
     return parseRules(sliceRoot);
   }
@@ -5941,7 +6136,7 @@ async function parseRulesAt(sliceRoot) {
   return [];
 }
 async function parseCommandsAt(sliceRoot) {
-  const base = basename27(sliceRoot);
+  const base = basename28(sliceRoot);
   if (base === "commands") {
     return parseCommands(sliceRoot);
   }
@@ -5952,7 +6147,7 @@ async function parseCommandsAt(sliceRoot) {
   return [];
 }
 async function parseAgentsAt(sliceRoot) {
-  const base = basename27(sliceRoot);
+  const base = basename28(sliceRoot);
   if (base === "agents") {
     return parseAgents(sliceRoot);
   }
@@ -6052,7 +6247,7 @@ Expected one of: .agentsmesh/, ${KNOWN_NATIVE_PATHS.join(", ")}.`
 }
 
 // src/canonical/extend-pick.ts
-import { basename as basename28 } from "path";
+import { basename as basename29 } from "path";
 function applyExtendPick(canonical, features, pick, extendName) {
   if (!pick) return canonical;
   let next = { ...canonical };
@@ -6095,7 +6290,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) => basename28(src).replace(/\.md$/i, "");
+    const stem = (src) => basename29(src).replace(/\.md$/i, "");
     next = {
       ...next,
       rules: prev.filter((r) => wanted.has(stem(r.source)))
@@ -6487,7 +6682,7 @@ function generateRules(canonical) {
   const root = canonical.rules.find((r) => r.root);
   if (root) {
     outputs.push({
-      path: ".claude/CLAUDE.md",
+      path: CLAUDE_ROOT,
       content: root.body.trim() ? root.body : ""
     });
   }
@@ -6500,7 +6695,7 @@ function generateRules(canonical) {
     if (rule.description) frontmatter.description = rule.description;
     if (rule.globs.length > 0) frontmatter.globs = rule.globs;
     const content = serializeFrontmatter(frontmatter, rule.body.trim() || "");
-    outputs.push({ path: `.claude/rules/${slug}.md`, content });
+    outputs.push({ path: `${CLAUDE_RULES_DIR}/${slug}.md`, content });
   }
   return outputs;
 }
@@ -6512,7 +6707,7 @@ function generateCommands(canonical) {
     };
     if (frontmatter["allowed-tools"] === void 0) delete frontmatter["allowed-tools"];
     const content = serializeFrontmatter(frontmatter, cmd.body.trim() || "");
-    return { path: `.claude/commands/${cmd.name}.md`, content };
+    return { path: `${CLAUDE_COMMANDS_DIR}/${cmd.name}.md`, content };
   });
 }
 function generateAgents(canonical) {
@@ -6534,13 +6729,13 @@ function generateAgents(canonical) {
       if (frontmatter[k] === void 0) delete frontmatter[k];
     });
     const content = serializeFrontmatter(frontmatter, agent.body.trim() || "");
-    return { path: `.claude/agents/${agent.name}.md`, content };
+    return { path: `${CLAUDE_AGENTS_DIR}/${agent.name}.md`, content };
   });
 }
 function generateMcp(canonical) {
   if (!canonical.mcp || Object.keys(canonical.mcp.mcpServers).length === 0) return [];
   const content = JSON.stringify({ mcpServers: canonical.mcp.mcpServers }, null, 2);
-  return [{ path: ".mcp.json", content }];
+  return [{ path: CLAUDE_MCP_JSON, content }];
 }
 function generateSkills(canonical) {
   const outputs = [];
@@ -6552,13 +6747,13 @@ function generateSkills(canonical) {
     if (frontmatter.description === void 0) delete frontmatter.description;
     const skillContent = serializeFrontmatter(frontmatter, skill.body.trim() || "");
     outputs.push({
-      path: `.claude/skills/${skill.name}/SKILL.md`,
+      path: `${CLAUDE_SKILLS_DIR}/${skill.name}/SKILL.md`,
       content: skillContent
     });
     for (const file of skill.supportingFiles) {
       const relPath = file.relativePath.replace(/\\/g, "/");
       outputs.push({
-        path: `.claude/skills/${skill.name}/${relPath}`,
+        path: `${CLAUDE_SKILLS_DIR}/${skill.name}/${relPath}`,
         content: file.content
       });
     }
@@ -6570,7 +6765,7 @@ function generatePermissions(canonical) {
   const { allow, deny } = canonical.permissions;
   if (allow.length === 0 && deny.length === 0) return [];
   const content = JSON.stringify({ permissions: { allow, deny } }, null, 2);
-  return [{ path: ".claude/settings.json", content }];
+  return [{ path: CLAUDE_SETTINGS, content }];
 }
 function toClaudeCodeHooks(hooks) {
   const result = {};
@@ -6598,17 +6793,18 @@ function generateHooks(canonical) {
   const claudeHooks = toClaudeCodeHooks(canonical.hooks);
   if (Object.keys(claudeHooks).length === 0) return [];
   const content = JSON.stringify({ hooks: claudeHooks }, null, 2);
-  return [{ path: ".claude/settings.json", content }];
+  return [{ path: CLAUDE_SETTINGS, content }];
 }
 function generateIgnore(canonical) {
   if (!canonical.ignore || canonical.ignore.length === 0) return [];
   const content = canonical.ignore.join("\n");
-  return [{ path: ".claudeignore", content }];
+  return [{ path: CLAUDE_IGNORE, content }];
 }
 
 // src/targets/claude-code/index.ts
 var target = {
   name: "claude-code",
+  primaryRootInstructionPath: CLAUDE_ROOT,
   generateRules,
   generateCommands,
   generateAgents,
@@ -6628,11 +6824,11 @@ function generateRules2(canonical) {
   const root = canonical.rules.find((r) => r.root);
   if (root) {
     const body = root.body.trim() ? root.body : "";
-    outputs.push({ path: "AGENTS.md", content: body });
+    outputs.push({ path: CURSOR_COMPAT_AGENTS, content: body });
     const frontmatter = { alwaysApply: true };
     if (root.description) frontmatter.description = root.description;
     const content = serializeFrontmatter(frontmatter, body);
-    outputs.push({ path: ".cursor/rules/general.mdc", content });
+    outputs.push({ path: CURSOR_GENERAL_RULE, content });
   }
   const nonRoot = canonical.rules.filter(
     (r) => !r.root && (r.targets.length === 0 || r.targets.includes("cursor"))
@@ -6644,20 +6840,20 @@ function generateRules2(canonical) {
     if (rule.description) frontmatter.description = rule.description;
     if (rule.globs.length > 0) frontmatter.globs = rule.globs;
     const content = serializeFrontmatter(frontmatter, rule.body.trim() || "");
-    outputs.push({ path: `.cursor/rules/${slug}.mdc`, content });
+    outputs.push({ path: `${CURSOR_RULES_DIR}/${slug}.mdc`, content });
   }
   return outputs;
 }
 function generateCommands2(canonical) {
   return canonical.commands.map((cmd) => ({
-    path: `.cursor/commands/${cmd.name}.md`,
+    path: `${CURSOR_COMMANDS_DIR}/${cmd.name}.md`,
     content: cmd.body.trim() || ""
   }));
 }
 function generateMcp2(canonical) {
   if (!canonical.mcp || Object.keys(canonical.mcp.mcpServers).length === 0) return [];
   const content = JSON.stringify({ mcpServers: canonical.mcp.mcpServers }, null, 2);
-  return [{ path: ".cursor/mcp.json", content }];
+  return [{ path: CURSOR_MCP, content }];
 }
 function generateSkills2(canonical) {
   const outputs = [];
@@ -6668,10 +6864,13 @@ function generateSkills2(canonical) {
     };
     if (frontmatter.description === void 0) delete frontmatter.description;
     const content = serializeFrontmatter(frontmatter, skill.body.trim() || "");
-    outputs.push({ path: `.cursor/skills/${skill.name}/SKILL.md`, content });
+    outputs.push({ path: `${CURSOR_SKILLS_DIR}/${skill.name}/SKILL.md`, content });
     for (const file of skill.supportingFiles) {
       const relPath = file.relativePath.replace(/\\/g, "/");
-      outputs.push({ path: `.cursor/skills/${skill.name}/${relPath}`, content: file.content });
+      outputs.push({
+        path: `${CURSOR_SKILLS_DIR}/${skill.name}/${relPath}`,
+        content: file.content
+      });
     }
   }
   return outputs;
@@ -6695,7 +6894,7 @@ function generateAgents2(canonical) {
       if (frontmatter[k] === void 0) delete frontmatter[k];
     });
     const content = serializeFrontmatter(frontmatter, agent.body.trim() || "");
-    return { path: `.cursor/agents/${agent.name}.md`, content };
+    return { path: `${CURSOR_AGENTS_DIR}/${agent.name}.md`, content };
   });
 }
 function generatePermissions2(_canonical) {
@@ -6727,17 +6926,18 @@ function generateHooks2(canonical) {
   const cursorHooks = toCursorHooks(canonical.hooks);
   if (Object.keys(cursorHooks).length === 0) return [];
   const content = JSON.stringify({ version: 1, hooks: cursorHooks }, null, 2);
-  return [{ path: ".cursor/hooks.json", content }];
+  return [{ path: CURSOR_HOOKS, content }];
 }
 function generateIgnore2(canonical) {
   if (!canonical.ignore || canonical.ignore.length === 0) return [];
   const content = canonical.ignore.join("\n");
-  return [{ path: ".cursorignore", content }];
+  return [{ path: CURSOR_IGNORE, content }];
 }
 
 // src/targets/cursor/index.ts
 var target2 = {
   name: "cursor",
+  primaryRootInstructionPath: CURSOR_GENERAL_RULE,
   generateRules: generateRules2,
   generateCommands: generateCommands2,
   generateAgents: generateAgents2,
@@ -6752,7 +6952,7 @@ registerTarget(target2);
 
 // src/targets/copilot/generator.ts
 init_markdown();
-import { basename as basename29 } from "path";
+import { basename as basename30 } from "path";
 
 // src/targets/copilot/hook-entry.ts
 function hasHookCommand2(entry) {
@@ -6760,8 +6960,8 @@ function hasHookCommand2(entry) {
 }
 
 // src/targets/copilot/generator.ts
-function ruleSlug2(source) {
-  const name = basename29(source, ".md");
+function ruleSlug3(source) {
+  const name = basename30(source, ".md");
   return name === "_root" ? "root" : name;
 }
 function mapHookEvent(event) {
@@ -6781,14 +6981,17 @@ function mapHookEvent(event) {
 function generateRules3(canonical) {
   const root = canonical.rules.find((r) => r.root);
   const outputs = [];
-  if (root?.body.trim()) {
-    outputs.push({ path: COPILOT_INSTRUCTIONS, content: root.body.trim() });
+  if (root) {
+    outputs.push({
+      path: COPILOT_INSTRUCTIONS,
+      content: root.body.trim() || ""
+    });
   }
   for (const rule of canonical.rules) {
     if (rule.root) continue;
     if (rule.targets.length > 0 && !rule.targets.includes("copilot")) continue;
     if (rule.globs.length === 0) continue;
-    const slug = ruleSlug2(rule.source);
+    const slug = ruleSlug3(rule.source);
     const frontmatter = {
       description: rule.description || void 0,
       applyTo: rule.globs.length === 1 ? rule.globs[0] : rule.globs
@@ -6880,6 +7083,7 @@ function generateHooks3(canonical) {
 // src/targets/copilot/index.ts
 var target3 = {
   name: "copilot",
+  primaryRootInstructionPath: COPILOT_INSTRUCTIONS,
   generateRules: generateRules3,
   generateCommands: generateCommands3,
   generateAgents: generateAgents3,
@@ -6938,6 +7142,7 @@ function generateSkills4(canonical) {
 // src/targets/continue/index.ts
 var target4 = {
   name: "continue",
+  primaryRootInstructionPath: CONTINUE_ROOT_RULE,
   generateRules: generateRules4,
   generateCommands: generateCommands4,
   generateSkills: generateSkills4,
@@ -6947,7 +7152,7 @@ var target4 = {
 registerTarget(target4);
 
 // src/targets/junie/generator.ts
-import { basename as basename30 } from "path";
+import { basename as basename31 } from "path";
 function generateRules5(canonical) {
   const outputs = [];
   const root = canonical.rules.find((rule) => rule.root);
@@ -6960,7 +7165,7 @@ function generateRules5(canonical) {
   for (const rule of canonical.rules) {
     if (rule.root) continue;
     if (rule.targets.length > 0 && !rule.targets.includes("junie")) continue;
-    const slug = basename30(rule.source, ".md");
+    const slug = basename31(rule.source, ".md");
     outputs.push({
       path: `${JUNIE_RULES_DIR}/${slug}.md`,
       content: rule.body.trim() || ""
@@ -7002,6 +7207,7 @@ function generateSkills5(canonical) {
 // src/targets/junie/index.ts
 var target5 = {
   name: "junie",
+  primaryRootInstructionPath: JUNIE_DOT_AGENTS,
   generateRules: generateRules5,
   generateCommands: generateCommands5,
   generateAgents: generateAgents4,
@@ -7258,6 +7464,7 @@ function generateGeminiPermissionsPolicies(canonical) {
 // src/targets/gemini-cli/index.ts
 var target6 = {
   name: "gemini-cli",
+  primaryRootInstructionPath: GEMINI_ROOT,
   generateRules: generateRules6,
   generateCommands: generateCommands6,
   generateAgents: generateAgents5,
@@ -7270,10 +7477,10 @@ var target6 = {
 registerTarget(target6);
 
 // src/targets/cline/generator.ts
-import { basename as basename31 } from "path";
+import { basename as basename32 } from "path";
 init_markdown();
-function ruleSlug3(source) {
-  const name = basename31(source, ".md");
+function ruleSlug4(source) {
+  const name = basename32(source, ".md");
   return name === "_root" ? "root" : name;
 }
 function generateRules7(canonical) {
@@ -7286,7 +7493,7 @@ function generateRules7(canonical) {
   for (const rule of canonical.rules) {
     if (rule.root) continue;
     if (rule.targets.length > 0 && !rule.targets.includes("cline")) continue;
-    const slug = ruleSlug3(rule.source);
+    const slug = ruleSlug4(rule.source);
     const frontmatter = {
       description: rule.description || void 0,
       paths: rule.globs.length > 0 ? rule.globs : void 0
@@ -7382,6 +7589,7 @@ function generateSkills7(canonical) {
 // src/targets/cline/index.ts
 var target7 = {
   name: "cline",
+  primaryRootInstructionPath: CLINE_AGENTS_MD,
   generateRules: generateRules7,
   generateWorkflows,
   generateAgents: generateAgents6,
@@ -7414,47 +7622,6 @@ function usesCursorSensitiveInterpolation(server) {
 // src/targets/codex-cli/generator.ts
 init_markdown();
 import { basename as basename33 } from "path";
-
-// src/targets/codex-cli/codex-rule-paths.ts
-import { basename as basename32 } from "path";
-function sanitizeRelativeDir(rawPrefix) {
-  const normalized = rawPrefix.replace(/\\/g, "/").replace(/\/+/g, "/");
-  const stripped = normalized.startsWith("./") ? normalized.slice(2) : normalized;
-  if (stripped.length === 0 || stripped === "." || stripped === "..") return null;
-  if (stripped.startsWith("/") || stripped.startsWith("../") || stripped.includes("/../"))
-    return null;
-  const segments = stripped.split("/");
-  if (segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
-    return null;
-  }
-  return stripped;
-}
-function directoryPrefixFromGlob(glob) {
-  const normalized = glob.replace(/\\/g, "/");
-  if (normalized.startsWith("{")) return null;
-  const wildcardIndex = normalized.search(/[*{]/);
-  if (wildcardIndex < 0) {
-    const trimmed = normalized.replace(/\/+$/, "");
-    return trimmed.length > 0 ? sanitizeRelativeDir(trimmed) : null;
-  }
-  if (wildcardIndex === 0) return null;
-  const prefix = normalized.slice(0, wildcardIndex).replace(/\/+$/, "");
-  return prefix.length > 0 ? sanitizeRelativeDir(prefix) : null;
-}
-function advisorySubdir(rule) {
-  for (const glob of rule.globs) {
-    const prefix = directoryPrefixFromGlob(glob);
-    if (prefix !== null && !prefix.includes("**")) return prefix;
-  }
-  return basename32(rule.source, ".md");
-}
-function codexAdvisoryInstructionPath(rule) {
-  const dir = advisorySubdir(rule);
-  const file = rule.codexInstructionVariant === "override" ? "AGENTS.override.md" : "AGENTS.md";
-  return `${dir}/${file}`;
-}
-
-// src/targets/codex-cli/generator.ts
 function looksLikeCodexRulesDsl(body) {
   return /(^|\n)\s*[A-Za-z_][A-Za-z0-9_]*\s*\(/.test(body);
 }
@@ -7487,22 +7654,21 @@ function generateRules8(canonical) {
   const root = canonical.rules.find((r) => r.root);
   const outputs = [];
   if (root) {
-    outputs.push({ path: AGENTS_MD2, content: root.body.trim() });
+    outputs.push({ path: AGENTS_MD, content: appendCodexRuleIndex(root.body, canonical.rules) });
   }
   for (const rule of canonical.rules) {
     if (rule.root) continue;
-    if (rule.targets.length > 0 && !rule.targets.includes("codex-cli")) continue;
     const slug = basename33(rule.source, ".md");
+    if (rule.targets.length > 0 && !rule.targets.includes("codex-cli")) continue;
     if (rule.codexEmit === "execution") {
       outputs.push({
         path: `${CODEX_RULES_DIR}/${slug}.rules`,
         content: toSafeCodexRulesContent(rule.body)
       });
-      continue;
     }
     outputs.push({
-      path: codexAdvisoryInstructionPath(rule),
-      content: rule.body.trim()
+      path: codexInstructionMirrorPath(rule),
+      content: serializeCodexInstructionMirror(rule)
     });
   }
   return outputs;
@@ -7608,6 +7774,7 @@ function needsTomlQuoting(key) {
 // src/targets/codex-cli/index.ts
 var target8 = {
   name: "codex-cli",
+  primaryRootInstructionPath: AGENTS_MD,
   generateRules: generateRules8,
   generateCommands: generateCommands7,
   generateAgents: generateAgents7,
@@ -7620,7 +7787,7 @@ registerTarget(target8);
 // src/targets/windsurf/generator.ts
 import { basename as basename34 } from "path";
 init_markdown();
-function ruleSlug4(source) {
+function ruleSlug5(source) {
   const name = basename34(source, ".md");
   return name === "_root" ? "root" : name;
 }
@@ -7641,7 +7808,7 @@ function generateRules9(canonical) {
   for (const rule of canonical.rules) {
     if (rule.root) continue;
     if (rule.targets.length > 0 && !rule.targets.includes("windsurf")) continue;
-    const slug = ruleSlug4(rule.source);
+    const slug = ruleSlug5(rule.source);
     const normalizedTrigger = rule.trigger || (rule.globs.length > 0 ? "glob" : void 0);
     const frontmatter = {
       description: rule.description || void 0,
@@ -7754,6 +7921,7 @@ function generateSkills9(canonical) {
 // src/targets/windsurf/index.ts
 var target9 = {
   name: "windsurf",
+  primaryRootInstructionPath: WINDSURF_AGENTS_MD,
   generateRules: generateRules9,
   generateWorkflows: generateWorkflows2,
   generateAgents: generateAgents8,
@@ -7786,6 +7954,13 @@ function addSkillDirectoryMappings(refs, canonicalPath, targetPath) {
 
 // src/core/reference-map-targets.ts
 import { basename as basename35 } from "path";
+
+// src/targets/codex-cli/codex-rule-paths.ts
+function codexAdvisoryInstructionPath(rule) {
+  return codexInstructionMirrorPath(rule);
+}
+
+// src/core/reference-map-targets.ts
 var ROOT_RULE_PATHS = {
   "claude-code": ".claude/CLAUDE.md",
   cursor: ".cursor/rules/general.mdc",
@@ -7794,7 +7969,7 @@ var ROOT_RULE_PATHS = {
   junie: ".junie/AGENTS.md",
   "gemini-cli": GEMINI_ROOT,
   cline: CLINE_AGENTS_MD,
-  "codex-cli": AGENTS_MD2,
+  "codex-cli": AGENTS_MD,
   windsurf: WINDSURF_AGENTS_MD
 };
 var SKILL_DIRS = {
@@ -7828,7 +8003,6 @@ function ruleTargetPath(target10, rule) {
     case "cline":
       return `${CLINE_RULES_DIR}/${slug}.md`;
     case "codex-cli":
-      if (rule.codexEmit === "execution") return `${CODEX_RULES_DIR}/${slug}.rules`;
       return codexAdvisoryInstructionPath(rule);
     case "windsurf":
       return `${WINDSURF_RULES_DIR}/${slug}.md`;
@@ -7937,6 +8111,12 @@ function isClineAgents(result) {
 function isCursorAgents(result) {
   return result.target === "cursor" && result.path.endsWith(AGENTS_SUFFIX);
 }
+function isGeminiAgents(result) {
+  return result.target === "gemini-cli" && result.path.endsWith(AGENTS_SUFFIX);
+}
+function isCompatibilityAgents(result) {
+  return isCursorAgents(result) || isGeminiAgents(result);
+}
 function reverseReferenceMap(target10, canonical, config, cache) {
   const cached = cache.get(target10);
   if (cached) return cached;
@@ -7961,25 +8141,47 @@ function hasEquivalentCanonicalContent(left, right, canonical, config, cache) {
   return normalizeContent(left.content, leftRefs) === normalizeContent(right.content, rightRefs);
 }
 function preferEquivalentCodexAgents(results, canonical, config) {
+  const overlapTargetsByPath = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    if (!result.path.endsWith(AGENTS_SUFFIX)) continue;
+    const targets = overlapTargetsByPath.get(result.path) ?? /* @__PURE__ */ new Set();
+    targets.add(result.target);
+    overlapTargetsByPath.set(result.path, targets);
+  }
   const codexByPath = /* @__PURE__ */ new Map();
   for (const result of results) {
     if (isCodexAgents(result)) codexByPath.set(result.path, result);
   }
   const reverseCache = /* @__PURE__ */ new Map();
   return results.filter((result) => {
-    if (!isWindsurfAgents(result) && !isClineAgents(result) && !isCursorAgents(result)) return true;
+    if (isCursorAgents(result)) {
+      const targets = overlapTargetsByPath.get(result.path);
+      if (targets && [...targets].some((target10) => target10 !== "cursor")) return false;
+    }
+    if (isGeminiAgents(result)) {
+      const targets = overlapTargetsByPath.get(result.path);
+      if (targets && [...targets].some((target10) => target10 !== "cursor" && target10 !== "gemini-cli")) {
+        return false;
+      }
+    }
+    if (!isWindsurfAgents(result) && !isClineAgents(result) && !isCursorAgents(result) && !isGeminiAgents(result)) {
+      return true;
+    }
     const codexResult = codexByPath.get(result.path);
     if (!codexResult) return true;
+    if (isCompatibilityAgents(result) || isWindsurfAgents(result) || isClineAgents(result)) {
+      return false;
+    }
     return !hasEquivalentCanonicalContent(codexResult, result, canonical, config, reverseCache);
   });
 }
 
 // src/core/reference-rewriter.ts
 import { existsSync as existsSync3 } from "fs";
-import { dirname as dirname19, join as join48 } from "path";
+import { dirname as dirname20, join as join48 } from "path";
 
 // src/core/output-source-map.ts
-import { join as join47, normalize as normalizePath2 } from "path";
+import { dirname as dirname19, join as join47, normalize as normalizePath2 } from "path";
 function canonicalRulePath(rule) {
   return `.agentsmesh/rules/${rule.source.split("/").pop()}`;
 }
@@ -8023,8 +8225,30 @@ function ruleOutputPaths(target10, rule, refs) {
   if (target10 === "gemini-cli") {
     paths.push(GEMINI_COMPAT_AGENTS);
   }
+  if (target10 === "codex-cli") {
+    if (!rule.root && rule.codexEmit === "execution") {
+      const slug = rule.source.split("/").pop().replace(/\.md$/, "");
+      paths.push(`${CODEX_RULES_DIR}/${slug}.rules`);
+    }
+  }
   return paths;
 }
+function addPackSkillPaths(refs, target10, canonical, projectRoot) {
+  const skillDir = SKILL_DIRS[target10];
+  if (!skillDir) return;
+  const packsPrefix = join47(projectRoot, ".agentsmesh", "packs");
+  for (const skill of canonical.skills) {
+    const skillSourceDir = dirname19(skill.source);
+    if (!skillSourceDir.startsWith(packsPrefix)) continue;
+    const targetSkillDir = normalizePath2(join47(projectRoot, skillDir, skill.name));
+    refs.set(normalizePath2(skillSourceDir), targetSkillDir);
+    refs.set(normalizePath2(skill.source), normalizePath2(join47(targetSkillDir, "SKILL.md")));
+    for (const file of skill.supportingFiles) {
+      const targetFilePath = normalizePath2(join47(targetSkillDir, file.relativePath));
+      refs.set(normalizePath2(file.absolutePath), targetFilePath);
+    }
+  }
+}
 function buildArtifactPathMap(target10, canonical, config, projectRoot, destinationPath) {
   const refs = new Map(
     [...buildReferenceMap(target10, canonical, config)].map(([canonicalPath, targetPath]) => [
@@ -8041,6 +8265,7 @@ function buildArtifactPathMap(target10, canonical, config, projectRoot, destinat
       );
     }
   }
+  addPackSkillPaths(refs, target10, canonical, projectRoot);
   return refs;
 }
 function buildOutputSourceMap(target10, canonical, config) {
@@ -8077,11 +8302,11 @@ function collectPlannedPaths(projectRoot, results) {
   for (const result of results) {
     const absolutePath = join48(projectRoot, result.path);
     planned.add(absolutePath);
-    let current = dirname19(absolutePath);
+    let current = dirname20(absolutePath);
     while (current.startsWith(projectRoot) && !planned.has(current)) {
       planned.add(current);
       if (current === projectRoot) break;
-      current = dirname19(current);
+      current = dirname20(current);
     }
   }
   return planned;
@@ -8199,6 +8424,23 @@ async function generateFeature(results, targets, canonical, projectRoot, enabled
   }
 }
 
+// src/core/root-instruction-decorator.ts
+function decoratePrimaryRootInstructions(results) {
+  return results.map((result) => {
+    let primaryRootInstructionPath;
+    try {
+      primaryRootInstructionPath = getTarget(result.target).primaryRootInstructionPath;
+    } catch {
+      return result;
+    }
+    if (!primaryRootInstructionPath || result.path !== primaryRootInstructionPath) {
+      return result;
+    }
+    const content = appendAgentsmeshRootInstructionParagraph(result.content);
+    return content === result.content ? result : { ...result, content };
+  });
+}
+
 // src/core/engine-optional-features.ts
 import { join as join51 } from "path";
 
@@ -8452,10 +8694,9 @@ async function generate(ctx) {
   if (hasMcp || hasIgnore || hasHooks || hasAgents) {
     await generateGeminiSettingsFeature(results, targets, canonical, projectRoot);
   }
-  const rewrittenResults = rewriteGeneratedReferences(results, canonical, config, projectRoot).map(
-    refreshResultStatus
-  );
-  return resolveOutputCollisions(preferEquivalentCodexAgents(rewrittenResults, canonical, config));
+  const rewrittenResults = rewriteGeneratedReferences(results, canonical, config, projectRoot);
+  const decoratedResults = decoratePrimaryRootInstructions(rewrittenResults).map(refreshResultStatus);
+  return resolveOutputCollisions(preferEquivalentCodexAgents(decoratedResults, canonical, config));
 }
 
 // src/core/matrix.ts
@@ -9580,7 +9821,7 @@ async function runCheck(flags, projectRoot) {
 import { join as join58 } from "path";
 
 // src/core/merger.ts
-import { dirname as dirname20, join as join57 } from "path";
+import { dirname as dirname21, join as join57 } from "path";
 var LOCK_FILENAME2 = ".lock";
 var CONFLICT_MARKER = "<<<<<<<";
 async function hasLockConflict(abDir) {
@@ -9595,7 +9836,7 @@ async function resolveLockConflict(abDir, libVersion, config) {
     throw new Error("No conflict to resolve.");
   }
   const checksums = await buildChecksums(abDir);
-  const configDir = dirname20(abDir);
+  const configDir = dirname21(abDir);
   const resolvedExtends = config ? await resolveExtendPaths(config, configDir) : [];
   const extendChecksums = resolvedExtends.length > 0 ? await buildExtendChecksums(resolvedExtends) : {};
   const packChecksums = await buildPackChecksums(join57(abDir, "packs"));
@@ -9626,7 +9867,7 @@ async function runMerge(flags, projectRoot) {
 }
 
 // src/install/run-install.ts
-import { join as join71 } from "path";
+import { join as join72 } from "path";
 
 // src/install/git-pin.ts
 import { execFile as execFile2 } from "child_process";
@@ -9785,7 +10026,7 @@ function validateAgent(agent) {
   }
   return { agent, ok: true };
 }
-function ruleSlug5(rule) {
+function ruleSlug6(rule) {
   return basename38(rule.source).replace(/\.md$/i, "");
 }
 
@@ -9822,7 +10063,7 @@ async function resolveRulePool(narrowed, force, dryRun, tty) {
   if (!force && !dryRun && tty) {
     for (const inv of invalid) {
       const ok = await confirm(
-        `Include invalid rule "${ruleSlug5(inv.rule)}" anyway? (${inv.reason}). You can fix it later.`
+        `Include invalid rule "${ruleSlug6(inv.rule)}" anyway? (${inv.reason}). You can fix it later.`
       );
       if (ok) pool.push(inv.rule);
     }
@@ -9876,7 +10117,7 @@ async function resolveAgentPool(narrowed, force, dryRun, tty) {
 // src/install/install-conflicts.ts
 async function resolveInstallConflicts(merged, pools) {
   let skillsSel = pools.skills.map((s) => s.name);
-  let rulesSel = pools.rules.map((r) => ruleSlug5(r));
+  let rulesSel = pools.rules.map((r) => ruleSlug6(r));
   let commandsSel = pools.commands.map((c2) => c2.name);
   let agentsSel = pools.agents.map((a) => a.name);
   for (const s of pools.skills) {
@@ -9888,8 +10129,8 @@ async function resolveInstallConflicts(merged, pools) {
     }
   }
   for (const r of pools.rules) {
-    const slug = ruleSlug5(r);
-    if (merged.rules.some((x) => ruleSlug5(x) === slug)) {
+    const slug = ruleSlug6(r);
+    if (merged.rules.some((x) => ruleSlug6(x) === slug)) {
       const ok = await confirm(
         `Rule "${slug}" already exists in merged config. Add extend anyway?`
       );
@@ -10001,6 +10242,50 @@ function parseGitlabBlobUrl(urlStr) {
     return null;
   }
 }
+var GITHUB_ROUTE_WORDS = /* @__PURE__ */ new Set([
+  "tree",
+  "blob",
+  "commit",
+  "releases",
+  "actions",
+  "issues",
+  "pulls",
+  "settings",
+  "wiki",
+  "discussions",
+  "security",
+  "projects",
+  "packages"
+]);
+function parseGithubRepoUrl(urlStr) {
+  try {
+    const u = new URL3(urlStr);
+    if (u.hostname !== "github.com") return null;
+    const parts = u.pathname.split("/").filter(Boolean).map((s) => s.replace(/\.git$/i, ""));
+    if (parts.length < 2) return null;
+    if (parts.length > 2 || GITHUB_ROUTE_WORDS.has(parts[1])) return null;
+    const org = parts[0];
+    const repo = parts[1];
+    return { org, repo };
+  } catch {
+    return null;
+  }
+}
+function parseGitlabRepoUrl(urlStr) {
+  try {
+    const u = new URL3(urlStr);
+    if (u.hostname !== "gitlab.com") return null;
+    const parts = u.pathname.split("/").filter(Boolean).map((s) => s.replace(/\.git$/i, ""));
+    if (parts.length < 2) return null;
+    if (parts.includes("-")) return null;
+    const project = parts[parts.length - 1];
+    const namespace = parts.slice(0, -1).join("/");
+    if (!namespace || !project) return null;
+    return { namespace, project };
+  } catch {
+    return null;
+  }
+}
 function parseGitSshGithub(ssh) {
   const m = ssh.match(/^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/i);
   if (!m) return null;
@@ -10038,26 +10323,48 @@ async function parseInstallSource(raw, configDir, explicitPath) {
     };
   }
   if (trimmed.startsWith("https://") || trimmed.startsWith("http://")) {
-    const gh = parseGithubTreeUrl(trimmed) ?? parseGithubBlobUrl(trimmed);
-    if (gh) {
+    const ghDetailed = parseGithubTreeUrl(trimmed) ?? parseGithubBlobUrl(trimmed);
+    if (ghDetailed) {
+      return {
+        kind: "github",
+        rawRef: ghDetailed.ref,
+        org: ghDetailed.org,
+        repo: ghDetailed.repo,
+        gitRemoteUrl: `https://github.com/${ghDetailed.org}/${ghDetailed.repo}.git`,
+        pathInRepo: pathFlag || ghDetailed.path
+      };
+    }
+    const ghBare = parseGithubRepoUrl(trimmed);
+    if (ghBare) {
       return {
         kind: "github",
-        rawRef: gh.ref,
-        org: gh.org,
-        repo: gh.repo,
-        gitRemoteUrl: `https://github.com/${gh.org}/${gh.repo}.git`,
-        pathInRepo: pathFlag || gh.path
+        rawRef: "HEAD",
+        org: ghBare.org,
+        repo: ghBare.repo,
+        gitRemoteUrl: `https://github.com/${ghBare.org}/${ghBare.repo}.git`,
+        pathInRepo: pathFlag
       };
     }
-    const gl = parseGitlabTreeUrl(trimmed) ?? parseGitlabBlobUrl(trimmed);
-    if (gl) {
+    const glDetailed = parseGitlabTreeUrl(trimmed) ?? parseGitlabBlobUrl(trimmed);
+    if (glDetailed) {
       return {
         kind: "gitlab",
-        rawRef: gl.ref,
-        org: gl.namespace,
-        repo: gl.project,
-        gitRemoteUrl: `https://gitlab.com/${gl.namespace}/${gl.project}.git`,
-        pathInRepo: pathFlag || gl.path
+        rawRef: glDetailed.ref,
+        org: glDetailed.namespace,
+        repo: glDetailed.project,
+        gitRemoteUrl: `https://gitlab.com/${glDetailed.namespace}/${glDetailed.project}.git`,
+        pathInRepo: pathFlag || glDetailed.path
+      };
+    }
+    const glBare = parseGitlabRepoUrl(trimmed);
+    if (glBare) {
+      return {
+        kind: "gitlab",
+        rawRef: "HEAD",
+        org: glBare.namespace,
+        repo: glBare.project,
+        gitRemoteUrl: `https://gitlab.com/${glBare.namespace}/${glBare.project}.git`,
+        pathInRepo: pathFlag
       };
     }
   }
@@ -10324,7 +10631,7 @@ import { join as join63 } from "path";
 import { rename as rename4 } from "fs/promises";
 
 // src/install/pack-writer.ts
-import { join as join60, basename as basename39, dirname as dirname21 } from "path";
+import { join as join60, basename as basename39, dirname as dirname22 } from "path";
 import { rm as rm6, rename as rename3, mkdir as mkdir5, copyFile as copyFile2 } from "fs/promises";
 import { stringify as yamlStringify6 } from "yaml";
 
@@ -10385,7 +10692,7 @@ async function writeSkills(canonical, packDir) {
     await copyFile2(skill.source, join60(skillDestDir, "SKILL.md"));
     for (const sf of skill.supportingFiles) {
       const destPath = join60(skillDestDir, sf.relativePath);
-      await mkdirp(dirname21(destPath));
+      await mkdirp(dirname22(destPath));
       await copyFile2(sf.absolutePath, destPath);
     }
   }
@@ -10430,7 +10737,7 @@ async function materializePack(packsDir, packName, canonical, metadataInput) {
 }
 
 // src/install/pack-merge.ts
-import { join as join61, basename as basename40, dirname as dirname22 } from "path";
+import { join as join61, basename as basename40, dirname as dirname23 } from "path";
 import { copyFile as copyFile3 } from "fs/promises";
 import { stringify as yamlStringify7 } from "yaml";
 function union(a, b) {
@@ -10493,7 +10800,7 @@ async function mergeSkills(canonical, packDir) {
     await copyFile3(skill.source, join61(destDir, "SKILL.md"));
     for (const sf of skill.supportingFiles) {
       const destPath = join61(destDir, sf.relativePath);
-      await mkdirp(dirname22(destPath));
+      await mkdirp(dirname23(destPath));
       await copyFile3(sf.absolutePath, destPath);
     }
   }
@@ -10620,7 +10927,7 @@ function applySelection(canonical, selected) {
   return {
     ...canonical,
     skills: canonical.skills.filter((s) => skillSet.has(s.name)),
-    rules: canonical.rules.filter((r) => ruleSlugSet.has(ruleSlug5(r))),
+    rules: canonical.rules.filter((r) => ruleSlugSet.has(ruleSlug6(r))),
     commands: canonical.commands.filter((c2) => cmdSet.has(c2.name)),
     agents: canonical.agents.filter((a) => agentSet.has(a.name))
   };
@@ -10892,7 +11199,7 @@ function narrowDiscoveredForInstallScope(canonical, options) {
     const w = new Set(implicitPick.rules);
     next = {
       ...next,
-      rules: implicitPick.rules.length === 0 ? [] : next.rules.filter((r) => w.has(ruleSlug5(r)))
+      rules: implicitPick.rules.length === 0 ? [] : next.rules.filter((r) => w.has(ruleSlug6(r)))
     };
   } else if (scopedFeatures && !allowed.has("rules")) {
     next = { ...next, rules: [] };
@@ -10919,9 +11226,66 @@ function narrowDiscoveredForInstallScope(canonical, options) {
 }
 
 // src/install/manual-install-scope.ts
-import { basename as basename41, dirname as dirname23, join as join65, relative as relative21 } from "path";
-import { cp, mkdtemp, stat as stat5, rm as rm7 } from "fs/promises";
+import { basename as basename41, dirname as dirname24, join as join65, relative as relative22 } from "path";
+import { cp as cp2, mkdtemp, stat as stat5, rm as rm7 } from "fs/promises";
 import { tmpdir } from "os";
+
+// src/install/skill-repo-filter.ts
+import { relative as relative21 } from "path";
+import { cp } from "fs/promises";
+init_markdown();
+var REPO_BOILERPLATE_FILES = /* @__PURE__ */ new Set([
+  "README.md",
+  "README.rst",
+  "README.txt",
+  "README",
+  "LICENSE",
+  "LICENSE.md",
+  "LICENSE.txt",
+  "LICENSE-MIT",
+  "LICENSE-APACHE",
+  "CONTRIBUTING.md",
+  "CHANGELOG.md",
+  "CODE_OF_CONDUCT.md",
+  "package.json",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  ".gitignore",
+  ".gitattributes",
+  ".editorconfig",
+  ".DS_Store"
+]);
+var REPO_BOILERPLATE_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".github",
+  ".gitlab",
+  "node_modules",
+  ".vscode",
+  ".idea"
+]);
+async function readSkillFrontmatterName(skillMdPath) {
+  const content = await readFileSafe(skillMdPath);
+  if (!content) return "";
+  const { frontmatter } = parseFrontmatter(content);
+  if (typeof frontmatter.name !== "string") return "";
+  return frontmatter.name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+async function cpFilteredSkill(sourceRoot, destDir) {
+  await cp(sourceRoot, destDir, {
+    recursive: true,
+    filter: (src) => {
+      const rel2 = relative21(sourceRoot, src).replace(/\\/g, "/");
+      if (rel2 === "") return true;
+      const first = rel2.split("/")[0];
+      if (REPO_BOILERPLATE_DIRS.has(first)) return false;
+      if (!rel2.includes("/") && REPO_BOILERPLATE_FILES.has(rel2)) return false;
+      return true;
+    }
+  });
+}
+
+// src/install/manual-install-scope.ts
 async function createStageRoot() {
   const stageBase = await mkdtemp(join65(tmpdir(), "am-install-manual-"));
   const discoveryRoot = join65(stageBase, "repo");
@@ -10940,7 +11304,7 @@ async function stageMarkdownCollection(sourceRoot, destinationDir) {
       throw new Error(`Manual install only supports .md files for this collection: ${sourceRoot}`);
     }
     await mkdirp(destinationDir);
-    await cp(sourceRoot, join65(destinationDir, basename41(sourceRoot)));
+    await cp2(sourceRoot, join65(destinationDir, basename41(sourceRoot)));
     return;
   }
   const files = (await readDirRecursive(sourceRoot)).filter(
@@ -10960,7 +11324,7 @@ async function stageMarkdownCollection(sourceRoot, destinationDir) {
       );
     }
     usedNames.set(name, file);
-    await cp(file, join65(destinationDir, name));
+    await cp2(file, join65(destinationDir, name));
   }
 }
 async function stagePreferredSkills(sourceRoot, destinationDir, preferredSkillNames) {
@@ -10971,7 +11335,7 @@ async function stagePreferredSkills(sourceRoot, destinationDir, preferredSkillNa
   const matches = /* @__PURE__ */ new Map();
   for (const file of await readDirRecursive(sourceRoot)) {
     if (!file.endsWith("/SKILL.md") && !file.endsWith("\\SKILL.md")) continue;
-    const skillDir = dirname23(file);
+    const skillDir = dirname24(file);
     const skillName = basename41(skillDir);
     if (!wanted.has(skillName)) continue;
     const previous = matches.get(skillName);
@@ -10985,7 +11349,7 @@ async function stagePreferredSkills(sourceRoot, destinationDir, preferredSkillNa
   if (matches.size !== preferredSkillNames.length) return false;
   await mkdirp(destinationDir);
   for (const skillName of preferredSkillNames) {
-    await cp(matches.get(skillName), join65(destinationDir, skillName), { recursive: true });
+    await cp2(matches.get(skillName), join65(destinationDir, skillName), { recursive: true });
   }
   return true;
 }
@@ -10995,10 +11359,10 @@ async function stageSkills(sourceRoot, destinationDir, options = {}) {
     if (basename41(sourceRoot) !== "SKILL.md") {
       throw new Error(`Manual skill install expects SKILL.md or a skill directory: ${sourceRoot}`);
     }
-    const skillName = basename41(dirname23(sourceRoot));
+    const skillName = basename41(dirname24(sourceRoot));
     const skillDir = join65(destinationDir, skillName);
     await mkdirp(skillDir);
-    await cp(dirname23(sourceRoot), skillDir, { recursive: true });
+    await cp2(dirname24(sourceRoot), skillDir, { recursive: true });
     return;
   }
   if (await isSkillPackLayout(sourceRoot)) {
@@ -11006,9 +11370,11 @@ async function stageSkills(sourceRoot, destinationDir, options = {}) {
       if (await stagePreferredSkills(sourceRoot, destinationDir, options.preferredSkillNames ?? [])) {
         return;
       }
-      const skillDir = join65(destinationDir, basename41(sourceRoot));
+      const fmName = await readSkillFrontmatterName(join65(sourceRoot, "SKILL.md"));
+      const skillName = fmName || basename41(sourceRoot);
+      const skillDir = join65(destinationDir, skillName);
       await mkdirp(destinationDir);
-      await cp(sourceRoot, skillDir, { recursive: true });
+      await cpFilteredSkill(sourceRoot, skillDir);
       return;
     }
     if (await stagePreferredSkills(sourceRoot, destinationDir, options.preferredSkillNames ?? [])) {
@@ -11020,10 +11386,10 @@ async function stageSkills(sourceRoot, destinationDir, options = {}) {
     for (const file of entries.filter(
       (entry) => entry.endsWith("/SKILL.md") || entry.endsWith("\\SKILL.md")
     )) {
-      roots.add(relative21(sourceRoot, dirname23(file)).split(/[\\/]/)[0]);
+      roots.add(relative22(sourceRoot, dirname24(file)).split(/[\\/]/)[0]);
     }
     for (const root of roots) {
-      await cp(join65(sourceRoot, root), join65(destinationDir, root), { recursive: true });
+      await cp2(join65(sourceRoot, root), join65(destinationDir, root), { recursive: true });
     }
     return;
   }
@@ -11132,7 +11498,7 @@ function extendPickHasArrays(p) {
 import { basename as basename44, join as join68 } from "path";
 
 // src/install/gemini-install-commands.ts
-import { join as join66, relative as relative22 } from "path";
+import { join as join66, relative as relative23 } from "path";
 async function inferGeminiCommandNamesFromFiles(repoRoot, pathInRepoPosix) {
   const commandsRoot = join66(repoRoot, ...GEMINI_COMMANDS_DIR.split("/"));
   const scanDir = join66(repoRoot, ...pathInRepoPosix.split("/"));
@@ -11140,7 +11506,7 @@ async function inferGeminiCommandNamesFromFiles(repoRoot, pathInRepoPosix) {
   const names = [];
   for (const f of files) {
     if (!/\.(toml|md)$/i.test(f)) continue;
-    const rel2 = relative22(commandsRoot, f).replace(/\\/g, "/");
+    const rel2 = relative23(commandsRoot, f).replace(/\\/g, "/");
     if (rel2.startsWith("..") || rel2 === "") continue;
     const noExt = rel2.replace(/\.(toml|md)$/i, "");
     const name = noExt.split("/").filter(Boolean).join(":");
@@ -11150,16 +11516,16 @@ async function inferGeminiCommandNamesFromFiles(repoRoot, pathInRepoPosix) {
 }
 
 // src/install/native-skill-scan.ts
-import { basename as basename42, dirname as dirname24, relative as relative23 } from "path";
+import { basename as basename42, dirname as dirname25, relative as relative24 } from "path";
 async function skillNamesFromNativeSkillDir(scanRoot) {
   const files = await readDirRecursive(scanRoot);
   const names = /* @__PURE__ */ new Set();
   for (const f of files) {
     if (basename42(f) === "SKILL.md") {
-      names.add(basename42(dirname24(f)));
+      names.add(basename42(dirname25(f)));
       continue;
     }
-    const rel2 = relative23(scanRoot, f).replace(/\\/g, "/");
+    const rel2 = relative24(scanRoot, f).replace(/\\/g, "/");
     if (!rel2.includes("/") && f.toLowerCase().endsWith(".md")) {
       names.add(basename42(f, ".md"));
     }
@@ -11342,8 +11708,8 @@ function isImplicitPickEmpty(p) {
 }
 
 // src/install/native-install-scope.ts
-import { basename as basename45, join as join69, relative as relative24 } from "path";
-import { cp as cp2, mkdtemp as mkdtemp2, rm as rm8 } from "fs/promises";
+import { basename as basename45, join as join69, relative as relative25 } from "path";
+import { cp as cp3, mkdtemp as mkdtemp2, rm as rm8 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 function normalizePath3(path) {
   return path.replace(/\\/g, "/").replace(/\/+$/, "");
@@ -11365,7 +11731,7 @@ async function makeStageRoot(repoRoot) {
     await rm8(stageBase, { recursive: true, force: true });
   };
   try {
-    await cp2(repoRoot, stageRoot, { recursive: true });
+    await cp3(repoRoot, stageRoot, { recursive: true });
     return { stageRoot, cleanup };
   } catch (error) {
     await cleanup();
@@ -11398,7 +11764,7 @@ function buildPickFromResults(results, stageRoot) {
     }
     if (result.feature === "skills" && result.toPath.startsWith(".agentsmesh/skills/")) {
       const rel2 = normalizePath3(
-        relative24(join69(stageRoot, ".agentsmesh", "skills"), join69(stageRoot, result.toPath))
+        relative25(join69(stageRoot, ".agentsmesh", "skills"), join69(stageRoot, result.toPath))
       );
       const skillName = rel2.split("/")[0];
       if (skillName) {
@@ -11586,7 +11952,7 @@ function applyReplayInstallScope(narrowed, discoveredFeatures, replay) {
 }
 
 // src/install/manual-install-persistence.ts
-import { basename as basename46, dirname as dirname25 } from "path";
+import { basename as basename46, dirname as dirname26, join as join71 } from "path";
 import { stat as stat6 } from "fs/promises";
 function trimDot(pathInRepo) {
   return pathInRepo === "." || pathInRepo === "" ? void 0 : pathInRepo;
@@ -11605,27 +11971,28 @@ async function resolveManualInstallPersistence(args) {
   const info = await stat6(args.contentRoot);
   if (args.as !== "skills" && info.isFile() && args.contentRoot.toLowerCase().endsWith(".md")) {
     return {
-      pathInRepo: trimDot(dirname25(normalizedPath)),
+      pathInRepo: trimDot(dirname26(normalizedPath)),
       pick: markdownPick(args.as, normalizedPath || args.contentRoot)
     };
   }
   if (args.as === "skills") {
     if (info.isFile() && basename46(args.contentRoot) === "SKILL.md") {
-      const skillDir = normalizedPath ? dirname25(normalizedPath) : dirname25(args.contentRoot);
+      const skillDir = normalizedPath ? dirname26(normalizedPath) : dirname26(args.contentRoot);
       return {
-        pathInRepo: trimDot(dirname25(skillDir)),
+        pathInRepo: trimDot(dirname26(skillDir)),
         pick: { skills: [basename46(skillDir)] }
       };
     }
     if (info.isDirectory()) {
       const skillDir = normalizedPath || basename46(args.contentRoot);
-      const skillFile = `${args.contentRoot.replace(/\/+$/g, "")}/SKILL.md`;
+      const skillFile = join71(args.contentRoot.replace(/\/+$/g, ""), "SKILL.md");
       try {
         const skillStat = await stat6(skillFile);
         if (skillStat.isFile()) {
+          const fmName = await readSkillFrontmatterName(skillFile);
           return {
-            pathInRepo: trimDot(dirname25(skillDir)),
-            pick: { skills: [basename46(skillDir)] }
+            pathInRepo: trimDot(dirname26(skillDir)),
+            pick: { skills: [fmName || basename46(skillDir)] }
           };
         }
       } catch {
@@ -11693,7 +12060,7 @@ async function runInstall(flags, args, projectRoot, replay) {
     sourceArg
   );
   const pathInRepo = parsed.pathInRepo.replace(/^\/+|\/+$/g, "");
-  const contentRoot = pathInRepo ? join71(resolvedPath, pathInRepo) : resolvedPath;
+  const contentRoot = pathInRepo ? join72(resolvedPath, pathInRepo) : resolvedPath;
   if (!await exists(contentRoot)) {
     throw new Error(`Install path does not exist: ${contentRoot}`);
   }
@@ -11735,7 +12102,7 @@ async function runInstall(flags, args, projectRoot, replay) {
       agents: agentsPool
     }) : {
       skillNames: skillsPool.map((s) => s.name),
-      ruleSlugs: rulesPool.map((r) => ruleSlug5(r)),
+      ruleSlugs: rulesPool.map((r) => ruleSlug6(r)),
       commandNames: commandsPool.map((c2) => c2.name),
       agentNames: agentsPool.map((a) => a.name)
     };