agentsmesh 0.2.10 → 0.3.1

package/dist/cli.js

@@ -91,7 +91,12 @@ var COMMANDS = [
     name: "init",
     usage: "agentsmesh init [flags]",
     description: "Create agentsmesh.yaml, agentsmesh.local.yaml, and canonical .agentsmesh scaffold",
-    flags: [{ name: "--yes", description: "Auto-import detected tool configs without prompting" }]
+    flags: [
+      {
+        name: "--yes",
+        description: "Auto-import detected tool configs, then add example scaffold only under empty canonical paths"
+      }
+    ]
   },
   {
     name: "generate",
@@ -247,7 +252,7 @@ function handleError(err, options) {
 }
 
 // src/cli/commands/generate.ts
-import { join as join55, resolve as resolve4, sep } from "path";
+import { join as join56, resolve as resolve4, sep } from "path";
 
 // src/config/core/loader.ts
 import { parse as parseYaml } from "yaml";
@@ -355,6 +360,7 @@ var TARGET_IDS = [
   "copilot",
   "continue",
   "junie",
+  "kiro",
   "gemini-cli",
   "cline",
   "codex-cli",
@@ -525,7 +531,7 @@ async function loadConfigFromDir(startDir) {
 }
 
 // src/canonical/extends/extends.ts
-import { join as join47 } from "path";
+import { join as join48 } from "path";
 
 // src/config/resolve/resolver.ts
 import { mkdir as mkdir4, rm as rm4 } from "fs/promises";
@@ -1465,7 +1471,7 @@ function mergeIgnore(base, overlay) {
 }
 
 // src/canonical/extends/extend-load.ts
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 
 // src/config/resolve/native-format-detector.ts
 import { join as join10 } from "path";
@@ -1521,6 +1527,10 @@ var TARGET_SIGNATURES = [
   {
     target: "junie",
     paths: [".junie", ".junie/guidelines.md"]
+  },
+  {
+    target: "kiro",
+    paths: [".kiro", ".kiro/steering", ".kiro/settings/mcp.json"]
   }
 ];
 async function detectNativeFormat(repoPath) {
@@ -1543,11 +1553,11 @@ var KNOWN_NATIVE_PATHS = TARGET_SIGNATURES.map((sig) => sig.paths[0]).filter(
 );
 
 // src/targets/claude-code/importer.ts
-import { join as join41, basename as basename26, relative as relative17, dirname as dirname18 } from "path";
+import { join as join42, basename as basename27, relative as relative17, dirname as dirname18 } from "path";
 
 // src/core/reference/import-rewriter.ts
 import { existsSync as existsSync2, realpathSync as realpathSync3 } from "fs";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 import { normalize as normalizePath } from "path";
 
 // src/config/core/conversions.ts
@@ -1562,22 +1572,22 @@ var DEFAULT_AGENTS_TO_SKILLS = {
   // native .codex/agents/*.toml per agent-structures
   windsurf: true
 };
-function hasOwnTarget(map, target12) {
-  return Object.prototype.hasOwnProperty.call(map, target12);
+function hasOwnTarget(map, target13) {
+  return Object.prototype.hasOwnProperty.call(map, target13);
 }
-function usesCommandSkillProjection(target12) {
-  return hasOwnTarget(DEFAULT_COMMANDS_TO_SKILLS, target12);
+function usesCommandSkillProjection(target13) {
+  return hasOwnTarget(DEFAULT_COMMANDS_TO_SKILLS, target13);
 }
-function usesAgentSkillProjection(target12) {
-  return hasOwnTarget(DEFAULT_AGENTS_TO_SKILLS, target12);
+function usesAgentSkillProjection(target13) {
+  return hasOwnTarget(DEFAULT_AGENTS_TO_SKILLS, target13);
 }
-function shouldConvertCommandsToSkills(config, target12) {
-  if (!usesCommandSkillProjection(target12)) return false;
-  return config.conversions?.commands_to_skills?.[target12] ?? DEFAULT_COMMANDS_TO_SKILLS[target12];
+function shouldConvertCommandsToSkills(config, target13) {
+  if (!usesCommandSkillProjection(target13)) return false;
+  return config.conversions?.commands_to_skills?.[target13] ?? DEFAULT_COMMANDS_TO_SKILLS[target13];
 }
-function shouldConvertAgentsToSkills(config, target12) {
-  if (!usesAgentSkillProjection(target12)) return false;
-  return config.conversions?.agents_to_skills?.[target12] ?? DEFAULT_AGENTS_TO_SKILLS[target12];
+function shouldConvertAgentsToSkills(config, target13) {
+  if (!usesAgentSkillProjection(target13)) return false;
+  return config.conversions?.agents_to_skills?.[target13] ?? DEFAULT_AGENTS_TO_SKILLS[target13];
 }
 
 // src/targets/claude-code/constants.ts
@@ -1874,6 +1884,22 @@ var JUNIE_CANONICAL_AGENTS_DIR = ".agentsmesh/agents";
 var JUNIE_CANONICAL_MCP = ".agentsmesh/mcp.json";
 var JUNIE_CANONICAL_IGNORE = ".agentsmesh/ignore";
 
+// src/targets/kiro/constants.ts
+var KIRO_TARGET = "kiro";
+var KIRO_AGENTS_MD = "AGENTS.md";
+var KIRO_DIR = ".kiro";
+var KIRO_STEERING_DIR = `${KIRO_DIR}/steering`;
+var KIRO_SKILLS_DIR = `${KIRO_DIR}/skills`;
+var KIRO_HOOKS_DIR = `${KIRO_DIR}/hooks`;
+var KIRO_SETTINGS_DIR = `${KIRO_DIR}/settings`;
+var KIRO_MCP_FILE = `${KIRO_SETTINGS_DIR}/mcp.json`;
+var KIRO_IGNORE = ".kiroignore";
+var KIRO_CANONICAL_ROOT_RULE = ".agentsmesh/rules/_root.md";
+var KIRO_CANONICAL_RULES_DIR = ".agentsmesh/rules";
+var KIRO_CANONICAL_MCP = ".agentsmesh/mcp.json";
+var KIRO_CANONICAL_HOOKS = ".agentsmesh/hooks.yaml";
+var KIRO_CANONICAL_IGNORE = ".agentsmesh/ignore";
+
 // src/targets/roo-code/constants.ts
 var ROO_CODE_TARGET = "roo-code";
 var ROO_CODE_DIR = ".roo";
@@ -2233,6 +2259,15 @@ async function buildJunieImportPaths(refs, projectRoot) {
     addSkillLikeMapping(refs, rel(projectRoot, absPath), ".junie/skills");
   }
 }
+async function buildKiroImportPaths(refs, projectRoot) {
+  refs.set(KIRO_AGENTS_MD, `${AB_RULES2}/_root.md`);
+  for (const absPath of await listFiles(projectRoot, KIRO_STEERING_DIR)) {
+    addSimpleFileMapping(refs, rel(projectRoot, absPath), AB_RULES2, ".md");
+  }
+  for (const absPath of await listFiles(projectRoot, KIRO_SKILLS_DIR)) {
+    addSkillLikeMapping(refs, rel(projectRoot, absPath), KIRO_SKILLS_DIR);
+  }
+}
 async function buildGeminiCliImportPaths(refs, projectRoot) {
   for (const absPath of await listFiles(projectRoot, ".gemini/rules")) {
     addSimpleFileMapping(refs, rel(projectRoot, absPath), AB_RULES2, ".md");
@@ -2536,7 +2571,12 @@ import { basename as basename8, dirname as dirname5 } from "path";
 // src/targets/projection/root-instruction-paragraph.ts
 var ROOT_INSTRUCTION_BODY_V1 = "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_V2 = "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 ROOT_INSTRUCTION_BODY = "AgentsMesh syncs AI coding tool configuration from a single canonical `.agentsmesh` directory. All target-specific files (`.claude/`, `.cursor/`, `AGENTS.md`, etc.) are generated artifacts \u2014 edit canonical config first, then regenerate. The import/generate contract is bidirectional and lossless: embedded or projected features round-trip without data loss.";
+var ROOT_INSTRUCTION_BODY_V3 = "AgentsMesh syncs AI coding tool configuration from a single canonical `.agentsmesh` directory. All target-specific files (`.claude/`, `.cursor/`, `AGENTS.md`, etc.) are generated artifacts \u2014 edit canonical config first, then regenerate. The import/generate contract is bidirectional and lossless: embedded or projected features round-trip without data loss.";
+var ROOT_INSTRUCTION_BODY_V4 = "Create agents, skills, commands, rules, hooks, and MCP in `.agentsmesh`, then run `agentsmesh generate` to sync each tool's native files. Edit `.agentsmesh`, not generated outputs.";
+var ROOT_INSTRUCTION_BODY_V5 = "Use Claude-style Markdown in `.agentsmesh`: `agents/*.md`, `commands/*.md`, and `skills/*/SKILL.md`; keep rules in `rules/*.md`, hooks in `hooks.yaml`, MCP in `mcp.json`, permissions in `permissions.yaml`, and ignore patterns in `ignore`, then run `agentsmesh generate`.";
+var ROOT_INSTRUCTION_BODY_V6 = "Create canonical files in `.agentsmesh`: `rules/_root.md` and `rules/*.md` are Markdown rules; `commands/*.md`, `agents/*.md`, and `skills/*/SKILL.md` plus supporting files use Claude-style frontmatter Markdown; `mcp.json` is MCP JSON; `hooks.yaml` and `permissions.yaml` are YAML; `ignore` is gitignore-style text. Then run `agentsmesh generate`.";
+var ROOT_INSTRUCTION_BODY_V7 = "`.agentsmesh` is the only folder you edit or add these files in: `rules/_root.md` and `rules/*.md` are Markdown rules; `commands/*.md`, `agents/*.md`, and `skills/*/SKILL.md` plus supporting files use Claude-style frontmatter Markdown; `mcp.json` is MCP JSON; `hooks.yaml` and `permissions.yaml` are YAML; `ignore` is gitignore-style text. Do not edit generated tool files; run `agentsmesh generate`.";
+var ROOT_INSTRUCTION_BODY = "`agentsmesh.yaml` selects targets/features (`agentsmesh.local.yaml` overrides locally), and `.agentsmesh` is the only place to add or edit canonical items: `rules/_root.md`, `rules/*.md`, `commands/*.md`, `agents/*.md`, `skills/*/SKILL.md` plus supporting files, `mcp.json`, `hooks.yaml`, `permissions.yaml`, and `ignore`; if missing run `agentsmesh init`, use `agentsmesh import --from <tool>` for native configs, `agentsmesh install <source>` or `install --sync` for reusable packs, then run `agentsmesh generate`. Use `diff`, `lint`, `check`, `watch`, `matrix`, and `merge` as needed; never edit generated tool files.";
 var LEGACY_AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH = ROOT_INSTRUCTION_BODY_V1;
 var LEGACY_AGENTSMESH_ROOT_INSTRUCTION_SECTION = `## Project-Specific Rules
 
@@ -2547,6 +2587,21 @@ ${ROOT_INSTRUCTION_BODY_V1}`;
 var AGENTSMESH_CONTRACT_WITH_V2_BODY = `## AgentsMesh Generation Contract
 
 ${ROOT_INSTRUCTION_BODY_V2}`;
+var AGENTSMESH_CONTRACT_WITH_V3_BODY = `## AgentsMesh Generation Contract
+
+${ROOT_INSTRUCTION_BODY_V3}`;
+var AGENTSMESH_CONTRACT_WITH_V4_BODY = `## AgentsMesh Generation Contract
+
+${ROOT_INSTRUCTION_BODY_V4}`;
+var AGENTSMESH_CONTRACT_WITH_V5_BODY = `## AgentsMesh Generation Contract
+
+${ROOT_INSTRUCTION_BODY_V5}`;
+var AGENTSMESH_CONTRACT_WITH_V6_BODY = `## AgentsMesh Generation Contract
+
+${ROOT_INSTRUCTION_BODY_V6}`;
+var AGENTSMESH_CONTRACT_WITH_V7_BODY = `## AgentsMesh Generation Contract
+
+${ROOT_INSTRUCTION_BODY_V7}`;
 var AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH = `## AgentsMesh Generation Contract
 
 ${ROOT_INSTRUCTION_BODY}`;
@@ -2554,6 +2609,11 @@ function normalizeWhitespace(value) {
   return value.replace(/\s+/g, " ").trim();
 }
 var LEGACY_FORMS = [
+  AGENTSMESH_CONTRACT_WITH_V7_BODY,
+  AGENTSMESH_CONTRACT_WITH_V6_BODY,
+  AGENTSMESH_CONTRACT_WITH_V5_BODY,
+  AGENTSMESH_CONTRACT_WITH_V4_BODY,
+  AGENTSMESH_CONTRACT_WITH_V3_BODY,
   AGENTSMESH_CONTRACT_WITH_V2_BODY,
   AGENTSMESH_CONTRACT_WITH_V1_BODY,
   LEGACY_AGENTSMESH_ROOT_INSTRUCTION_SECTION,
@@ -4372,6 +4432,347 @@ var descriptor5 = {
   ]
 };
 
+// src/targets/kiro/generator.ts
+import { basename as basename17 } from "path";
+
+// src/targets/kiro/hook-format.ts
+import { stringify as yamlStringify4 } from "yaml";
+var CANONICAL_TO_KIRO = {
+  UserPromptSubmit: "promptSubmit",
+  SubagentStop: "agentStop",
+  PreToolUse: "preToolUse",
+  PostToolUse: "postToolUse"
+};
+var KIRO_TO_CANONICAL = /* @__PURE__ */ new Map([
+  ["promptSubmit", "UserPromptSubmit"],
+  ["agentStop", "SubagentStop"],
+  ["preToolUse", "PreToolUse"],
+  ["postToolUse", "PostToolUse"]
+]);
+function toKebab(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase();
+}
+function hookText(entry) {
+  return entry.type === "prompt" ? entry.prompt : entry.command;
+}
+function toWhen(event, matcher) {
+  const type = CANONICAL_TO_KIRO[event];
+  if (event === "PreToolUse" || event === "PostToolUse") {
+    return { type, tools: [matcher || "*"] };
+  }
+  return { type };
+}
+function generateKiroHooks(hooks) {
+  const outputs = [];
+  for (const [event, entries] of Object.entries(hooks)) {
+    const mappedEvent = event;
+    if (!(mappedEvent in CANONICAL_TO_KIRO) || !Array.isArray(entries)) continue;
+    let index = 1;
+    for (const entry of entries) {
+      const text = hookText(entry);
+      if (!text) continue;
+      const file = {
+        name: `${toKebab(event)} ${index}`,
+        version: "1",
+        when: toWhen(mappedEvent, entry.matcher),
+        then: entry.type === "prompt" ? { type: "askAgent", prompt: text } : { type: "shellCommand", command: text }
+      };
+      outputs.push({
+        name: `${toKebab(event)}-${index}.kiro.hook`,
+        content: JSON.stringify(file, null, 2)
+      });
+      index += 1;
+    }
+  }
+  return outputs;
+}
+function toCanonicalEntry(file) {
+  const canonicalEvent = KIRO_TO_CANONICAL.get(file.when.type);
+  if (!canonicalEvent) return null;
+  const matcher = file.when.tools?.[0] ?? file.when.patterns?.[0] ?? "*";
+  if (file.then.type === "askAgent" && typeof file.then.prompt === "string") {
+    return {
+      event: canonicalEvent,
+      entry: {
+        matcher,
+        command: file.then.prompt,
+        prompt: file.then.prompt,
+        type: "prompt"
+      }
+    };
+  }
+  if (file.then.type === "shellCommand" && typeof file.then.command === "string") {
+    return {
+      event: canonicalEvent,
+      entry: { matcher, command: file.then.command, type: "command" }
+    };
+  }
+  return null;
+}
+function parseKiroHookFile(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const file = parsed;
+  if (!file.when || !file.then || typeof file.when.type !== "string") return null;
+  return toCanonicalEntry(file);
+}
+function serializeCanonicalHooks(hooks) {
+  return yamlStringify4(hooks).trimEnd();
+}
+
+// src/targets/kiro/generator.ts
+function steeringFrontmatter(rule) {
+  const frontmatter = {};
+  if (rule.globs.length > 0) {
+    frontmatter.inclusion = "fileMatch";
+    frontmatter.fileMatchPattern = rule.globs.length === 1 ? rule.globs[0] : rule.globs;
+  } else if (rule.trigger === "manual") {
+    frontmatter.inclusion = "manual";
+  } else if (rule.trigger === "model_decision") {
+    frontmatter.inclusion = "auto";
+  } else {
+    frontmatter.inclusion = "always";
+  }
+  if (rule.description) frontmatter.description = rule.description;
+  return frontmatter;
+}
+function generateRules6(canonical) {
+  const outputs = [];
+  const root = canonical.rules.find((rule) => rule.root);
+  if (root) {
+    outputs.push({ path: KIRO_AGENTS_MD, content: root.body.trim() || "" });
+  }
+  for (const rule of canonical.rules) {
+    if (rule.root) continue;
+    if (rule.targets.length > 0 && !rule.targets.includes(KIRO_TARGET)) continue;
+    const slug = basename17(rule.source, ".md");
+    outputs.push({
+      path: `${KIRO_STEERING_DIR}/${slug}.md`,
+      content: serializeFrontmatter(steeringFrontmatter(rule), rule.body.trim() || "")
+    });
+  }
+  return outputs;
+}
+function generateSkills6(canonical) {
+  return generateEmbeddedSkills(canonical, KIRO_SKILLS_DIR);
+}
+function generateMcp5(canonical) {
+  if (!canonical.mcp || Object.keys(canonical.mcp.mcpServers).length === 0) return [];
+  return [
+    {
+      path: KIRO_MCP_FILE,
+      content: JSON.stringify({ mcpServers: canonical.mcp.mcpServers }, null, 2)
+    }
+  ];
+}
+function generateHooks4(canonical) {
+  if (!canonical.hooks || Object.keys(canonical.hooks).length === 0) return [];
+  return generateKiroHooks(canonical.hooks).map((hook) => ({
+    path: `${KIRO_HOOKS_DIR}/${hook.name}`,
+    content: hook.content
+  }));
+}
+function generateIgnore4(canonical) {
+  if (canonical.ignore.length === 0) return [];
+  return [{ path: KIRO_IGNORE, content: canonical.ignore.join("\n") }];
+}
+
+// src/targets/kiro/importer.ts
+import { join as join22 } from "path";
+function readMcpServers3(content) {
+  const parsed = JSON.parse(content);
+  const rawServers = parsed.mcpServers;
+  if (!rawServers || typeof rawServers !== "object" || Array.isArray(rawServers)) return {};
+  const servers = {};
+  for (const [name, value] of Object.entries(rawServers)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const server = value;
+    if (typeof server.command === "string") {
+      servers[name] = {
+        type: typeof server.type === "string" ? server.type : "stdio",
+        command: server.command,
+        args: toStringArray4(server.args),
+        env: toStringRecord(server.env)
+      };
+      continue;
+    }
+    if (typeof server.url === "string") {
+      servers[name] = {
+        type: typeof server.type === "string" ? server.type : "http",
+        url: server.url,
+        headers: toStringRecord(server.headers),
+        env: toStringRecord(server.env)
+      };
+    }
+  }
+  return servers;
+}
+function canonicalRuleMeta(frontmatter) {
+  const inclusion = typeof frontmatter.inclusion === "string" ? frontmatter.inclusion : "";
+  const meta = {
+    root: false,
+    description: typeof frontmatter.description === "string" ? frontmatter.description : void 0,
+    globs: toGlobsArray(frontmatter.fileMatchPattern)
+  };
+  if (inclusion === "manual") meta.trigger = "manual";
+  if (inclusion === "auto") meta.trigger = "model_decision";
+  if (inclusion === "fileMatch") meta.trigger = "glob";
+  return meta;
+}
+async function importRoot(projectRoot, results, normalize) {
+  const srcPath = join22(projectRoot, KIRO_AGENTS_MD);
+  const content = await readFileSafe(srcPath);
+  if (content === null) return;
+  const destPath = join22(projectRoot, KIRO_CANONICAL_ROOT_RULE);
+  const { frontmatter, body } = parseFrontmatter(normalize(content, srcPath, destPath));
+  await writeFileAtomic(
+    destPath,
+    await serializeImportedRuleWithFallback(destPath, { ...frontmatter, root: true }, body)
+  );
+  results.push({
+    fromTool: KIRO_TARGET,
+    fromPath: srcPath,
+    toPath: KIRO_CANONICAL_ROOT_RULE,
+    feature: "rules"
+  });
+}
+async function importRules4(projectRoot, results, normalize) {
+  results.push(
+    ...await importFileDirectory({
+      srcDir: join22(projectRoot, KIRO_STEERING_DIR),
+      destDir: join22(projectRoot, KIRO_CANONICAL_RULES_DIR),
+      extensions: [".md"],
+      fromTool: KIRO_TARGET,
+      normalize,
+      mapEntry: async ({ relativePath, normalizeTo }) => {
+        const destPath = join22(projectRoot, KIRO_CANONICAL_RULES_DIR, relativePath);
+        const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
+        return {
+          destPath,
+          toPath: `${KIRO_CANONICAL_RULES_DIR}/${relativePath}`,
+          feature: "rules",
+          content: await serializeImportedRuleWithFallback(
+            destPath,
+            canonicalRuleMeta(frontmatter),
+            body
+          )
+        };
+      }
+    })
+  );
+}
+async function importMcp4(projectRoot, results) {
+  const content = await readFileSafe(join22(projectRoot, KIRO_MCP_FILE));
+  if (content === null) return;
+  const servers = readMcpServers3(content);
+  if (Object.keys(servers).length === 0) return;
+  await writeFileAtomic(
+    join22(projectRoot, KIRO_CANONICAL_MCP),
+    JSON.stringify({ mcpServers: servers }, null, 2)
+  );
+  results.push({
+    fromTool: KIRO_TARGET,
+    fromPath: join22(projectRoot, KIRO_MCP_FILE),
+    toPath: KIRO_CANONICAL_MCP,
+    feature: "mcp"
+  });
+}
+async function importHooks2(projectRoot, results) {
+  const hooks = {};
+  for (const absPath of await readDirRecursive(join22(projectRoot, KIRO_HOOKS_DIR))) {
+    if (!absPath.endsWith(".kiro.hook")) continue;
+    const parsed = parseKiroHookFile(await readFileSafe(absPath) ?? "");
+    if (!parsed) continue;
+    hooks[parsed.event] ??= [];
+    hooks[parsed.event].push(parsed.entry);
+  }
+  if (Object.keys(hooks).length === 0) return;
+  await writeFileAtomic(join22(projectRoot, KIRO_CANONICAL_HOOKS), serializeCanonicalHooks(hooks));
+  results.push({
+    fromTool: KIRO_TARGET,
+    fromPath: join22(projectRoot, KIRO_HOOKS_DIR),
+    toPath: KIRO_CANONICAL_HOOKS,
+    feature: "hooks"
+  });
+}
+async function importIgnore3(projectRoot, results) {
+  const content = await readFileSafe(join22(projectRoot, KIRO_IGNORE));
+  if (content === null) return;
+  await writeFileAtomic(join22(projectRoot, KIRO_CANONICAL_IGNORE), content.trimEnd());
+  results.push({
+    fromTool: KIRO_TARGET,
+    fromPath: join22(projectRoot, KIRO_IGNORE),
+    toPath: KIRO_CANONICAL_IGNORE,
+    feature: "ignore"
+  });
+}
+async function importFromKiro(projectRoot) {
+  const results = [];
+  const normalize = await createImportReferenceNormalizer(KIRO_TARGET, projectRoot);
+  await importRoot(projectRoot, results, normalize);
+  await importRules4(projectRoot, results, normalize);
+  await importEmbeddedSkills(projectRoot, KIRO_SKILLS_DIR, KIRO_TARGET, results, normalize);
+  await importMcp4(projectRoot, results);
+  await importHooks2(projectRoot, results);
+  await importIgnore3(projectRoot, results);
+  return results;
+}
+
+// src/targets/kiro/linter.ts
+function lintRules6(canonical, projectRoot, projectFiles) {
+  return validateRules(canonical, projectRoot, projectFiles).map((diagnostic) => ({
+    ...diagnostic,
+    target: KIRO_TARGET
+  }));
+}
+
+// src/targets/kiro/index.ts
+var target6 = {
+  name: KIRO_TARGET,
+  primaryRootInstructionPath: KIRO_AGENTS_MD,
+  generateRules: generateRules6,
+  generateSkills: generateSkills6,
+  generateMcp: generateMcp5,
+  generateHooks: generateHooks4,
+  generateIgnore: generateIgnore4,
+  importFrom: importFromKiro
+};
+var descriptor6 = {
+  id: KIRO_TARGET,
+  generators: target6,
+  capabilities: {
+    rules: "native",
+    commands: "none",
+    agents: "none",
+    skills: "native",
+    mcp: "native",
+    hooks: "native",
+    ignore: "native",
+    permissions: "none"
+  },
+  emptyImportMessage: "No Kiro config found (AGENTS.md, .kiro/steering, .kiro/skills, .kiro/hooks, .kiro/settings/mcp.json, or .kiroignore).",
+  lintRules: lintRules6,
+  skillDir: KIRO_SKILLS_DIR,
+  paths: {
+    rulePath(slug, _rule) {
+      return `${KIRO_STEERING_DIR}/${slug}.md`;
+    },
+    commandPath(_name, _config) {
+      return null;
+    },
+    agentPath(_name, _config) {
+      return null;
+    }
+  },
+  buildImportPaths: buildKiroImportPaths,
+  detectionPaths: [KIRO_STEERING_DIR, KIRO_SKILLS_DIR, KIRO_HOOKS_DIR, KIRO_MCP_FILE, KIRO_IGNORE]
+};
+
 // src/targets/gemini-cli/constants.ts
 var GEMINI_TARGET = "gemini-cli";
 var GEMINI_ROOT = "GEMINI.md";
@@ -4434,7 +4835,7 @@ function mapHookEvent2(event) {
       return null;
   }
 }
-function generateRules6(canonical) {
+function generateRules7(canonical) {
   const root = canonical.rules.find((r) => r.root);
   const nonRootRules = canonical.rules.filter((r) => {
     if (r.root) return false;
@@ -4489,7 +4890,7 @@ function generateAgents5(canonical) {
     return { path: `${GEMINI_AGENTS_DIR}/${agent.name}.md`, content };
   });
 }
-function generateSkills6(canonical) {
+function generateSkills7(canonical) {
   const outputs = [];
   for (const skill of canonical.skills) {
     const frontmatter = {
@@ -4553,7 +4954,7 @@ function generateSettings(canonical) {
   if (Object.keys(settings).length === 0) return [];
   return [{ path: GEMINI_SETTINGS, content: JSON.stringify(settings, null, 2) }];
 }
-function generateIgnore4(canonical) {
+function generateIgnore5(canonical) {
   if (!canonical.ignore || canonical.ignore.length === 0) return [];
   return [{ path: GEMINI_IGNORE, content: canonical.ignore.join("\n") }];
 }
@@ -4637,14 +5038,14 @@ function generateGeminiPermissionsPolicies(canonical) {
 
 // src/targets/gemini-cli/importer.ts
 import { realpathSync } from "fs";
-import { join as join25, basename as basename17, dirname as dirname13, relative as relative9 } from "path";
+import { join as join26, basename as basename18, dirname as dirname13, relative as relative9 } from "path";
 
 // src/targets/gemini-cli/importer-mappers.ts
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 import { parse as parseToml2 } from "smol-toml";
 
 // src/targets/gemini-cli/format-helpers.ts
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import { parse as parseToml } from "smol-toml";
 import { stringify as stringifyYaml } from "yaml";
 function mapGeminiHookEvent(event) {
@@ -4685,7 +5086,7 @@ function parseFlexibleFrontmatter(content) {
   return { frontmatter: {}, body: content.trim() };
 }
 async function importGeminiSettings(projectRoot, results) {
-  const settingsPath = join22(projectRoot, GEMINI_SETTINGS);
+  const settingsPath = join23(projectRoot, GEMINI_SETTINGS);
   const settingsContent = await readFileSafe(settingsPath);
   if (settingsContent === null) return;
   let settings;
@@ -4696,8 +5097,8 @@ 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 = join22(projectRoot, GEMINI_CANONICAL_MCP);
-    await mkdirp(join22(projectRoot, ".agentsmesh"));
+    const mcpPath = join23(projectRoot, GEMINI_CANONICAL_MCP);
+    await mkdirp(join23(projectRoot, ".agentsmesh"));
     await writeFileAtomic(mcpPath, JSON.stringify({ mcpServers }, null, 2));
     results.push({
       fromTool: "gemini-cli",
@@ -4708,8 +5109,8 @@ async function importGeminiSettings(projectRoot, results) {
   }
   const ignorePatterns = settings.ignorePatterns;
   if (Array.isArray(ignorePatterns) && ignorePatterns.length > 0 && ignorePatterns.every((p) => typeof p === "string")) {
-    const ignorePath = join22(projectRoot, GEMINI_CANONICAL_IGNORE);
-    await mkdirp(join22(projectRoot, ".agentsmesh"));
+    const ignorePath = join23(projectRoot, GEMINI_CANONICAL_IGNORE);
+    await mkdirp(join23(projectRoot, ".agentsmesh"));
     await writeFileAtomic(ignorePath, ignorePatterns.join("\n") + "\n");
     results.push({
       fromTool: "gemini-cli",
@@ -4751,8 +5152,8 @@ async function importGeminiSettings(projectRoot, results) {
     );
     if (mappedHooks.length > 0) {
       const hooksYaml = Object.fromEntries(mappedHooks);
-      const hooksPath = join22(projectRoot, GEMINI_CANONICAL_HOOKS);
-      await mkdirp(join22(projectRoot, ".agentsmesh"));
+      const hooksPath = join23(projectRoot, GEMINI_CANONICAL_HOOKS);
+      await mkdirp(join23(projectRoot, ".agentsmesh"));
       await writeFileAtomic(hooksPath, stringifyYaml(hooksYaml, { lineWidth: 0 }).trimEnd());
       results.push({
         fromTool: "gemini-cli",
@@ -4764,13 +5165,13 @@ async function importGeminiSettings(projectRoot, results) {
   }
 }
 async function importGeminiIgnore(projectRoot, results) {
-  const geminiIgnorePath = join22(projectRoot, GEMINI_IGNORE);
+  const geminiIgnorePath = join23(projectRoot, GEMINI_IGNORE);
   const geminiIgnoreContent = await readFileSafe(geminiIgnorePath);
   if (geminiIgnoreContent !== null && geminiIgnoreContent.trim()) {
     const patterns = geminiIgnoreContent.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
     if (patterns.length > 0) {
-      await mkdirp(join22(projectRoot, ".agentsmesh"));
-      const ignorePath = join22(projectRoot, GEMINI_CANONICAL_IGNORE);
+      await mkdirp(join23(projectRoot, ".agentsmesh"));
+      const ignorePath = join23(projectRoot, GEMINI_CANONICAL_IGNORE);
       await writeFileAtomic(ignorePath, patterns.join("\n") + "\n");
       results.push({
         fromTool: "gemini-cli",
@@ -4785,7 +5186,7 @@ async function importGeminiIgnore(projectRoot, results) {
 // src/targets/gemini-cli/importer-mappers.ts
 async function mapGeminiRuleFile(relativePath, destDir, normalizeTo) {
   const relativeMdPath = relativePath.replace(/\\/g, "/");
-  const destPath = join23(destDir, relativeMdPath);
+  const destPath = join24(destDir, relativeMdPath);
   const { frontmatter, body } = parseFlexibleFrontmatter(normalizeTo(destPath));
   const globs = toGlobsArray(frontmatter.globs);
   const canonicalFm = {
@@ -4805,7 +5206,7 @@ async function mapGeminiRuleFile(relativePath, destDir, normalizeTo) {
 }
 async function mapGeminiCommandFile(relativePath, destDir, normalizeTo) {
   const relativeMdPath = relativePath.replace(/\.(toml|md)$/i, ".md").replace(/\\/g, "/");
-  const destPath = join23(destDir, relativeMdPath);
+  const destPath = join24(destDir, relativeMdPath);
   const normalized = normalizeTo(destPath);
   const { frontmatter, body } = relativePath.endsWith(".toml") ? parseTomlCommand(normalized) : parseFlexibleFrontmatter(normalized);
   const fromCamel = toToolsArray2(frontmatter.allowedTools);
@@ -4842,7 +5243,7 @@ function parseTomlCommand(normalized) {
 // src/targets/gemini-cli/policies-importer.ts
 import { parse as parseToml3 } from "smol-toml";
 import { stringify as stringifyYaml2 } from "yaml";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 function unescapeRegexLiteral(value) {
   return value.replace(/\\(.)/g, "$1");
 }
@@ -4870,7 +5271,7 @@ function argsPatternToReadExpr(argsPattern) {
 }
 async function importGeminiPolicies(projectRoot) {
   const results = [];
-  const policiesDir = join24(projectRoot, GEMINI_POLICIES_DIR);
+  const policiesDir = join25(projectRoot, GEMINI_POLICIES_DIR);
   let policyFiles;
   try {
     policyFiles = await readDirRecursive(policiesDir);
@@ -4931,13 +5332,13 @@ async function importGeminiPolicies(projectRoot) {
     }
   }
   if (allow.length === 0 && deny.length === 0) return results;
-  await mkdirp(join24(projectRoot, ".agentsmesh"));
-  const outPath = join24(projectRoot, GEMINI_CANONICAL_PERMISSIONS);
+  await mkdirp(join25(projectRoot, ".agentsmesh"));
+  const outPath = join25(projectRoot, GEMINI_CANONICAL_PERMISSIONS);
   const yaml = stringifyYaml2({ allow, deny });
   await writeFileAtomic(outPath, yaml.trimEnd() + "\n");
   results.push({
     fromTool: GEMINI_TARGET,
-    fromPath: join24(projectRoot, GEMINI_POLICIES_DIR),
+    fromPath: join25(projectRoot, GEMINI_POLICIES_DIR),
     toPath: GEMINI_CANONICAL_PERMISSIONS,
     feature: "permissions"
   });
@@ -4949,12 +5350,12 @@ async function importFromGemini(projectRoot) {
   const results = [];
   const normalize = await createImportReferenceNormalizer(GEMINI_TARGET, projectRoot);
   const normalizeCodex = await createImportReferenceNormalizer("codex-cli", projectRoot);
-  const rulesDir = join25(projectRoot, GEMINI_CANONICAL_RULES_DIR);
-  const commandsDir = join25(projectRoot, GEMINI_CANONICAL_COMMANDS_DIR);
-  const geminiRootPath = join25(projectRoot, GEMINI_ROOT);
-  const compatAgentsRootPath = join25(projectRoot, GEMINI_COMPAT_AGENTS);
-  const compatInnerRootPath = join25(projectRoot, GEMINI_COMPAT_INNER_ROOT);
-  const systemPath = join25(projectRoot, GEMINI_SYSTEM);
+  const rulesDir = join26(projectRoot, GEMINI_CANONICAL_RULES_DIR);
+  const commandsDir = join26(projectRoot, GEMINI_CANONICAL_COMMANDS_DIR);
+  const geminiRootPath = join26(projectRoot, GEMINI_ROOT);
+  const compatAgentsRootPath = join26(projectRoot, GEMINI_COMPAT_AGENTS);
+  const compatInnerRootPath = join26(projectRoot, GEMINI_COMPAT_INNER_ROOT);
+  const systemPath = join26(projectRoot, GEMINI_SYSTEM);
   const geminiRootContent = await readFileSafe(geminiRootPath);
   const compatAgentsRootContent = await readFileSafe(compatAgentsRootPath);
   const compatInnerRootContent = await readFileSafe(compatInnerRootPath);
@@ -4969,7 +5370,7 @@ async function importFromGemini(projectRoot) {
   const rootContent = rootCandidate?.content ?? null;
   if (rootContent !== null) {
     await mkdirp(rulesDir);
-    const destPath = join25(rulesDir, "_root.md");
+    const destPath = join26(rulesDir, "_root.md");
     const compatNormalized = rootSourcePath === compatAgentsRootPath || rootSourcePath === compatInnerRootPath ? normalize(normalizeCodex(rootContent, rootSourcePath, destPath), rootSourcePath, destPath) : normalize(rootContent, rootSourcePath, destPath);
     const normalizedRoot = stripProjectRootCanonicalPrefix(
       compatNormalized.replace(/\.agents\/skills\//g, ".agentsmesh/skills/").replace(/\.agents\\skills\\/g, ".agentsmesh/skills/"),
@@ -4990,7 +5391,7 @@ async function importFromGemini(projectRoot) {
       feature: "rules"
     });
   }
-  const geminiRulesPath = join25(projectRoot, GEMINI_RULES_DIR);
+  const geminiRulesPath = join26(projectRoot, GEMINI_RULES_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: geminiRulesPath,
@@ -5001,7 +5402,7 @@ async function importFromGemini(projectRoot) {
       mapEntry: ({ relativePath, normalizeTo }) => mapGeminiRuleFile(relativePath, rulesDir, normalizeTo)
     })
   );
-  const geminiCommandsPath = join25(projectRoot, GEMINI_COMMANDS_DIR);
+  const geminiCommandsPath = join26(projectRoot, GEMINI_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: geminiCommandsPath,
@@ -5012,19 +5413,19 @@ async function importFromGemini(projectRoot) {
       mapEntry: ({ relativePath, normalizeTo }) => mapGeminiCommandFile(relativePath, commandsDir, normalizeTo)
     })
   );
-  const geminiSkillsPath = join25(projectRoot, GEMINI_SKILLS_DIR);
+  const geminiSkillsPath = join26(projectRoot, GEMINI_SKILLS_DIR);
   const skillDirs = await readDirRecursive(geminiSkillsPath);
-  const skillMdFiles = skillDirs.filter((f) => basename17(f) === "SKILL.md");
+  const skillMdFiles = skillDirs.filter((f) => basename18(f) === "SKILL.md");
   for (const srcPath of skillMdFiles) {
     const content = await readFileSafe(srcPath);
     if (!content) continue;
-    const skillName = basename17(srcPath.slice(0, -"/SKILL.md".length));
+    const skillName = basename18(srcPath.slice(0, -"/SKILL.md".length));
     const rawParsed = parseFrontmatter(content);
     const projectedAgent = parseProjectedAgentSkillFrontmatter(rawParsed.frontmatter, skillName);
     if (projectedAgent) {
-      const agentsDir = join25(projectRoot, GEMINI_CANONICAL_AGENTS_DIR);
+      const agentsDir = join26(projectRoot, GEMINI_CANONICAL_AGENTS_DIR);
       await mkdirp(agentsDir);
-      const agentPath = join25(agentsDir, `${projectedAgent.name}.md`);
+      const agentPath = join26(agentsDir, `${projectedAgent.name}.md`);
       await writeFileAtomic(
         agentPath,
         serializeImportedAgent(projectedAgent, normalize(rawParsed.body, srcPath, agentPath))
@@ -5037,9 +5438,9 @@ async function importFromGemini(projectRoot) {
       });
       continue;
     }
-    const destPath = join25(projectRoot, GEMINI_CANONICAL_SKILLS_DIR, skillName, "SKILL.md");
+    const destPath = join26(projectRoot, GEMINI_CANONICAL_SKILLS_DIR, skillName, "SKILL.md");
     const normalized = normalize(content, srcPath, destPath);
-    const skillDir = join25(projectRoot, GEMINI_CANONICAL_SKILLS_DIR, skillName);
+    const skillDir = join26(projectRoot, GEMINI_CANONICAL_SKILLS_DIR, skillName);
     await mkdirp(skillDir);
     const { frontmatter, body } = parseFrontmatter(normalized);
     await writeFileAtomic(
@@ -5058,7 +5459,7 @@ async function importFromGemini(projectRoot) {
       const supportContent = await readFileSafe(absPath);
       if (supportContent === null) continue;
       const relPath = relative9(dirname13(srcPath), absPath).replace(/\\/g, "/");
-      const destSupportPath = join25(skillDir, relPath);
+      const destSupportPath = join26(skillDir, relPath);
       await mkdirp(dirname13(destSupportPath));
       await writeFileAtomic(destSupportPath, normalize(supportContent, absPath, destSupportPath));
       results.push({
@@ -5069,7 +5470,7 @@ async function importFromGemini(projectRoot) {
       });
     }
   }
-  const geminiAgentsPath = join25(projectRoot, GEMINI_AGENTS_DIR);
+  const geminiAgentsPath = join26(projectRoot, GEMINI_AGENTS_DIR);
   try {
     const agentFiles = await readDirRecursive(geminiAgentsPath);
     const agentMdFiles = agentFiles.filter((f) => f.endsWith(".md"));
@@ -5079,9 +5480,9 @@ async function importFromGemini(projectRoot) {
       const { frontmatter, body } = parseFrontmatter(content);
       const relPath = relative9(geminiAgentsPath, srcPath).replace(/\\/g, "/");
       const relativeMdPath = relPath.replace(/\.md$/i, ".md");
-      const agentsDir = join25(projectRoot, GEMINI_CANONICAL_AGENTS_DIR);
+      const agentsDir = join26(projectRoot, GEMINI_CANONICAL_AGENTS_DIR);
       await mkdirp(agentsDir);
-      const destPath = join25(agentsDir, relativeMdPath);
+      const destPath = join26(agentsDir, relativeMdPath);
       const normalizedBody = normalize(body, srcPath, destPath);
       await writeFileAtomic(
         destPath,
@@ -5089,7 +5490,7 @@ async function importFromGemini(projectRoot) {
           destPath,
           {
             ...frontmatter,
-            name: typeof frontmatter.name === "string" ? frontmatter.name : basename17(relativeMdPath, ".md"),
+            name: typeof frontmatter.name === "string" ? frontmatter.name : basename18(relativeMdPath, ".md"),
             maxTurns: frontmatter.maxTurns ?? frontmatter["max-turns"] ?? frontmatter.max_turns,
             permissionMode: frontmatter.permissionMode ?? frontmatter["permission-mode"] ?? frontmatter.permission_mode,
             disallowedTools: frontmatter.disallowedTools ?? frontmatter["disallowed-tools"] ?? frontmatter.disallowed_tools
@@ -5130,27 +5531,27 @@ function stripProjectRootCanonicalPrefix(content, projectRoot) {
 }
 
 // src/targets/gemini-cli/linter.ts
-function lintRules6(canonical, projectRoot, projectFiles) {
+function lintRules7(canonical, projectRoot, projectFiles) {
   const diags = validateRules(canonical, projectRoot, projectFiles);
   return diags.map((d) => ({ ...d, target: GEMINI_TARGET }));
 }
 
 // src/targets/gemini-cli/index.ts
-var target6 = {
+var target7 = {
   name: "gemini-cli",
   primaryRootInstructionPath: GEMINI_ROOT,
-  generateRules: generateRules6,
+  generateRules: generateRules7,
   generateCommands: generateCommands6,
   generateAgents: generateAgents5,
-  generateSkills: generateSkills6,
+  generateSkills: generateSkills7,
   generateSettings,
-  generateIgnore: generateIgnore4,
+  generateIgnore: generateIgnore5,
   generatePermissions: generateGeminiPermissionsPolicies,
   importFrom: importFromGemini
 };
-var descriptor6 = {
+var descriptor7 = {
   id: "gemini-cli",
-  generators: target6,
+  generators: target7,
   capabilities: {
     rules: "native",
     commands: "native",
@@ -5162,7 +5563,7 @@ var descriptor6 = {
     permissions: "partial"
   },
   emptyImportMessage: "No Gemini CLI config found (GEMINI.md or .gemini/rules, .gemini/commands, .gemini/settings.json).",
-  lintRules: lintRules6,
+  lintRules: lintRules7,
   skillDir: ".gemini/skills",
   paths: {
     rulePath(_slug, _rule) {
@@ -5186,7 +5587,7 @@ var descriptor6 = {
 };
 
 // src/targets/cline/generator.ts
-import { basename as basename18 } from "path";
+import { basename as basename19 } from "path";
 
 // src/targets/cline/constants.ts
 var CLINE_TARGET = "cline";
@@ -5207,10 +5608,10 @@ var CLINE_CANONICAL_SKILLS_DIR = ".agentsmesh/skills";
 
 // src/targets/cline/generator.ts
 function ruleSlug3(source) {
-  const name = basename18(source, ".md");
+  const name = basename19(source, ".md");
   return name === "_root" ? "root" : name;
 }
-function generateRules7(canonical) {
+function generateRules8(canonical) {
   const outputs = [];
   const root = canonical.rules.find((r) => r.root);
   if (root) {
@@ -5243,12 +5644,12 @@ ${body}` : desc || body;
     return { path: `${CLINE_WORKFLOWS_DIR}/${cmd.name}.md`, content };
   });
 }
-function generateIgnore5(canonical) {
+function generateIgnore6(canonical) {
   if (!canonical.ignore || canonical.ignore.length === 0) return [];
   const content = canonical.ignore.join("\n");
   return [{ path: CLINE_IGNORE, content }];
 }
-function generateMcp5(canonical) {
+function generateMcp6(canonical) {
   if (!canonical.mcp || Object.keys(canonical.mcp.mcpServers).length === 0) return [];
   const content = JSON.stringify({ mcpServers: canonical.mcp.mcpServers }, null, 2);
   return [{ path: CLINE_MCP_SETTINGS, content }];
@@ -5272,7 +5673,7 @@ function buildHookScript(command, matcher) {
     ""
   ].join("\n");
 }
-function generateHooks4(canonical) {
+function generateHooks5(canonical) {
   if (!canonical.hooks || Object.keys(canonical.hooks).length === 0) return [];
   const outputs = [];
   for (const [event, entries] of Object.entries(canonical.hooks)) {
@@ -5289,7 +5690,7 @@ function generateHooks4(canonical) {
   }
   return outputs;
 }
-function generateSkills7(canonical) {
+function generateSkills8(canonical) {
   const outputs = [];
   for (const skill of canonical.skills) {
     const frontmatter = {
@@ -5315,15 +5716,15 @@ function generateSkills7(canonical) {
 
 // src/targets/cline/importer.ts
 import { stat as stat3 } from "fs/promises";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 
 // src/targets/cline/importer-mappers.ts
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 async function mapClineRuleFile(relativePath, destDir, normalizeTo) {
   if (relativePath === "workflows" || relativePath.startsWith("workflows/")) return null;
   const relativeMdPath = relativePath.replace(/\\/g, "/");
   if (relativeMdPath === "_root.md") return null;
-  const destPath = join26(destDir, relativeMdPath);
+  const destPath = join27(destDir, relativeMdPath);
   const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
   const globs = toGlobsArray(frontmatter.paths ?? frontmatter.globs);
   const canonicalFm = {
@@ -5342,7 +5743,7 @@ async function mapClineRuleFile(relativePath, destDir, normalizeTo) {
   };
 }
 async function mapClineWorkflowFile(relativePath, destDir, normalizeTo) {
-  const destPath = join26(destDir, relativePath);
+  const destPath = join27(destDir, relativePath);
   const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
   const hasFrontmatterDescription = Object.prototype.hasOwnProperty.call(
     frontmatter,
@@ -5380,7 +5781,7 @@ async function mapClineWorkflowFile(relativePath, destDir, normalizeTo) {
 }
 
 // src/targets/cline/mcp-mapper.ts
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function mapClineServerToCanonical(raw) {
   if (!raw || typeof raw !== "object") return null;
   const obj = raw;
@@ -5405,7 +5806,7 @@ function mapClineServerToCanonical(raw) {
 }
 async function importClineMcp(projectRoot, results) {
   const candidatePaths = [CLINE_MCP_SETTINGS, CLINE_MCP_SETTINGS_LEGACY].map(
-    (path) => join27(projectRoot, path)
+    (path) => join28(projectRoot, path)
   );
   let mcpPath = null;
   let mcpContent = null;
@@ -5432,9 +5833,9 @@ async function importClineMcp(projectRoot, results) {
       if (server) mcpServers[n] = server;
     }
     if (Object.keys(mcpServers).length > 0) {
-      await mkdirp(join27(projectRoot, ".agentsmesh"));
+      await mkdirp(join28(projectRoot, ".agentsmesh"));
       await writeFileAtomic(
-        join27(projectRoot, CLINE_CANONICAL_MCP),
+        join28(projectRoot, CLINE_CANONICAL_MCP),
         JSON.stringify({ mcpServers }, null, 2)
       );
       results.push({
@@ -5449,16 +5850,16 @@ async function importClineMcp(projectRoot, results) {
 
 // src/targets/cline/skills-helpers.ts
 import { readdir as readdir6 } from "fs/promises";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 async function importClineSkills(projectRoot, results, normalize) {
-  const skillsDir = join28(projectRoot, CLINE_SKILLS_DIR);
+  const skillsDir = join29(projectRoot, CLINE_SKILLS_DIR);
   const skillDirs = [];
   try {
     const entries = await readdir6(skillsDir, { withFileTypes: true });
     for (const ent of entries) {
       if (!ent.isDirectory()) continue;
-      const skillPath = join28(skillsDir, ent.name);
-      const skillMd = join28(skillPath, "SKILL.md");
+      const skillPath = join29(skillsDir, ent.name);
+      const skillMd = join29(skillPath, "SKILL.md");
       const content = await readFileSafe(skillMd);
       if (!content) continue;
       skillDirs.push({ name: ent.name, path: skillPath });
@@ -5466,15 +5867,15 @@ async function importClineSkills(projectRoot, results, normalize) {
   } catch {
   }
   for (const { name, path: skillPath } of skillDirs) {
-    const skillMdPath = join28(skillPath, "SKILL.md");
+    const skillMdPath = join29(skillPath, "SKILL.md");
     const content = await readFileSafe(skillMdPath);
     if (!content) continue;
     const rawParsed = parseFrontmatter(content);
     const projectedAgent = parseProjectedAgentSkillFrontmatter(rawParsed.frontmatter, name);
     if (projectedAgent) {
-      const destAgentsDir = join28(projectRoot, CLINE_CANONICAL_AGENTS_DIR);
+      const destAgentsDir = join29(projectRoot, CLINE_CANONICAL_AGENTS_DIR);
       await mkdirp(destAgentsDir);
-      const agentPath = join28(destAgentsDir, `${projectedAgent.name}.md`);
+      const agentPath = join29(destAgentsDir, `${projectedAgent.name}.md`);
       await writeFileAtomic(
         agentPath,
         serializeImportedAgent(projectedAgent, normalize(rawParsed.body, skillMdPath, agentPath))
@@ -5487,10 +5888,10 @@ async function importClineSkills(projectRoot, results, normalize) {
       });
       continue;
     }
-    const destSkillPath = join28(projectRoot, CLINE_CANONICAL_SKILLS_DIR, name, "SKILL.md");
+    const destSkillPath = join29(projectRoot, CLINE_CANONICAL_SKILLS_DIR, name, "SKILL.md");
     const normalized = normalize(content, skillMdPath, destSkillPath);
     const { frontmatter, body } = parseFrontmatter(normalized);
-    const destSkillDir = join28(projectRoot, CLINE_CANONICAL_SKILLS_DIR, name);
+    const destSkillDir = join29(projectRoot, CLINE_CANONICAL_SKILLS_DIR, name);
     await mkdirp(destSkillDir);
     const skillContent = await serializeImportedSkillWithFallback(
       destSkillPath,
@@ -5510,8 +5911,8 @@ async function importClineSkills(projectRoot, results, normalize) {
       const relPath = absPath.slice(skillPath.length + 1).replace(/\\/g, "/");
       const supportContent = await readFileSafe(absPath);
       if (supportContent === null) continue;
-      const destSupportPath = join28(destSkillDir, relPath);
-      await mkdirp(join28(destSupportPath, ".."));
+      const destSupportPath = join29(destSkillDir, relPath);
+      await mkdirp(join29(destSupportPath, ".."));
       await writeFileAtomic(destSupportPath, normalize(supportContent, absPath, destSupportPath));
       results.push({
         fromTool: CLINE_TARGET,
@@ -5527,9 +5928,9 @@ async function importClineSkills(projectRoot, results, normalize) {
 async function importFromCline(projectRoot) {
   const results = [];
   const normalize = await createImportReferenceNormalizer(CLINE_TARGET, projectRoot);
-  const destRulesDir = join29(projectRoot, CLINE_CANONICAL_RULES_DIR);
-  const clineRulesPath = join29(projectRoot, CLINE_RULES_DIR);
-  const clineRulesRaw = join29(projectRoot, CLINE_RULES_DIR);
+  const destRulesDir = join30(projectRoot, CLINE_CANONICAL_RULES_DIR);
+  const clineRulesPath = join30(projectRoot, CLINE_RULES_DIR);
+  const clineRulesRaw = join30(projectRoot, CLINE_RULES_DIR);
   let clineRulesIsFile = false;
   try {
     const clineRulesStat = await stat3(clineRulesRaw);
@@ -5540,7 +5941,7 @@ async function importFromCline(projectRoot) {
     const flatContent = await readFileSafe(clineRulesRaw);
     if (flatContent !== null) {
       await mkdirp(destRulesDir);
-      const destPath = join29(destRulesDir, "_root.md");
+      const destPath = join30(destRulesDir, "_root.md");
       const { frontmatter, body } = parseFrontmatter(
         normalize(flatContent, clineRulesRaw, destPath)
       );
@@ -5557,15 +5958,15 @@ async function importFromCline(projectRoot) {
     }
   } else {
     let rootSourcePath = null;
-    const rootPath = join29(clineRulesPath, "_root.md");
+    const rootPath = join30(clineRulesPath, "_root.md");
     const rootContent = await readFileSafe(rootPath);
     if (rootContent === null) {
-      const agentsMdPath = join29(projectRoot, CLINE_AGENTS_MD);
+      const agentsMdPath = join30(projectRoot, CLINE_AGENTS_MD);
       const agentsMdContent = await readFileSafe(agentsMdPath);
       if (agentsMdContent !== null) {
         rootSourcePath = agentsMdPath;
         await mkdirp(destRulesDir);
-        const destPath = join29(destRulesDir, "_root.md");
+        const destPath = join30(destRulesDir, "_root.md");
         const { frontmatter, body } = parseFrontmatter(
           normalize(agentsMdContent, agentsMdPath, destPath)
         );
@@ -5588,7 +5989,7 @@ async function importFromCline(projectRoot) {
           if (fc !== null) {
             rootSourcePath = first;
             await mkdirp(destRulesDir);
-            const destPath = join29(destRulesDir, "_root.md");
+            const destPath = join30(destRulesDir, "_root.md");
             const { frontmatter, body } = parseFrontmatter(normalize(fc, first, destPath));
             const hasRoot = frontmatter.root === true;
             const outFm = hasRoot ? frontmatter : { ...frontmatter, root: true };
@@ -5606,7 +6007,7 @@ async function importFromCline(projectRoot) {
     } else {
       rootSourcePath = rootPath;
       await mkdirp(destRulesDir);
-      const destPath = join29(destRulesDir, "_root.md");
+      const destPath = join30(destRulesDir, "_root.md");
       const { frontmatter, body } = parseFrontmatter(normalize(rootContent, rootPath, destPath));
       const hasRoot = frontmatter.root === true;
       const outFm = hasRoot ? frontmatter : { ...frontmatter, root: true };
@@ -5633,7 +6034,7 @@ async function importFromCline(projectRoot) {
       })
     );
   }
-  const ignorePath = join29(projectRoot, CLINE_IGNORE);
+  const ignorePath = join30(projectRoot, CLINE_IGNORE);
   const ignoreContent = await readFileSafe(ignorePath);
   if (ignoreContent !== null && ignoreContent.trim()) {
     const lines = ignoreContent.split(/\r?\n/);
@@ -5643,8 +6044,8 @@ async function importFromCline(projectRoot) {
       if (t && !t.startsWith("#")) patterns.push(t);
     }
     if (patterns.length > 0) {
-      await mkdirp(join29(projectRoot, ".agentsmesh"));
-      const destIgnorePath = join29(projectRoot, CLINE_CANONICAL_IGNORE);
+      await mkdirp(join30(projectRoot, ".agentsmesh"));
+      const destIgnorePath = join30(projectRoot, CLINE_CANONICAL_IGNORE);
       await writeFileAtomic(destIgnorePath, patterns.join("\n"));
       results.push({
         fromTool: "cline",
@@ -5655,11 +6056,11 @@ async function importFromCline(projectRoot) {
     }
   }
   await importClineMcp(projectRoot, results);
-  const destCommandsDir = join29(projectRoot, CLINE_CANONICAL_COMMANDS_DIR);
+  const destCommandsDir = join30(projectRoot, CLINE_CANONICAL_COMMANDS_DIR);
   if (!clineRulesIsFile) {
     results.push(
       ...await importFileDirectory({
-        srcDir: join29(projectRoot, CLINE_WORKFLOWS_DIR),
+        srcDir: join30(projectRoot, CLINE_WORKFLOWS_DIR),
         destDir: destCommandsDir,
         extensions: [".md"],
         fromTool: "cline",
@@ -5673,27 +6074,27 @@ async function importFromCline(projectRoot) {
 }
 
 // src/targets/cline/linter.ts
-function lintRules7(canonical, projectRoot, projectFiles) {
+function lintRules8(canonical, projectRoot, projectFiles) {
   const diags = validateRules(canonical, projectRoot, projectFiles);
   return diags.map((d) => ({ ...d, target: CLINE_TARGET }));
 }
 
 // src/targets/cline/index.ts
-var target7 = {
+var target8 = {
   name: "cline",
   primaryRootInstructionPath: CLINE_AGENTS_MD,
-  generateRules: generateRules7,
+  generateRules: generateRules8,
   generateWorkflows,
   generateAgents: generateAgents6,
-  generateSkills: generateSkills7,
-  generateMcp: generateMcp5,
-  generateHooks: generateHooks4,
-  generateIgnore: generateIgnore5,
+  generateSkills: generateSkills8,
+  generateMcp: generateMcp6,
+  generateHooks: generateHooks5,
+  generateIgnore: generateIgnore6,
   importFrom: importFromCline
 };
-var descriptor7 = {
+var descriptor8 = {
   id: "cline",
-  generators: target7,
+  generators: target8,
   capabilities: {
     rules: "native",
     commands: "native",
@@ -5705,7 +6106,7 @@ var descriptor7 = {
     permissions: "none"
   },
   emptyImportMessage: "No Cline config found (.clinerules, .clineignore, .cline/cline_mcp_settings.json, or .cline/skills).",
-  lintRules: lintRules7,
+  lintRules: lintRules8,
   skillDir: ".cline/skills",
   paths: {
     rulePath(slug, _rule) {
@@ -5741,7 +6142,7 @@ function usesCursorSensitiveInterpolation(server) {
 }
 
 // src/targets/codex-cli/generator.ts
-import { basename as basename20 } from "path";
+import { basename as basename21 } from "path";
 
 // src/targets/codex-cli/constants.ts
 var CODEX_TARGET = "codex-cli";
@@ -5767,9 +6168,9 @@ var CODEX_RULE_INDEX_START = "<!-- agentsmesh:codex-rule-index:start -->";
 var CODEX_RULE_INDEX_END = "<!-- agentsmesh:codex-rule-index:end -->";
 
 // src/targets/codex-cli/instruction-mirror.ts
-import { basename as basename19 } from "path";
+import { basename as basename20 } from "path";
 function ruleSlug4(source) {
-  return basename19(source, ".md");
+  return basename20(source, ".md");
 }
 function codexInstructionMirrorPath(rule) {
   return `${CODEX_INSTRUCTIONS_DIR}/${ruleSlug4(rule.source)}.md`;
@@ -5804,7 +6205,7 @@ function summarizeRule(rule) {
     scopes.push(`Enforced in \`${CODEX_RULES_DIR}/${ruleSlug4(rule.source)}.rules\`.`);
   }
   if (rule.targets.length > 0) {
-    scopes.push(`Targeted to ${rule.targets.map((target12) => `\`${target12}\``).join(", ")}.`);
+    scopes.push(`Targeted to ${rule.targets.map((target13) => `\`${target13}\``).join(", ")}.`);
   }
   return scopes.join(" ");
 }
@@ -5861,7 +6262,7 @@ function toSafeCodexRulesContent(body) {
   return `${lines.join("\n")}
 `;
 }
-function generateRules8(canonical) {
+function generateRules9(canonical) {
   const root = canonical.rules.find((r) => r.root);
   const outputs = [];
   if (root) {
@@ -5869,7 +6270,7 @@ function generateRules8(canonical) {
   }
   for (const rule of canonical.rules) {
     if (rule.root) continue;
-    const slug = basename20(rule.source, ".md");
+    const slug = basename21(rule.source, ".md");
     if (rule.targets.length > 0 && !rule.targets.includes("codex-cli")) continue;
     if (rule.codexEmit === "execution") {
       outputs.push({
@@ -5884,7 +6285,7 @@ function generateRules8(canonical) {
   }
   return outputs;
 }
-function generateSkills8(canonical) {
+function generateSkills9(canonical) {
   const outputs = [];
   for (const skill of canonical.skills) {
     const frontmatter = {
@@ -5949,7 +6350,7 @@ ${body}
   }
   return lines.join("\n") + "\n";
 }
-function generateMcp6(canonical) {
+function generateMcp7(canonical) {
   if (!canonical.mcp || Object.keys(canonical.mcp.mcpServers).length === 0) return [];
   const stdioServers = Object.fromEntries(
     Object.entries(canonical.mcp.mcpServers).flatMap(
@@ -5983,10 +6384,10 @@ function needsTomlQuoting(key) {
 }
 
 // src/targets/codex-cli/importer.ts
-import { join as join33, relative as relative12, dirname as dirname15, basename as basename21 } from "path";
+import { join as join34, relative as relative12, dirname as dirname15, basename as basename22 } from "path";
 
 // src/targets/codex-cli/import-codex-non-root-rules.ts
-import { join as join30, relative as relative10 } from "path";
+import { join as join31, relative as relative10 } from "path";
 
 // src/targets/codex-cli/codex-rules-embed.ts
 import { Buffer } from "buffer";
@@ -6032,7 +6433,7 @@ function tryParseEmbeddedCanonicalFromCodexRules(content) {
 // src/targets/codex-cli/import-codex-non-root-rules.ts
 async function importCodexNonRootRuleFiles(projectRoot, destDir, normalize) {
   const results = [];
-  const codexRulesPath = join30(projectRoot, CODEX_RULES_DIR);
+  const codexRulesPath = join31(projectRoot, CODEX_RULES_DIR);
   try {
     const ruleFiles = await readDirRecursive(codexRulesPath);
     const mdFiles = ruleFiles.filter((f) => f.endsWith(".md"));
@@ -6040,7 +6441,7 @@ async function importCodexNonRootRuleFiles(projectRoot, destDir, normalize) {
       const content = await readFileSafe(srcPath);
       if (!content) continue;
       const relativePath = relative10(codexRulesPath, srcPath).replace(/\\/g, "/");
-      const destPath = join30(destDir, relativePath);
+      const destPath = join31(destDir, relativePath);
       const { frontmatter, body } = parseFrontmatter(normalize(content, srcPath, destPath));
       await mkdirp(destDir);
       const outFm = frontmatter.root === true ? frontmatter : { ...frontmatter, root: false };
@@ -6058,7 +6459,7 @@ async function importCodexNonRootRuleFiles(projectRoot, destDir, normalize) {
       const raw = await readFileSafe(srcPath);
       if (!raw) continue;
       const relativePath = relative10(codexRulesPath, srcPath).replace(/\\/g, "/").replace(/\.rules$/i, ".md");
-      const destPath = join30(destDir, relativePath);
+      const destPath = join31(destDir, relativePath);
       await mkdirp(destDir);
       const embedded = tryParseEmbeddedCanonicalFromCodexRules(raw);
       if (embedded) {
@@ -6098,7 +6499,7 @@ async function importCodexNonRootRuleFiles(projectRoot, destDir, normalize) {
 }
 
 // src/targets/codex-cli/mcp-helpers.ts
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 import { parse as parseToml4 } from "smol-toml";
 function mapTomlServerToCanonical(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
@@ -6119,8 +6520,8 @@ function mapTomlServerToCanonical(raw) {
     env
   };
 }
-async function importMcp4(projectRoot, results) {
-  const configPath = join31(projectRoot, CODEX_CONFIG_TOML);
+async function importMcp5(projectRoot, results) {
+  const configPath = join32(projectRoot, CODEX_CONFIG_TOML);
   const content = await readFileSafe(configPath);
   if (content === null) return;
   let parsed;
@@ -6139,9 +6540,9 @@ async function importMcp4(projectRoot, results) {
     if (server) mcpServers[name] = server;
   }
   if (Object.keys(mcpServers).length === 0) return;
-  await mkdirp(join31(projectRoot, ".agentsmesh"));
+  await mkdirp(join32(projectRoot, ".agentsmesh"));
   await writeFileAtomic(
-    join31(projectRoot, CODEX_CANONICAL_MCP),
+    join32(projectRoot, CODEX_CANONICAL_MCP),
     JSON.stringify({ mcpServers }, null, 2)
   );
   results.push({
@@ -6154,7 +6555,7 @@ async function importMcp4(projectRoot, results) {
 
 // src/targets/codex-cli/skills-helpers.ts
 import { readdir as readdir7 } from "fs/promises";
-import { join as join32, relative as relative11, dirname as dirname14 } from "path";
+import { join as join33, relative as relative11, dirname as dirname14 } from "path";
 
 // src/targets/import/scoped-agents-import.ts
 import { rm as rm5 } from "fs/promises";
@@ -6172,7 +6573,7 @@ async function removePathIfExists(path) {
 // src/targets/codex-cli/skills-helpers.ts
 async function importSkills3(projectRoot, results, normalize) {
   for (const skillsRoot of [CODEX_SKILLS_DIR, CODEX_SKILLS_FALLBACK_DIR]) {
-    const skillsDir = join32(projectRoot, skillsRoot);
+    const skillsDir = join33(projectRoot, skillsRoot);
     const entries = await readdir7(skillsDir, {
       encoding: "utf8",
       withFileTypes: true
@@ -6183,21 +6584,21 @@ async function importSkills3(projectRoot, results, normalize) {
     let importedAny = false;
     for (const ent of entries) {
       if (!ent.isDirectory() && !ent.isSymbolicLink()) continue;
-      const skillPath = join32(skillsDir, ent.name);
-      const skillMdPath = join32(skillPath, "SKILL.md");
+      const skillPath = join33(skillsDir, ent.name);
+      const skillMdPath = join33(skillPath, "SKILL.md");
       const skillMdContent = await readFileSafe(skillMdPath);
       if (!skillMdContent) continue;
       importedAny = true;
       const skillName = ent.name;
-      const destSkillPath = join32(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName, "SKILL.md");
+      const destSkillPath = join33(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(join32(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName));
-        const destCommandsDir = join32(projectRoot, CODEX_CANONICAL_COMMANDS_DIR);
+        await removePathIfExists(join33(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName));
+        const destCommandsDir = join33(projectRoot, CODEX_CANONICAL_COMMANDS_DIR);
         await mkdirp(destCommandsDir);
-        const commandPath = join32(destCommandsDir, `${command.name}.md`);
+        const commandPath = join33(destCommandsDir, `${command.name}.md`);
         await writeFileAtomic(
           commandPath,
           serializeImportedCommand(command, normalize(body, skillMdPath, commandPath))
@@ -6212,10 +6613,10 @@ async function importSkills3(projectRoot, results, normalize) {
       }
       const projectedAgent = parseProjectedAgentSkillFrontmatter(frontmatter, ent.name);
       if (projectedAgent) {
-        await removePathIfExists(join32(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName));
-        const destAgentsDir = join32(projectRoot, CODEX_CANONICAL_AGENTS_DIR);
+        await removePathIfExists(join33(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName));
+        const destAgentsDir = join33(projectRoot, CODEX_CANONICAL_AGENTS_DIR);
         await mkdirp(destAgentsDir);
-        const agentPath = join32(destAgentsDir, `${projectedAgent.name}.md`);
+        const agentPath = join33(destAgentsDir, `${projectedAgent.name}.md`);
         await writeFileAtomic(
           agentPath,
           serializeImportedAgent(projectedAgent, normalize(body, skillMdPath, agentPath))
@@ -6228,7 +6629,7 @@ async function importSkills3(projectRoot, results, normalize) {
         });
         continue;
       }
-      const destSkillDir = join32(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName);
+      const destSkillDir = join33(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName);
       await mkdirp(destSkillDir);
       const outContent = await serializeImportedSkillWithFallback(
         destSkillPath,
@@ -6248,7 +6649,7 @@ async function importSkills3(projectRoot, results, normalize) {
         const relPath = relative11(skillPath, absPath).replace(/\\/g, "/");
         const fileContent = await readFileSafe(absPath);
         if (fileContent === null) continue;
-        const destPath = join32(destSkillDir, relPath);
+        const destPath = join33(destSkillDir, relPath);
         await mkdirp(dirname14(destPath));
         await writeFileAtomic(destPath, normalize(fileContent, absPath, destPath));
         results.push({
@@ -6271,15 +6672,15 @@ async function importFromCodex(projectRoot) {
   const results = [];
   const normalize = await createImportReferenceNormalizer(CODEX_TARGET, projectRoot);
   const normalizeWindsurf = await createImportReferenceNormalizer("windsurf", projectRoot);
-  await importRules4(projectRoot, results, normalize, normalizeWindsurf);
+  await importRules5(projectRoot, results, normalize, normalizeWindsurf);
   await importSkills3(projectRoot, results, normalize);
   await importAgents4(projectRoot, results, normalize);
-  await importMcp4(projectRoot, results);
+  await importMcp5(projectRoot, results);
   return results;
 }
 async function importAgents4(projectRoot, results, normalize) {
-  const agentsPath = join33(projectRoot, CODEX_AGENTS_DIR);
-  const agentsDestDir = join33(projectRoot, CODEX_CANONICAL_AGENTS_DIR);
+  const agentsPath = join34(projectRoot, CODEX_AGENTS_DIR);
+  const agentsDestDir = join34(projectRoot, CODEX_CANONICAL_AGENTS_DIR);
   try {
     const agentFiles = await readDirRecursive(agentsPath);
     const tomlFiles = agentFiles.filter((f) => f.endsWith(".toml"));
@@ -6288,7 +6689,7 @@ async function importAgents4(projectRoot, results, normalize) {
       if (!content) continue;
       const parsed = parseToml5(content);
       if (!parsed || typeof parsed !== "object") continue;
-      const name = typeof parsed.name === "string" ? parsed.name : basename21(srcPath, ".toml");
+      const name = typeof parsed.name === "string" ? parsed.name : basename22(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 : "";
@@ -6296,7 +6697,7 @@ async function importAgents4(projectRoot, results, normalize) {
       const permissionMode = sandbox === "read-only" ? "read-only" : sandbox === "workspace-write" ? "allow" : "";
       const mcpServers = Array.isArray(parsed.mcp_servers) ? parsed.mcp_servers.filter((s) => typeof s === "string") : [];
       await mkdirp(agentsDestDir);
-      const destPath = join33(agentsDestDir, `${name}.md`);
+      const destPath = join34(agentsDestDir, `${name}.md`);
       const normalizedBody = normalize(body, srcPath, destPath);
       const agent = {
         name,
@@ -6323,17 +6724,17 @@ async function importAgents4(projectRoot, results, normalize) {
   } catch {
   }
 }
-async function importRules4(projectRoot, results, normalize, normalizeWindsurf) {
-  const codexPath = join33(projectRoot, CODEX_MD);
-  const agentsPath = join33(projectRoot, AGENTS_MD);
+async function importRules5(projectRoot, results, normalize, normalizeWindsurf) {
+  const codexPath = join34(projectRoot, CODEX_MD);
+  const agentsPath = join34(projectRoot, AGENTS_MD);
   const agentsContent = await readFileSafe(agentsPath);
   const codexContent = await readFileSafe(codexPath);
   const sourcePath = agentsContent !== null ? agentsPath : codexPath;
-  const destDir = join33(projectRoot, CODEX_CANONICAL_RULES_DIR);
+  const destDir = join34(projectRoot, CODEX_CANONICAL_RULES_DIR);
   const content = agentsContent ?? codexContent;
   if (content !== null) {
     await mkdirp(destDir);
-    const destPath = join33(destDir, "_root.md");
+    const destPath = join34(destDir, "_root.md");
     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);
@@ -6363,10 +6764,10 @@ async function importRules4(projectRoot, results, normalize, normalizeWindsurf)
         if (!isOverride && !srcPath.endsWith("/AGENTS.md")) return null;
         const ruleName = relDir.replace(/\//g, "-");
         if (!shouldImportScopedAgentsRule(relDir)) {
-          await removePathIfExists(join33(destDir, `${ruleName}.md`));
+          await removePathIfExists(join34(destDir, `${ruleName}.md`));
           return null;
         }
-        const destPath = join33(destDir, `${ruleName}.md`);
+        const destPath = join34(destDir, `${ruleName}.md`);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         return {
           destPath,
@@ -6389,15 +6790,15 @@ async function importRules4(projectRoot, results, normalize, normalizeWindsurf)
 }
 async function importInstructionMirrors(projectRoot, destDir, results, normalize) {
   try {
-    const files = await readDirRecursive(join33(projectRoot, CODEX_INSTRUCTIONS_DIR));
+    const files = await readDirRecursive(join34(projectRoot, CODEX_INSTRUCTIONS_DIR));
     const instructionFiles = files.filter((file) => file.endsWith(".md"));
-    const instructionsRoot = join33(projectRoot, CODEX_INSTRUCTIONS_DIR);
+    const instructionsRoot = join34(projectRoot, CODEX_INSTRUCTIONS_DIR);
     for (const srcPath of instructionFiles) {
       const relativePath = relative12(instructionsRoot, srcPath).replace(/\\/g, "/");
       if (relativePath === "_root.md") continue;
       const content = await readFileSafe(srcPath);
       if (!content) continue;
-      const destPath = join33(destDir, relativePath);
+      const destPath = join34(destDir, relativePath);
       const { frontmatter, body } = parseFrontmatter(normalize(content, srcPath, destPath));
       await mkdirp(destDir);
       const outFm = frontmatter.root === true ? frontmatter : { ...frontmatter, root: false };
@@ -6416,7 +6817,7 @@ async function importInstructionMirrors(projectRoot, destDir, results, normalize
 
 // src/targets/codex-cli/linter.ts
 import { relative as relative13 } from "path";
-function lintRules8(canonical, projectRoot, _projectFiles) {
+function lintRules9(canonical, projectRoot, _projectFiles) {
   const { rules } = canonical;
   if (rules.length === 0) return [];
   const hasRoot = rules.some((r) => r.root);
@@ -6439,19 +6840,19 @@ function codexAdvisoryInstructionPath(rule) {
 }
 
 // src/targets/codex-cli/index.ts
-var target8 = {
+var target9 = {
   name: "codex-cli",
   primaryRootInstructionPath: AGENTS_MD,
-  generateRules: generateRules8,
+  generateRules: generateRules9,
   generateCommands: generateCommands7,
   generateAgents: generateAgents7,
-  generateSkills: generateSkills8,
-  generateMcp: generateMcp6,
+  generateSkills: generateSkills9,
+  generateMcp: generateMcp7,
   importFrom: importFromCodex
 };
-var descriptor8 = {
+var descriptor9 = {
   id: "codex-cli",
-  generators: target8,
+  generators: target9,
   capabilities: {
     rules: "native",
     commands: "embedded",
@@ -6463,7 +6864,7 @@ var descriptor8 = {
     permissions: "none"
   },
   emptyImportMessage: "No Codex config found (codex.md or AGENTS.md).",
-  lintRules: lintRules8,
+  lintRules: lintRules9,
   skillDir: ".agents/skills",
   paths: {
     rulePath(_slug, rule) {
@@ -6481,7 +6882,7 @@ var descriptor8 = {
 };
 
 // src/targets/windsurf/generator.ts
-import { basename as basename22 } from "path";
+import { basename as basename23 } from "path";
 
 // src/targets/windsurf/constants.ts
 var WINDSURF_TARGET = "windsurf";
@@ -6505,7 +6906,7 @@ var WINDSURF_CANONICAL_MCP = ".agentsmesh/mcp.json";
 
 // src/targets/windsurf/generator.ts
 function ruleSlug5(source) {
-  const name = basename22(source, ".md");
+  const name = basename23(source, ".md");
   return name === "_root" ? "root" : name;
 }
 function directoryScopedRuleDir(globs) {
@@ -6514,7 +6915,7 @@ function directoryScopedRuleDir(globs) {
   if (dirs.length !== globs.length) return null;
   return dirs.every((dir) => dir === dirs[0]) ? dirs[0] : null;
 }
-function generateRules9(canonical) {
+function generateRules10(canonical) {
   const outputs = [];
   const root = canonical.rules.find((r) => r.root);
   if (!root) return [];
@@ -6548,7 +6949,7 @@ function generateRules9(canonical) {
   }
   return outputs;
 }
-function generateIgnore6(canonical) {
+function generateIgnore7(canonical) {
   if (!canonical.ignore || canonical.ignore.length === 0) return [];
   return [{ path: CODEIUM_IGNORE, content: canonical.ignore.join("\n") }];
 }
@@ -6574,7 +6975,7 @@ function generateAgents8(canonical) {
     content: serializeProjectedAgentSkill(agent)
   }));
 }
-function generateMcp7(canonical) {
+function generateMcp8(canonical) {
   if (!canonical.mcp || Object.keys(canonical.mcp.mcpServers).length === 0) return [];
   return [
     {
@@ -6612,13 +7013,13 @@ function toWindsurfHooks(hooks) {
   }
   return result;
 }
-function generateHooks5(canonical) {
+function generateHooks6(canonical) {
   if (!canonical.hooks || Object.keys(canonical.hooks).length === 0) return [];
   const hooks = toWindsurfHooks(canonical.hooks);
   if (Object.keys(hooks).length === 0) return [];
   return [{ path: WINDSURF_HOOKS_FILE, content: JSON.stringify({ hooks }, null, 2) }];
 }
-function generateSkills9(canonical) {
+function generateSkills10(canonical) {
   const outputs = [];
   for (const skill of canonical.skills) {
     const frontmatter = {
@@ -6639,11 +7040,11 @@ function generateSkills9(canonical) {
 }
 
 // src/targets/windsurf/importer.ts
-import { join as join35, dirname as dirname16, relative as relative15 } from "path";
-import { stringify as yamlStringify4 } from "yaml";
+import { join as join36, dirname as dirname16, relative as relative15 } from "path";
+import { stringify as yamlStringify5 } from "yaml";
 
 // src/targets/windsurf/workflows-skills-helpers.ts
-import { join as join34, relative as relative14 } from "path";
+import { join as join35, relative as relative14 } from "path";
 import { readdir as readdir8 } from "fs/promises";
 function toStringArray7(value) {
   if (Array.isArray(value)) {
@@ -6655,16 +7056,16 @@ function toStringArray7(value) {
   return [];
 }
 async function importWorkflows(projectRoot, results, normalize) {
-  const workflowsDir = join34(projectRoot, WINDSURF_WORKFLOWS_DIR);
+  const workflowsDir = join35(projectRoot, WINDSURF_WORKFLOWS_DIR);
   const workflowFiles = await readDirRecursive(workflowsDir);
   const workflowMdFiles = workflowFiles.filter((f) => f.endsWith(".md"));
-  const destCommandsDir = join34(projectRoot, WINDSURF_CANONICAL_COMMANDS_DIR);
+  const destCommandsDir = join35(projectRoot, WINDSURF_CANONICAL_COMMANDS_DIR);
   for (const srcPath of workflowMdFiles) {
     const content = await readFileSafe(srcPath);
     if (!content) continue;
     const relativePath = relative14(workflowsDir, srcPath).replace(/\\/g, "/");
     await mkdirp(destCommandsDir);
-    const destPath = join34(destCommandsDir, relativePath);
+    const destPath = join35(destCommandsDir, relativePath);
     const normalized = normalize(content, srcPath, destPath);
     const { frontmatter, body } = parseFrontmatter(normalized);
     const outContent = await serializeImportedCommandWithFallback(
@@ -6690,22 +7091,22 @@ async function importWorkflows(projectRoot, results, normalize) {
   }
 }
 async function importSkills4(projectRoot, results, normalize) {
-  const windsurfSkillsBaseDir = join34(projectRoot, WINDSURF_SKILLS_DIR);
+  const windsurfSkillsBaseDir = join35(projectRoot, WINDSURF_SKILLS_DIR);
   try {
     const skillEntries = await readdir8(windsurfSkillsBaseDir, { withFileTypes: true });
     for (const ent of skillEntries) {
       if (!ent.isDirectory()) continue;
-      const skillPath = join34(windsurfSkillsBaseDir, ent.name);
-      const skillMdPath = join34(skillPath, "SKILL.md");
+      const skillPath = join35(windsurfSkillsBaseDir, ent.name);
+      const skillMdPath = join35(skillPath, "SKILL.md");
       const skillContent = await readFileSafe(skillMdPath);
       if (!skillContent) continue;
       const rawParsed = parseFrontmatter(skillContent);
       const projectedAgent = parseProjectedAgentSkillFrontmatter(rawParsed.frontmatter, ent.name);
       if (projectedAgent) {
-        await removePathIfExists(join34(projectRoot, WINDSURF_CANONICAL_SKILLS_DIR, ent.name));
-        const destAgentsDir = join34(projectRoot, WINDSURF_CANONICAL_AGENTS_DIR);
+        await removePathIfExists(join35(projectRoot, WINDSURF_CANONICAL_SKILLS_DIR, ent.name));
+        const destAgentsDir = join35(projectRoot, WINDSURF_CANONICAL_AGENTS_DIR);
         await mkdirp(destAgentsDir);
-        const agentPath = join34(destAgentsDir, `${projectedAgent.name}.md`);
+        const agentPath = join35(destAgentsDir, `${projectedAgent.name}.md`);
         await writeFileAtomic(
           agentPath,
           serializeImportedAgent(projectedAgent, normalize(rawParsed.body, skillMdPath, agentPath))
@@ -6718,8 +7119,8 @@ async function importSkills4(projectRoot, results, normalize) {
         });
         continue;
       }
-      const destSkillDir = join34(projectRoot, WINDSURF_CANONICAL_SKILLS_DIR, ent.name);
-      const destSkillPath = join34(destSkillDir, "SKILL.md");
+      const destSkillDir = join35(projectRoot, WINDSURF_CANONICAL_SKILLS_DIR, ent.name);
+      const destSkillPath = join35(destSkillDir, "SKILL.md");
       const normalized = normalize(skillContent, skillMdPath, destSkillPath);
       await mkdirp(destSkillDir);
       const { frontmatter, body } = parseFrontmatter(normalized);
@@ -6743,8 +7144,8 @@ async function importSkills4(projectRoot, results, normalize) {
         const relPath = absPath.slice(skillPath.length + 1).replace(/\\/g, "/");
         const supportContent = await readFileSafe(absPath);
         if (supportContent === null) continue;
-        const destSupportPath = join34(destSkillDir, relPath);
-        await mkdirp(join34(destSupportPath, ".."));
+        const destSupportPath = join35(destSkillDir, relPath);
+        await mkdirp(join35(destSupportPath, ".."));
         await writeFileAtomic(destSupportPath, normalize(supportContent, absPath, destSupportPath));
         results.push({
           fromTool: WINDSURF_TARGET,
@@ -6763,12 +7164,12 @@ async function importFromWindsurf(projectRoot) {
   const results = [];
   const normalize = await createImportReferenceNormalizer(WINDSURF_TARGET, projectRoot);
   const normalizeCodex = await createImportReferenceNormalizer("codex-cli", projectRoot);
-  const destRulesDir = join35(projectRoot, WINDSURF_CANONICAL_RULES_DIR);
-  const rootPath = join35(projectRoot, WINDSURF_RULES_ROOT);
+  const destRulesDir = join36(projectRoot, WINDSURF_CANONICAL_RULES_DIR);
+  const rootPath = join36(projectRoot, WINDSURF_RULES_ROOT);
   const rootContent = await readFileSafe(rootPath);
   if (rootContent !== null) {
     await mkdirp(destRulesDir);
-    const destPath = join35(destRulesDir, "_root.md");
+    const destPath = join36(destRulesDir, "_root.md");
     const body = normalize(rootContent, rootPath, destPath).trim();
     const outContent = await serializeImportedRuleWithFallback(destPath, { root: true }, body);
     await writeFileAtomic(destPath, outContent);
@@ -6780,11 +7181,11 @@ async function importFromWindsurf(projectRoot) {
     });
   }
   if (rootContent === null) {
-    const agentsMdPath = join35(projectRoot, WINDSURF_AGENTS_MD);
+    const agentsMdPath = join36(projectRoot, WINDSURF_AGENTS_MD);
     const agentsMdContent = await readFileSafe(agentsMdPath);
     if (agentsMdContent !== null) {
       await mkdirp(destRulesDir);
-      const destPath = join35(destRulesDir, "_root.md");
+      const destPath = join36(destRulesDir, "_root.md");
       const body = normalize(
         normalizeCodex(agentsMdContent, agentsMdPath, destPath),
         agentsMdPath,
@@ -6812,10 +7213,10 @@ async function importFromWindsurf(projectRoot) {
         if (!relDir || relDir === "." || !srcPath.endsWith("/AGENTS.md")) return null;
         const ruleName = relDir.replace(/\//g, "-");
         if (!shouldImportScopedAgentsRule(relDir)) {
-          await removePathIfExists(join35(destRulesDir, `${ruleName}.md`));
+          await removePathIfExists(join36(destRulesDir, `${ruleName}.md`));
           return null;
         }
-        const destPath = join35(destRulesDir, `${ruleName}.md`);
+        const destPath = join36(destRulesDir, `${ruleName}.md`);
         return {
           destPath,
           toPath: `${WINDSURF_CANONICAL_RULES_DIR}/${ruleName}.md`,
@@ -6829,7 +7230,7 @@ async function importFromWindsurf(projectRoot) {
       }
     })
   );
-  const rulesDir = join35(projectRoot, WINDSURF_RULES_DIR);
+  const rulesDir = join36(projectRoot, WINDSURF_RULES_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: rulesDir,
@@ -6839,7 +7240,7 @@ async function importFromWindsurf(projectRoot) {
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
         if (relativePath === "_root.md" && rootContent !== null) return null;
-        const destPath = join35(destRulesDir, relativePath);
+        const destPath = join36(destRulesDir, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         const normalizedFrontmatter = { ...frontmatter };
         if (typeof normalizedFrontmatter.glob === "string" && normalizedFrontmatter.glob.trim()) {
@@ -6859,10 +7260,10 @@ async function importFromWindsurf(projectRoot) {
       }
     })
   );
-  let ignorePath = join35(projectRoot, WINDSURF_IGNORE);
+  let ignorePath = join36(projectRoot, WINDSURF_IGNORE);
   let ignoreContent = await readFileSafe(ignorePath);
   if (ignoreContent === null || !ignoreContent.trim()) {
-    ignorePath = join35(projectRoot, CODEIUM_IGNORE);
+    ignorePath = join36(projectRoot, CODEIUM_IGNORE);
     ignoreContent = await readFileSafe(ignorePath);
   }
   if (ignoreContent !== null && ignoreContent.trim()) {
@@ -6873,8 +7274,8 @@ async function importFromWindsurf(projectRoot) {
       if (t && !t.startsWith("#")) patterns.push(t);
     }
     if (patterns.length > 0) {
-      await mkdirp(join35(projectRoot, ".agentsmesh"));
-      const destIgnorePath = join35(projectRoot, WINDSURF_CANONICAL_IGNORE);
+      await mkdirp(join36(projectRoot, ".agentsmesh"));
+      const destIgnorePath = join36(projectRoot, WINDSURF_CANONICAL_IGNORE);
       await writeFileAtomic(destIgnorePath, patterns.join("\n"));
       results.push({
         fromTool: "windsurf",
@@ -6886,12 +7287,12 @@ async function importFromWindsurf(projectRoot) {
   }
   await importWorkflows(projectRoot, results, normalize);
   await importSkills4(projectRoot, results, normalize);
-  await importHooks2(projectRoot, results);
-  await importMcp5(projectRoot, results);
+  await importHooks3(projectRoot, results);
+  await importMcp6(projectRoot, results);
   return results;
 }
-async function importHooks2(projectRoot, results) {
-  const hooksPath = join35(projectRoot, WINDSURF_HOOKS_FILE);
+async function importHooks3(projectRoot, results) {
+  const hooksPath = join36(projectRoot, WINDSURF_HOOKS_FILE);
   const hooksContent = await readFileSafe(hooksPath);
   if (!hooksContent) return;
   try {
@@ -6899,9 +7300,9 @@ async function importHooks2(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 = join35(projectRoot, WINDSURF_CANONICAL_HOOKS);
+    const destPath = join36(projectRoot, WINDSURF_CANONICAL_HOOKS);
     await mkdirp(dirname16(destPath));
-    await writeFileAtomic(destPath, yamlStringify4(canonical));
+    await writeFileAtomic(destPath, yamlStringify5(canonical));
     results.push({
       fromTool: WINDSURF_TARGET,
       fromPath: hooksPath,
@@ -6959,16 +7360,16 @@ function windsurfHooksToCanonical(hooks) {
   }
   return result;
 }
-async function importMcp5(projectRoot, results) {
+async function importMcp6(projectRoot, results) {
   const sourceCandidates = [WINDSURF_MCP_EXAMPLE_FILE, WINDSURF_MCP_CONFIG_FILE];
   for (const relPath of sourceCandidates) {
-    const srcPath = join35(projectRoot, relPath);
+    const srcPath = join36(projectRoot, relPath);
     const content = await readFileSafe(srcPath);
     if (!content) continue;
     try {
       const parsed = JSON.parse(content);
       if (!parsed.mcpServers || typeof parsed.mcpServers !== "object") continue;
-      const destPath = join35(projectRoot, WINDSURF_CANONICAL_MCP);
+      const destPath = join36(projectRoot, WINDSURF_CANONICAL_MCP);
       await mkdirp(dirname16(destPath));
       await writeFileAtomic(destPath, JSON.stringify({ mcpServers: parsed.mcpServers }, null, 2));
       results.push({
@@ -6985,7 +7386,7 @@ async function importMcp5(projectRoot, results) {
 
 // src/targets/windsurf/linter.ts
 import { relative as relative16 } from "path";
-function lintRules9(canonical, projectRoot, _projectFiles) {
+function lintRules10(canonical, projectRoot, _projectFiles) {
   const diags = [];
   const { rules } = canonical;
   if (rules.length > 0) {
@@ -7014,21 +7415,21 @@ function lintRules9(canonical, projectRoot, _projectFiles) {
 }
 
 // src/targets/windsurf/index.ts
-var target9 = {
+var target10 = {
   name: "windsurf",
   primaryRootInstructionPath: WINDSURF_AGENTS_MD,
-  generateRules: generateRules9,
+  generateRules: generateRules10,
   generateWorkflows: generateWorkflows2,
   generateAgents: generateAgents8,
-  generateSkills: generateSkills9,
-  generateMcp: generateMcp7,
-  generateHooks: generateHooks5,
-  generateIgnore: generateIgnore6,
+  generateSkills: generateSkills10,
+  generateMcp: generateMcp8,
+  generateHooks: generateHooks6,
+  generateIgnore: generateIgnore7,
   importFrom: importFromWindsurf
 };
-var descriptor9 = {
+var descriptor10 = {
   id: "windsurf",
-  generators: target9,
+  generators: target10,
   capabilities: {
     rules: "native",
     commands: "native",
@@ -7040,7 +7441,7 @@ var descriptor9 = {
     permissions: "none"
   },
   emptyImportMessage: "No Windsurf config found (.windsurfrules, .windsurf/rules, .windsurfignore, or .codeiumignore).",
-  lintRules: lintRules9,
+  lintRules: lintRules10,
   skillDir: ".windsurf/skills",
   paths: {
     rulePath(slug, _rule) {
@@ -7058,8 +7459,8 @@ var descriptor9 = {
 };
 
 // src/targets/antigravity/generator.ts
-import { basename as basename23 } from "path";
-function generateRules10(canonical) {
+import { basename as basename24 } from "path";
+function generateRules11(canonical) {
   const root = canonical.rules.find((r) => r.root);
   if (!root) return [];
   const outputs = [
@@ -7068,7 +7469,7 @@ function generateRules10(canonical) {
   for (const rule of canonical.rules) {
     if (rule.root) continue;
     if (rule.targets.length > 0 && !rule.targets.includes("antigravity")) continue;
-    const slug = basename23(rule.source, ".md");
+    const slug = basename24(rule.source, ".md");
     outputs.push({
       path: `${ANTIGRAVITY_RULES_DIR}/${slug}.md`,
       content: rule.body.trim() || ""
@@ -7089,15 +7490,15 @@ ${body}` : body || intro;
     };
   });
 }
-function generateSkills10(canonical) {
+function generateSkills11(canonical) {
   return generateEmbeddedSkills(canonical, ANTIGRAVITY_SKILLS_DIR);
 }
 
 // src/targets/antigravity/importer.ts
-import { basename as basename24, join as join36 } from "path";
+import { basename as basename25, join as join37 } from "path";
 async function importRootRule(projectRoot, results, normalize) {
-  const primary = join36(projectRoot, ANTIGRAVITY_RULES_ROOT);
-  const legacy = join36(projectRoot, ANTIGRAVITY_RULES_ROOT_LEGACY);
+  const primary = join37(projectRoot, ANTIGRAVITY_RULES_ROOT);
+  const legacy = join37(projectRoot, ANTIGRAVITY_RULES_ROOT_LEGACY);
   let srcPath = primary;
   let content = await readFileSafe(primary);
   if (content === null) {
@@ -7105,10 +7506,10 @@ async function importRootRule(projectRoot, results, normalize) {
     content = await readFileSafe(legacy);
   }
   if (content === null) return;
-  const destPath = join36(projectRoot, ANTIGRAVITY_CANONICAL_ROOT_RULE);
+  const destPath = join37(projectRoot, ANTIGRAVITY_CANONICAL_ROOT_RULE);
   const { body } = parseFrontmatter(normalize(content, srcPath, destPath));
   const output = await serializeImportedRuleWithFallback(destPath, { root: true }, body);
-  await mkdirp(join36(projectRoot, ANTIGRAVITY_CANONICAL_RULES_DIR));
+  await mkdirp(join37(projectRoot, ANTIGRAVITY_CANONICAL_RULES_DIR));
   await writeFileAtomic(destPath, output);
   results.push({
     fromTool: ANTIGRAVITY_TARGET,
@@ -7118,8 +7519,8 @@ async function importRootRule(projectRoot, results, normalize) {
   });
 }
 async function importNonRootRules2(projectRoot, results, normalize) {
-  const srcDir = join36(projectRoot, ANTIGRAVITY_RULES_DIR);
-  const destDir = join36(projectRoot, ANTIGRAVITY_CANONICAL_RULES_DIR);
+  const srcDir = join37(projectRoot, ANTIGRAVITY_RULES_DIR);
+  const destDir = join37(projectRoot, ANTIGRAVITY_CANONICAL_RULES_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir,
@@ -7128,9 +7529,9 @@ async function importNonRootRules2(projectRoot, results, normalize) {
       fromTool: ANTIGRAVITY_TARGET,
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
-        if (basename24(relativePath) === "general.md" || basename24(relativePath) === "_root.md")
+        if (basename25(relativePath) === "general.md" || basename25(relativePath) === "_root.md")
           return null;
-        const destPath = join36(destDir, relativePath);
+        const destPath = join37(destDir, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         const output = await serializeImportedRuleWithFallback(
           destPath,
@@ -7152,8 +7553,8 @@ async function importNonRootRules2(projectRoot, results, normalize) {
   );
 }
 async function importWorkflows2(projectRoot, results, normalize) {
-  const srcDir = join36(projectRoot, ANTIGRAVITY_WORKFLOWS_DIR);
-  const destDir = join36(projectRoot, ANTIGRAVITY_CANONICAL_COMMANDS_DIR);
+  const srcDir = join37(projectRoot, ANTIGRAVITY_WORKFLOWS_DIR);
+  const destDir = join37(projectRoot, ANTIGRAVITY_CANONICAL_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir,
@@ -7162,7 +7563,7 @@ async function importWorkflows2(projectRoot, results, normalize) {
       fromTool: ANTIGRAVITY_TARGET,
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
-        const destPath = join36(destDir, relativePath);
+        const destPath = join37(destDir, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         const normalized = await serializeImportedCommandWithFallback(
           destPath,
@@ -7201,7 +7602,7 @@ async function importFromAntigravity(projectRoot) {
 }
 
 // src/targets/antigravity/linter.ts
-function lintRules10(canonical, projectRoot, projectFiles) {
+function lintRules11(canonical, projectRoot, projectFiles) {
   return validateRules(canonical, projectRoot, projectFiles).map((diagnostic) => ({
     ...diagnostic,
     target: ANTIGRAVITY_TARGET
@@ -7209,17 +7610,17 @@ function lintRules10(canonical, projectRoot, projectFiles) {
 }
 
 // src/targets/antigravity/index.ts
-var target10 = {
+var target11 = {
   name: "antigravity",
   primaryRootInstructionPath: ANTIGRAVITY_RULES_ROOT,
-  generateRules: generateRules10,
+  generateRules: generateRules11,
   generateCommands: generateWorkflows3,
-  generateSkills: generateSkills10,
+  generateSkills: generateSkills11,
   importFrom: importFromAntigravity
 };
-var descriptor10 = {
+var descriptor11 = {
   id: "antigravity",
-  generators: target10,
+  generators: target11,
   capabilities: {
     rules: "native",
     commands: "partial",
@@ -7231,7 +7632,7 @@ var descriptor10 = {
     permissions: "none"
   },
   emptyImportMessage: "No Antigravity config found (.agents/rules/, .agents/skills/, or .agents/workflows/).",
-  lintRules: lintRules10,
+  lintRules: lintRules11,
   skillDir: ".agents/skills",
   paths: {
     rulePath(slug, _rule) {
@@ -7254,8 +7655,8 @@ var descriptor10 = {
 };
 
 // src/targets/roo-code/generator.ts
-import { basename as basename25 } from "path";
-function generateRules11(canonical) {
+import { basename as basename26 } from "path";
+function generateRules12(canonical) {
   const outputs = [];
   const root = canonical.rules.find((rule) => rule.root);
   if (root) {
@@ -7267,7 +7668,7 @@ function generateRules11(canonical) {
   for (const rule of canonical.rules) {
     if (rule.root) continue;
     if (rule.targets.length > 0 && !rule.targets.includes(ROO_CODE_TARGET)) continue;
-    const slug = basename25(rule.source, ".md");
+    const slug = basename26(rule.source, ".md");
     outputs.push({
       path: `${ROO_CODE_RULES_DIR}/${slug}.md`,
       content: rule.body.trim() || ""
@@ -7285,7 +7686,7 @@ function generateCommands8(canonical) {
     };
   });
 }
-function generateMcp8(canonical) {
+function generateMcp9(canonical) {
   if (!canonical.mcp || Object.keys(canonical.mcp.mcpServers).length === 0) return [];
   return [
     {
@@ -7294,18 +7695,18 @@ function generateMcp8(canonical) {
     }
   ];
 }
-function generateIgnore7(canonical) {
+function generateIgnore8(canonical) {
   if (canonical.ignore.length === 0) return [];
   return [{ path: ROO_CODE_IGNORE, content: canonical.ignore.join("\n") }];
 }
-function generateSkills11(canonical) {
+function generateSkills12(canonical) {
   return generateEmbeddedSkills(canonical, ROO_CODE_SKILLS_DIR);
 }
 
 // src/targets/roo-code/importer.ts
 import { readdir as readdir9 } from "fs/promises";
-import { join as join37 } from "path";
-function readMcpServers3(content) {
+import { join as join38 } from "path";
+function readMcpServers4(content) {
   const parsed = JSON.parse(content);
   const rawServers = parsed.mcpServers;
   if (!rawServers || typeof rawServers !== "object" || Array.isArray(rawServers)) return {};
@@ -7336,10 +7737,10 @@ function readMcpServers3(content) {
   return servers;
 }
 async function importRootRule2(projectRoot, results, normalize) {
-  const destPath = join37(projectRoot, ROO_CODE_CANONICAL_ROOT_RULE);
+  const destPath = join38(projectRoot, ROO_CODE_CANONICAL_ROOT_RULE);
   const sources = [ROO_CODE_ROOT_RULE, ROO_CODE_ROOT_RULE_FALLBACK];
   for (const relPath of sources) {
-    const srcPath = join37(projectRoot, relPath);
+    const srcPath = join38(projectRoot, relPath);
     const content = await readFileSafe(srcPath);
     if (content === null) continue;
     const { frontmatter, body } = parseFrontmatter(normalize(content, srcPath, destPath));
@@ -7363,8 +7764,8 @@ async function importRootRule2(projectRoot, results, normalize) {
   }
 }
 async function importNonRootRules3(projectRoot, results, normalize) {
-  const srcDir = join37(projectRoot, ROO_CODE_RULES_DIR);
-  const destDir = join37(projectRoot, ROO_CODE_CANONICAL_RULES_DIR);
+  const srcDir = join38(projectRoot, ROO_CODE_RULES_DIR);
+  const destDir = join38(projectRoot, ROO_CODE_CANONICAL_RULES_DIR);
   const rootRuleName = "00-root.md";
   results.push(
     ...await importFileDirectory({
@@ -7375,7 +7776,7 @@ async function importNonRootRules3(projectRoot, results, normalize) {
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
         if (relativePath === rootRuleName) return null;
-        const destPath = join37(destDir, relativePath);
+        const destPath = join38(destDir, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         const output = await serializeImportedRuleWithFallback(
           destPath,
@@ -7397,7 +7798,7 @@ async function importNonRootRules3(projectRoot, results, normalize) {
   );
 }
 async function importPerModeRules(projectRoot, results, normalize) {
-  const rooDir = join37(projectRoot, ROO_CODE_DIR);
+  const rooDir = join38(projectRoot, ROO_CODE_DIR);
   let entries;
   try {
     entries = await readdir9(rooDir, { withFileTypes: true });
@@ -7406,8 +7807,8 @@ async function importPerModeRules(projectRoot, results, normalize) {
   }
   const modeRuleDirs = entries.filter((e) => e.isDirectory() && e.name.startsWith("rules-")).map((e) => e.name);
   for (const dirName of modeRuleDirs) {
-    const srcDir = join37(rooDir, dirName);
-    const destDir = join37(projectRoot, ROO_CODE_CANONICAL_RULES_DIR);
+    const srcDir = join38(rooDir, dirName);
+    const destDir = join38(projectRoot, ROO_CODE_CANONICAL_RULES_DIR);
     results.push(
       ...await importFileDirectory({
         srcDir,
@@ -7416,7 +7817,7 @@ async function importPerModeRules(projectRoot, results, normalize) {
         fromTool: ROO_CODE_TARGET,
         normalize,
         mapEntry: async ({ relativePath, normalizeTo }) => {
-          const destPath = join37(destDir, relativePath);
+          const destPath = join38(destDir, relativePath);
           const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
           const output = await serializeImportedRuleWithFallback(
             destPath,
@@ -7439,8 +7840,8 @@ async function importPerModeRules(projectRoot, results, normalize) {
   }
 }
 async function importCommands5(projectRoot, results, normalize) {
-  const srcDir = join37(projectRoot, ROO_CODE_COMMANDS_DIR);
-  const destDir = join37(projectRoot, ROO_CODE_CANONICAL_COMMANDS_DIR);
+  const srcDir = join38(projectRoot, ROO_CODE_COMMANDS_DIR);
+  const destDir = join38(projectRoot, ROO_CODE_CANONICAL_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir,
@@ -7449,7 +7850,7 @@ async function importCommands5(projectRoot, results, normalize) {
       fromTool: ROO_CODE_TARGET,
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
-        const destPath = join37(destDir, relativePath);
+        const destPath = join38(destDir, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         const output = await serializeImportedCommandWithFallback(
           destPath,
@@ -7471,14 +7872,14 @@ async function importCommands5(projectRoot, results, normalize) {
     })
   );
 }
-async function importMcp6(projectRoot, results) {
-  const srcPath = join37(projectRoot, ROO_CODE_MCP_FILE);
+async function importMcp7(projectRoot, results) {
+  const srcPath = join38(projectRoot, ROO_CODE_MCP_FILE);
   const content = await readFileSafe(srcPath);
   if (content === null) return;
-  const servers = readMcpServers3(content);
+  const servers = readMcpServers4(content);
   if (Object.keys(servers).length === 0) return;
   await writeFileAtomic(
-    join37(projectRoot, ROO_CODE_CANONICAL_MCP),
+    join38(projectRoot, ROO_CODE_CANONICAL_MCP),
     JSON.stringify({ mcpServers: servers }, null, 2)
   );
   results.push({
@@ -7488,11 +7889,11 @@ async function importMcp6(projectRoot, results) {
     feature: "mcp"
   });
 }
-async function importIgnore3(projectRoot, results) {
-  const srcPath = join37(projectRoot, ROO_CODE_IGNORE);
+async function importIgnore4(projectRoot, results) {
+  const srcPath = join38(projectRoot, ROO_CODE_IGNORE);
   const content = await readFileSafe(srcPath);
   if (content === null) return;
-  await writeFileAtomic(join37(projectRoot, ROO_CODE_CANONICAL_IGNORE), content.trimEnd());
+  await writeFileAtomic(join38(projectRoot, ROO_CODE_CANONICAL_IGNORE), content.trimEnd());
   results.push({
     fromTool: ROO_CODE_TARGET,
     fromPath: srcPath,
@@ -7508,13 +7909,13 @@ async function importFromRooCode(projectRoot) {
   await importPerModeRules(projectRoot, results, normalize);
   await importCommands5(projectRoot, results, normalize);
   await importEmbeddedSkills(projectRoot, ROO_CODE_SKILLS_DIR, ROO_CODE_TARGET, results, normalize);
-  await importMcp6(projectRoot, results);
-  await importIgnore3(projectRoot, results);
+  await importMcp7(projectRoot, results);
+  await importIgnore4(projectRoot, results);
   return results;
 }
 
 // src/targets/roo-code/linter.ts
-function lintRules11(canonical, projectRoot, projectFiles) {
+function lintRules12(canonical, projectRoot, projectFiles) {
   return validateRules(canonical, projectRoot, projectFiles).map((diagnostic) => ({
     ...diagnostic,
     target: ROO_CODE_TARGET
@@ -7522,19 +7923,19 @@ function lintRules11(canonical, projectRoot, projectFiles) {
 }
 
 // src/targets/roo-code/index.ts
-var target11 = {
+var target12 = {
   name: "roo-code",
   primaryRootInstructionPath: ROO_CODE_ROOT_RULE,
-  generateRules: generateRules11,
+  generateRules: generateRules12,
   generateCommands: generateCommands8,
-  generateSkills: generateSkills11,
-  generateMcp: generateMcp8,
-  generateIgnore: generateIgnore7,
+  generateSkills: generateSkills12,
+  generateMcp: generateMcp9,
+  generateIgnore: generateIgnore8,
   importFrom: importFromRooCode
 };
-var descriptor11 = {
+var descriptor12 = {
   id: "roo-code",
-  generators: target11,
+  generators: target12,
   capabilities: {
     rules: "native",
     commands: "native",
@@ -7546,7 +7947,7 @@ var descriptor11 = {
     permissions: "none"
   },
   emptyImportMessage: "No Roo Code config found (.roo/rules, .roo/commands, .roo/skills, .roo/mcp.json, .rooignore, or .roorules).",
-  lintRules: lintRules11,
+  lintRules: lintRules12,
   skillDir: ".roo/skills",
   paths: {
     rulePath(slug, _rule) {
@@ -7582,39 +7983,40 @@ var BUILTIN_TARGETS = [
   descriptor8,
   descriptor9,
   descriptor10,
-  descriptor11
+  descriptor11,
+  descriptor12
 ];
-function getBuiltinTargetDefinition(target12) {
-  return BUILTIN_TARGETS.find((candidate) => candidate.id === target12);
+function getBuiltinTargetDefinition(target13) {
+  return BUILTIN_TARGETS.find((candidate) => candidate.id === target13);
 }
-function getTargetSkillDir(target12) {
-  return getBuiltinTargetDefinition(target12)?.skillDir;
+function getTargetSkillDir(target13) {
+  return getBuiltinTargetDefinition(target13)?.skillDir;
 }
-function getEffectiveTargetSupportLevel(target12, feature, config) {
-  const definition = getBuiltinTargetDefinition(target12);
+function getEffectiveTargetSupportLevel(target13, feature, config) {
+  const definition = getBuiltinTargetDefinition(target13);
   const baseLevel = definition?.capabilities[feature] ?? "none";
   if (baseLevel !== "embedded") return baseLevel;
-  if (feature === "commands" && target12 === "codex-cli") {
-    return shouldConvertCommandsToSkills(config, target12) ? "embedded" : "none";
+  if (feature === "commands" && target13 === "codex-cli") {
+    return shouldConvertCommandsToSkills(config, target13) ? "embedded" : "none";
   }
-  if (feature === "agents" && (target12 === "cline" || target12 === "windsurf")) {
-    return shouldConvertAgentsToSkills(config, target12) ? "embedded" : "none";
+  if (feature === "agents" && (target13 === "cline" || target13 === "windsurf")) {
+    return shouldConvertAgentsToSkills(config, target13) ? "embedded" : "none";
   }
   return baseLevel;
 }
-function resolveTargetFeatureGenerator(target12, feature, config) {
-  const generators = getBuiltinTargetDefinition(target12)?.generators;
+function resolveTargetFeatureGenerator(target13, feature, config) {
+  const generators = getBuiltinTargetDefinition(target13)?.generators;
   if (!generators) return void 0;
   switch (feature) {
     case "rules":
       return generators.generateRules;
     case "commands":
-      if (target12 === "codex-cli" && config && !shouldConvertCommandsToSkills(config, target12)) {
+      if (target13 === "codex-cli" && config && !shouldConvertCommandsToSkills(config, target13)) {
         return void 0;
       }
       return generators.generateWorkflows ?? generators.generateCommands;
     case "agents":
-      if (config && (target12 === "cline" || target12 === "windsurf") && !shouldConvertAgentsToSkills(config, target12)) {
+      if (config && (target13 === "cline" || target13 === "windsurf") && !shouldConvertAgentsToSkills(config, target13)) {
         return void 0;
       }
       return generators.generateAgents;
@@ -7634,9 +8036,9 @@ function resolveTargetFeatureGenerator(target12, feature, config) {
 }
 
 // src/core/reference/import-map.ts
-async function buildImportReferenceMap(target12, projectRoot) {
+async function buildImportReferenceMap(target13, projectRoot) {
   const refs = /* @__PURE__ */ new Map();
-  const def = getBuiltinTargetDefinition(target12);
+  const def = getBuiltinTargetDefinition(target13);
   if (def) {
     await def.buildImportPaths(refs, projectRoot);
   }
@@ -7688,6 +8090,7 @@ var ROOT_RELATIVE_PREFIXES = [
   ".github/",
   ".continue/",
   ".junie/",
+  ".kiro/",
   ".gemini/",
   ".clinerules/",
   ".cline/",
@@ -7710,7 +8113,7 @@ var EXTERNAL_REF_PATTERNS = [
   /\/\/[A-Za-z0-9][\w.-]*\.[A-Za-z]{2,}[^\s<>()\]]*/g
 ];
 var FENCED_CODE_BLOCK = /^(?:```|~~~)[^\n]*\n[\s\S]*?^(?:```|~~~)/gm;
-var PATH_TOKEN = /(?:\.\.[\\/]|\.\/|\.\\|\/[A-Za-z0-9._-]|[A-Za-z]:[\\/][A-Za-z0-9._-]|\.agentsmesh[\\/]|\.claude[\\/]|\.cursor[\\/]|\.github[\\/]|\.continue[\\/]|\.junie[\\/]|\.gemini[\\/]|\.clinerules[\\/]|\.cline[\\/]|\.agents[\\/]|\.windsurf[\\/]|\.roo[\\/]|(?:[A-Za-z0-9._-]+[\\/])+|[A-Za-z0-9._-]+\.[A-Za-z0-9._-]+)[A-Za-z0-9._@%+~:\\/-]*/g;
+var PATH_TOKEN = /(?:\.\.[\\/]|\.\/|\.\\|\/[A-Za-z0-9._-]|[A-Za-z]:[\\/][A-Za-z0-9._-]|\.agentsmesh[\\/]|\.claude[\\/]|\.cursor[\\/]|\.github[\\/]|\.continue[\\/]|\.junie[\\/]|\.kiro[\\/]|\.gemini[\\/]|\.clinerules[\\/]|\.cline[\\/]|\.agents[\\/]|\.windsurf[\\/]|\.roo[\\/]|(?:[A-Za-z0-9._-]+[\\/])+|[A-Za-z0-9._-]+\.[A-Za-z0-9._-]+)[A-Za-z0-9._@%+~:\\/-]*/g;
 var LINE_NUMBER_SUFFIX = /(?::(\d+)){1,2}$/;
 function resolveProjectPath(token, projectRoot, sourceFile) {
   const api = pathApi(projectRoot);
@@ -7854,6 +8257,7 @@ var IMPORT_REFERENCE_TARGETS = [
   "copilot",
   "continue",
   "junie",
+  "kiro",
   "gemini-cli",
   "cline",
   "codex-cli",
@@ -7873,9 +8277,9 @@ function pathVariants(path) {
   }
   return variants;
 }
-async function createImportReferenceNormalizer(target12, projectRoot) {
+async function createImportReferenceNormalizer(target13, projectRoot) {
   const refs = /* @__PURE__ */ new Map();
-  const targets = Array.from(/* @__PURE__ */ new Set([target12, ...IMPORT_REFERENCE_TARGETS]));
+  const targets = Array.from(/* @__PURE__ */ new Set([target13, ...IMPORT_REFERENCE_TARGETS]));
   for (const candidate of targets) {
     const candidateRefs = await buildImportReferenceMap(candidate, projectRoot);
     for (const [targetPath, canonicalPath] of candidateRefs.entries()) {
@@ -7884,8 +8288,8 @@ async function createImportReferenceNormalizer(target12, projectRoot) {
   }
   const artifactMap = /* @__PURE__ */ new Map();
   for (const [targetPath, canonicalPath] of refs.entries()) {
-    const canonicalAbsPath = normalizePath(join38(projectRoot, canonicalPath));
-    for (const variant of pathVariants(join38(projectRoot, targetPath))) {
+    const canonicalAbsPath = normalizePath(join39(projectRoot, canonicalPath));
+    for (const variant of pathVariants(join39(projectRoot, targetPath))) {
       artifactMap.set(variant, canonicalAbsPath);
     }
   }
@@ -7900,9 +8304,9 @@ async function createImportReferenceNormalizer(target12, projectRoot) {
 }
 
 // src/targets/claude-code/importer-mappers.ts
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 async function mapClaudeRuleFile(relativePath, destDir, normalizeTo) {
-  const destPath = join39(destDir, relativePath);
+  const destPath = join40(destDir, relativePath);
   const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
   return {
     destPath,
@@ -7916,7 +8320,7 @@ async function mapClaudeRuleFile(relativePath, destDir, normalizeTo) {
   };
 }
 async function mapClaudeMarkdownFile(relativePath, destDir, feature, normalizeTo) {
-  const destPath = join39(destDir, relativePath);
+  const destPath = join40(destDir, relativePath);
   const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
   const basePath = feature === "commands" ? CLAUDE_CANONICAL_COMMANDS_DIR : CLAUDE_CANONICAL_AGENTS_DIR;
   return {
@@ -7940,8 +8344,8 @@ async function mapClaudeMarkdownFile(relativePath, destDir, feature, normalizeTo
 }
 
 // src/targets/claude-code/settings-helpers.ts
-import { join as join40, dirname as dirname17 } from "path";
-import { stringify as yamlStringify5 } from "yaml";
+import { join as join41, dirname as dirname17 } from "path";
+import { stringify as yamlStringify6 } from "yaml";
 function claudeHooksToCanonical(hooks) {
   const result = {};
   for (const [event, entries] of Object.entries(hooks)) {
@@ -7967,7 +8371,7 @@ function claudeHooksToCanonical(hooks) {
   return result;
 }
 async function importMcpJson(projectRoot, results) {
-  const mcpPath = join40(projectRoot, CLAUDE_MCP_JSON);
+  const mcpPath = join41(projectRoot, CLAUDE_MCP_JSON);
   const content = await readFileSafe(mcpPath);
   if (content === null) return;
   let parsed;
@@ -7978,7 +8382,7 @@ async function importMcpJson(projectRoot, results) {
   }
   if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
     const mcpContent = JSON.stringify({ mcpServers: parsed.mcpServers }, null, 2);
-    const destPath = join40(projectRoot, CLAUDE_CANONICAL_MCP);
+    const destPath = join41(projectRoot, CLAUDE_CANONICAL_MCP);
     await mkdirp(dirname17(destPath));
     await writeFileAtomic(destPath, mcpContent);
     results.push({
@@ -7990,7 +8394,7 @@ async function importMcpJson(projectRoot, results) {
   }
 }
 async function importSettings2(projectRoot, results) {
-  const settingsPath = join40(projectRoot, CLAUDE_SETTINGS);
+  const settingsPath = join41(projectRoot, CLAUDE_SETTINGS);
   const content = await readFileSafe(settingsPath);
   if (!content) return;
   let settings;
@@ -8002,7 +8406,7 @@ async function importSettings2(projectRoot, results) {
   const alreadyImportedMcp = results.some((r) => r.feature === "mcp");
   if (!alreadyImportedMcp && settings.mcpServers && typeof settings.mcpServers === "object") {
     const mcpContent = JSON.stringify({ mcpServers: settings.mcpServers }, null, 2);
-    const destPath = join40(projectRoot, CLAUDE_CANONICAL_MCP);
+    const destPath = join41(projectRoot, CLAUDE_CANONICAL_MCP);
     await mkdirp(dirname17(destPath));
     await writeFileAtomic(destPath, mcpContent);
     results.push({
@@ -8018,8 +8422,8 @@ async function importSettings2(projectRoot, results) {
     const allow = Array.isArray(perms.allow) ? perms.allow.filter((s) => typeof s === "string") : [];
     const deny = Array.isArray(perms.deny) ? perms.deny.filter((s) => typeof s === "string") : [];
     if (allow.length > 0 || deny.length > 0) {
-      const permContent = yamlStringify5({ allow, deny });
-      const destPath = join40(projectRoot, CLAUDE_CANONICAL_PERMISSIONS);
+      const permContent = yamlStringify6({ allow, deny });
+      const destPath = join41(projectRoot, CLAUDE_CANONICAL_PERMISSIONS);
       await mkdirp(dirname17(destPath));
       await writeFileAtomic(destPath, permContent);
       results.push({
@@ -8034,8 +8438,8 @@ async function importSettings2(projectRoot, results) {
   if (rawHooks && typeof rawHooks === "object" && !Array.isArray(rawHooks)) {
     const canonicalHooks = claudeHooksToCanonical(rawHooks);
     if (Object.keys(canonicalHooks).length > 0) {
-      const hooksContent = yamlStringify5(canonicalHooks);
-      const destPath = join40(projectRoot, CLAUDE_CANONICAL_HOOKS);
+      const hooksContent = yamlStringify6(canonicalHooks);
+      const destPath = join41(projectRoot, CLAUDE_CANONICAL_HOOKS);
       await mkdirp(dirname17(destPath));
       await writeFileAtomic(destPath, hooksContent);
       results.push({
@@ -8052,26 +8456,26 @@ async function importSettings2(projectRoot, results) {
 async function importFromClaudeCode(projectRoot) {
   const results = [];
   const normalize = await createImportReferenceNormalizer("claude-code", projectRoot);
-  await importRules5(projectRoot, results, normalize);
+  await importRules6(projectRoot, results, normalize);
   await importCommands6(projectRoot, results, normalize);
   await importAgents5(projectRoot, results, normalize);
   await importSkills5(projectRoot, results, normalize);
   await importMcpJson(projectRoot, results);
   await importSettings2(projectRoot, results);
-  await importIgnore4(projectRoot, results);
+  await importIgnore5(projectRoot, results);
   return results;
 }
-async function importRules5(projectRoot, results, normalize) {
-  const destDir = join41(projectRoot, CLAUDE_CANONICAL_RULES_DIR);
-  const primaryClaudePath = join41(projectRoot, CLAUDE_ROOT);
+async function importRules6(projectRoot, results, normalize) {
+  const destDir = join42(projectRoot, CLAUDE_CANONICAL_RULES_DIR);
+  const primaryClaudePath = join42(projectRoot, CLAUDE_ROOT);
   const primaryContent = await readFileSafe(primaryClaudePath);
-  const legacyClaudePath = join41(projectRoot, CLAUDE_LEGACY_ROOT);
+  const legacyClaudePath = join42(projectRoot, CLAUDE_LEGACY_ROOT);
   const legacyContent = primaryContent === null ? await readFileSafe(legacyClaudePath) : null;
   const claudeContent = primaryContent ?? legacyContent;
   const claudePath = primaryContent !== null ? primaryClaudePath : legacyClaudePath;
   if (claudeContent !== null) {
     await mkdirp(destDir);
-    const destPath = join41(destDir, "_root.md");
+    const destPath = join42(destDir, "_root.md");
     const { frontmatter, body } = parseFrontmatter(normalize(claudeContent, claudePath, destPath));
     const hasRoot = frontmatter.root === true;
     const outFm = hasRoot ? frontmatter : { ...frontmatter, root: true };
@@ -8084,7 +8488,7 @@ async function importRules5(projectRoot, results, normalize) {
       feature: "rules"
     });
   }
-  const rulesDir = join41(projectRoot, CLAUDE_RULES_DIR);
+  const rulesDir = join42(projectRoot, CLAUDE_RULES_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: rulesDir,
@@ -8097,8 +8501,8 @@ async function importRules5(projectRoot, results, normalize) {
   );
 }
 async function importCommands6(projectRoot, results, normalize) {
-  const destDir = join41(projectRoot, CLAUDE_CANONICAL_COMMANDS_DIR);
-  const commandsDir = join41(projectRoot, CLAUDE_COMMANDS_DIR);
+  const destDir = join42(projectRoot, CLAUDE_CANONICAL_COMMANDS_DIR);
+  const commandsDir = join42(projectRoot, CLAUDE_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: commandsDir,
@@ -8111,8 +8515,8 @@ async function importCommands6(projectRoot, results, normalize) {
   );
 }
 async function importAgents5(projectRoot, results, normalize) {
-  const destDir = join41(projectRoot, CLAUDE_CANONICAL_AGENTS_DIR);
-  const agentsDir = join41(projectRoot, CLAUDE_AGENTS_DIR);
+  const destDir = join42(projectRoot, CLAUDE_CANONICAL_AGENTS_DIR);
+  const agentsDir = join42(projectRoot, CLAUDE_AGENTS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: agentsDir,
@@ -8125,20 +8529,20 @@ async function importAgents5(projectRoot, results, normalize) {
   );
 }
 async function importSkills5(projectRoot, results, normalize) {
-  const skillsBaseDir = join41(projectRoot, CLAUDE_SKILLS_DIR);
-  const destBase = join41(projectRoot, CLAUDE_CANONICAL_SKILLS_DIR);
+  const skillsBaseDir = join42(projectRoot, CLAUDE_SKILLS_DIR);
+  const destBase = join42(projectRoot, CLAUDE_CANONICAL_SKILLS_DIR);
   const allFiles = await readDirRecursive(skillsBaseDir);
   const skillMdFiles = allFiles.filter((f) => f.endsWith("SKILL.md"));
   for (const skillMdPath of skillMdFiles) {
     const skillDir = dirname18(skillMdPath);
-    const skillName = basename26(skillDir);
-    const destSkillDir = join41(destBase, skillName);
+    const skillName = basename27(skillDir);
+    const destSkillDir = join42(destBase, skillName);
     const skillFiles = await readDirRecursive(skillDir);
     for (const filePath of skillFiles) {
       const fileContent = await readFileSafe(filePath);
       if (fileContent === null) continue;
       const relPath = relative17(skillDir, filePath);
-      const destPath = join41(destSkillDir, relPath);
+      const destPath = join42(destSkillDir, relPath);
       await mkdirp(dirname18(destPath));
       const normalized = normalize(fileContent, filePath, destPath);
       const parsed = relPath === "SKILL.md" ? parseFrontmatter(normalized) : null;
@@ -8160,11 +8564,11 @@ async function importSkills5(projectRoot, results, normalize) {
     }
   }
 }
-async function importIgnore4(projectRoot, results) {
-  const ignorePath = join41(projectRoot, CLAUDE_IGNORE);
+async function importIgnore5(projectRoot, results) {
+  const ignorePath = join42(projectRoot, CLAUDE_IGNORE);
   const content = await readFileSafe(ignorePath);
   if (content === null) return;
-  const destPath = join41(projectRoot, CLAUDE_CANONICAL_IGNORE);
+  const destPath = join42(projectRoot, CLAUDE_CANONICAL_IGNORE);
   await mkdirp(dirname18(destPath));
   await writeFileAtomic(destPath, content);
   results.push({
@@ -8185,7 +8589,8 @@ var NATIVE_IMPORTERS = {
   windsurf: importFromWindsurf,
   cline: importFromCline,
   continue: importFromContinue,
-  junie: importFromJunie
+  junie: importFromJunie,
+  kiro: importFromKiro
 };
 async function importNativeToCanonical(repoPath, targetName) {
   const importFn = NATIVE_IMPORTERS[targetName];
@@ -8196,17 +8601,17 @@ async function importNativeToCanonical(repoPath, targetName) {
 }
 
 // src/canonical/load/skill-pack-load.ts
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 import { readdir as readdir10 } from "fs/promises";
 var SKILL = "SKILL.md";
 async function isSkillPackLayout(root) {
   if (!await exists(root)) return false;
-  if (await exists(join42(root, SKILL))) return true;
+  if (await exists(join43(root, SKILL))) return true;
   try {
     const ents = await readdir10(root, { withFileTypes: true });
     for (const e of ents) {
       if (!e.isDirectory() || e.name.startsWith(".")) continue;
-      if (await exists(join42(root, e.name, SKILL))) return true;
+      if (await exists(join43(root, e.name, SKILL))) return true;
     }
   } catch {
     return false;
@@ -8215,7 +8620,7 @@ async function isSkillPackLayout(root) {
 }
 async function loadSkillsAtExtendPath(skillsRoot) {
   if (!await exists(skillsRoot)) return [];
-  if (await exists(join42(skillsRoot, SKILL))) {
+  if (await exists(join43(skillsRoot, SKILL))) {
     const one = await parseSkillDirectory(skillsRoot);
     return one ? [one] : [];
   }
@@ -8223,7 +8628,7 @@ async function loadSkillsAtExtendPath(skillsRoot) {
 }
 
 // src/canonical/load/load-canonical-slice.ts
-import { basename as basename27, dirname as dirname19, join as join43 } from "path";
+import { basename as basename28, dirname as dirname19, join as join44 } from "path";
 import { stat as stat4 } from "fs/promises";
 function emptyCanonical() {
   return {
@@ -8254,8 +8659,8 @@ async function normalizeSlicePath(absolutePath) {
     );
   }
   const parent = dirname19(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] } };
@@ -8271,33 +8676,33 @@ async function normalizeSlicePath(absolutePath) {
   );
 }
 async function parseRulesAt(sliceRoot) {
-  const base = basename27(sliceRoot);
+  const base = basename28(sliceRoot);
   if (base === "rules") {
     return parseRules(sliceRoot);
   }
-  const nested = join43(sliceRoot, "rules");
+  const nested = join44(sliceRoot, "rules");
   if (await exists(nested)) {
     return parseRules(nested);
   }
   return [];
 }
 async function parseCommandsAt(sliceRoot) {
-  const base = basename27(sliceRoot);
+  const base = basename28(sliceRoot);
   if (base === "commands") {
     return parseCommands(sliceRoot);
   }
-  const nested = join43(sliceRoot, "commands");
+  const nested = join44(sliceRoot, "commands");
   if (await exists(nested)) {
     return parseCommands(nested);
   }
   return [];
 }
 async function parseAgentsAt(sliceRoot) {
-  const base = basename27(sliceRoot);
+  const base = basename28(sliceRoot);
   if (base === "agents") {
     return parseAgents(sliceRoot);
   }
-  const nested = join43(sliceRoot, "agents");
+  const nested = join44(sliceRoot, "agents");
   if (await exists(nested)) {
     return parseAgents(nested);
   }
@@ -8307,15 +8712,15 @@ async function loadSkillsForPartialSlice(sliceRoot) {
   if (await isSkillPackLayout(sliceRoot)) {
     return loadSkillsAtExtendPath(sliceRoot);
   }
-  const nestedSkills = join43(sliceRoot, "skills");
+  const nestedSkills = join44(sliceRoot, "skills");
   if (await isSkillPackLayout(nestedSkills)) {
     return loadSkillsAtExtendPath(nestedSkills);
   }
   return [];
 }
 async function loadCanonicalSliceAtPath(sliceRoot) {
-  const ab = join43(sliceRoot, ".agentsmesh");
-  if (await exists(ab)) {
+  const ab2 = join44(sliceRoot, ".agentsmesh");
+  if (await exists(ab2)) {
     return loadCanonicalFiles(sliceRoot);
   }
   const partial = emptyCanonical();
@@ -8347,7 +8752,7 @@ function emptyCanonical2() {
 async function loadCanonicalForExtend(ext) {
   const base = ext.resolvedPath;
   if (!ext.path) {
-    const agentsmeshDir = join44(base, ".agentsmesh");
+    const agentsmeshDir = join45(base, ".agentsmesh");
     if (!await exists(agentsmeshDir)) {
       if (await isSkillPackLayout(base)) {
         const skills = await loadSkillsAtExtendPath(base);
@@ -8367,12 +8772,12 @@ Expected one of: .agentsmesh/, ${KNOWN_NATIVE_PATHS.join(", ")}.`
     }
     return loadCanonicalFiles(base);
   }
-  const rawRoot = join44(base, ext.path);
+  const rawRoot = join45(base, ext.path);
   if (!await exists(rawRoot)) {
     throw new Error(`Extend "${ext.name}": path does not exist: ${rawRoot}`);
   }
   if (ext.target) {
-    const agentsmeshDir = join44(base, ".agentsmesh");
+    const agentsmeshDir = join45(base, ".agentsmesh");
     if (!await exists(agentsmeshDir)) {
       logger.info(
         `[agentsmesh] Extend "${ext.name}": path "${ext.path}" with target "${ext.target}" \u2014 importing at extend root, then loading canonical.`
@@ -8393,7 +8798,7 @@ Expected one of: .agentsmesh/, ${KNOWN_NATIVE_PATHS.join(", ")}.`
 }
 
 // src/canonical/extends/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 };
@@ -8436,7 +8841,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)))
@@ -8453,10 +8858,10 @@ function applyExtendPick(canonical, features, pick, extendName) {
 }
 
 // src/canonical/load/pack-load.ts
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 
 // src/install/pack/pack-reader.ts
-import { join as join45 } from "path";
+import { join as join46 } from "path";
 import { readdir as readdir11 } from "fs/promises";
 import { parse as parseYaml5 } from "yaml";
 
@@ -8503,7 +8908,7 @@ function sameFeatures(a, b) {
   return a.length === b.length && [...a].sort().every((feature, index) => feature === [...b].sort()[index]);
 }
 async function readPackMetadata(packDir) {
-  const metaPath = join45(packDir, "pack.yaml");
+  const metaPath = join46(packDir, "pack.yaml");
   const content = await readFileSafe(metaPath);
   if (content === null) return null;
   try {
@@ -8524,7 +8929,7 @@ async function findExistingPack(packsDir, source, scope) {
   }
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const packDir = join45(packsDir, entry.name);
+    const packDir = join46(packsDir, entry.name);
     const meta = await readPackMetadata(packDir);
     if (meta && sourceIdentity(meta.source) === requestedIdentity && meta.target === scope.target && meta.as === scope.as && sameFeatures(meta.features, scope.features)) {
       return { meta, packDir, name: meta.name };
@@ -8543,7 +8948,7 @@ async function listPacks(packsDir) {
   const result = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const packDir = join45(packsDir, entry.name);
+    const packDir = join46(packsDir, entry.name);
     const meta = await readPackMetadata(packDir);
     if (meta) {
       result.push({ meta, packDir, name: meta.name });
@@ -8567,19 +8972,19 @@ function emptyCanonical3() {
 }
 async function loadPackCanonical(packDir) {
   const [rules, commands, agents, skills, mcp, permissions, hooks, ignore] = await Promise.all([
-    parseRules(join46(packDir, "rules")),
-    parseCommands(join46(packDir, "commands")),
-    parseAgents(join46(packDir, "agents")),
-    parseSkills(join46(packDir, "skills")),
-    parseMcp(join46(packDir, "mcp.json")),
-    parsePermissions(join46(packDir, "permissions.yaml")),
-    parseHooks(join46(packDir, "hooks.yaml")),
-    parseIgnore(join46(packDir, "ignore"))
+    parseRules(join47(packDir, "rules")),
+    parseCommands(join47(packDir, "commands")),
+    parseAgents(join47(packDir, "agents")),
+    parseSkills(join47(packDir, "skills")),
+    parseMcp(join47(packDir, "mcp.json")),
+    parsePermissions(join47(packDir, "permissions.yaml")),
+    parseHooks(join47(packDir, "hooks.yaml")),
+    parseIgnore(join47(packDir, "ignore"))
   ]);
   return { ...emptyCanonical3(), rules, commands, agents, skills, mcp, permissions, hooks, ignore };
 }
 async function loadPacksCanonical(abDir) {
-  const packsDir = join46(abDir, "packs");
+  const packsDir = join47(abDir, "packs");
   const packs = await listPacks(packsDir);
   let merged = emptyCanonical3();
   for (const { meta, packDir } of packs) {
@@ -8641,7 +9046,7 @@ async function loadCanonicalWithExtends(config, configDir, options = {}) {
     const picked = applyExtendPick(filtered, ext.features, ext.pick, ext.name);
     merged = mergeCanonicalFiles(merged, picked);
   }
-  const packsCanonical = await loadPacksCanonical(join47(configDir, ".agentsmesh"));
+  const packsCanonical = await loadPacksCanonical(join48(configDir, ".agentsmesh"));
   merged = mergeCanonicalFiles(merged, packsCanonical);
   const localCanonical = await loadCanonicalFiles(configDir);
   merged = mergeCanonicalFiles(merged, localCanonical);
@@ -8650,7 +9055,7 @@ async function loadCanonicalWithExtends(config, configDir, options = {}) {
 
 // src/config/core/lock.ts
 import { parse as parseYaml6, stringify as stringifyYaml3 } from "yaml";
-import { join as join48, relative as relative18 } from "path";
+import { join as join49, relative as relative18 } from "path";
 
 // src/utils/crypto/hash.ts
 import { createHash } from "crypto";
@@ -8697,7 +9102,7 @@ var FEATURE_PATTERNS = {
   ignore: (path) => path === "ignore"
 };
 async function readLock(abDir) {
-  const lockPath = join48(abDir, LOCK_FILENAME);
+  const lockPath = join49(abDir, LOCK_FILENAME);
   const content = await readFileSafe(lockPath);
   if (content === null) return null;
   try {
@@ -8716,7 +9121,7 @@ async function readLock(abDir) {
   }
 }
 async function writeLock(abDir, lock) {
-  const lockPath = join48(abDir, LOCK_FILENAME);
+  const lockPath = join49(abDir, LOCK_FILENAME);
   const raw = {
     generated_at: lock.generatedAt,
     generated_by: lock.generatedBy,
@@ -8770,7 +9175,7 @@ async function buildExtendChecksums(resolvedExtends) {
       result[ext.name] = ext.version;
       continue;
     }
-    const abDir = join48(ext.resolvedPath, ".agentsmesh");
+    const abDir = join49(ext.resolvedPath, ".agentsmesh");
     const checksums = await buildChecksums(abDir);
     const fingerprint = Object.keys(checksums).sort().map((p) => `${p}:${checksums[p]}`).join("\n");
     const h = hashContent(fingerprint);
@@ -8781,7 +9186,7 @@ async function buildExtendChecksums(resolvedExtends) {
 }
 
 // src/core/reference/map.ts
-import { basename as basename30 } from "path";
+import { basename as basename31 } from "path";
 
 // src/core/reference/map-directories.ts
 import { posix as posix2 } from "path";
@@ -8800,29 +9205,29 @@ function addSkillDirectoryMappings(refs, canonicalPath, targetPath) {
 }
 
 // src/core/reference/map-targets.ts
-import { basename as basename29 } from "path";
+import { basename as basename30 } from "path";
 var SKILL_DIRS = Object.fromEntries(
-  TARGET_IDS.map((target12) => [target12, getTargetSkillDir(target12)]).filter(
+  TARGET_IDS.map((target13) => [target13, getTargetSkillDir(target13)]).filter(
     (entry) => typeof entry[1] === "string"
   )
 );
-function ruleTargetPath(target12, rule) {
-  const def = getBuiltinTargetDefinition(target12);
+function ruleTargetPath(target13, rule) {
+  const def = getBuiltinTargetDefinition(target13);
   if (!def) return null;
   if (rule.root) {
     return def.generators.primaryRootInstructionPath ?? null;
   }
-  if (rule.targets.length > 0 && !rule.targets.includes(target12)) return null;
-  const slug = basename29(rule.source, ".md");
+  if (rule.targets.length > 0 && !rule.targets.includes(target13)) return null;
+  const slug = basename30(rule.source, ".md");
   return def.paths.rulePath(slug, rule);
 }
-function commandTargetPath(target12, name, config) {
-  const def = getBuiltinTargetDefinition(target12);
+function commandTargetPath(target13, name, config) {
+  const def = getBuiltinTargetDefinition(target13);
   if (!def) return null;
   return def.paths.commandPath(name, config);
 }
-function agentTargetPath(target12, name, config) {
-  const def = getBuiltinTargetDefinition(target12);
+function agentTargetPath(target13, name, config) {
+  const def = getBuiltinTargetDefinition(target13);
   if (!def) return null;
   return def.paths.agentPath(name, config);
 }
@@ -8832,21 +9237,21 @@ function addDirectoryMapping3(refs, from, to) {
   refs.set(from, to);
   refs.set(`${from}/`, `${to}/`);
 }
-function buildReferenceMap(target12, canonical, config) {
+function buildReferenceMap(target13, canonical, config) {
   const refs = /* @__PURE__ */ new Map();
   for (const rule of canonical.rules) {
-    const path = ruleTargetPath(target12, rule);
-    if (path) refs.set(`.agentsmesh/rules/${basename30(rule.source)}`, path);
+    const path = ruleTargetPath(target13, rule);
+    if (path) refs.set(`.agentsmesh/rules/${basename31(rule.source)}`, path);
   }
   for (const command of canonical.commands) {
-    const path = commandTargetPath(target12, command.name, config);
+    const path = commandTargetPath(target13, command.name, config);
     if (path) refs.set(`.agentsmesh/commands/${command.name}.md`, path);
   }
   for (const agent of canonical.agents) {
-    const path = agentTargetPath(target12, agent.name, config);
+    const path = agentTargetPath(target13, agent.name, config);
     if (path) refs.set(`.agentsmesh/agents/${agent.name}.md`, path);
   }
-  const skillDir = SKILL_DIRS[target12];
+  const skillDir = SKILL_DIRS[target13];
   if (!skillDir) return refs;
   for (const skill of canonical.skills) {
     addDirectoryMapping3(refs, `.agentsmesh/skills/${skill.name}`, `${skillDir}/${skill.name}`);
@@ -8879,17 +9284,20 @@ function isCursorAgents(result) {
 function isGeminiAgents(result) {
   return result.target === "gemini-cli" && result.path.endsWith(AGENTS_SUFFIX);
 }
+function isKiroAgents(result) {
+  return result.target === "kiro" && result.path.endsWith(AGENTS_SUFFIX);
+}
 function isCompatibilityAgents(result) {
   return isCursorAgents(result) || isGeminiAgents(result);
 }
-function reverseReferenceMap(target12, canonical, config, cache) {
-  const cached = cache.get(target12);
+function reverseReferenceMap(target13, canonical, config, cache) {
+  const cached = cache.get(target13);
   if (cached) return cached;
   const reversed = /* @__PURE__ */ new Map();
-  for (const [canonicalPath, targetPath] of buildReferenceMap(target12, canonical, config)) {
+  for (const [canonicalPath, targetPath] of buildReferenceMap(target13, canonical, config)) {
     if (!reversed.has(targetPath)) reversed.set(targetPath, canonicalPath);
   }
-  cache.set(target12, reversed);
+  cache.set(target13, reversed);
   return reversed;
 }
 function normalizeContent(content, refs) {
@@ -8905,6 +9313,13 @@ function hasEquivalentCanonicalContent(left, right, canonical, config, cache) {
   const rightRefs = reverseReferenceMap(right.target, canonical, config, cache);
   return normalizeContent(left.content, leftRefs) === normalizeContent(right.content, rightRefs);
 }
+function hasCanonicalSupersetContent(richer, plainer, canonical, config, cache) {
+  const richerRefs = reverseReferenceMap(richer.target, canonical, config, cache);
+  const plainerRefs = reverseReferenceMap(plainer.target, canonical, config, cache);
+  const richerContent = normalizeContent(richer.content, richerRefs).trim();
+  const plainerContent = normalizeContent(plainer.content, plainerRefs).trim();
+  return richerContent.length > plainerContent.length && richerContent.includes(plainerContent);
+}
 function preferEquivalentCodexAgents(results, canonical, config) {
   const overlapTargetsByPath = /* @__PURE__ */ new Map();
   for (const result of results) {
@@ -8921,15 +9336,15 @@ function preferEquivalentCodexAgents(results, canonical, config) {
   return results.filter((result) => {
     if (isCursorAgents(result)) {
       const targets = overlapTargetsByPath.get(result.path);
-      if (targets && [...targets].some((target12) => target12 !== "cursor")) return false;
+      if (targets && [...targets].some((target13) => target13 !== "cursor")) return false;
     }
     if (isGeminiAgents(result)) {
       const targets = overlapTargetsByPath.get(result.path);
-      if (targets && [...targets].some((target12) => target12 !== "cursor" && target12 !== "gemini-cli")) {
+      if (targets && [...targets].some((target13) => target13 !== "cursor" && target13 !== "gemini-cli")) {
         return false;
       }
     }
-    if (!isWindsurfAgents(result) && !isClineAgents(result) && !isCursorAgents(result) && !isGeminiAgents(result)) {
+    if (!isWindsurfAgents(result) && !isClineAgents(result) && !isCursorAgents(result) && !isGeminiAgents(result) && !isKiroAgents(result)) {
       return true;
     }
     const codexResult = codexByPath.get(result.path);
@@ -8937,16 +9352,16 @@ function preferEquivalentCodexAgents(results, canonical, config) {
     if (isCompatibilityAgents(result) || isWindsurfAgents(result) || isClineAgents(result)) {
       return false;
     }
-    return !hasEquivalentCanonicalContent(codexResult, result, canonical, config, reverseCache);
+    return !(hasEquivalentCanonicalContent(codexResult, result, canonical, config, reverseCache) || hasCanonicalSupersetContent(codexResult, result, canonical, config, reverseCache));
   });
 }
 
 // src/core/reference/rewriter.ts
 import { existsSync as existsSync3 } from "fs";
-import { dirname as dirname21, join as join50 } from "path";
+import { dirname as dirname21, join as join51 } from "path";
 
 // src/core/reference/output-source-map.ts
-import { dirname as dirname20, join as join49, normalize as normalizePath2 } from "path";
+import { dirname as dirname20, join as join50, normalize as normalizePath2 } from "path";
 function canonicalRulePath(rule) {
   return `.agentsmesh/rules/${rule.source.split("/").pop()}`;
 }
@@ -8969,17 +9384,17 @@ function copilotInstructionsPath(rule) {
   const slug = rule.source.split("/").pop().replace(/\.md$/, "");
   return `.github/instructions/${slug}.instructions.md`;
 }
-function ruleOutputPaths(target12, rule, refs) {
+function ruleOutputPaths(target13, rule, refs) {
   const paths = [];
   const targetPath = refs.get(canonicalRulePath(rule));
   if (targetPath) paths.push(targetPath);
-  if (target12 === "copilot" && !rule.root && rule.globs.length > 0) {
+  if (target13 === "copilot" && !rule.root && rule.globs.length > 0) {
     paths.push(copilotInstructionsPath(rule));
   }
-  if ((target12 === "cline" || target12 === "cursor") && rule.root) {
+  if ((target13 === "cline" || target13 === "cursor") && rule.root) {
     paths.push("AGENTS.md");
   }
-  if (target12 === "windsurf") {
+  if (target13 === "windsurf") {
     if (rule.root) {
       paths.push("AGENTS.md");
     } else {
@@ -8987,10 +9402,10 @@ function ruleOutputPaths(target12, rule, refs) {
       if (dir) paths.push(`${dir}/AGENTS.md`);
     }
   }
-  if (target12 === "gemini-cli") {
+  if (target13 === "gemini-cli") {
     paths.push(GEMINI_COMPAT_AGENTS);
   }
-  if (target12 === "codex-cli") {
+  if (target13 === "codex-cli") {
     if (!rule.root && rule.codexEmit === "execution") {
       const slug = rule.source.split("/").pop().replace(/\.md$/, "");
       paths.push(`${CODEX_RULES_DIR}/${slug}.rules`);
@@ -8998,46 +9413,46 @@ function ruleOutputPaths(target12, rule, refs) {
   }
   return paths;
 }
-function addPackSkillPaths(refs, target12, canonical, projectRoot) {
-  const skillDir = SKILL_DIRS[target12];
+function addPackSkillPaths(refs, target13, canonical, projectRoot) {
+  const skillDir = SKILL_DIRS[target13];
   if (!skillDir) return;
-  const packsPrefix = join49(projectRoot, ".agentsmesh", "packs");
+  const packsPrefix = join50(projectRoot, ".agentsmesh", "packs");
   for (const skill of canonical.skills) {
     const skillSourceDir = dirname20(skill.source);
     if (!skillSourceDir.startsWith(packsPrefix)) continue;
-    const targetSkillDir = normalizePath2(join49(projectRoot, skillDir, skill.name));
+    const targetSkillDir = normalizePath2(join50(projectRoot, skillDir, skill.name));
     refs.set(normalizePath2(skillSourceDir), targetSkillDir);
-    refs.set(normalizePath2(skill.source), normalizePath2(join49(targetSkillDir, "SKILL.md")));
+    refs.set(normalizePath2(skill.source), normalizePath2(join50(targetSkillDir, "SKILL.md")));
     for (const file of skill.supportingFiles) {
-      const targetFilePath = normalizePath2(join49(targetSkillDir, file.relativePath));
+      const targetFilePath = normalizePath2(join50(targetSkillDir, file.relativePath));
       refs.set(normalizePath2(file.absolutePath), targetFilePath);
     }
   }
 }
-function buildArtifactPathMap(target12, canonical, config, projectRoot, destinationPath) {
+function buildArtifactPathMap(target13, canonical, config, projectRoot, destinationPath) {
   const refs = new Map(
-    [...buildReferenceMap(target12, canonical, config)].map(([canonicalPath, targetPath]) => [
-      normalizePath2(join49(projectRoot, canonicalPath)),
-      normalizePath2(join49(projectRoot, targetPath))
+    [...buildReferenceMap(target13, canonical, config)].map(([canonicalPath, targetPath]) => [
+      normalizePath2(join50(projectRoot, canonicalPath)),
+      normalizePath2(join50(projectRoot, targetPath))
     ])
   );
-  if (target12 === "copilot" && destinationPath?.startsWith(".github/instructions/")) {
+  if (target13 === "copilot" && destinationPath?.startsWith(".github/instructions/")) {
     for (const rule of canonical.rules) {
       if (rule.root || rule.globs.length === 0) continue;
       refs.set(
-        normalizePath2(join49(projectRoot, canonicalRulePath(rule))),
-        normalizePath2(join49(projectRoot, copilotInstructionsPath(rule)))
+        normalizePath2(join50(projectRoot, canonicalRulePath(rule))),
+        normalizePath2(join50(projectRoot, copilotInstructionsPath(rule)))
       );
     }
   }
-  addPackSkillPaths(refs, target12, canonical, projectRoot);
+  addPackSkillPaths(refs, target13, canonical, projectRoot);
   return refs;
 }
-function buildOutputSourceMap(target12, canonical, config) {
-  const refs = buildReferenceMap(target12, canonical, config);
+function buildOutputSourceMap(target13, canonical, config) {
+  const refs = buildReferenceMap(target13, canonical, config);
   const sourceMap = /* @__PURE__ */ new Map();
   for (const rule of canonical.rules) {
-    for (const targetPath of ruleOutputPaths(target12, rule, refs)) {
+    for (const targetPath of ruleOutputPaths(target13, rule, refs)) {
       sourceMap.set(targetPath, rule.source);
     }
   }
@@ -9065,7 +9480,7 @@ function buildOutputSourceMap(target12, canonical, config) {
 function collectPlannedPaths(projectRoot, results) {
   const planned = /* @__PURE__ */ new Set();
   for (const result of results) {
-    const absolutePath = join50(projectRoot, result.path);
+    const absolutePath = join51(projectRoot, result.path);
     planned.add(absolutePath);
     let current = dirname21(absolutePath);
     while (current.startsWith(projectRoot) && !planned.has(current)) {
@@ -9107,7 +9522,7 @@ function rewriteGeneratedReferences(results, canonical, config, projectRoot) {
       content: result.content,
       projectRoot,
       sourceFile,
-      destinationFile: join50(projectRoot, result.path),
+      destinationFile: join51(projectRoot, result.path),
       translatePath: (absolutePath) => artifactMap.get(absolutePath) ?? absolutePath,
       pathExists: (absolutePath) => plannedPaths.has(absolutePath) || existsSync3(absolutePath)
     });
@@ -9116,6 +9531,8 @@ function rewriteGeneratedReferences(results, canonical, config, projectRoot) {
 }
 
 // src/core/generate/collision.ts
+var AGENTS_SUFFIX2 = "AGENTS.md";
+var CODEX_TARGET2 = "codex-cli";
 function statusRank(status) {
   switch (status) {
     case "created":
@@ -9128,6 +9545,34 @@ function statusRank(status) {
       return 0;
   }
 }
+function mergeDuplicateMetadata(preferred, other) {
+  if (statusRank(other.status) <= statusRank(preferred.status)) return preferred;
+  return {
+    ...preferred,
+    status: other.status,
+    currentContent: other.currentContent ?? preferred.currentContent
+  };
+}
+function trimmedContent(content) {
+  return content.trim();
+}
+function richerAgentsResult(left, right) {
+  if (!left.path.endsWith(AGENTS_SUFFIX2) || left.path !== right.path) return null;
+  const leftTrimmed = trimmedContent(left.content);
+  const rightTrimmed = trimmedContent(right.content);
+  if (!leftTrimmed || !rightTrimmed) return null;
+  const leftContainsRight = leftTrimmed.includes(rightTrimmed);
+  const rightContainsLeft = rightTrimmed.includes(leftTrimmed);
+  if (leftContainsRight === rightContainsLeft) return null;
+  return leftContainsRight ? mergeDuplicateMetadata(left, right) : mergeDuplicateMetadata(right, left);
+}
+function richerCodexAgentsResult(left, right) {
+  if (!left.path.endsWith(AGENTS_SUFFIX2) || left.path !== right.path) return null;
+  const codex = left.target === CODEX_TARGET2 ? left : right.target === CODEX_TARGET2 ? right : null;
+  const other = codex === left ? right : left;
+  if (!codex) return null;
+  return trimmedContent(codex.content).length > trimmedContent(other.content).length ? mergeDuplicateMetadata(codex, other) : null;
+}
 function resolveOutputCollisions(results) {
   const deduped = [];
   for (const result of results) {
@@ -9138,17 +9583,21 @@ function resolveOutputCollisions(results) {
     }
     const existing = deduped[existingIdx];
     if (existing.content !== result.content) {
+      const richer = richerAgentsResult(existing, result);
+      if (richer) {
+        deduped[existingIdx] = richer;
+        continue;
+      }
+      const richerCodex = richerCodexAgentsResult(existing, result);
+      if (richerCodex) {
+        deduped[existingIdx] = richerCodex;
+        continue;
+      }
       throw new Error(
         `Conflicting generated outputs for ${result.path}: ${existing.target} and ${result.target} produce different content.`
       );
     }
-    if (statusRank(result.status) > statusRank(existing.status)) {
-      deduped[existingIdx] = {
-        ...existing,
-        status: result.status,
-        currentContent: result.currentContent ?? existing.currentContent
-      };
-    }
+    deduped[existingIdx] = mergeDuplicateMetadata(existing, result);
   }
   return deduped;
 }
@@ -9158,7 +9607,7 @@ function refreshResultStatus(result) {
 }
 
 // src/core/generate/feature-loop.ts
-import { join as join51 } from "path";
+import { join as join52 } from "path";
 function computeStatus(existing, content) {
   if (existing === null) return "created";
   if (existing !== content) return "updated";
@@ -9166,13 +9615,13 @@ function computeStatus(existing, content) {
 }
 async function generateFeature(results, targets, canonical, projectRoot, enabled, getGen) {
   if (!enabled) return;
-  for (const target12 of targets) {
-    const gen = getGen(target12);
+  for (const target13 of targets) {
+    const gen = getGen(target13);
     if (!gen) continue;
     for (const out of gen(canonical)) {
-      const existing = await readFileSafe(join51(projectRoot, out.path));
+      const existing = await readFileSafe(join52(projectRoot, out.path));
       results.push({
-        target: target12,
+        target: target13,
         path: out.path,
         content: out.content,
         currentContent: existing ?? void 0,
@@ -9190,8 +9639,8 @@ function getDescriptor(name) {
   return descriptorRegistry.get(name) ?? builtinDescriptors.get(name);
 }
 function getTarget(name) {
-  const descriptor12 = getDescriptor(name);
-  if (descriptor12) return descriptor12.generators;
+  const descriptor13 = getDescriptor(name);
+  if (descriptor13) return descriptor13.generators;
   const legacy = legacyRegistry.get(name);
   if (legacy) return legacy;
   throw new Error(`Unknown target: ${name}`);
@@ -9215,10 +9664,10 @@ function decoratePrimaryRootInstructions(results) {
 }
 
 // src/core/generate/optional-features.ts
-import { join as join53 } from "path";
+import { join as join54 } from "path";
 
 // src/targets/copilot/hook-assets.ts
-import { join as join52, relative as relative19 } from "path";
+import { join as join53, relative as relative19 } from "path";
 var SCRIPT_PREFIX_RE = /^(?<prefix>\s*(?:(?:bash|sh|zsh)\s+)?)["']?(?<path>(?:\.\.\/|\.\/|[^/\s"'`]+\/)[^\s"'`]+)["']?(?<suffix>(?:\s.*)?)$/;
 function safePhaseName(phase) {
   return phase.replace(/[^a-zA-Z0-9]/g, "-").toLowerCase();
@@ -9239,7 +9688,7 @@ async function buildAssetOutput(projectRoot, command) {
   const match = command.match(SCRIPT_PREFIX_RE);
   const sourceToken = match?.groups?.["path"];
   if (!sourceToken) return null;
-  const sourcePath = join52(projectRoot, sourceToken);
+  const sourcePath = join53(projectRoot, sourceToken);
   const assetContent = await readFileSafe(sourcePath);
   if (assetContent === null) return null;
   const repoRelative = toRepoRelative(projectRoot, sourcePath);
@@ -9327,14 +9776,14 @@ function mergeGeminiSettingsJson(existing, newContent) {
 
 // src/core/generate/optional-features.ts
 async function generatePermissionsFeature(results, targets, canonical, projectRoot) {
-  for (const target12 of targets) {
-    const gen = resolveTargetFeatureGenerator(target12, "permissions");
+  for (const target13 of targets) {
+    const gen = resolveTargetFeatureGenerator(target13, "permissions");
     if (!gen) continue;
     for (const out of gen(canonical)) {
-      const existing = await readFileSafe(join53(projectRoot, out.path));
+      const existing = await readFileSafe(join54(projectRoot, out.path));
       const content = existing !== null && SETTINGS_JSON_PATHS.includes(out.path) ? mergeSettingsJson(existing, out.content) : out.content;
       results.push({
-        target: target12,
+        target: target13,
         path: out.path,
         content,
         currentContent: existing ?? void 0,
@@ -9344,15 +9793,15 @@ async function generatePermissionsFeature(results, targets, canonical, projectRo
   }
 }
 async function generateHooksFeature(results, targets, canonical, projectRoot) {
-  for (const target12 of targets) {
-    const gen = resolveTargetFeatureGenerator(target12, "hooks");
+  for (const target13 of targets) {
+    const gen = resolveTargetFeatureGenerator(target13, "hooks");
     if (!gen) continue;
-    const outputs = target12 === "copilot" ? await addHookScriptAssets(projectRoot, canonical, gen(canonical)) : gen(canonical);
+    const outputs = target13 === "copilot" ? await addHookScriptAssets(projectRoot, canonical, gen(canonical)) : gen(canonical);
     for (const out of outputs) {
-      const existing = await readFileSafe(join53(projectRoot, out.path));
+      const existing = await readFileSafe(join54(projectRoot, out.path));
       let content = out.content;
       if (SETTINGS_JSON_PATHS.includes(out.path)) {
-        const pendingIdx = results.findIndex((r) => r.path === out.path && r.target === target12);
+        const pendingIdx = results.findIndex((r) => r.path === out.path && r.target === target13);
         const pendingResult = pendingIdx >= 0 ? results[pendingIdx] : void 0;
         const base = pendingResult?.content ?? existing;
         if (base !== null) {
@@ -9363,7 +9812,7 @@ async function generateHooksFeature(results, targets, canonical, projectRoot) {
         }
       }
       results.push({
-        target: target12,
+        target: target13,
         path: out.path,
         content,
         currentContent: existing ?? void 0,
@@ -9373,17 +9822,17 @@ async function generateHooksFeature(results, targets, canonical, projectRoot) {
   }
 }
 async function generateGeminiSettingsFeature(results, targets, canonical, projectRoot) {
-  for (const target12 of targets) {
-    if (target12 !== "gemini-cli") continue;
-    const gen = resolveTargetFeatureGenerator(target12, "settings");
+  for (const target13 of targets) {
+    if (target13 !== "gemini-cli") continue;
+    const gen = resolveTargetFeatureGenerator(target13, "settings");
     if (!gen) continue;
     const outputs = gen(canonical);
     if (outputs.length === 0) continue;
     for (const out of outputs) {
-      const existing = await readFileSafe(join53(projectRoot, out.path));
+      const existing = await readFileSafe(join54(projectRoot, out.path));
       const content = existing !== null && out.path === GEMINI_SETTINGS ? mergeGeminiSettingsJson(existing, out.content) : out.content;
       results.push({
-        target: target12,
+        target: target13,
         path: out.path,
         content,
         currentContent: existing ?? void 0,
@@ -9412,7 +9861,7 @@ async function generate(ctx) {
     canonical,
     projectRoot,
     hasRules,
-    (target12) => resolveTargetFeatureGenerator(target12, "rules", config)
+    (target13) => resolveTargetFeatureGenerator(target13, "rules", config)
   );
   await generateFeature(
     results,
@@ -9420,7 +9869,7 @@ async function generate(ctx) {
     canonical,
     projectRoot,
     hasCommands,
-    (target12) => resolveTargetFeatureGenerator(target12, "commands", config)
+    (target13) => resolveTargetFeatureGenerator(target13, "commands", config)
   );
   await generateFeature(
     results,
@@ -9428,7 +9877,7 @@ async function generate(ctx) {
     canonical,
     projectRoot,
     hasAgents,
-    (target12) => resolveTargetFeatureGenerator(target12, "agents", config)
+    (target13) => resolveTargetFeatureGenerator(target13, "agents", config)
   );
   await generateFeature(
     results,
@@ -9436,7 +9885,7 @@ async function generate(ctx) {
     canonical,
     projectRoot,
     hasSkills,
-    (target12) => resolveTargetFeatureGenerator(target12, "skills", config)
+    (target13) => resolveTargetFeatureGenerator(target13, "skills", config)
   );
   await generateFeature(
     results,
@@ -9444,7 +9893,7 @@ async function generate(ctx) {
     canonical,
     projectRoot,
     hasMcp,
-    (target12) => resolveTargetFeatureGenerator(target12, "mcp", config)
+    (target13) => resolveTargetFeatureGenerator(target13, "mcp", config)
   );
   if (hasPermissions) await generatePermissionsFeature(results, targets, canonical, projectRoot);
   if (hasHooks) await generateHooksFeature(results, targets, canonical, projectRoot);
@@ -9454,7 +9903,7 @@ async function generate(ctx) {
     canonical,
     projectRoot,
     hasIgnore,
-    (target12) => resolveTargetFeatureGenerator(target12, "ignore", config)
+    (target13) => resolveTargetFeatureGenerator(target13, "ignore", config)
   );
   if (hasMcp || hasIgnore || hasHooks || hasAgents) {
     await generateGeminiSettingsFeature(results, targets, canonical, projectRoot);
@@ -9466,7 +9915,7 @@ async function generate(ctx) {
 
 // src/core/generate/stale-cleanup.ts
 import { readdir as readdir12, rm as rm6 } from "fs/promises";
-import { join as join54, relative as relative20 } from "path";
+import { join as join55, relative as relative20 } from "path";
 var TARGET_MANAGED_OUTPUTS = {
   "claude-code": {
     dirs: [".claude/agents", ".claude/commands", ".claude/rules", ".claude/skills"],
@@ -9494,6 +9943,10 @@ var TARGET_MANAGED_OUTPUTS = {
     dirs: [".junie/agents", ".junie/commands", ".junie/rules", ".junie/skills"],
     files: [".aiignore", ".junie/AGENTS.md", ".junie/mcp/mcp.json"]
   },
+  kiro: {
+    dirs: [".kiro/hooks", ".kiro/skills", ".kiro/steering"],
+    files: ["AGENTS.md", ".kiro/settings/mcp.json", ".kiroignore"]
+  },
   "gemini-cli": {
     dirs: [".gemini/agents", ".gemini/commands", ".gemini/skills"],
     files: [
@@ -9532,7 +9985,7 @@ async function listFiles2(root, base = root) {
   const entries = await readdir12(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const abs = join54(root, entry.name);
+    const abs = join55(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFiles2(abs, base));
       continue;
@@ -9543,18 +9996,18 @@ async function listFiles2(root, base = root) {
 }
 async function removeIfStale(projectRoot, relPath, expected) {
   if (expected.has(relPath)) return;
-  const abs = join54(projectRoot, relPath);
+  const abs = join55(projectRoot, relPath);
   if (await exists(abs)) await rm6(abs, { recursive: true, force: true });
 }
 async function cleanupStaleGeneratedOutputs(args) {
   const expected = new Set(args.expectedPaths);
   const stale = /* @__PURE__ */ new Set();
-  for (const target12 of args.targets) {
-    const managed = TARGET_MANAGED_OUTPUTS[target12];
+  for (const target13 of args.targets) {
+    const managed = TARGET_MANAGED_OUTPUTS[target13];
     if (!managed) continue;
     for (const file of managed.files) stale.add(file);
     for (const dir of managed.dirs) {
-      const absDir = join54(args.projectRoot, dir);
+      const absDir = join55(args.projectRoot, dir);
       if (!await exists(absDir)) continue;
       for (const file of await listFiles2(absDir)) {
         stale.add(`${dir}/${file}`.replace(/\/+/g, "/"));
@@ -9567,17 +10020,17 @@ async function cleanupStaleGeneratedOutputs(args) {
 }
 
 // src/core/matrix/matrix.ts
-import { basename as basename31 } from "path";
+import { basename as basename32 } from "path";
 
 // src/targets/catalog/target-catalog.ts
 var TARGET_CATALOG = Object.fromEntries(
-  BUILTIN_TARGETS.map((target12) => [
-    target12.id,
+  BUILTIN_TARGETS.map((target13) => [
+    target13.id,
     {
-      importFrom: target12.generators.importFrom,
-      emptyImportMessage: target12.emptyImportMessage,
-      lintRules: target12.lintRules,
-      capabilities: target12.capabilities
+      importFrom: target13.generators.importFrom,
+      emptyImportMessage: target13.emptyImportMessage,
+      lintRules: target13.lintRules,
+      capabilities: target13.capabilities
     }
   ])
 );
@@ -9604,7 +10057,7 @@ var SUPPORT_MATRIX = Object.fromEntries(
   FEATURE_IDS.map((feature) => [
     feature,
     Object.fromEntries(
-      TARGET_IDS.map((target12) => [target12, TARGET_CATALOG[target12].capabilities[feature]])
+      TARGET_IDS.map((target13) => [target13, TARGET_CATALOG[target13].capabilities[feature]])
     )
   ])
 );
@@ -9710,13 +10163,13 @@ function formatMatrix(rows, targets) {
 function formatVerboseDetails(canonical) {
   const lines = [];
   if (canonical.rules.length > 0) {
-    lines.push(`rules: ${canonical.rules.map((r) => basename31(r.source)).join(", ")}`);
+    lines.push(`rules: ${canonical.rules.map((r) => basename32(r.source)).join(", ")}`);
   }
   if (canonical.commands.length > 0) {
-    lines.push(`commands: ${canonical.commands.map((c2) => basename31(c2.source)).join(", ")}`);
+    lines.push(`commands: ${canonical.commands.map((c2) => basename32(c2.source)).join(", ")}`);
   }
   if (canonical.agents.length > 0) {
-    lines.push(`agents: ${canonical.agents.map((a) => basename31(a.source)).join(", ")}`);
+    lines.push(`agents: ${canonical.agents.map((a) => basename32(a.source)).join(", ")}`);
   }
   if (canonical.skills.length > 0) {
     lines.push(`skills: ${canonical.skills.map((s) => s.name).join(", ")}`);
@@ -9768,11 +10221,11 @@ async function runMatrix(flags, projectRoot) {
 }
 
 // src/cli/commands/generate.ts
-function ensurePathInsideRoot(rootDir, relativePath, target12) {
+function ensurePathInsideRoot(rootDir, relativePath, target13) {
   const rootAbs = resolve4(rootDir);
   const outputAbs = resolve4(rootDir, relativePath);
   if (outputAbs === rootAbs || outputAbs.startsWith(`${rootAbs}${sep}`)) return outputAbs;
-  throw new Error(`Unsafe generated output path for ${target12}: ${relativePath}`);
+  throw new Error(`Unsafe generated output path for ${target13}: ${relativePath}`);
 }
 async function runGenerate(flags, projectRoot, options = {}) {
   if (flags.features !== void 0) {
@@ -9788,7 +10241,7 @@ async function runGenerate(flags, projectRoot, options = {}) {
   const { config, configDir } = await loadConfigFromDir(root);
   const lockFeatures = config.collaboration?.lock_features ?? [];
   if (config.collaboration?.strategy === "lock" && !force && lockFeatures.length > 0) {
-    const abDir = join55(configDir, ".agentsmesh");
+    const abDir = join56(configDir, ".agentsmesh");
     const existingLock = await readLock(abDir);
     if (existingLock !== null) {
       const currentChecksums = await buildChecksums(abDir);
@@ -9824,10 +10277,10 @@ async function runGenerate(flags, projectRoot, options = {}) {
       return 0;
     }
     if (!dryRun) {
-      const abDir = join55(configDir, ".agentsmesh");
+      const abDir = join56(configDir, ".agentsmesh");
       const checksums = await buildChecksums(abDir);
       const extendChecksums = resolvedExtends.length > 0 ? await buildExtendChecksums(resolvedExtends) : {};
-      const packChecksums = await buildPackChecksums(join55(abDir, "packs"));
+      const packChecksums = await buildPackChecksums(join56(abDir, "packs"));
       const generatedBy = process.env["USER"] ?? process.env["USERNAME"] ?? "unknown";
       await writeLock(abDir, {
         generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -9838,7 +10291,7 @@ async function runGenerate(flags, projectRoot, options = {}) {
         packs: packChecksums
       });
       try {
-        await ensureCacheSymlink(getCacheDir(), join55(configDir, ".agentsmeshcache"));
+        await ensureCacheSymlink(getCacheDir(), join56(configDir, ".agentsmeshcache"));
       } catch (err) {
         logger.warn(
           `Could not create .agentsmeshcache symlink: ${err instanceof Error ? err.message : String(err)}`
@@ -9885,10 +10338,10 @@ async function runGenerate(flags, projectRoot, options = {}) {
     } else {
       logger.info(`Nothing changed. (${unchanged} unchanged)`);
     }
-    const abDir = join55(configDir, ".agentsmesh");
+    const abDir = join56(configDir, ".agentsmesh");
     const checksums = await buildChecksums(abDir);
     const extendChecksums = resolvedExtends.length > 0 ? await buildExtendChecksums(resolvedExtends) : {};
-    const packChecksums = await buildPackChecksums(join55(abDir, "packs"));
+    const packChecksums = await buildPackChecksums(join56(abDir, "packs"));
     const generatedBy = process.env["USER"] ?? process.env["USERNAME"] ?? "unknown";
     await writeLock(abDir, {
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -9899,7 +10352,7 @@ async function runGenerate(flags, projectRoot, options = {}) {
       packs: packChecksums
     });
     try {
-      await ensureCacheSymlink(getCacheDir(), join55(configDir, ".agentsmeshcache"));
+      await ensureCacheSymlink(getCacheDir(), join56(configDir, ".agentsmeshcache"));
     } catch (err) {
       logger.warn(
         `Could not create .agentsmeshcache symlink: ${err instanceof Error ? err.message : String(err)}`
@@ -9913,7 +10366,7 @@ async function runGenerate(flags, projectRoot, options = {}) {
 }
 
 // src/cli/commands/init.ts
-import { join as join57 } from "path";
+import { join as join59 } from "path";
 
 // src/cli/commands/init-templates.ts
 var ALL_FEATURES = [
@@ -9926,8 +10379,9 @@ var ALL_FEATURES = [
   "ignore",
   "permissions"
 ];
+var DEFAULT_INIT_TARGETS = TARGET_IDS.filter((target13) => target13 !== "codex-cli");
 function buildConfig(targets) {
-  const targetList = (targets.length > 0 ? targets : TARGET_IDS).map((t) => `  - ${t}`).join("\n");
+  const targetList = (targets.length > 0 ? targets : DEFAULT_INIT_TARGETS).map((t) => `  - ${t}`).join("\n");
   const featureList = ALL_FEATURES.map((f) => `  - ${f}`).join("\n");
   return `version: 1
 targets:
@@ -10058,7 +10512,7 @@ var LOCAL_TEMPLATE = `# Personal overrides \u2014 NOT committed to git
 `;
 
 // src/cli/commands/init-detect.ts
-import { join as join56 } from "path";
+import { join as join57 } from "path";
 var TOOL_INDICATORS = BUILTIN_TARGETS.map((d) => ({
   id: d.id,
   paths: [...d.detectionPaths]
@@ -10067,7 +10521,7 @@ async function detectExistingConfigs(projectRoot) {
   const found = [];
   for (const { id, paths } of TOOL_INDICATORS) {
     for (const p of paths) {
-      const full = join56(projectRoot, p);
+      const full = join57(projectRoot, p);
       if (await exists(full)) {
         found.push(id);
         break;
@@ -10077,6 +10531,110 @@ async function detectExistingConfigs(projectRoot) {
   return [...new Set(found)];
 }
 
+// src/cli/commands/init-scaffold.ts
+import { join as join58 } from "path";
+import { readdir as readdir13 } from "fs/promises";
+function ab(projectRoot, rel2) {
+  return join58(projectRoot, ".agentsmesh", rel2);
+}
+async function countMdFiles(dir) {
+  if (!await exists(dir)) return 0;
+  const entries = await readdir13(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).length;
+}
+async function hasAnyImportedSkill(projectRoot) {
+  const skillsRoot = ab(projectRoot, "skills");
+  if (!await exists(skillsRoot)) return false;
+  const entries = await readdir13(skillsRoot, { withFileTypes: true });
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    if (await exists(join58(skillsRoot, e.name, "SKILL.md"))) return true;
+  }
+  return false;
+}
+async function writeScaffoldFull(projectRoot) {
+  const rulesDir = ab(projectRoot, "rules");
+  await mkdirp(rulesDir);
+  await writeFileAtomic(join58(rulesDir, "_root.md"), TEMPLATE_ROOT_RULE);
+  logger.success("Created .agentsmesh/rules/_root.md");
+  await writeFileAtomic(join58(rulesDir, "example.md"), TEMPLATE_EXAMPLE_RULE);
+  logger.success("Created .agentsmesh/rules/example.md");
+  const commandsDir = ab(projectRoot, "commands");
+  await mkdirp(commandsDir);
+  await writeFileAtomic(join58(commandsDir, "example.md"), TEMPLATE_EXAMPLE_COMMAND);
+  logger.success("Created .agentsmesh/commands/example.md");
+  const agentsDir = ab(projectRoot, "agents");
+  await mkdirp(agentsDir);
+  await writeFileAtomic(join58(agentsDir, "example.md"), TEMPLATE_EXAMPLE_AGENT);
+  logger.success("Created .agentsmesh/agents/example.md");
+  const skillDir = ab(projectRoot, join58("skills", "example"));
+  await mkdirp(skillDir);
+  await writeFileAtomic(join58(skillDir, "SKILL.md"), TEMPLATE_EXAMPLE_SKILL);
+  logger.success("Created .agentsmesh/skills/example/SKILL.md");
+  await writeFileAtomic(ab(projectRoot, "mcp.json"), TEMPLATE_MCP);
+  logger.success("Created .agentsmesh/mcp.json");
+  await writeFileAtomic(ab(projectRoot, "hooks.yaml"), TEMPLATE_HOOKS);
+  logger.success("Created .agentsmesh/hooks.yaml");
+  await writeFileAtomic(ab(projectRoot, "permissions.yaml"), TEMPLATE_PERMISSIONS);
+  logger.success("Created .agentsmesh/permissions.yaml");
+  await writeFileAtomic(ab(projectRoot, "ignore"), TEMPLATE_IGNORE);
+  logger.success("Created .agentsmesh/ignore");
+}
+async function writeScaffoldGapFill(projectRoot) {
+  const rulesDir = ab(projectRoot, "rules");
+  const rulesMd = await countMdFiles(rulesDir);
+  const rootPath = join58(rulesDir, "_root.md");
+  const hasRoot = await exists(rootPath);
+  await mkdirp(rulesDir);
+  if (rulesMd === 0) {
+    await writeFileAtomic(rootPath, TEMPLATE_ROOT_RULE);
+    logger.success("Created .agentsmesh/rules/_root.md");
+    await writeFileAtomic(join58(rulesDir, "example.md"), TEMPLATE_EXAMPLE_RULE);
+    logger.success("Created .agentsmesh/rules/example.md");
+  } else if (!hasRoot) {
+    await writeFileAtomic(rootPath, TEMPLATE_ROOT_RULE);
+    logger.success("Created .agentsmesh/rules/_root.md");
+  }
+  const commandsDir = ab(projectRoot, "commands");
+  if (await countMdFiles(commandsDir) === 0) {
+    await mkdirp(commandsDir);
+    await writeFileAtomic(join58(commandsDir, "example.md"), TEMPLATE_EXAMPLE_COMMAND);
+    logger.success("Created .agentsmesh/commands/example.md");
+  }
+  const agentsDir = ab(projectRoot, "agents");
+  if (await countMdFiles(agentsDir) === 0) {
+    await mkdirp(agentsDir);
+    await writeFileAtomic(join58(agentsDir, "example.md"), TEMPLATE_EXAMPLE_AGENT);
+    logger.success("Created .agentsmesh/agents/example.md");
+  }
+  if (!await hasAnyImportedSkill(projectRoot)) {
+    const skillDir = ab(projectRoot, join58("skills", "example"));
+    await mkdirp(skillDir);
+    await writeFileAtomic(join58(skillDir, "SKILL.md"), TEMPLATE_EXAMPLE_SKILL);
+    logger.success("Created .agentsmesh/skills/example/SKILL.md");
+  }
+  const mcpPath = ab(projectRoot, "mcp.json");
+  if (!await exists(mcpPath)) {
+    await writeFileAtomic(mcpPath, TEMPLATE_MCP);
+    logger.success("Created .agentsmesh/mcp.json");
+  }
+  const hooksPath = ab(projectRoot, "hooks.yaml");
+  if (!await exists(hooksPath)) {
+    await writeFileAtomic(hooksPath, TEMPLATE_HOOKS);
+    logger.success("Created .agentsmesh/hooks.yaml");
+  }
+  const permsPath = ab(projectRoot, "permissions.yaml");
+  if (!await exists(permsPath)) {
+    await writeFileAtomic(permsPath, TEMPLATE_PERMISSIONS);
+    logger.success("Created .agentsmesh/permissions.yaml");
+  }
+  const ignorePath = ab(projectRoot, "ignore");
+  if (!await exists(ignorePath)) {
+    await writeFileAtomic(ignorePath, TEMPLATE_IGNORE);
+    logger.success("Created .agentsmesh/ignore");
+  }
+}
+
 // src/cli/commands/init.ts
 var CONFIG_FILENAME2 = "agentsmesh.yaml";
 var LOCAL_CONFIG_FILENAME2 = "agentsmesh.local.yaml";
@@ -10085,7 +10643,7 @@ var IMPORTERS = Object.fromEntries(
   BUILTIN_TARGETS.map((d) => [d.id, (root) => d.generators.importFrom(root)])
 );
 async function appendToGitignore(projectRoot) {
-  const gitignorePath = join57(projectRoot, ".gitignore");
+  const gitignorePath = join59(projectRoot, ".gitignore");
   const current = await readFileSafe(gitignorePath) ?? "";
   const lines = new Set(current.split("\n").map((s) => s.trim()));
   const toAdd = GITIGNORE_ENTRIES.filter((e) => !lines.has(e));
@@ -10093,33 +10651,8 @@ async function appendToGitignore(projectRoot) {
   const suffix = current.endsWith("\n") || current === "" ? "" : "\n";
   await writeFileAtomic(gitignorePath, current + suffix + toAdd.join("\n") + "\n");
 }
-async function writeScaffold(projectRoot) {
-  const ab = (rel2) => join57(projectRoot, ".agentsmesh", rel2);
-  await mkdirp(ab("rules"));
-  await writeFileAtomic(ab("rules/_root.md"), TEMPLATE_ROOT_RULE);
-  logger.success("Created .agentsmesh/rules/_root.md");
-  await writeFileAtomic(ab("rules/example.md"), TEMPLATE_EXAMPLE_RULE);
-  logger.success("Created .agentsmesh/rules/example.md");
-  await mkdirp(ab("commands"));
-  await writeFileAtomic(ab("commands/example.md"), TEMPLATE_EXAMPLE_COMMAND);
-  logger.success("Created .agentsmesh/commands/example.md");
-  await mkdirp(ab("agents"));
-  await writeFileAtomic(ab("agents/example.md"), TEMPLATE_EXAMPLE_AGENT);
-  logger.success("Created .agentsmesh/agents/example.md");
-  await mkdirp(ab("skills/example"));
-  await writeFileAtomic(ab("skills/example/SKILL.md"), TEMPLATE_EXAMPLE_SKILL);
-  logger.success("Created .agentsmesh/skills/example/SKILL.md");
-  await writeFileAtomic(ab("mcp.json"), TEMPLATE_MCP);
-  logger.success("Created .agentsmesh/mcp.json");
-  await writeFileAtomic(ab("hooks.yaml"), TEMPLATE_HOOKS);
-  logger.success("Created .agentsmesh/hooks.yaml");
-  await writeFileAtomic(ab("permissions.yaml"), TEMPLATE_PERMISSIONS);
-  logger.success("Created .agentsmesh/permissions.yaml");
-  await writeFileAtomic(ab("ignore"), TEMPLATE_IGNORE);
-  logger.success("Created .agentsmesh/ignore");
-}
 async function runInit(projectRoot, options = {}) {
-  const configPath = join57(projectRoot, CONFIG_FILENAME2);
+  const configPath = join59(projectRoot, CONFIG_FILENAME2);
   if (await exists(configPath)) {
     throw new Error(`Already initialized. ${CONFIG_FILENAME2} exists. Remove it first to re-init.`);
   }
@@ -10141,22 +10674,23 @@ async function runInit(projectRoot, options = {}) {
       if (totalImported > 0) {
         logger.info(`Imported ${totalImported} file(s) from ${existing.length} tool(s).`);
       }
+      await writeScaffoldGapFill(projectRoot);
       await writeFileAtomic(configPath, buildConfig(existing));
       logger.success(`Created ${CONFIG_FILENAME2} (targets: ${existing.join(", ")})`);
     } else {
       logger.info(
         `Run 'agentsmesh init --yes' to auto-import, or 'agentsmesh import --from <tool>' manually.`
       );
-      await writeScaffold(projectRoot);
+      await writeScaffoldFull(projectRoot);
       await writeFileAtomic(configPath, buildConfig([]));
       logger.success(`Created ${CONFIG_FILENAME2}`);
     }
   } else {
-    await writeScaffold(projectRoot);
+    await writeScaffoldFull(projectRoot);
     await writeFileAtomic(configPath, buildConfig([]));
     logger.success(`Created ${CONFIG_FILENAME2}`);
   }
-  const localPath = join57(projectRoot, LOCAL_CONFIG_FILENAME2);
+  const localPath = join59(projectRoot, LOCAL_CONFIG_FILENAME2);
   await writeFileAtomic(localPath, LOCAL_TEMPLATE);
   logger.success(`Created ${LOCAL_CONFIG_FILENAME2}`);
   await appendToGitignore(projectRoot);
@@ -10175,10 +10709,10 @@ async function runImport(flags, projectRoot) {
   if (!isBuiltinTargetId(normalized)) {
     throw new Error(`Unknown --from "${from}". Supported: ${TARGET_IDS.join(", ")}.`);
   }
-  const target12 = getTargetCatalogEntry(normalized);
-  const results = await target12.importFrom(root);
+  const target13 = getTargetCatalogEntry(normalized);
+  const results = await target13.importFrom(root);
   if (results.length === 0) {
-    logger.info(target12.emptyImportMessage);
+    logger.info(target13.emptyImportMessage);
     return;
   }
   for (const r of results) {
@@ -10263,56 +10797,56 @@ async function runDiff(flags, projectRoot) {
 import { relative as relative22 } from "path";
 
 // src/core/lint/commands.ts
-function lintCommands(canonical, target12) {
+function lintCommands(canonical, target13) {
   if (canonical.commands.length === 0) return [];
   return canonical.commands.flatMap((command) => {
-    if (target12 === "copilot" && command.allowedTools.length > 0) {
+    if (target13 === "copilot" && command.allowedTools.length > 0) {
       return [
         {
           level: "warning",
           file: command.source,
-          target: target12,
+          target: target13,
           message: "Copilot prompt files do not enforce canonical allowed-tools natively."
         }
       ];
     }
-    if (target12 === "cursor" && (command.description.length > 0 || command.allowedTools.length > 0)) {
+    if (target13 === "cursor" && (command.description.length > 0 || command.allowedTools.length > 0)) {
       return [
         {
           level: "warning",
           file: command.source,
-          target: target12,
+          target: target13,
           message: "Cursor command files are plain Markdown; command description and allowed-tools metadata are not projected."
         }
       ];
     }
-    if (target12 === "gemini-cli" && command.allowedTools.length > 0) {
+    if (target13 === "gemini-cli" && command.allowedTools.length > 0) {
       return [
         {
           level: "warning",
           file: command.source,
-          target: target12,
+          target: target13,
           message: "Gemini TOML command files do not project canonical allowed-tools metadata."
         }
       ];
     }
-    if (target12 === "continue" && command.allowedTools.length > 0) {
+    if (target13 === "continue" && command.allowedTools.length > 0) {
       return [
         {
           level: "warning",
           file: command.source,
-          target: target12,
+          target: target13,
           message: "Continue invokable prompt rules do not natively enforce canonical allowed-tools metadata."
         }
       ];
     }
-    if (["cline", "windsurf"].includes(target12) && (command.description.length > 0 || command.allowedTools.length > 0)) {
+    if (["cline", "windsurf"].includes(target13) && (command.description.length > 0 || command.allowedTools.length > 0)) {
       return [
         {
           level: "warning",
           file: command.source,
-          target: target12,
-          message: `${target12} workflow files are plain Markdown; command description and allowed-tools metadata are not projected.`
+          target: target13,
+          message: `${target13} workflow files are plain Markdown; command description and allowed-tools metadata are not projected.`
         }
       ];
     }
@@ -10321,48 +10855,48 @@ function lintCommands(canonical, target12) {
 }
 
 // src/core/lint/mcp.ts
-function lintMcp(canonical, target12) {
+function lintMcp(canonical, target13) {
   if (!canonical.mcp || Object.keys(canonical.mcp.mcpServers).length === 0) return [];
   const diagnostics = [];
   for (const [name, server] of Object.entries(canonical.mcp.mcpServers)) {
-    if (target12 === "cursor" && usesCursorSensitiveInterpolation(server)) {
+    if (target13 === "cursor" && usesCursorSensitiveInterpolation(server)) {
       diagnostics.push({
         level: "warning",
         file: ".agentsmesh/mcp.json",
-        target: target12,
+        target: target13,
         message: `MCP server "${name}" uses env vars or URL/header interpolation; Cursor handling may differ from canonical MCP.`
       });
     }
-    if (target12 === "codex-cli" && typeof server.description === "string" && server.description) {
+    if (target13 === "codex-cli" && typeof server.description === "string" && server.description) {
       diagnostics.push({
         level: "warning",
         file: ".agentsmesh/mcp.json",
-        target: target12,
+        target: target13,
         message: `MCP server "${name}" has a description, but codex-cli does not project MCP descriptions into .codex/config.toml.`
       });
     }
-    if (target12 === "codex-cli" && isUrlMcpServer(server)) {
+    if (target13 === "codex-cli" && isUrlMcpServer(server)) {
       diagnostics.push({
         level: "warning",
         file: ".agentsmesh/mcp.json",
-        target: target12,
+        target: target13,
         message: `MCP server "${name}" uses ${server.type} transport; codex-cli only generates stdio MCP servers.`
       });
     }
-    if (target12 === "junie" && isUrlMcpServer(server)) {
+    if (target13 === "junie" && isUrlMcpServer(server)) {
       diagnostics.push({
         level: "warning",
         file: ".agentsmesh/mcp.json",
-        target: target12,
+        target: target13,
         message: `MCP server "${name}" uses ${server.type} transport; Junie project mcp.json currently documents stdio MCP servers only.`
       });
     }
   }
-  if (target12 === "windsurf") {
+  if (target13 === "windsurf") {
     diagnostics.push({
       level: "warning",
       file: ".agentsmesh/mcp.json",
-      target: target12,
+      target: target13,
       message: "Windsurf MCP is partial; generated .windsurf/mcp_config.example.json is a reference artifact and may require manual setup."
     });
   }
@@ -10370,42 +10904,51 @@ function lintMcp(canonical, target12) {
 }
 
 // src/core/lint/permissions.ts
-function lintPermissions(canonical, target12) {
+function lintPermissions(canonical, target13) {
   if (!canonical.permissions) return [];
-  if (target12 !== "cursor") return [];
+  if (target13 !== "cursor") return [];
   const hasEntries = canonical.permissions.allow.length > 0 || canonical.permissions.deny.length > 0;
   if (!hasEntries) return [];
   return [
     {
       level: "warning",
       file: ".agentsmesh/permissions.yaml",
-      target: target12,
+      target: target13,
       message: "Cursor permissions are partial; tool-level allow/deny may lose fidelity."
     }
   ];
 }
 
 // src/core/lint/hooks.ts
-function lintHooks(canonical, target12) {
+function lintHooks(canonical, target13) {
   if (!canonical.hooks || Object.keys(canonical.hooks).length === 0) return [];
-  if (target12 === "gemini-cli") {
+  if (target13 === "gemini-cli") {
     const supported = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse", "Notification"]);
     return Object.keys(canonical.hooks).filter((event) => !supported.has(event)).map((event) => ({
       level: "warning",
       file: ".agentsmesh/hooks.yaml",
-      target: target12,
+      target: target13,
       message: `${event} is not supported by gemini-cli; only PreToolUse, PostToolUse, and Notification are projected.`
     }));
   }
-  if (target12 === "copilot") {
+  if (target13 === "copilot") {
     const supported = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse", "Notification", "UserPromptSubmit"]);
     return Object.keys(canonical.hooks).filter((event) => !supported.has(event)).map((event) => ({
       level: "warning",
       file: ".agentsmesh/hooks.yaml",
-      target: target12,
+      target: target13,
       message: `${event} is not supported by Copilot hooks; only PreToolUse, PostToolUse, Notification, and UserPromptSubmit are projected.`
     }));
   }
+  if (target13 === "kiro") {
+    const supported = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse", "UserPromptSubmit", "SubagentStop"]);
+    return Object.keys(canonical.hooks).filter((event) => !supported.has(event)).map((event) => ({
+      level: "warning",
+      file: ".agentsmesh/hooks.yaml",
+      target: target13,
+      message: `${event} is not supported by Kiro hooks; only PreToolUse, PostToolUse, UserPromptSubmit, and SubagentStop are projected.`
+    }));
+  }
   return [];
 }
 
@@ -10428,22 +10971,22 @@ async function runLint(config, canonical, projectRoot, targetFilter) {
   const hasHooks = config.features.includes("hooks");
   const diagnostics = [];
   const projectFiles = await getProjectFiles(projectRoot);
-  for (const target12 of targets) {
-    const linter = isBuiltinTargetId(target12) ? getTargetCatalogEntry(target12).lintRules : null;
+  for (const target13 of targets) {
+    const linter = isBuiltinTargetId(target13) ? getTargetCatalogEntry(target13).lintRules : null;
     if (hasRules && linter) {
       diagnostics.push(...linter(canonical, projectRoot, projectFiles));
     }
     if (hasCommands) {
-      diagnostics.push(...lintCommands(canonical, target12));
+      diagnostics.push(...lintCommands(canonical, target13));
     }
     if (hasMcp) {
-      diagnostics.push(...lintMcp(canonical, target12));
+      diagnostics.push(...lintMcp(canonical, target13));
     }
     if (hasPermissions) {
-      diagnostics.push(...lintPermissions(canonical, target12));
+      diagnostics.push(...lintPermissions(canonical, target13));
     }
     if (hasHooks) {
-      diagnostics.push(...lintHooks(canonical, target12));
+      diagnostics.push(...lintHooks(canonical, target13));
     }
   }
   const hasErrors = diagnostics.some((d) => d.level === "error");
@@ -10483,7 +11026,7 @@ async function runLintCmd(flags, projectRoot) {
 }
 
 // src/cli/commands/watch.ts
-import { join as join58, relative as relative23 } from "path";
+import { join as join60, relative as relative23 } from "path";
 import chokidar from "chokidar";
 var DEBOUNCE_MS = 300;
 function normalizeWatchPath(path) {
@@ -10510,9 +11053,9 @@ async function runWatch(flags, projectRoot) {
   const root = projectRoot ?? process.cwd();
   const { configDir } = await loadConfigFromDir(root);
   const paths = [
-    join58(configDir, ".agentsmesh"),
-    join58(configDir, "agentsmesh.yaml"),
-    join58(configDir, "agentsmesh.local.yaml")
+    join60(configDir, ".agentsmesh"),
+    join60(configDir, "agentsmesh.yaml"),
+    join60(configDir, "agentsmesh.local.yaml")
   ];
   let debounceTimer = null;
   let lastFingerprint = null;
@@ -10598,12 +11141,12 @@ async function runWatch(flags, projectRoot) {
 }
 
 // src/cli/commands/check.ts
-import { join as join59 } from "path";
+import { join as join61 } from "path";
 async function runCheck(flags, projectRoot) {
   void flags;
   const root = projectRoot ?? process.cwd();
   const { config, configDir } = await loadConfigFromDir(root);
-  const abDir = join59(configDir, ".agentsmesh");
+  const abDir = join61(configDir, ".agentsmesh");
   const lock = await readLock(abDir);
   if (lock === null) {
     logger.error("Not initialized for collaboration. Run 'agentsmesh generate' first.");
@@ -10673,14 +11216,14 @@ async function runCheck(flags, projectRoot) {
 }
 
 // src/cli/commands/merge.ts
-import { join as join61 } from "path";
+import { join as join63 } from "path";
 
 // src/core/merger.ts
-import { dirname as dirname22, join as join60 } from "path";
+import { dirname as dirname22, join as join62 } from "path";
 var LOCK_FILENAME2 = ".lock";
 var CONFLICT_MARKER = "<<<<<<<";
 async function hasLockConflict(abDir) {
-  const lockPath = join60(abDir, LOCK_FILENAME2);
+  const lockPath = join62(abDir, LOCK_FILENAME2);
   const content = await readFileSafe(lockPath);
   if (content === null) return false;
   return content.includes(CONFLICT_MARKER);
@@ -10694,7 +11237,7 @@ async function resolveLockConflict(abDir, libVersion, config) {
   const configDir = dirname22(abDir);
   const resolvedExtends = config ? await resolveExtendPaths(config, configDir) : [];
   const extendChecksums = resolvedExtends.length > 0 ? await buildExtendChecksums(resolvedExtends) : {};
-  const packChecksums = await buildPackChecksums(join60(abDir, "packs"));
+  const packChecksums = await buildPackChecksums(join62(abDir, "packs"));
   const generatedBy = process.env["USER"] ?? process.env["USERNAME"] ?? "unknown";
   await writeLock(abDir, {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10711,7 +11254,7 @@ async function runMerge(flags, projectRoot) {
   void flags;
   const root = projectRoot ?? process.cwd();
   const { config, configDir } = await loadConfigFromDir(root);
-  const abDir = join61(configDir, ".agentsmesh");
+  const abDir = join63(configDir, ".agentsmesh");
   const hasConflict = await hasLockConflict(abDir);
   if (!hasConflict) {
     logger.info("No conflicts to resolve.");
@@ -10722,7 +11265,7 @@ async function runMerge(flags, projectRoot) {
 }
 
 // src/install/run/run-install.ts
-import { join as join75 } from "path";
+import { join as join77 } from "path";
 
 // src/install/source/git-pin.ts
 import { execFile as execFile2 } from "child_process";
@@ -10856,7 +11399,7 @@ async function confirm(message) {
 }
 
 // src/install/core/validate-resources.ts
-import { basename as basename32 } from "path";
+import { basename as basename33 } from "path";
 function validateSkill(skill) {
   if (!skill.description.trim()) {
     return { skill, ok: false, reason: "missing description in frontmatter" };
@@ -10882,7 +11425,7 @@ function validateAgent(agent) {
   return { agent, ok: true };
 }
 function ruleSlug6(rule) {
-  return basename32(rule.source).replace(/\.md$/i, "");
+  return basename33(rule.source).replace(/\.md$/i, "");
 }
 
 // src/install/core/pool-resolution.ts
@@ -11376,7 +11919,7 @@ function ensureInstallSelection(args) {
 }
 
 // src/install/core/install-extend-entry.ts
-import { join as join62 } from "path";
+import { join as join64 } from "path";
 
 // src/install/core/merge-extend-entry.ts
 function assertExtendNameAvailable(extendsList, entry) {
@@ -11465,7 +12008,7 @@ async function writeInstallAsExtend(args) {
 ${JSON.stringify(entry, null, 2)}`);
     return;
   }
-  const configPath = join62(configDir, "agentsmesh.yaml");
+  const configPath = join64(configDir, "agentsmesh.yaml");
   await writeAgentsmeshWithNewExtend(configPath, config, entry);
   logger.success(`Wrote extends entry "${entry.name}" to agentsmesh.yaml.`);
 }
@@ -11482,13 +12025,13 @@ function toNewExtendEntry(args) {
 }
 
 // src/install/run/run-install-pack.ts
-import { join as join66 } from "path";
+import { join as join68 } from "path";
 import { rename as rename4 } from "fs/promises";
 
 // src/install/pack/pack-writer.ts
-import { join as join63, basename as basename33, dirname as dirname23 } from "path";
+import { join as join65, basename as basename34, dirname as dirname23 } from "path";
 import { rm as rm7, rename as rename3, mkdir as mkdir5, copyFile as copyFile2 } from "fs/promises";
-import { stringify as yamlStringify6 } from "yaml";
+import { stringify as yamlStringify7 } from "yaml";
 
 // src/install/pack/pack-hash.ts
 import { relative as relative25 } from "path";
@@ -11512,41 +12055,41 @@ async function hashPackContent(packDir) {
 // src/install/pack/pack-writer.ts
 async function writeRules(canonical, packDir) {
   if (canonical.rules.length === 0) return;
-  const rulesDir = join63(packDir, "rules");
+  const rulesDir = join65(packDir, "rules");
   await mkdirp(rulesDir);
   for (const rule of canonical.rules) {
-    const dest = join63(rulesDir, basename33(rule.source));
+    const dest = join65(rulesDir, basename34(rule.source));
     await copyFile2(rule.source, dest);
   }
 }
 async function writeCommands(canonical, packDir) {
   if (canonical.commands.length === 0) return;
-  const dir = join63(packDir, "commands");
+  const dir = join65(packDir, "commands");
   await mkdirp(dir);
   for (const cmd of canonical.commands) {
-    const dest = join63(dir, basename33(cmd.source));
+    const dest = join65(dir, basename34(cmd.source));
     await copyFile2(cmd.source, dest);
   }
 }
 async function writeAgents(canonical, packDir) {
   if (canonical.agents.length === 0) return;
-  const dir = join63(packDir, "agents");
+  const dir = join65(packDir, "agents");
   await mkdirp(dir);
   for (const agent of canonical.agents) {
-    const dest = join63(dir, basename33(agent.source));
+    const dest = join65(dir, basename34(agent.source));
     await copyFile2(agent.source, dest);
   }
 }
 async function writeSkills(canonical, packDir) {
   if (canonical.skills.length === 0) return;
-  const skillsDir = join63(packDir, "skills");
+  const skillsDir = join65(packDir, "skills");
   await mkdirp(skillsDir);
   for (const skill of canonical.skills) {
-    const skillDestDir = join63(skillsDir, skill.name);
+    const skillDestDir = join65(skillsDir, skill.name);
     await mkdirp(skillDestDir);
-    await copyFile2(skill.source, join63(skillDestDir, "SKILL.md"));
+    await copyFile2(skill.source, join65(skillDestDir, "SKILL.md"));
     for (const sf of skill.supportingFiles) {
-      const destPath = join63(skillDestDir, sf.relativePath);
+      const destPath = join65(skillDestDir, sf.relativePath);
       await mkdirp(dirname23(destPath));
       await copyFile2(sf.absolutePath, destPath);
     }
@@ -11554,23 +12097,23 @@ async function writeSkills(canonical, packDir) {
 }
 async function writeSettings(canonical, packDir) {
   if (canonical.mcp !== null) {
-    await writeFileAtomic(join63(packDir, "mcp.json"), `${JSON.stringify(canonical.mcp, null, 2)}
+    await writeFileAtomic(join65(packDir, "mcp.json"), `${JSON.stringify(canonical.mcp, null, 2)}
 `);
   }
   if (canonical.permissions !== null) {
-    await writeFileAtomic(join63(packDir, "permissions.yaml"), yamlStringify6(canonical.permissions));
+    await writeFileAtomic(join65(packDir, "permissions.yaml"), yamlStringify7(canonical.permissions));
   }
   if (canonical.hooks !== null) {
-    await writeFileAtomic(join63(packDir, "hooks.yaml"), yamlStringify6(canonical.hooks));
+    await writeFileAtomic(join65(packDir, "hooks.yaml"), yamlStringify7(canonical.hooks));
   }
   if (canonical.ignore.length > 0) {
-    await writeFileAtomic(join63(packDir, "ignore"), `${canonical.ignore.join("\n")}
+    await writeFileAtomic(join65(packDir, "ignore"), `${canonical.ignore.join("\n")}
 `);
   }
 }
 async function materializePack(packsDir, packName, canonical, metadataInput) {
-  const tmpDir = join63(packsDir, `${packName}.tmp`);
-  const finalDir = join63(packsDir, packName);
+  const tmpDir = join65(packsDir, `${packName}.tmp`);
+  const finalDir = join65(packsDir, packName);
   if (await exists(tmpDir)) {
     await rm7(tmpDir, { recursive: true, force: true });
   }
@@ -11582,7 +12125,7 @@ async function materializePack(packsDir, packName, canonical, metadataInput) {
   await writeSettings(canonical, tmpDir);
   const contentHash = await hashPackContent(tmpDir);
   const metadata = { ...metadataInput, content_hash: contentHash };
-  await writeFileAtomic(join63(tmpDir, "pack.yaml"), yamlStringify6(metadata));
+  await writeFileAtomic(join65(tmpDir, "pack.yaml"), yamlStringify7(metadata));
   if (await exists(finalDir)) {
     await rm7(finalDir, { recursive: true, force: true });
   }
@@ -11592,9 +12135,9 @@ async function materializePack(packsDir, packName, canonical, metadataInput) {
 }
 
 // src/install/pack/pack-merge.ts
-import { join as join64, basename as basename34, dirname as dirname24 } from "path";
+import { join as join66, basename as basename35, dirname as dirname24 } from "path";
 import { copyFile as copyFile3 } from "fs/promises";
-import { stringify as yamlStringify7 } from "yaml";
+import { stringify as yamlStringify8 } from "yaml";
 function union(a, b) {
   return [.../* @__PURE__ */ new Set([...a, ...b])];
 }
@@ -11623,38 +12166,38 @@ function mergePick2(existing, newFeatures, newPick) {
 }
 async function mergeRules(canonical, packDir) {
   if (canonical.rules.length === 0) return;
-  const dir = join64(packDir, "rules");
+  const dir = join66(packDir, "rules");
   await mkdirp(dir);
   for (const rule of canonical.rules) {
-    await copyFile3(rule.source, join64(dir, basename34(rule.source)));
+    await copyFile3(rule.source, join66(dir, basename35(rule.source)));
   }
 }
 async function mergeCommands(canonical, packDir) {
   if (canonical.commands.length === 0) return;
-  const dir = join64(packDir, "commands");
+  const dir = join66(packDir, "commands");
   await mkdirp(dir);
   for (const cmd of canonical.commands) {
-    await copyFile3(cmd.source, join64(dir, basename34(cmd.source)));
+    await copyFile3(cmd.source, join66(dir, basename35(cmd.source)));
   }
 }
 async function mergeAgents(canonical, packDir) {
   if (canonical.agents.length === 0) return;
-  const dir = join64(packDir, "agents");
+  const dir = join66(packDir, "agents");
   await mkdirp(dir);
   for (const agent of canonical.agents) {
-    await copyFile3(agent.source, join64(dir, basename34(agent.source)));
+    await copyFile3(agent.source, join66(dir, basename35(agent.source)));
   }
 }
 async function mergeSkills(canonical, packDir) {
   if (canonical.skills.length === 0) return;
-  const skillsDir = join64(packDir, "skills");
+  const skillsDir = join66(packDir, "skills");
   await mkdirp(skillsDir);
   for (const skill of canonical.skills) {
-    const destDir = join64(skillsDir, skill.name);
+    const destDir = join66(skillsDir, skill.name);
     await mkdirp(destDir);
-    await copyFile3(skill.source, join64(destDir, "SKILL.md"));
+    await copyFile3(skill.source, join66(destDir, "SKILL.md"));
     for (const sf of skill.supportingFiles) {
-      const destPath = join64(destDir, sf.relativePath);
+      const destPath = join66(destDir, sf.relativePath);
       await mkdirp(dirname24(destPath));
       await copyFile3(sf.absolutePath, destPath);
     }
@@ -11662,17 +12205,17 @@ async function mergeSkills(canonical, packDir) {
 }
 async function mergeSettings(canonical, packDir) {
   if (canonical.mcp !== null) {
-    await writeFileAtomic(join64(packDir, "mcp.json"), `${JSON.stringify(canonical.mcp, null, 2)}
+    await writeFileAtomic(join66(packDir, "mcp.json"), `${JSON.stringify(canonical.mcp, null, 2)}
 `);
   }
   if (canonical.permissions !== null) {
-    await writeFileAtomic(join64(packDir, "permissions.yaml"), yamlStringify7(canonical.permissions));
+    await writeFileAtomic(join66(packDir, "permissions.yaml"), yamlStringify8(canonical.permissions));
   }
   if (canonical.hooks !== null) {
-    await writeFileAtomic(join64(packDir, "hooks.yaml"), yamlStringify7(canonical.hooks));
+    await writeFileAtomic(join66(packDir, "hooks.yaml"), yamlStringify8(canonical.hooks));
   }
   if (canonical.ignore.length > 0) {
-    await writeFileAtomic(join64(packDir, "ignore"), `${canonical.ignore.join("\n")}
+    await writeFileAtomic(join66(packDir, "ignore"), `${canonical.ignore.join("\n")}
 `);
   }
 }
@@ -11699,13 +12242,13 @@ async function mergeIntoPack(packDir, existingMeta, newCanonical, newFeatures, n
     updated_at: updatedAt,
     content_hash: contentHash
   };
-  await writeFileAtomic(join64(packDir, "pack.yaml"), yamlStringify7(updatedMeta));
+  await writeFileAtomic(join66(packDir, "pack.yaml"), yamlStringify8(updatedMeta));
   return updatedMeta;
 }
 
 // src/install/core/install-manifest.ts
-import { join as join65 } from "path";
-import { parse as parseYaml8, stringify as yamlStringify8 } from "yaml";
+import { join as join67 } from "path";
+import { parse as parseYaml8, stringify as yamlStringify9 } from "yaml";
 import { z as z4 } from "zod";
 var installManifestEntrySchema = z4.object({
   name: z4.string().min(1),
@@ -11730,7 +12273,7 @@ function sameInstallIdentity(a, b) {
   return a.source === b.source && a.target === b.target && a.as === b.as && sameFeatures2(a.features, b.features);
 }
 function manifestPath(configDir) {
-  return join65(configDir, ".agentsmesh", "installs.yaml");
+  return join67(configDir, ".agentsmesh", "installs.yaml");
 }
 async function readInstallManifest(configDir) {
   const content = await readFileSafe(manifestPath(configDir));
@@ -11749,7 +12292,7 @@ async function upsertInstallManifestEntry(configDir, entry) {
   next.push(entry);
   await writeFileAtomic(
     manifestPath(configDir),
-    yamlStringify8({ version: 1, installs: next.sort((a, b) => a.name.localeCompare(b.name)) })
+    yamlStringify9({ version: 1, installs: next.sort((a, b) => a.name.localeCompare(b.name)) })
   );
 }
 function buildInstallManifestEntry(args) {
@@ -11803,7 +12346,7 @@ async function installAsPack(args) {
     manualAs,
     renameExistingPack
   } = args;
-  const packsDir = join66(configDir, ".agentsmesh", "packs");
+  const packsDir = join68(configDir, ".agentsmesh", "packs");
   const selectedCanonical = applySelection(narrowed, selected);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const parsedTarget = yamlTarget !== void 0 ? targetSchema.parse(yamlTarget) : void 0;
@@ -11821,7 +12364,7 @@ async function installAsPack(args) {
     let packDir = existingPack.packDir;
     let packMeta = existingPack.meta;
     if (renameExistingPack && existingPack.name !== packName) {
-      const nextDir = join66(packsDir, packName);
+      const nextDir = join68(packsDir, packName);
       if (await exists(nextDir)) {
         throw new Error(
           `Auto-generated pack name "${packName}" collides with an existing incompatible pack. Use --name to choose a different pack name.`
@@ -11852,7 +12395,7 @@ async function installAsPack(args) {
     persistedPaths = mergedMeta.paths;
     logger.success(`Updated pack "${mergedMeta.name}" in .agentsmesh/packs/.`);
   } else {
-    const collidingMeta = await readPackMetadata(join66(packsDir, packName));
+    const collidingMeta = await readPackMetadata(join68(packsDir, packName));
     if (collidingMeta) {
       throw new Error(
         `Auto-generated pack name "${packName}" collides with an existing incompatible pack. Use --name to choose a different pack name.`
@@ -11894,7 +12437,7 @@ async function installAsPack(args) {
 }
 
 // src/install/run/install-sync.ts
-import { join as join67 } from "path";
+import { join as join69 } from "path";
 async function syncInstalledPacks(args) {
   const installs = await readInstallManifest(args.configDir);
   if (installs.length === 0) {
@@ -11903,7 +12446,7 @@ async function syncInstalledPacks(args) {
   }
   const missing = [];
   for (const entry of installs) {
-    const packDir = join67(args.configDir, ".agentsmesh", "packs", entry.name);
+    const packDir = join69(args.configDir, ".agentsmesh", "packs", entry.name);
     if (!await exists(packDir)) {
       missing.push(entry);
     }
@@ -12081,7 +12624,7 @@ function narrowDiscoveredForInstallScope(canonical, options) {
 }
 
 // src/install/manual/manual-install-scope.ts
-import { basename as basename35, dirname as dirname25, join as join68, relative as relative27 } from "path";
+import { basename as basename36, dirname as dirname25, join as join70, relative as relative27 } from "path";
 import { cp as cp2, mkdtemp, stat as stat5, rm as rm8 } from "fs/promises";
 import { tmpdir } from "os";
 
@@ -12141,9 +12684,9 @@ async function cpFilteredSkill(sourceRoot, destDir) {
 
 // src/install/manual/manual-install-scope.ts
 async function createStageRoot() {
-  const stageBase = await mkdtemp(join68(tmpdir(), "am-install-manual-"));
-  const discoveryRoot = join68(stageBase, "repo");
-  await mkdirp(join68(discoveryRoot, ".agentsmesh"));
+  const stageBase = await mkdtemp(join70(tmpdir(), "am-install-manual-"));
+  const discoveryRoot = join70(stageBase, "repo");
+  await mkdirp(join70(discoveryRoot, ".agentsmesh"));
   return {
     discoveryRoot,
     cleanup: async () => {
@@ -12158,7 +12701,7 @@ async function stageMarkdownCollection(sourceRoot, destinationDir) {
       throw new Error(`Manual install only supports .md files for this collection: ${sourceRoot}`);
     }
     await mkdirp(destinationDir);
-    await cp2(sourceRoot, join68(destinationDir, basename35(sourceRoot)));
+    await cp2(sourceRoot, join70(destinationDir, basename36(sourceRoot)));
     return;
   }
   const files = (await readDirRecursive(sourceRoot)).filter(
@@ -12170,7 +12713,7 @@ async function stageMarkdownCollection(sourceRoot, destinationDir) {
   const usedNames = /* @__PURE__ */ new Map();
   await mkdirp(destinationDir);
   for (const file of files) {
-    const name = basename35(file);
+    const name = basename36(file);
     const previous = usedNames.get(name);
     if (previous) {
       throw new Error(
@@ -12178,7 +12721,7 @@ async function stageMarkdownCollection(sourceRoot, destinationDir) {
       );
     }
     usedNames.set(name, file);
-    await cp2(file, join68(destinationDir, name));
+    await cp2(file, join70(destinationDir, name));
   }
 }
 async function stagePreferredSkills(sourceRoot, destinationDir, preferredSkillNames) {
@@ -12190,7 +12733,7 @@ async function stagePreferredSkills(sourceRoot, destinationDir, preferredSkillNa
   for (const file of await readDirRecursive(sourceRoot)) {
     if (!file.endsWith("/SKILL.md") && !file.endsWith("\\SKILL.md")) continue;
     const skillDir = dirname25(file);
-    const skillName = basename35(skillDir);
+    const skillName = basename36(skillDir);
     if (!wanted.has(skillName)) continue;
     const previous = matches.get(skillName);
     if (previous && previous !== skillDir) {
@@ -12203,30 +12746,30 @@ async function stagePreferredSkills(sourceRoot, destinationDir, preferredSkillNa
   if (matches.size !== preferredSkillNames.length) return false;
   await mkdirp(destinationDir);
   for (const skillName of preferredSkillNames) {
-    await cp2(matches.get(skillName), join68(destinationDir, skillName), { recursive: true });
+    await cp2(matches.get(skillName), join70(destinationDir, skillName), { recursive: true });
   }
   return true;
 }
 async function stageSkills(sourceRoot, destinationDir, options = {}) {
   const info = await stat5(sourceRoot);
   if (info.isFile()) {
-    if (basename35(sourceRoot) !== "SKILL.md") {
+    if (basename36(sourceRoot) !== "SKILL.md") {
       throw new Error(`Manual skill install expects SKILL.md or a skill directory: ${sourceRoot}`);
     }
-    const skillName = basename35(dirname25(sourceRoot));
-    const skillDir = join68(destinationDir, skillName);
+    const skillName = basename36(dirname25(sourceRoot));
+    const skillDir = join70(destinationDir, skillName);
     await mkdirp(skillDir);
     await cp2(dirname25(sourceRoot), skillDir, { recursive: true });
     return;
   }
   if (await isSkillPackLayout(sourceRoot)) {
-    if ((await stat5(join68(sourceRoot, "SKILL.md")).catch(() => null))?.isFile()) {
+    if ((await stat5(join70(sourceRoot, "SKILL.md")).catch(() => null))?.isFile()) {
       if (await stagePreferredSkills(sourceRoot, destinationDir, options.preferredSkillNames ?? [])) {
         return;
       }
-      const fmName = await readSkillFrontmatterName(join68(sourceRoot, "SKILL.md"));
-      const skillName = fmName || basename35(sourceRoot);
-      const skillDir = join68(destinationDir, skillName);
+      const fmName = await readSkillFrontmatterName(join70(sourceRoot, "SKILL.md"));
+      const skillName = fmName || basename36(sourceRoot);
+      const skillDir = join70(destinationDir, skillName);
       await mkdirp(destinationDir);
       await cpFilteredSkill(sourceRoot, skillDir);
       return;
@@ -12243,7 +12786,7 @@ async function stageSkills(sourceRoot, destinationDir, options = {}) {
       roots.add(relative27(sourceRoot, dirname25(file)).split(/[\\/]/)[0]);
     }
     for (const root of roots) {
-      await cp2(join68(sourceRoot, root), join68(destinationDir, root), { recursive: true });
+      await cp2(join70(sourceRoot, root), join70(destinationDir, root), { recursive: true });
     }
     return;
   }
@@ -12254,7 +12797,7 @@ async function stageSkills(sourceRoot, destinationDir, options = {}) {
 async function stageManualInstallScope(sourceRoot, as, options = {}) {
   const staged = await createStageRoot();
   try {
-    const destDir = join68(staged.discoveryRoot, ".agentsmesh", as);
+    const destDir = join70(staged.discoveryRoot, ".agentsmesh", as);
     if (as === "skills") {
       await stageSkills(sourceRoot, destDir, options);
     } else {
@@ -12288,7 +12831,7 @@ async function resolveManualDiscoveredForInstall(sourceRoot, explicitAs, explici
 }
 
 // src/install/core/prepare-install-discovery.ts
-import { join as join73 } from "path";
+import { join as join75 } from "path";
 
 // src/install/native/native-path-pick.ts
 var PATH_PREFIX_TO_TARGET = [
@@ -12315,6 +12858,8 @@ var PATH_PREFIX_TO_TARGET = [
   { prefix: ".junie/rules", target: "junie" },
   { prefix: ".junie/agents", target: "junie" },
   { prefix: ".junie/skills", target: "junie" },
+  { prefix: ".kiro/steering", target: "kiro" },
+  { prefix: ".kiro/skills", target: "kiro" },
   { prefix: ".cline/skills", target: "cline" },
   { prefix: ".clinerules/workflows", target: "cline" },
   { prefix: ".windsurf/rules", target: "windsurf" },
@@ -12326,14 +12871,14 @@ function norm(p) {
 function targetHintFromNativePath(pathInRepoPosix) {
   const p = norm(pathInRepoPosix);
   const sorted = [...PATH_PREFIX_TO_TARGET].sort((a, b) => b.prefix.length - a.prefix.length);
-  for (const { prefix, target: target12 } of sorted) {
-    if (p === prefix || p.startsWith(`${prefix}/`)) return target12;
+  for (const { prefix, target: target13 } of sorted) {
+    if (p === prefix || p.startsWith(`${prefix}/`)) return target13;
   }
   return void 0;
 }
-function pathSupportsNativePick(pathInRepoPosix, target12) {
+function pathSupportsNativePick(pathInRepoPosix, target13) {
   const hint = targetHintFromNativePath(pathInRepoPosix);
-  return hint === target12;
+  return hint === target13;
 }
 function validateTargetMatchesPath(explicitTarget, pathInRepoPosix) {
   if (!explicitTarget || !pathInRepoPosix) return;
@@ -12349,13 +12894,13 @@ function extendPickHasArrays(p) {
 }
 
 // src/install/native/native-path-pick-infer.ts
-import { basename as basename38, join as join71 } from "path";
+import { basename as basename39, join as join73 } from "path";
 
 // src/install/native/gemini-install-commands.ts
-import { join as join69, relative as relative28 } from "path";
+import { join as join71, relative as relative28 } from "path";
 async function inferGeminiCommandNamesFromFiles(repoRoot, pathInRepoPosix) {
-  const commandsRoot = join69(repoRoot, ...GEMINI_COMMANDS_DIR.split("/"));
-  const scanDir = join69(repoRoot, ...pathInRepoPosix.split("/"));
+  const commandsRoot = join71(repoRoot, ...GEMINI_COMMANDS_DIR.split("/"));
+  const scanDir = join71(repoRoot, ...pathInRepoPosix.split("/"));
   const files = await readDirRecursive(scanDir);
   const names = [];
   for (const f of files) {
@@ -12370,32 +12915,32 @@ async function inferGeminiCommandNamesFromFiles(repoRoot, pathInRepoPosix) {
 }
 
 // src/install/native/native-skill-scan.ts
-import { basename as basename36, dirname as dirname26, relative as relative29 } from "path";
+import { basename as basename37, dirname as dirname26, relative as relative29 } from "path";
 async function skillNamesFromNativeSkillDir(scanRoot) {
   const files = await readDirRecursive(scanRoot);
   const names = /* @__PURE__ */ new Set();
   for (const f of files) {
-    if (basename36(f) === "SKILL.md") {
-      names.add(basename36(dirname26(f)));
+    if (basename37(f) === "SKILL.md") {
+      names.add(basename37(dirname26(f)));
       continue;
     }
     const rel2 = relative29(scanRoot, f).replace(/\\/g, "/");
     if (!rel2.includes("/") && f.toLowerCase().endsWith(".md")) {
-      names.add(basename36(f, ".md"));
+      names.add(basename37(f, ".md"));
     }
   }
   return [...names].filter(Boolean).sort();
 }
 
 // src/install/native/native-path-pick-infer-copilot.ts
-import { basename as basename37, join as join70 } from "path";
+import { basename as basename38, join as join72 } from "path";
 async function inferCopilotPickFromPath(repoRoot, posixPath) {
-  const scan = join70(repoRoot, ...posixPath.split("/"));
+  const scan = join72(repoRoot, ...posixPath.split("/"));
   if (posixPath.startsWith(COPILOT_PROMPTS_DIR)) {
     const files = await readDirRecursive(scan);
     const commands = [
       ...new Set(
-        files.filter((f) => f.toLowerCase().endsWith(".prompt.md")).map((f) => basename37(f, ".prompt.md"))
+        files.filter((f) => f.toLowerCase().endsWith(".prompt.md")).map((f) => basename38(f, ".prompt.md"))
       )
     ].sort();
     return commands.length ? { commands } : {};
@@ -12404,7 +12949,7 @@ async function inferCopilotPickFromPath(repoRoot, posixPath) {
     const files = await readDirRecursive(scan);
     const rules = [
       ...new Set(
-        files.filter((f) => f.includes(".instructions.md")).map((f) => basename37(f).replace(/\.instructions\.md$/i, ""))
+        files.filter((f) => f.includes(".instructions.md")).map((f) => basename38(f).replace(/\.instructions\.md$/i, ""))
       )
     ].sort();
     return rules.length ? { rules } : {};
@@ -12413,10 +12958,10 @@ async function inferCopilotPickFromPath(repoRoot, posixPath) {
     const files = await readDirRecursive(scan);
     const names = /* @__PURE__ */ new Set();
     for (const f of files) {
-      const b = basename37(f);
+      const b = basename38(f);
       if (b.toLowerCase().endsWith(".instructions.md"))
         names.add(b.replace(/\.instructions\.md$/i, ""));
-      else if (b.toLowerCase().endsWith(".md")) names.add(basename37(f, ".md"));
+      else if (b.toLowerCase().endsWith(".md")) names.add(basename38(f, ".md"));
     }
     const rules = [...names].sort();
     return rules.length ? { rules } : {};
@@ -12429,7 +12974,7 @@ async function inferCopilotPickFromPath(repoRoot, posixPath) {
     const files = await readDirRecursive(scan);
     const agents = [
       ...new Set(
-        files.filter((f) => f.toLowerCase().endsWith(".agent.md")).map((f) => basename37(f, ".agent.md"))
+        files.filter((f) => f.toLowerCase().endsWith(".agent.md")).map((f) => basename38(f, ".agent.md"))
       )
     ].sort();
     return agents.length ? { agents } : {};
@@ -12442,20 +12987,20 @@ async function mdNames(dir, ext) {
   const files = await readDirRecursive(dir);
   const e = ext.toLowerCase();
   return [
-    ...new Set(files.filter((f) => f.toLowerCase().endsWith(e)).map((f) => basename38(f, ext)))
+    ...new Set(files.filter((f) => f.toLowerCase().endsWith(e)).map((f) => basename39(f, ext)))
   ].sort();
 }
-async function inferImplicitPickFromNativePath(repoRoot, pathInRepoPosix, target12) {
+async function inferImplicitPickFromNativePath(repoRoot, pathInRepoPosix, target13) {
   const posixPath = pathInRepoPosix.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
-  const scan = join71(repoRoot, ...posixPath.split("/"));
-  if (target12 === "gemini-cli") {
+  const scan = join73(repoRoot, ...posixPath.split("/"));
+  if (target13 === "gemini-cli") {
     if (posixPath === GEMINI_COMMANDS_DIR || posixPath.startsWith(`${GEMINI_COMMANDS_DIR}/`)) {
       const commands = await inferGeminiCommandNamesFromFiles(repoRoot, posixPath);
       return commands.length ? { commands } : {};
     }
     return {};
   }
-  if (target12 === "claude-code") {
+  if (target13 === "claude-code") {
     if (posixPath.startsWith(".claude/commands")) {
       const commands = await mdNames(scan, ".md");
       return commands.length ? { commands } : {};
@@ -12475,7 +13020,7 @@ async function inferImplicitPickFromNativePath(repoRoot, pathInRepoPosix, target
     }
     return {};
   }
-  if (target12 === "cursor") {
+  if (target13 === "cursor") {
     if (posixPath.startsWith(".cursor/rules")) {
       const rules = await mdNames(scan, ".mdc");
       return rules.length ? { rules } : {};
@@ -12494,14 +13039,14 @@ async function inferImplicitPickFromNativePath(repoRoot, pathInRepoPosix, target
     }
     return {};
   }
-  if (target12 === "copilot") {
+  if (target13 === "copilot") {
     return inferCopilotPickFromPath(repoRoot, posixPath);
   }
-  if (target12 === "windsurf" && posixPath.startsWith(".windsurf/rules")) {
+  if (target13 === "windsurf" && posixPath.startsWith(".windsurf/rules")) {
     const rules = await mdNames(scan, ".md");
     return rules.length ? { rules } : {};
   }
-  if (target12 === "cline") {
+  if (target13 === "cline") {
     if (posixPath.startsWith(CLINE_SKILLS_DIR)) {
       const skills = await skillNamesFromNativeSkillDir(scan);
       return skills.length ? { skills } : {};
@@ -12512,7 +13057,7 @@ async function inferImplicitPickFromNativePath(repoRoot, pathInRepoPosix, target
     }
     return {};
   }
-  if (target12 === "continue") {
+  if (target13 === "continue") {
     if (posixPath.startsWith(".continue/rules")) {
       const rules = await mdNames(scan, ".md");
       return rules.length ? { rules } : {};
@@ -12527,7 +13072,7 @@ async function inferImplicitPickFromNativePath(repoRoot, pathInRepoPosix, target
     }
     return {};
   }
-  if (target12 === "junie") {
+  if (target13 === "junie") {
     if (posixPath.startsWith(".junie/commands")) {
       const commands = await mdNames(scan, ".md");
       return commands.length ? { commands } : {};
@@ -12546,11 +13091,11 @@ async function inferImplicitPickFromNativePath(repoRoot, pathInRepoPosix, target
     }
     return {};
   }
-  if (target12 === "codex-cli" && posixPath.startsWith(".codex")) {
+  if (target13 === "codex-cli" && posixPath.startsWith(".codex")) {
     const files = await readDirRecursive(scan);
     const rules = [
       ...new Set(
-        files.filter((f) => f.toLowerCase().endsWith(".md")).map((f) => basename38(f, ".md"))
+        files.filter((f) => f.toLowerCase().endsWith(".md")).map((f) => basename39(f, ".md"))
       )
     ].sort();
     return rules.length ? { rules } : {};
@@ -12562,7 +13107,7 @@ function isImplicitPickEmpty(p) {
 }
 
 // src/install/native/native-install-scope.ts
-import { basename as basename39, join as join72, relative as relative30 } from "path";
+import { basename as basename40, join as join74, relative as relative30 } from "path";
 import { cp as cp3, mkdtemp as mkdtemp2, rm as rm9 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 function normalizePath3(path) {
@@ -12573,14 +13118,14 @@ function overlapsPath(requested, imported) {
   const b = normalizePath3(imported);
   return a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
 }
-function addUnique(target12, value) {
-  const next = target12 ?? [];
+function addUnique(target13, value) {
+  const next = target13 ?? [];
   if (!next.includes(value)) next.push(value);
   return next;
 }
 async function makeStageRoot(repoRoot) {
-  const stageBase = await mkdtemp2(join72(tmpdir2(), "am-install-native-"));
-  const stageRoot = join72(stageBase, "repo");
+  const stageBase = await mkdtemp2(join74(tmpdir2(), "am-install-native-"));
+  const stageRoot = join74(stageBase, "repo");
   const cleanup = async () => {
     await rm9(stageBase, { recursive: true, force: true });
   };
@@ -12598,13 +13143,13 @@ function buildPickFromResults(results, stageRoot) {
     if (result.feature === "rules" && result.toPath.startsWith(".agentsmesh/rules/")) {
       pick = {
         ...pick,
-        rules: addUnique(pick?.rules, basename39(result.toPath, ".md"))
+        rules: addUnique(pick?.rules, basename40(result.toPath, ".md"))
       };
       continue;
     }
     if (result.feature === "commands" && result.toPath.startsWith(".agentsmesh/commands/")) {
       const rel2 = normalizePath3(
-        relative30(join72(stageRoot, ".agentsmesh", "commands"), join72(stageRoot, result.toPath))
+        relative30(join74(stageRoot, ".agentsmesh", "commands"), join74(stageRoot, result.toPath))
       );
       pick = {
         ...pick,
@@ -12618,13 +13163,13 @@ function buildPickFromResults(results, stageRoot) {
     if (result.feature === "agents" && result.toPath.startsWith(".agentsmesh/agents/")) {
       pick = {
         ...pick,
-        agents: addUnique(pick?.agents, basename39(result.toPath, ".md"))
+        agents: addUnique(pick?.agents, basename40(result.toPath, ".md"))
       };
       continue;
     }
     if (result.feature === "skills" && result.toPath.startsWith(".agentsmesh/skills/")) {
       const rel2 = normalizePath3(
-        relative30(join72(stageRoot, ".agentsmesh", "skills"), join72(stageRoot, result.toPath))
+        relative30(join74(stageRoot, ".agentsmesh", "skills"), join74(stageRoot, result.toPath))
       );
       const skillName = rel2.split("/")[0];
       if (skillName) {
@@ -12639,12 +13184,12 @@ function buildPickFromResults(results, stageRoot) {
   const hasAny = (pick.rules?.length ?? 0) + (pick.commands?.length ?? 0) + (pick.agents?.length ?? 0) + (pick.skills?.length ?? 0) > 0;
   return hasAny ? pick : void 0;
 }
-function scopeImportedResults(pathInRepoPosix, stageRoot, results, target12) {
-  const requestedPath = join72(stageRoot, ...normalizePath3(pathInRepoPosix).split("/"));
+function scopeImportedResults(pathInRepoPosix, stageRoot, results, target13) {
+  const requestedPath = join74(stageRoot, ...normalizePath3(pathInRepoPosix).split("/"));
   const filtered = results.filter((result) => overlapsPath(requestedPath, result.fromPath));
   if (filtered.length === 0) {
     throw new Error(
-      `No installable native resources found under "${pathInRepoPosix}" for target "${target12}".`
+      `No installable native resources found under "${pathInRepoPosix}" for target "${target13}".`
     );
   }
   return {
@@ -12652,23 +13197,23 @@ function scopeImportedResults(pathInRepoPosix, stageRoot, results, target12) {
     pick: buildPickFromResults(filtered, stageRoot)
   };
 }
-async function stageImportedNativeRepo(repoRoot, target12) {
+async function stageImportedNativeRepo(repoRoot, target13) {
   const { stageRoot, cleanup } = await makeStageRoot(repoRoot);
   try {
-    const results = await importNativeToCanonical(stageRoot, target12);
+    const results = await importNativeToCanonical(stageRoot, target13);
     return { stageRoot, results, cleanup };
   } catch (error) {
     await cleanup();
     throw error;
   }
 }
-async function stageNativeInstallScope(repoRoot, pathInRepoPosix, target12) {
-  const staged = await stageImportedNativeRepo(repoRoot, target12);
+async function stageNativeInstallScope(repoRoot, pathInRepoPosix, target13) {
+  const staged = await stageImportedNativeRepo(repoRoot, target13);
   try {
     return {
       stageRoot: staged.stageRoot,
       cleanup: staged.cleanup,
-      ...scopeImportedResults(pathInRepoPosix, staged.stageRoot, staged.results, target12)
+      ...scopeImportedResults(pathInRepoPosix, staged.stageRoot, staged.results, target13)
     };
   } catch (error) {
     await staged.cleanup();
@@ -12684,7 +13229,7 @@ async function prepareInstallDiscovery(repoRoot, contentRoot, pathInRepo, option
   }
   const posixPath = pathInRepo.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
   validateTargetMatchesPath(explicitTarget, posixPath);
-  const agentsmeshAtRoot = join73(repoRoot, ".agentsmesh");
+  const agentsmeshAtRoot = join75(repoRoot, ".agentsmesh");
   const hasAbRoot = await exists(agentsmeshAtRoot);
   const pathHint = posixPath ? targetHintFromNativePath(posixPath) : void 0;
   const detectedTarget = !hasAbRoot && !explicitTarget ? await detectNativeFormat(repoRoot) ?? void 0 : void 0;
@@ -12709,7 +13254,7 @@ async function prepareInstallDiscovery(repoRoot, contentRoot, pathInRepo, option
     }
     const staged = await stageImportedNativeRepo(repoRoot, effectiveTarget);
     return {
-      discoveryRoot: posixPath ? join73(staged.stageRoot, posixPath) : staged.stageRoot,
+      discoveryRoot: posixPath ? join75(staged.stageRoot, posixPath) : staged.stageRoot,
       yamlTarget: effectiveTarget,
       importHappened: true,
       cleanup: staged.cleanup
@@ -12812,13 +13357,13 @@ function applyReplayInstallScope(narrowed, discoveredFeatures, replay) {
 }
 
 // src/install/manual/manual-install-persistence.ts
-import { basename as basename40, dirname as dirname27, join as join74 } from "path";
+import { basename as basename41, dirname as dirname27, join as join76 } from "path";
 import { stat as stat6 } from "fs/promises";
 function trimDot(pathInRepo) {
   return pathInRepo === "." || pathInRepo === "" ? void 0 : pathInRepo;
 }
 function markdownPick(as, pathValue) {
-  const name = basename40(pathValue).replace(/\.md$/i, "");
+  const name = basename41(pathValue).replace(/\.md$/i, "");
   if (as === "agents") return { agents: [name] };
   if (as === "commands") return { commands: [name] };
   return { rules: [name] };
@@ -12836,23 +13381,23 @@ async function resolveManualInstallPersistence(args) {
     };
   }
   if (args.as === "skills") {
-    if (info.isFile() && basename40(args.contentRoot) === "SKILL.md") {
+    if (info.isFile() && basename41(args.contentRoot) === "SKILL.md") {
       const skillDir = normalizedPath ? dirname27(normalizedPath) : dirname27(args.contentRoot);
       return {
         pathInRepo: trimDot(dirname27(skillDir)),
-        pick: { skills: [basename40(skillDir)] }
+        pick: { skills: [basename41(skillDir)] }
       };
     }
     if (info.isDirectory()) {
-      const skillDir = normalizedPath || basename40(args.contentRoot);
-      const skillFile = join74(args.contentRoot.replace(/\/+$/g, ""), "SKILL.md");
+      const skillDir = normalizedPath || basename41(args.contentRoot);
+      const skillFile = join76(args.contentRoot.replace(/\/+$/g, ""), "SKILL.md");
       try {
         const skillStat = await stat6(skillFile);
         if (skillStat.isFile()) {
           const fmName = await readSkillFrontmatterName(skillFile);
           return {
             pathInRepo: trimDot(dirname27(skillDir)),
-            pick: { skills: [fmName || basename40(skillDir)] }
+            pick: { skills: [fmName || basename41(skillDir)] }
           };
         }
       } catch {
@@ -12920,7 +13465,7 @@ async function runInstall(flags, args, projectRoot, replay) {
     sourceArg
   );
   const pathInRepo = parsed.pathInRepo.replace(/^\/+|\/+$/g, "");
-  const contentRoot = pathInRepo ? join75(resolvedPath, pathInRepo) : resolvedPath;
+  const contentRoot = pathInRepo ? join77(resolvedPath, pathInRepo) : resolvedPath;
   if (!await exists(contentRoot)) {
     throw new Error(`Install path does not exist: ${contentRoot}`);
   }