npm - agentsmesh - Versions diffs - 0.5.0 → 0.6.0 - Mend

agentsmesh 0.5.0 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

package/CHANGELOG.md +65 -6
package/README.md +167 -78
package/dist/{canonical-types-gdrUi3bD.d.ts → canonical-types-CZwrJoBX.d.ts} +1 -1
package/dist/canonical.d.ts +3 -2
package/dist/canonical.js +59 -70
package/dist/canonical.js.map +1 -1
package/dist/cli.js +453 -17020
package/dist/engine.d.ts +186 -5
package/dist/engine.js +1673 -882
package/dist/engine.js.map +1 -1
package/dist/index.d.ts +6 -0
package/dist/index.js +12312 -0
package/dist/index.js.map +1 -0
package/dist/{target-descriptor-D64xD0C2.d.ts → target-descriptor-DjHhww11.d.ts} +30 -9
package/dist/targets.d.ts +4 -3
package/dist/targets.js +572 -775
package/dist/targets.js.map +1 -1
package/package.json +17 -3
package/schemas/agentsmesh.json +122 -8
package/dist/cli.js.map +0 -1

package/dist/targets.js CHANGED Viewed

@@ -1,3 +1,10 @@
+import { stringify, parse } from 'yaml';
+import { join, basename, relative, normalize, dirname, extname, win32, isAbsolute, posix } from 'path';
+import { readFile, mkdir, lstat, writeFile, rename, rm, readdir, stat, realpath, access } from 'fs/promises';
+import { realpathSync, existsSync, constants, statSync } from 'fs';
+import { parse as parse$1 } from 'smol-toml';
+import { Buffer } from 'buffer';
 // src/config/core/conversions.ts
 var DEFAULT_COMMANDS_TO_SKILLS = {
   "codex-cli": true
@@ -10,22 +17,30 @@ var DEFAULT_AGENTS_TO_SKILLS = {
   // native .codex/agents/*.toml per agent-structures
   windsurf: true
 };
-function hasOwnTarget(map, target13) {
-  return Object.prototype.hasOwnProperty.call(map, target13);
-}
 function usesCommandSkillProjection(target13) {
-  return hasOwnTarget(DEFAULT_COMMANDS_TO_SKILLS, target13);
+  return Object.prototype.hasOwnProperty.call(DEFAULT_COMMANDS_TO_SKILLS, target13);
 }
 function usesAgentSkillProjection(target13) {
-  return hasOwnTarget(DEFAULT_AGENTS_TO_SKILLS, target13);
+  return Object.prototype.hasOwnProperty.call(DEFAULT_AGENTS_TO_SKILLS, target13);
+}
+function resolveConversionValue(value, scope) {
+  if (value === void 0) return void 0;
+  if (typeof value === "boolean") return value;
+  return value[scope];
 }
-function shouldConvertCommandsToSkills(config, target13) {
-  if (!usesCommandSkillProjection(target13)) return false;
-  return config.conversions?.commands_to_skills?.[target13] ?? DEFAULT_COMMANDS_TO_SKILLS[target13];
+function shouldConvertCommandsToSkills(config, target13, defaultEnabled, scope = "project") {
+  const raw = config.conversions?.commands_to_skills?.[target13];
+  const configVal = resolveConversionValue(raw, scope);
+  if (configVal !== void 0) return configVal;
+  if (usesCommandSkillProjection(target13)) return DEFAULT_COMMANDS_TO_SKILLS[target13];
+  return defaultEnabled ?? false;
 }
-function shouldConvertAgentsToSkills(config, target13) {
-  if (!usesAgentSkillProjection(target13)) return false;
-  return config.conversions?.agents_to_skills?.[target13] ?? DEFAULT_AGENTS_TO_SKILLS[target13];
+function shouldConvertAgentsToSkills(config, target13, defaultEnabled, scope = "project") {
+  const raw = config.conversions?.agents_to_skills?.[target13];
+  const configVal = resolveConversionValue(raw, scope);
+  if (configVal !== void 0) return configVal;
+  if (usesAgentSkillProjection(target13)) return DEFAULT_AGENTS_TO_SKILLS[target13];
+  return defaultEnabled ?? false;
 }
 // src/targets/catalog/capabilities.ts
@@ -52,6 +67,61 @@ function normalizeTargetCapabilities(caps) {
   };
 }
+// src/targets/catalog/registry.ts
+var descriptorRegistry = /* @__PURE__ */ new Map();
+var _builtinDescriptors;
+function builtinDescriptors() {
+  if (!_builtinDescriptors) {
+    _builtinDescriptors = new Map(BUILTIN_TARGETS.map((d) => [d.id, d]));
+  }
+  return _builtinDescriptors;
+}
+function registerTargetDescriptor(descriptor13) {
+  descriptorRegistry.set(descriptor13.id, descriptor13);
+}
+function getDescriptor(name) {
+  return descriptorRegistry.get(name) ?? builtinDescriptors().get(name);
+}
+function getAllDescriptors() {
+  return [...descriptorRegistry.values()];
+}
+// src/targets/catalog/shared-artifact-owner.ts
+function findSharedArtifactOwnershipConflicts(descriptors) {
+  const owners = [];
+  for (const descriptor13 of descriptors) {
+    if (!descriptor13.sharedArtifacts) continue;
+    for (const [prefix, role] of Object.entries(descriptor13.sharedArtifacts)) {
+      if (role !== "owner") continue;
+      owners.push({ targetId: descriptor13.id, prefix });
+    }
+  }
+  const conflicts = [];
+  for (let i = 0; i < owners.length; i++) {
+    for (let j = i + 1; j < owners.length; j++) {
+      const a = owners[i];
+      const b = owners[j];
+      if (a === void 0 || b === void 0) continue;
+      if (a.prefix === b.prefix || a.prefix.startsWith(b.prefix) || b.prefix.startsWith(a.prefix)) {
+        conflicts.push({ a, b });
+      }
+    }
+  }
+  return conflicts;
+}
+function assertSharedArtifactOwnersUnique(descriptors) {
+  const conflicts = findSharedArtifactOwnershipConflicts(descriptors);
+  if (conflicts.length === 0) return;
+  const lines = conflicts.map(
+    ({ a, b }) => `  - "${a.targetId}" owns "${a.prefix}" and "${b.targetId}" owns "${b.prefix}"`
+  );
+  throw new Error(
+    `Shared-artifact ownership conflict: two targets claim the same or overlapping prefix.
+` + lines.join("\n") + `
+Resolve by changing one target's role to 'consumer' or by namespacing its prefix.`
+  );
+}
 // src/targets/catalog/target-ids.ts
 var TARGET_IDS = [
   "claude-code",
@@ -67,9 +137,6 @@ var TARGET_IDS = [
   "antigravity",
   "roo-code"
 ];
-// src/utils/text/markdown.ts
-import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 function parseFrontmatter(content) {
   const open = content.indexOf("---");
   if (open !== 0) {
@@ -81,13 +148,13 @@ function parseFrontmatter(content) {
   }
   const yamlStr = content.slice(3, close).trim();
   const body = content.slice(close + 3).trim();
-  const frontmatter = yamlStr === "" ? {} : yamlParse(yamlStr) ?? {};
+  const frontmatter = yamlStr === "" ? {} : parse(yamlStr) ?? {};
   return { frontmatter, body };
 }
 function serializeFrontmatter(frontmatter, body) {
   const keys = Object.keys(frontmatter);
   if (keys.length === 0) return body;
-  const yamlStr = yamlStringify(frontmatter, { lineWidth: 0 }).trimEnd();
+  const yamlStr = stringify(frontmatter, { lineWidth: 0 }).trimEnd();
   return `---
 ${yamlStr}
 ---
@@ -308,27 +375,27 @@ ${body}
 `;
 }
-// src/targets/claude-code/global-extras.ts
-import { join as join2 } from "path";
+// src/core/errors.ts
+var AgentsMeshError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "AgentsMeshError";
+    this.code = code;
+  }
+};
+var FileSystemError = class extends AgentsMeshError {
+  path;
+  errnoCode;
+  constructor(path, message, options) {
+    super("AM_FILESYSTEM", message, options);
+    this.name = "FileSystemError";
+    this.path = path;
+    this.errnoCode = options?.errnoCode;
+  }
+};
 // src/utils/filesystem/fs.ts
-import {
-  readFile,
-  writeFile,
-  access,
-  mkdir,
-  rename,
-  readdir,
-  copyFile,
-  stat,
-  symlink,
-  unlink,
-  lstat,
-  readlink,
-  realpath
-} from "fs/promises";
-import { dirname, join, resolve } from "path";
-import { constants } from "fs";
 var UTF8_BOM = "\uFEFF";
 async function readFileSafe(path) {
   try {
@@ -337,24 +404,43 @@ async function readFileSafe(path) {
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") return null;
-    throw new Error(
+    throw new FileSystemError(
+      path,
       `Failed to read ${path}: ${e.message}. Ensure the file exists and is readable.`,
-      { cause: err }
+      { cause: err, errnoCode: e.code }
     );
   }
 }
 async function writeFileAtomic(path, content) {
   const dir = dirname(path);
   await mkdir(dir, { recursive: true });
+  try {
+    const info = await lstat(path);
+    if (info.isDirectory()) {
+      throw new FileSystemError(
+        path,
+        `Failed to write ${path}: target exists and is a directory. Remove it or choose a different path.`,
+        { errnoCode: "EISDIR" }
+      );
+    }
+  } catch (err) {
+    if (err instanceof FileSystemError) throw err;
+    const e = err;
+    if (e.code !== "ENOENT") throw err;
+  }
   const tmpPath = `${path}.tmp`;
   try {
     await writeFile(tmpPath, content, "utf-8");
     await rename(tmpPath, path);
   } catch (err) {
-    const e = err;
-    throw new Error(`Failed to write ${path}: ${e.message}. Check permissions and disk space.`, {
-      cause: err
+    await rm(tmpPath, { force: true }).catch(() => {
     });
+    const e = err;
+    throw new FileSystemError(
+      path,
+      `Failed to write ${path}: ${e.message}. Check permissions and disk space.`,
+      { cause: err, errnoCode: e.code }
+    );
   }
 }
 async function exists(path) {
@@ -375,9 +461,11 @@ async function readDirRecursive(dir, visited) {
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT" || e.code === "ENOTDIR" || e.code === "ELOOP") return [];
-    throw new Error(`Failed to read directory ${dir}: ${e.message}. Check permissions.`, {
-      cause: err
-    });
+    throw new FileSystemError(
+      dir,
+      `Failed to read directory ${dir}: ${e.message}. Check permissions.`,
+      { cause: err, errnoCode: e.code }
+    );
   }
   const seen = visited ?? /* @__PURE__ */ new Set();
   if (seen.has(canonicalDir)) return [];
@@ -401,9 +489,11 @@ async function readDirRecursive(dir, visited) {
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT" || e.code === "ENOTDIR" || e.code === "EACCES") return [];
-    throw new Error(`Failed to read directory ${dir}: ${e.message}. Check permissions.`, {
-      cause: err
-    });
+    throw new FileSystemError(
+      dir,
+      `Failed to read directory ${dir}: ${e.message}. Check permissions.`,
+      { cause: err, errnoCode: e.code }
+    );
   }
 }
@@ -425,7 +515,7 @@ async function generateClaudeGlobalExtras(canonical, projectRoot, scope, enabled
       const fm = { name: agent.name, description: agent.description || void 0 };
       const content = serializeFrontmatter(fm, agent.body.trim());
       const path = `${CLAUDE_OUTPUT_STYLES_DIR}/${agent.name}.md`;
-      const existing = await readFileSafe(join2(projectRoot, path));
+      const existing = await readFileSafe(join(projectRoot, path));
       results.push({
         target: "claude-code",
         path,
@@ -441,7 +531,7 @@ async function generateClaudeGlobalExtras(canonical, projectRoot, scope, enabled
       const fm = { name: cmd.name, description: cmd.description || void 0 };
       const content = serializeFrontmatter(fm, cmd.body.trim());
       const path = `${CLAUDE_OUTPUT_STYLES_DIR}/${cmd.name}.md`;
-      const existing = await readFileSafe(join2(projectRoot, path));
+      const existing = await readFileSafe(join(projectRoot, path));
       results.push({
         target: "claude-code",
         path,
@@ -454,14 +544,6 @@ async function generateClaudeGlobalExtras(canonical, projectRoot, scope, enabled
   return results;
 }
-// src/targets/claude-code/importer.ts
-import { dirname as dirname7, join as join8 } from "path";
-// src/core/reference/import-rewriter.ts
-import { existsSync as existsSync2, realpathSync as realpathSync2, statSync } from "fs";
-import { join as join3 } from "path";
-import { normalize as normalizePath } from "path";
 // src/core/reference/import-map.ts
 async function buildImportReferenceMap(target13, projectRoot, scope = "project") {
   const refs = /* @__PURE__ */ new Map();
@@ -471,9 +553,6 @@ async function buildImportReferenceMap(target13, projectRoot, scope = "project")
   }
   return refs;
 }
-// src/core/path-helpers.ts
-import { posix, win32 } from "path";
 var WINDOWS_ABSOLUTE_PATH = /^[A-Za-z]:[\\/]/;
 var TRAILING_PUNCTUATION = /[.!?:;]+$/;
 function pathApi(projectRoot) {
@@ -506,10 +585,6 @@ function rootFallbackPath(token, projectRoot) {
   const stripped = token.replace(/^(\.\.\/)+/, "").replace(/^\.\//, "");
   return stripped && stripped !== token ? normalizeForProject(projectRoot, api.join(projectRoot, stripped)) : null;
 }
-// src/core/reference/link-rebaser-helpers.ts
-import { existsSync, realpathSync } from "fs";
-import { isAbsolute, win32 as win322 } from "path";
 var ROOT_RELATIVE_PREFIXES = [
   ".agentsmesh/",
   ".claude/",
@@ -572,7 +647,7 @@ function resolveProjectPath(token, projectRoot, sourceFile) {
   const normalizedToken = normalizeSeparators(token);
   if (WINDOWS_ABSOLUTE_PATH.test(token)) {
     const windowsToken = normalizeForProject(projectRoot, token);
-    if (api === win322 || windowsToken.startsWith(`${normalizedProjectRoot}${api.sep}`)) {
+    if (api === win32 || windowsToken.startsWith(`${normalizedProjectRoot}${api.sep}`)) {
       return [windowsToken];
     }
     return [windowsToken];
@@ -662,9 +737,6 @@ function protectedRanges(content) {
   }
   return ranges;
 }
-// src/core/reference/link-rebaser-formatting.ts
-import { dirname as dirname2 } from "path";
 function isReadingContext(context) {
   return context === void 0 || context.role === "inline-code" || context.role === "bracketed" || context.role === "quoted" || context.role === "at-prefix" || context.role === "bracket-label" || context.role === "bare-prose";
 }
@@ -725,7 +797,7 @@ function formatLinkPathForDestinationLegacy(projectRoot, destinationFile, absolu
   if (!isUnderProjectRoot(projectRoot, target13)) {
     return toProjectRootReference(projectRoot, target13, keepSlash)?.text ?? null;
   }
-  const destDir = normalizeForProject(projectRoot, dirname2(destFile));
+  const destDir = normalizeForProject(projectRoot, dirname(destFile));
   if (!isUnderProjectRoot(projectRoot, destDir) && destDir !== root) {
     return toProjectRootReference(projectRoot, target13, keepSlash)?.text ?? null;
   }
@@ -1089,12 +1161,12 @@ function rewriteFileLinks(input) {
 // src/core/reference/import-rewriter.ts
 function pathVariants(path) {
-  const variants = [normalizePath(path)];
-  if (!existsSync2(path)) return variants;
+  const variants = [normalize(path)];
+  if (!existsSync(path)) return variants;
   try {
-    const realPaths = [realpathSync2(path), realpathSync2.native(path)];
+    const realPaths = [realpathSync(path), realpathSync.native(path)];
     for (const realPath of realPaths) {
-      const normalized = normalizePath(realPath);
+      const normalized = normalize(realPath);
       if (!variants.includes(normalized)) variants.push(normalized);
     }
   } catch {
@@ -1112,17 +1184,17 @@ async function createImportReferenceNormalizer(target13, projectRoot, scope = "p
   }
   const artifactMap = /* @__PURE__ */ new Map();
   for (const [targetPath, canonicalPath] of refs.entries()) {
-    const canonicalAbsPath = normalizePath(join3(projectRoot, canonicalPath));
-    for (const variant of pathVariants(join3(projectRoot, targetPath))) {
+    const canonicalAbsPath = normalize(join(projectRoot, canonicalPath));
+    for (const variant of pathVariants(join(projectRoot, targetPath))) {
       artifactMap.set(variant, canonicalAbsPath);
     }
   }
   const canonicalDestAbs = /* @__PURE__ */ new Set();
   for (const canonicalPath of new Set(refs.values())) {
-    const abs = normalizePath(join3(projectRoot, canonicalPath));
+    const abs = normalize(join(projectRoot, canonicalPath));
     canonicalDestAbs.add(abs);
     for (const variant of pathVariants(abs)) {
-      canonicalDestAbs.add(normalizePath(variant));
+      canonicalDestAbs.add(normalize(variant));
     }
   }
   return (content, sourceFile, destinationFile) => rewriteFileLinks({
@@ -1132,8 +1204,8 @@ async function createImportReferenceNormalizer(target13, projectRoot, scope = "p
     destinationFile,
     translatePath: (absolutePath) => artifactMap.get(absolutePath) ?? absolutePath,
     pathExists: (absolutePath) => {
-      const normalized = normalizePath(absolutePath);
-      return artifactMap.has(absolutePath) || artifactMap.has(normalized) || existsSync2(absolutePath) || canonicalDestAbs.has(normalized);
+      const normalized = normalize(absolutePath);
+      return artifactMap.has(absolutePath) || artifactMap.has(normalized) || existsSync(absolutePath) || canonicalDestAbs.has(normalized);
     },
     explicitCurrentDirLinks: false,
     rewriteBarePathTokens: true,
@@ -1147,12 +1219,6 @@ async function createImportReferenceNormalizer(target13, projectRoot, scope = "p
     }
   }).content;
 }
-// src/targets/import/import-metadata-core.ts
-import { basename as basename2 } from "path";
-// src/targets/projection/managed-blocks.ts
-import { basename, join as join4 } from "path";
 var ROOT_CONTRACT_START = "<!-- agentsmesh:root-generation-contract:start -->";
 var ROOT_CONTRACT_END = "<!-- agentsmesh:root-generation-contract:end -->";
 var EMBEDDED_RULES_START = "<!-- agentsmesh:embedded-rules:start -->";
@@ -1174,7 +1240,7 @@ function ruleSource(source) {
   const meshIndex = normalized.lastIndexOf(".agentsmesh/");
   if (meshIndex >= 0) return normalized.slice(meshIndex + ".agentsmesh/".length);
   if (normalized.startsWith("rules/")) return normalized;
-  return join4("rules", basename(normalized)).replace(/\\/g, "/");
+  return join("rules", basename(normalized)).replace(/\\/g, "/");
 }
 function markerForRule(rule) {
   return {
@@ -1346,7 +1412,7 @@ function pruneUndefined(frontmatter) {
   return Object.fromEntries(Object.entries(frontmatter).filter(([, value]) => value !== void 0));
 }
 function serializeCanonicalRuleFrontmatter(destinationPath, frontmatter) {
-  const isRootRule = basename2(destinationPath, ".md") === "_root";
+  const isRootRule = basename(destinationPath, ".md") === "_root";
   const rest = { ...frontmatter };
   delete rest.root;
   return {
@@ -1356,7 +1422,7 @@ function serializeCanonicalRuleFrontmatter(destinationPath, frontmatter) {
 }
 async function serializeImportedRuleWithFallback(destinationPath, importedFrontmatter, body) {
   const existingFrontmatter = await readExistingFrontmatter(destinationPath);
-  const normalizedBody = basename2(destinationPath, ".md") === "_root" ? stripAgentsmeshRootInstructionParagraph(body) : body.trim();
+  const normalizedBody = basename(destinationPath, ".md") === "_root" ? stripAgentsmeshRootInstructionParagraph(body) : body.trim();
   const mergedFrontmatter = serializeCanonicalRuleFrontmatter(
     destinationPath,
     pruneUndefined({ ...existingFrontmatter, ...importedFrontmatter })
@@ -1374,9 +1440,6 @@ async function serializeImportedRuleWithFallback(destinationPath, importedFrontm
   }
   return serializeFrontmatter(canonicalFrontmatter, normalizedBody || "");
 }
-// src/targets/import/import-metadata-serialize.ts
-import { basename as basename3, dirname as dirname3 } from "path";
 async function serializeImportedCommandWithFallback(destinationPath, imported, body) {
   const existingFrontmatter = await readExistingFrontmatter(destinationPath);
   const existingAllowedTools = (() => {
@@ -1395,7 +1458,7 @@ async function serializeImportedCommandWithFallback(destinationPath, imported, b
 }
 async function serializeImportedSkillWithFallback(destinationPath, importedFrontmatter, body) {
   const existingFrontmatter = await readExistingFrontmatter(destinationPath);
-  const derivedName = basename3(dirname3(destinationPath));
+  const derivedName = basename(dirname(destinationPath));
   const name = readString(importedFrontmatter, "name") ?? readString(existingFrontmatter, "name") ?? derivedName;
   const description = readString(importedFrontmatter, "description") ?? readString(existingFrontmatter, "description") ?? "";
   return serializeFrontmatter({ name, description }, body.trim() || "");
@@ -1416,7 +1479,7 @@ async function serializeImportedAgentWithFallback(destinationPath, importedFront
   const maxTurns = typeof maxTurnsRaw === "number" ? maxTurnsRaw : Number(maxTurnsRaw ?? 0);
   const hooks = readHooks(importedFrontmatter) ?? readHooks(existingFrontmatter);
   const frontmatter = {
-    name: readString(importedFrontmatter, "name") ?? readString(existingFrontmatter, "name") ?? basename3(destinationPath, ".md"),
+    name: readString(importedFrontmatter, "name") ?? readString(existingFrontmatter, "name") ?? basename(destinationPath, ".md"),
     description: readString(importedFrontmatter, "description") ?? readString(existingFrontmatter, "description") ?? "",
     tools
   };
@@ -1433,9 +1496,6 @@ async function serializeImportedAgentWithFallback(destinationPath, importedFront
   if (memory) frontmatter.memory = memory;
   return serializeFrontmatter(frontmatter, body.trim() || "");
 }
-// src/targets/import/import-orchestrator.ts
-import { dirname as dirname4, relative } from "path";
 function matchesExtension(path, extensions) {
   return extensions.some((extension) => path.endsWith(extension));
 }
@@ -1454,7 +1514,7 @@ async function importFileDirectory(opts) {
       normalizeTo: (destinationFile, sourceContent = content) => opts.normalize(sourceContent, srcPath, destinationFile)
     });
     if (!mapping) continue;
-    await mkdirp(dirname4(mapping.destPath));
+    await mkdirp(dirname(mapping.destPath));
     await writeFileAtomic(mapping.destPath, mapping.content);
     results.push({
       fromTool: opts.fromTool,
@@ -1466,9 +1526,6 @@ async function importFileDirectory(opts) {
   return results;
 }
-// src/targets/claude-code/importer-mappers.ts
-import { join as join5 } from "path";
 // src/targets/import/shared-import-helpers.ts
 function toGlobsArray(v) {
   if (Array.isArray(v)) return v.filter((x) => typeof x === "string");
@@ -1498,7 +1555,7 @@ function toStringRecord(value) {
 // src/targets/claude-code/importer-mappers.ts
 async function mapClaudeRuleFile(relativePath, destDir, normalizeTo) {
-  const destPath = join5(destDir, relativePath);
+  const destPath = join(destDir, relativePath);
   const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
   return {
     destPath,
@@ -1512,7 +1569,7 @@ async function mapClaudeRuleFile(relativePath, destDir, normalizeTo) {
   };
 }
 async function mapClaudeMarkdownFile(relativePath, destDir, feature, normalizeTo) {
-  const destPath = join5(destDir, relativePath);
+  const destPath = join(destDir, relativePath);
   const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
   const basePath = feature === "commands" ? CLAUDE_CANONICAL_COMMANDS_DIR : CLAUDE_CANONICAL_AGENTS_DIR;
   return {
@@ -1534,10 +1591,6 @@ async function mapClaudeMarkdownFile(relativePath, destDir, feature, normalizeTo
     ) : await serializeImportedAgentWithFallback(destPath, frontmatter, body)
   };
 }
-// src/targets/claude-code/settings-helpers.ts
-import { join as join6, dirname as dirname5 } from "path";
-import { stringify as yamlStringify2 } from "yaml";
 function claudeHooksToCanonical(hooks) {
   const result = {};
   for (const [event, entries] of Object.entries(hooks)) {
@@ -1563,7 +1616,7 @@ function claudeHooksToCanonical(hooks) {
   return result;
 }
 async function importClaudeHooksJson(projectRoot, results) {
-  const hooksPath = join6(projectRoot, CLAUDE_HOOKS_JSON);
+  const hooksPath = join(projectRoot, CLAUDE_HOOKS_JSON);
   const content = await readFileSafe(hooksPath);
   if (content === null) return false;
   let parsed;
@@ -1575,9 +1628,9 @@ async function importClaudeHooksJson(projectRoot, results) {
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
   const canonicalHooks = claudeHooksToCanonical(parsed);
   if (Object.keys(canonicalHooks).length === 0) return false;
-  const hooksContent = yamlStringify2(canonicalHooks);
-  const destPath = join6(projectRoot, CLAUDE_CANONICAL_HOOKS);
-  await mkdirp(dirname5(destPath));
+  const hooksContent = stringify(canonicalHooks);
+  const destPath = join(projectRoot, CLAUDE_CANONICAL_HOOKS);
+  await mkdirp(dirname(destPath));
   await writeFileAtomic(destPath, hooksContent);
   results.push({
     fromTool: "claude-code",
@@ -1588,7 +1641,7 @@ async function importClaudeHooksJson(projectRoot, results) {
   return true;
 }
 async function importMcpJson(projectRoot, results, scope = "project") {
-  const mcpPath = join6(projectRoot, scope === "global" ? CLAUDE_GLOBAL_MCP_JSON : CLAUDE_MCP_JSON);
+  const mcpPath = join(projectRoot, scope === "global" ? CLAUDE_GLOBAL_MCP_JSON : CLAUDE_MCP_JSON);
   const content = await readFileSafe(mcpPath);
   if (content === null) return;
   let parsed;
@@ -1599,8 +1652,8 @@ async function importMcpJson(projectRoot, results, scope = "project") {
   }
   if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
     const mcpContent = JSON.stringify({ mcpServers: parsed.mcpServers }, null, 2);
-    const destPath = join6(projectRoot, CLAUDE_CANONICAL_MCP);
-    await mkdirp(dirname5(destPath));
+    const destPath = join(projectRoot, CLAUDE_CANONICAL_MCP);
+    await mkdirp(dirname(destPath));
     await writeFileAtomic(destPath, mcpContent);
     results.push({
       fromTool: "claude-code",
@@ -1614,7 +1667,7 @@ async function importSettings(projectRoot, results) {
   const hooksFromStandaloneFile = results.some(
     (r) => r.feature === "hooks" && r.fromPath.replace(/\\/g, "/").endsWith(CLAUDE_HOOKS_JSON)
   );
-  const settingsPath = join6(projectRoot, CLAUDE_SETTINGS);
+  const settingsPath = join(projectRoot, CLAUDE_SETTINGS);
   const content = await readFileSafe(settingsPath);
   if (!content) return;
   let settings;
@@ -1626,8 +1679,8 @@ async function importSettings(projectRoot, results) {
   const alreadyImportedMcp = results.some((r) => r.feature === "mcp");
   if (!alreadyImportedMcp && settings.mcpServers && typeof settings.mcpServers === "object") {
     const mcpContent = JSON.stringify({ mcpServers: settings.mcpServers }, null, 2);
-    const destPath = join6(projectRoot, CLAUDE_CANONICAL_MCP);
-    await mkdirp(dirname5(destPath));
+    const destPath = join(projectRoot, CLAUDE_CANONICAL_MCP);
+    await mkdirp(dirname(destPath));
     await writeFileAtomic(destPath, mcpContent);
     results.push({
       fromTool: "claude-code",
@@ -1643,9 +1696,9 @@ async function importSettings(projectRoot, results) {
     const deny = Array.isArray(perms.deny) ? perms.deny.filter((s) => typeof s === "string") : [];
     const ask = Array.isArray(perms.ask) ? perms.ask.filter((s) => typeof s === "string") : [];
     if (allow.length > 0 || deny.length > 0 || ask.length > 0) {
-      const permContent = yamlStringify2({ allow, deny, ask });
-      const destPath = join6(projectRoot, CLAUDE_CANONICAL_PERMISSIONS);
-      await mkdirp(dirname5(destPath));
+      const permContent = stringify({ allow, deny, ask });
+      const destPath = join(projectRoot, CLAUDE_CANONICAL_PERMISSIONS);
+      await mkdirp(dirname(destPath));
       await writeFileAtomic(destPath, permContent);
       results.push({
         fromTool: "claude-code",
@@ -1659,9 +1712,9 @@ async function importSettings(projectRoot, results) {
   if (!hooksFromStandaloneFile && rawHooks && typeof rawHooks === "object" && !Array.isArray(rawHooks)) {
     const canonicalHooks = claudeHooksToCanonical(rawHooks);
     if (Object.keys(canonicalHooks).length > 0) {
-      const hooksContent = yamlStringify2(canonicalHooks);
-      const destPath = join6(projectRoot, CLAUDE_CANONICAL_HOOKS);
-      await mkdirp(dirname5(destPath));
+      const hooksContent = stringify(canonicalHooks);
+      const destPath = join(projectRoot, CLAUDE_CANONICAL_HOOKS);
+      await mkdirp(dirname(destPath));
       await writeFileAtomic(destPath, hooksContent);
       results.push({
         fromTool: "claude-code",
@@ -1672,25 +1725,22 @@ async function importSettings(projectRoot, results) {
     }
   }
 }
-// src/targets/claude-code/importer-skills.ts
-import { basename as basename4, dirname as dirname6, join as join7, relative as relative2 } from "path";
 async function importClaudeSkills(projectRoot, results, normalize) {
-  const skillsBaseDir = join7(projectRoot, CLAUDE_SKILLS_DIR);
-  const destBase = join7(projectRoot, CLAUDE_CANONICAL_SKILLS_DIR);
+  const skillsBaseDir = join(projectRoot, CLAUDE_SKILLS_DIR);
+  const destBase = join(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 = dirname6(skillMdPath);
-    const skillName = basename4(skillDir);
-    const destSkillDir = join7(destBase, skillName);
+    const skillDir = dirname(skillMdPath);
+    const skillName = basename(skillDir);
+    const destSkillDir = join(destBase, skillName);
     const skillFiles = await readDirRecursive(skillDir);
     for (const filePath of skillFiles) {
       const fileContent = await readFileSafe(filePath);
       if (fileContent === null) continue;
-      const relPath = relative2(skillDir, filePath);
-      const destPath = join7(destSkillDir, relPath);
-      await mkdirp(dirname6(destPath));
+      const relPath = relative(skillDir, filePath);
+      const destPath = join(destSkillDir, relPath);
+      await mkdirp(dirname(destPath));
       const normalized = normalize(fileContent, filePath, destPath);
       const parsed = relPath === "SKILL.md" ? parseFrontmatter(normalized) : null;
       await writeFileAtomic(
@@ -1728,16 +1778,16 @@ async function importFromClaudeCode(projectRoot, options = {}) {
   return results;
 }
 async function importRules(projectRoot, results, normalize, scope) {
-  const destDir = join8(projectRoot, CLAUDE_CANONICAL_RULES_DIR);
-  const primaryClaudePath = join8(projectRoot, CLAUDE_ROOT);
+  const destDir = join(projectRoot, CLAUDE_CANONICAL_RULES_DIR);
+  const primaryClaudePath = join(projectRoot, CLAUDE_ROOT);
   const primaryContent = await readFileSafe(primaryClaudePath);
-  const legacyClaudePath = join8(projectRoot, CLAUDE_LEGACY_ROOT);
+  const legacyClaudePath = join(projectRoot, CLAUDE_LEGACY_ROOT);
   const legacyContent = scope === "project" && primaryContent === null ? await readFileSafe(legacyClaudePath) : null;
   const claudeContent = primaryContent ?? legacyContent;
   const claudePath = primaryContent !== null ? primaryClaudePath : legacyClaudePath;
   if (claudeContent !== null) {
     await mkdirp(destDir);
-    const destPath = join8(destDir, "_root.md");
+    const destPath = join(destDir, "_root.md");
     const { frontmatter, body } = parseFrontmatter(normalize(claudeContent, claudePath, destPath));
     const hasRoot = frontmatter.root === true;
     const outFm = hasRoot ? frontmatter : { ...frontmatter, root: true };
@@ -1750,7 +1800,7 @@ async function importRules(projectRoot, results, normalize, scope) {
       feature: "rules"
     });
   }
-  const rulesDir = join8(projectRoot, CLAUDE_RULES_DIR);
+  const rulesDir = join(projectRoot, CLAUDE_RULES_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: rulesDir,
@@ -1763,8 +1813,8 @@ async function importRules(projectRoot, results, normalize, scope) {
   );
 }
 async function importCommands(projectRoot, results, normalize) {
-  const destDir = join8(projectRoot, CLAUDE_CANONICAL_COMMANDS_DIR);
-  const commandsDir = join8(projectRoot, CLAUDE_COMMANDS_DIR);
+  const destDir = join(projectRoot, CLAUDE_CANONICAL_COMMANDS_DIR);
+  const commandsDir = join(projectRoot, CLAUDE_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: commandsDir,
@@ -1777,8 +1827,8 @@ async function importCommands(projectRoot, results, normalize) {
   );
 }
 async function importAgents(projectRoot, results, normalize) {
-  const destDir = join8(projectRoot, CLAUDE_CANONICAL_AGENTS_DIR);
-  const agentsDir = join8(projectRoot, CLAUDE_AGENTS_DIR);
+  const destDir = join(projectRoot, CLAUDE_CANONICAL_AGENTS_DIR);
+  const agentsDir = join(projectRoot, CLAUDE_AGENTS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: agentsDir,
@@ -1791,11 +1841,11 @@ async function importAgents(projectRoot, results, normalize) {
   );
 }
 async function importIgnore(projectRoot, results) {
-  const ignorePath = join8(projectRoot, CLAUDE_IGNORE);
+  const ignorePath = join(projectRoot, CLAUDE_IGNORE);
   const content = await readFileSafe(ignorePath);
   if (content === null) return;
-  const destPath = join8(projectRoot, CLAUDE_CANONICAL_IGNORE);
-  await mkdirp(dirname7(destPath));
+  const destPath = join(projectRoot, CLAUDE_CANONICAL_IGNORE);
+  await mkdirp(dirname(destPath));
   await writeFileAtomic(destPath, content);
   results.push({
     fromTool: "claude-code",
@@ -1805,9 +1855,6 @@ async function importIgnore(projectRoot, results) {
   });
 }
-// src/core/lint/validate-rules.ts
-import { relative as relative3 } from "path";
 // src/utils/text/glob.ts
 function globMatch(filepath, pattern) {
   const alternatives = expandBraces(pattern);
@@ -1899,7 +1946,7 @@ function validateRules(canonical, projectRoot, projectFiles, options = {}) {
   if (!hasRoot) {
     diags.push({
       level: "error",
-      file: relative3(projectRoot, rules[0].source),
+      file: relative(projectRoot, rules[0].source),
       message: "Rules exist but no root rule (_root.md or root: true). Add a root rule."
     });
   }
@@ -1919,7 +1966,7 @@ function validateRules(canonical, projectRoot, projectFiles, options = {}) {
     if (!anyMatch) {
       diags.push({
         level: "warning",
-        file: relative3(projectRoot, rule.source),
+        file: relative(projectRoot, rule.source),
         message: `globs "${rule.globs.join(", ")}" match 0 files in project`
       });
     }
@@ -1935,9 +1982,6 @@ function lintRules(canonical, _projectRoot, projectFiles, options) {
   return diags.map((d) => ({ ...d, target: CLAUDE_CODE_TARGET }));
 }
-// src/core/reference/import-map-shared.ts
-import { basename as basename5, dirname as dirname8, join as join9, relative as relative4 } from "path";
 // src/targets/codex-cli/command-skill.ts
 var CODEX_COMMAND_SKILL_PREFIX = "am-command-";
 var LEGACY_CODEX_COMMAND_SKILL_PREFIX = "ab-command-";
@@ -2082,34 +2126,34 @@ var AB_COMMANDS = ".agentsmesh/commands";
 var AB_AGENTS = ".agentsmesh/agents";
 var AB_SKILLS = ".agentsmesh/skills";
 function rel(projectRoot, absPath) {
-  return relative4(projectRoot, absPath).replace(/\\/g, "/");
+  return relative(projectRoot, absPath).replace(/\\/g, "/");
 }
 async function listFiles(projectRoot, dir) {
-  return readDirRecursive(join9(projectRoot, dir)).catch(() => []);
+  return readDirRecursive(join(projectRoot, dir)).catch(() => []);
 }
 function addDirectoryMapping(refs, from, to) {
   refs.set(from, to);
   refs.set(`${from}/`, `${to}/`);
 }
 function addAncestorMappings(refs, fromPath, toPath, stopDir) {
-  let fromDir = dirname8(fromPath);
-  let toDir = dirname8(toPath);
+  let fromDir = dirname(fromPath);
+  let toDir = dirname(toPath);
   while (fromDir !== stopDir && fromDir !== ".") {
     addDirectoryMapping(refs, fromDir, toDir);
-    fromDir = dirname8(fromDir);
-    toDir = dirname8(toDir);
+    fromDir = dirname(fromDir);
+    toDir = dirname(toDir);
   }
 }
 function addSimpleFileMapping(refs, fromPath, canonicalDir, extension) {
-  refs.set(fromPath, `${canonicalDir}/${basename5(fromPath, extension)}.md`);
+  refs.set(fromPath, `${canonicalDir}/${basename(fromPath, extension)}.md`);
 }
 function addSkillLikeMapping(refs, relPath, skillsDir) {
   if (!relPath.startsWith(`${skillsDir}/`)) return;
   const rest = relPath.slice(skillsDir.length + 1);
   if (!rest) return;
   if (!rest.includes("/")) {
-    if (!rest.endsWith(".md") || basename5(rest) === "SKILL.md") return;
-    const name = basename5(rest, ".md");
+    if (!rest.endsWith(".md") || basename(rest) === "SKILL.md") return;
+    const name = basename(rest, ".md");
     refs.set(relPath, `${AB_SKILLS}/${name}/SKILL.md`);
     return;
   }
@@ -2155,7 +2199,7 @@ async function addScopedAgentsMappings(refs, projectRoot) {
     const isNestedAgents = relPath.endsWith("/AGENTS.md") && relPath !== "AGENTS.md" && !relPath.endsWith("/AGENTS.override.md");
     const isNestedOverride = relPath.endsWith("/AGENTS.override.md") && relPath !== "AGENTS.override.md";
     if (!isNestedAgents && !isNestedOverride) continue;
-    const parentDir = dirname8(relPath);
+    const parentDir = dirname(relPath);
     if (SCOPED_AGENTS_SKIP_DIRS.has(parentDir)) continue;
     const ruleName = parentDir.replace(/\//g, "-");
     refs.set(relPath, `${AB_RULES}/${ruleName}.md`);
@@ -2236,9 +2280,6 @@ async function buildClaudeCodeImportPaths(refs, projectRoot, scope = "project")
   }
 }
-// src/core/reference/import-maps/cline.ts
-import { basename as basename6 } from "path";
 // src/targets/cline/constants.ts
 var CLINE_TARGET = "cline";
 var CLINE_RULES_DIR = ".clinerules";
@@ -2278,7 +2319,7 @@ async function buildClineImportPaths(refs, projectRoot, scope = "project") {
   refs.set(".clinerules/_root.md", `${AB_RULES2}/_root.md`);
   for (const absPath of await listFiles(projectRoot, ".clinerules")) {
     const relPath = rel(projectRoot, absPath);
-    if (!relPath.endsWith(".md") || relPath.includes("/workflows/") || basename6(relPath) === "_root.md") {
+    if (!relPath.endsWith(".md") || relPath.includes("/workflows/") || basename(relPath) === "_root.md") {
       continue;
     }
     addSimpleFileMapping(refs, relPath, AB_RULES2, ".md");
@@ -2321,12 +2362,9 @@ async function buildCodexCliImportPaths(refs, projectRoot, scope = "project") {
     addSkillLikeMapping(refs, rel(projectRoot, absPath), ".agents/skills");
   }
 }
-// src/core/reference/import-maps/copilot.ts
-import { basename as basename7 } from "path";
 function addCopilotInstructionMapping(refs, fromPath) {
   if (fromPath.endsWith(".instructions.md")) {
-    refs.set(fromPath, `${AB_RULES2}/${basename7(fromPath, ".instructions.md")}.md`);
+    refs.set(fromPath, `${AB_RULES2}/${basename(fromPath, ".instructions.md")}.md`);
     return;
   }
   addSimpleFileMapping(refs, fromPath, AB_RULES2, ".md");
@@ -2334,25 +2372,22 @@ function addCopilotInstructionMapping(refs, fromPath) {
 async function buildCopilotImportPaths(refs, projectRoot) {
   refs.set(".github/copilot-instructions.md", `${AB_RULES2}/_root.md`);
   for (const absPath of await listFiles(projectRoot, ".github/copilot")) {
-    refs.set(rel(projectRoot, absPath), `${AB_RULES2}/${basename7(absPath, ".instructions.md")}.md`);
+    refs.set(rel(projectRoot, absPath), `${AB_RULES2}/${basename(absPath, ".instructions.md")}.md`);
   }
   for (const absPath of await listFiles(projectRoot, ".github/instructions")) {
     addCopilotInstructionMapping(refs, rel(projectRoot, absPath));
   }
   for (const absPath of await listFiles(projectRoot, ".github/prompts")) {
-    refs.set(rel(projectRoot, absPath), `${AB_COMMANDS2}/${basename7(absPath, ".prompt.md")}.md`);
+    refs.set(rel(projectRoot, absPath), `${AB_COMMANDS2}/${basename(absPath, ".prompt.md")}.md`);
   }
   for (const absPath of await listFiles(projectRoot, ".github/agents")) {
-    refs.set(rel(projectRoot, absPath), `${AB_AGENTS2}/${basename7(absPath, ".agent.md")}.md`);
+    refs.set(rel(projectRoot, absPath), `${AB_AGENTS2}/${basename(absPath, ".agent.md")}.md`);
   }
   for (const absPath of await listFiles(projectRoot, ".github/skills")) {
     addSkillLikeMapping(refs, rel(projectRoot, absPath), ".github/skills");
   }
 }
-// src/core/reference/import-maps/continue.ts
-import { basename as basename8 } from "path";
 // src/targets/continue/constants.ts
 var CONTINUE_TARGET = "continue";
 var CONTINUE_RULES_DIR = ".continue/rules";
@@ -2378,7 +2413,7 @@ async function buildContinueImportPaths(refs, projectRoot, scope = "project") {
     addSimpleFileMapping(refs, relPath, AB_RULES2, ".md");
   }
   for (const absPath of await listFiles(projectRoot, ".continue/prompts")) {
-    refs.set(rel(projectRoot, absPath), `${AB_COMMANDS2}/${basename8(absPath, ".md")}.md`);
+    refs.set(rel(projectRoot, absPath), `${AB_COMMANDS2}/${basename(absPath, ".md")}.md`);
   }
   for (const absPath of await listFiles(projectRoot, ".continue/skills")) {
     addSkillLikeMapping(refs, rel(projectRoot, absPath), ".continue/skills");
@@ -2534,7 +2569,6 @@ var KIRO_AGENTS_DIR = `${KIRO_DIR}/agents`;
 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_CLI_FILE = `${KIRO_SETTINGS_DIR}/cli.json`;
 var KIRO_IGNORE = ".kiroignore";
 var KIRO_GLOBAL_STEERING_DIR = ".kiro/steering";
 var KIRO_GLOBAL_STEERING_AGENTS_MD = ".kiro/steering/AGENTS.md";
@@ -2919,18 +2953,12 @@ function generateIgnore2(canonical) {
   const content = canonical.ignore.join("\n");
   return [{ path: CURSOR_IGNORE, content }];
 }
-// src/targets/cursor/importer.ts
-import { join as join18, dirname as dirname12 } from "path";
-// src/targets/cursor/importer-mappers.ts
-import { join as join10 } from "path";
 async function mapCursorRuleFile(relativePath, destDir, normalizeTo, onRootRule) {
   const rawRelativePath = relativePath.replace(/\.mdc$/i, ".md");
-  const rawDestPath = join10(destDir, rawRelativePath);
+  const rawDestPath = join(destDir, rawRelativePath);
   const initial = parseFrontmatter(normalizeTo(rawDestPath));
   const isRoot = initial.frontmatter.alwaysApply === true;
-  const destPath = isRoot ? join10(destDir, "_root.md") : rawDestPath;
+  const destPath = isRoot ? join(destDir, "_root.md") : rawDestPath;
   const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
   if (isRoot) onRootRule();
   const canonicalFm = { ...frontmatter, root: isRoot };
@@ -2943,7 +2971,7 @@ async function mapCursorRuleFile(relativePath, destDir, normalizeTo, onRootRule)
   };
 }
 async function mapCursorCommandFile(relativePath, destDir, normalizeTo) {
-  const destPath = join10(destDir, relativePath);
+  const destPath = join(destDir, relativePath);
   const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
   const fromCamel = toToolsArray(frontmatter.allowedTools);
   const allowedTools = fromCamel.length > 0 ? fromCamel : toToolsArray(frontmatter["allowed-tools"]);
@@ -2964,7 +2992,7 @@ async function mapCursorCommandFile(relativePath, destDir, normalizeTo) {
   };
 }
 async function mapCursorAgentFile(relativePath, destDir, normalizeTo) {
-  const destPath = join10(destDir, relativePath);
+  const destPath = join(destDir, relativePath);
   const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
   return {
     destPath,
@@ -2973,15 +3001,6 @@ async function mapCursorAgentFile(relativePath, destDir, normalizeTo) {
     content: await serializeImportedAgentWithFallback(destPath, frontmatter, body)
   };
 }
-// src/targets/cursor/importer-rules.ts
-import { join as join13 } from "path";
-// src/targets/cursor/import-root-helpers.ts
-import { join as join12 } from "path";
-// src/targets/import/embedded-rules.ts
-import { join as join11 } from "path";
 function canonicalRulePath(source) {
   const normalized = source.replace(/\\/g, "/");
   if (!normalized.startsWith("rules/") || normalized.endsWith("/")) return null;
@@ -2994,11 +3013,11 @@ async function splitEmbeddedRulesToCanonical(input) {
   if (extracted.rules.length === 0) {
     return { rootContent: extracted.rootContent, results };
   }
-  await mkdirp(join11(input.projectRoot, input.rulesDir));
+  await mkdirp(join(input.projectRoot, input.rulesDir));
   for (const rule of extracted.rules) {
     const canonicalSource = canonicalRulePath(rule.source);
     if (canonicalSource === null || canonicalSource === "rules/_root.md") continue;
-    const destPath = join11(input.projectRoot, ".agentsmesh", canonicalSource);
+    const destPath = join(input.projectRoot, ".agentsmesh", canonicalSource);
     const normalized = input.normalize(rule.body, input.sourcePath, destPath);
     const { frontmatter, body } = parseFrontmatter(normalized);
     const content = await serializeImportedRuleWithFallback(
@@ -3025,9 +3044,9 @@ async function splitEmbeddedRulesToCanonical(input) {
 // src/targets/cursor/import-root-helpers.ts
 async function importCursorRootFile(input) {
-  const destDir = join12(input.projectRoot, CURSOR_CANONICAL_RULES_DIR);
+  const destDir = join(input.projectRoot, CURSOR_CANONICAL_RULES_DIR);
   await mkdirp(destDir);
-  const destPath = join12(destDir, "_root.md");
+  const destPath = join(destDir, "_root.md");
   const split = await splitEmbeddedRulesToCanonical({
     content: input.content,
     projectRoot: input.projectRoot,
@@ -3054,9 +3073,9 @@ async function importCursorRootFile(input) {
 // src/targets/cursor/importer-rules.ts
 async function importCursorRules(projectRoot, results, normalize) {
-  const destDir = join13(projectRoot, CURSOR_CANONICAL_RULES_DIR);
+  const destDir = join(projectRoot, CURSOR_CANONICAL_RULES_DIR);
   let rootWritten = false;
-  const rulesDir = join13(projectRoot, CURSOR_RULES_DIR);
+  const rulesDir = join(projectRoot, CURSOR_RULES_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: rulesDir,
@@ -3079,7 +3098,7 @@ async function importCursorRules(projectRoot, results, normalize) {
     })
   );
   if (!rootWritten) {
-    const agentsPath = join13(projectRoot, CURSOR_COMPAT_AGENTS);
+    const agentsPath = join(projectRoot, CURSOR_COMPAT_AGENTS);
     const agentsContent = await readFileSafe(agentsPath);
     if (agentsContent !== null) {
       rootWritten = await importCursorRootFile({
@@ -3092,7 +3111,7 @@ async function importCursorRules(projectRoot, results, normalize) {
     }
   }
   if (!rootWritten) {
-    const cursorRulesPath = join13(projectRoot, CURSOR_LEGACY_RULES);
+    const cursorRulesPath = join(projectRoot, CURSOR_LEGACY_RULES);
     const cursorRulesContent = await readFileSafe(cursorRulesPath);
     if (cursorRulesContent !== null) {
       await importCursorRootFile({
@@ -3105,10 +3124,6 @@ async function importCursorRules(projectRoot, results, normalize) {
     }
   }
 }
-// src/targets/cursor/settings-helpers.ts
-import { join as join14, dirname as dirname9 } from "path";
-import { stringify as yamlStringify3 } from "yaml";
 function cursorHooksToCanonical(hooks) {
   const result = {};
   for (const [event, entries] of Object.entries(hooks)) {
@@ -3135,7 +3150,7 @@ function cursorHooksToCanonical(hooks) {
 }
 async function importSettings2(projectRoot, results) {
   let hooksImportedFromHooksJson = false;
-  const hooksJsonPath = join14(projectRoot, CURSOR_HOOKS);
+  const hooksJsonPath = join(projectRoot, CURSOR_HOOKS);
   const hooksJsonContent = await readFileSafe(hooksJsonPath);
   if (hooksJsonContent) {
     try {
@@ -3143,9 +3158,9 @@ async function importSettings2(projectRoot, results) {
       if (hooksFile.hooks && typeof hooksFile.hooks === "object") {
         const canonical = cursorHooksToCanonical(hooksFile.hooks);
         if (Object.keys(canonical).length > 0) {
-          const hooksContent = yamlStringify3(canonical);
-          const destPath = join14(projectRoot, CURSOR_CANONICAL_HOOKS);
-          await mkdirp(dirname9(destPath));
+          const hooksContent = stringify(canonical);
+          const destPath = join(projectRoot, CURSOR_CANONICAL_HOOKS);
+          await mkdirp(dirname(destPath));
           await writeFileAtomic(destPath, hooksContent);
           results.push({
             fromTool: "cursor",
@@ -3159,7 +3174,7 @@ async function importSettings2(projectRoot, results) {
     } catch {
     }
   }
-  const settingsPath = join14(projectRoot, CURSOR_SETTINGS);
+  const settingsPath = join(projectRoot, CURSOR_SETTINGS);
   const content = await readFileSafe(settingsPath);
   if (!content) return;
   let settings;
@@ -3174,9 +3189,9 @@ 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 = yamlStringify3({ allow, deny });
-      const destPath = join14(projectRoot, CURSOR_CANONICAL_PERMISSIONS);
-      await mkdirp(dirname9(destPath));
+      const permContent = stringify({ allow, deny });
+      const destPath = join(projectRoot, CURSOR_CANONICAL_PERMISSIONS);
+      await mkdirp(dirname(destPath));
       await writeFileAtomic(destPath, permContent);
       results.push({
         fromTool: "cursor",
@@ -3190,9 +3205,9 @@ async function importSettings2(projectRoot, results) {
   if (rawHooks && typeof rawHooks === "object" && !Array.isArray(rawHooks)) {
     const canonicalHooks = cursorHooksToCanonical(rawHooks);
     if (Object.keys(canonicalHooks).length > 0) {
-      const hooksContent = yamlStringify3(canonicalHooks);
-      const destPath = join14(projectRoot, CURSOR_CANONICAL_HOOKS);
-      await mkdirp(dirname9(destPath));
+      const hooksContent = stringify(canonicalHooks);
+      const destPath = join(projectRoot, CURSOR_CANONICAL_HOOKS);
+      await mkdirp(dirname(destPath));
       await writeFileAtomic(destPath, hooksContent);
       results.push({
         fromTool: "cursor",
@@ -3205,8 +3220,8 @@ async function importSettings2(projectRoot, results) {
 }
 async function importIgnore2(projectRoot, results) {
   const sources = [
-    { path: join14(projectRoot, CURSOR_IGNORE), label: CURSOR_IGNORE },
-    { path: join14(projectRoot, CURSOR_INDEXING_IGNORE), label: CURSOR_INDEXING_IGNORE }
+    { path: join(projectRoot, CURSOR_IGNORE), label: CURSOR_IGNORE },
+    { path: join(projectRoot, CURSOR_INDEXING_IGNORE), label: CURSOR_INDEXING_IGNORE }
   ];
   const patterns = [];
   const importedFrom = [];
@@ -3222,23 +3237,17 @@ async function importIgnore2(projectRoot, results) {
     }
   }
   if (patterns.length === 0) return;
-  const destPath = join14(projectRoot, CURSOR_CANONICAL_IGNORE);
-  await mkdirp(dirname9(destPath));
+  const destPath = join(projectRoot, CURSOR_CANONICAL_IGNORE);
+  await mkdirp(dirname(destPath));
   await writeFileAtomic(destPath, patterns.join("\n") + "\n");
   results.push({
     fromTool: "cursor",
-    fromPath: join14(projectRoot, importedFrom[0]),
+    fromPath: join(projectRoot, importedFrom[0]),
     toPath: CURSOR_CANONICAL_IGNORE,
     feature: "ignore"
   });
 }
-// src/targets/cursor/skills-adapter.ts
-import { join as join16, basename as basename10 } from "path";
-// src/targets/import/shared/skill-import-pipeline.ts
-import { join as join15, basename as basename9, dirname as dirname10, relative as relative5 } from "path";
 // src/targets/import/shared/reserved.ts
 var RESERVED_SKILL_PATTERNS = [
   /^\./,
@@ -3261,8 +3270,8 @@ async function readNativeSkill(skillDir) {
   const allFiles = await readDirRecursive(skillDir).catch(() => []);
   const entries = [];
   for (const absPath of allFiles) {
-    const relPath = relative5(skillDir, absPath).replace(/\\/g, "/");
-    const filename = basename9(relPath);
+    const relPath = relative(skillDir, absPath).replace(/\\/g, "/");
+    const filename = basename(relPath);
     if (isReservedArtifactName(filename)) {
       continue;
     }
@@ -3278,10 +3287,10 @@ async function readNativeSkill(skillDir) {
 }
 async function importDirectorySkill(skillName, skillDir, options) {
   const entries = await readNativeSkill(skillDir);
-  const destSkillDir = join15(options.projectRoot, options.destCanonicalSkillsDir, skillName);
+  const destSkillDir = join(options.projectRoot, options.destCanonicalSkillsDir, skillName);
   for (const entry of entries) {
-    const destPath = join15(destSkillDir, entry.relativePath);
-    await mkdirp(dirname10(destPath));
+    const destPath = join(destSkillDir, entry.relativePath);
+    await mkdirp(dirname(destPath));
     const normalized = options.normalize(entry.content, entry.absolutePath, destPath);
     if (entry.relativePath === "SKILL.md") {
       const { frontmatter, body } = parseFrontmatter(normalized);
@@ -3303,9 +3312,9 @@ async function importDirectorySkill(skillName, skillDir, options) {
   }
 }
 async function importFlatSkill(skillName, srcPath, content, options) {
-  const destSkillDir = join15(options.projectRoot, options.destCanonicalSkillsDir, skillName);
+  const destSkillDir = join(options.projectRoot, options.destCanonicalSkillsDir, skillName);
   await mkdirp(destSkillDir);
-  const destPath = join15(destSkillDir, "SKILL.md");
+  const destPath = join(destSkillDir, "SKILL.md");
   const normalized = options.normalize(content, srcPath, destPath);
   const { frontmatter, body } = parseFrontmatter(normalized);
   const outContent = await serializeImportedSkillWithFallback(
@@ -3325,10 +3334,10 @@ async function findDirectorySkills(skillsDir) {
   const skills = /* @__PURE__ */ new Map();
   try {
     const allFiles = await readDirRecursive(skillsDir);
-    const skillMdFiles = allFiles.filter((f) => basename9(f) === "SKILL.md");
+    const skillMdFiles = allFiles.filter((f) => basename(f) === "SKILL.md");
     for (const skillMdPath of skillMdFiles) {
-      const skillDir = dirname10(skillMdPath);
-      const skillName = basename9(skillDir);
+      const skillDir = dirname(skillMdPath);
+      const skillName = basename(skillDir);
       skills.set(skillName, skillDir);
     }
   } catch {
@@ -3338,7 +3347,7 @@ async function findDirectorySkills(skillsDir) {
 // src/targets/cursor/skills-adapter.ts
 async function importSkills(projectRoot, results, normalize, skillsRelDir = CURSOR_SKILLS_DIR) {
-  const skillsDir = join16(projectRoot, skillsRelDir);
+  const skillsDir = join(projectRoot, skillsRelDir);
   const directorySkills = await findDirectorySkills(skillsDir);
   const options = {
     projectRoot,
@@ -3362,42 +3371,39 @@ async function importSkills(projectRoot, results, normalize, skillsRelDir = CURS
     if (handledPaths.has(srcPath)) continue;
     const content = await readFileSafe(srcPath);
     if (!content) continue;
-    const name = basename10(srcPath, ".md");
+    const name = basename(srcPath, ".md");
     await importFlatSkill(name, srcPath, content, options);
   }
 }
-// src/targets/cursor/import-global-exports-helpers.ts
-import { join as join17, dirname as dirname11 } from "path";
 var CURSOR_TARGET2 = "cursor";
 async function hasGlobalCursorArtifacts(projectRoot) {
-  if (await exists(join17(projectRoot, CURSOR_RULES_DIR))) return true;
+  if (await exists(join(projectRoot, CURSOR_RULES_DIR))) return true;
   const candidates = [
-    join17(projectRoot, CURSOR_DOT_CURSOR_AGENTS),
-    join17(projectRoot, CURSOR_GLOBAL_USER_RULES),
-    join17(projectRoot, CURSOR_GLOBAL_MCP_EXPORT),
-    join17(projectRoot, CURSOR_HOOKS),
-    join17(projectRoot, CURSOR_IGNORE),
-    join17(projectRoot, CURSOR_GLOBAL_SKILLS_DIR),
-    join17(projectRoot, CURSOR_GLOBAL_AGENTS_DIR),
-    join17(projectRoot, CURSOR_COMMANDS_DIR)
+    join(projectRoot, CURSOR_DOT_CURSOR_AGENTS),
+    join(projectRoot, CURSOR_GLOBAL_USER_RULES),
+    join(projectRoot, CURSOR_GLOBAL_MCP_EXPORT),
+    join(projectRoot, CURSOR_HOOKS),
+    join(projectRoot, CURSOR_IGNORE),
+    join(projectRoot, CURSOR_GLOBAL_SKILLS_DIR),
+    join(projectRoot, CURSOR_GLOBAL_AGENTS_DIR),
+    join(projectRoot, CURSOR_COMMANDS_DIR)
   ];
   for (const p of candidates) {
     const stat3 = await readFileSafe(p);
     if (stat3 !== null && stat3.trim() !== "") return true;
   }
-  const skillFiles = await readDirRecursive(join17(projectRoot, CURSOR_GLOBAL_SKILLS_DIR));
+  const skillFiles = await readDirRecursive(join(projectRoot, CURSOR_GLOBAL_SKILLS_DIR));
   if (skillFiles.some((f) => f.endsWith(".md"))) return true;
-  const agentFiles = await readDirRecursive(join17(projectRoot, CURSOR_GLOBAL_AGENTS_DIR));
+  const agentFiles = await readDirRecursive(join(projectRoot, CURSOR_GLOBAL_AGENTS_DIR));
   if (agentFiles.some((f) => f.endsWith(".md"))) return true;
-  const commandFiles = await readDirRecursive(join17(projectRoot, CURSOR_COMMANDS_DIR));
+  const commandFiles = await readDirRecursive(join(projectRoot, CURSOR_COMMANDS_DIR));
   if (commandFiles.some((f) => f.endsWith(".md"))) return true;
   return false;
 }
 async function importGlobalCursorRulesFromDir(projectRoot, results, normalize) {
-  const destDir = join17(projectRoot, CURSOR_CANONICAL_RULES_DIR);
+  const destDir = join(projectRoot, CURSOR_CANONICAL_RULES_DIR);
   let rootWritten = false;
-  const rulesDir = join17(projectRoot, CURSOR_RULES_DIR);
+  const rulesDir = join(projectRoot, CURSOR_RULES_DIR);
   const batch = await importFileDirectory({
     srcDir: rulesDir,
     destDir,
@@ -3421,7 +3427,7 @@ async function importGlobalCursorRulesFromDir(projectRoot, results, normalize) {
   return rootWritten;
 }
 async function importGlobalUserRules(projectRoot, results, normalize) {
-  const srcPath = join17(projectRoot, CURSOR_GLOBAL_USER_RULES);
+  const srcPath = join(projectRoot, CURSOR_GLOBAL_USER_RULES);
   const raw = await readFileSafe(srcPath);
   if (raw === null || raw.trim() === "") return false;
   return importCursorRootFile({
@@ -3433,7 +3439,7 @@ async function importGlobalUserRules(projectRoot, results, normalize) {
   });
 }
 async function importGlobalDotCursorAgents(projectRoot, results, normalize) {
-  const srcPath = join17(projectRoot, CURSOR_DOT_CURSOR_AGENTS);
+  const srcPath = join(projectRoot, CURSOR_DOT_CURSOR_AGENTS);
   const raw = await readFileSafe(srcPath);
   if (raw === null || raw.trim() === "") return false;
   return importCursorRootFile({
@@ -3445,7 +3451,7 @@ async function importGlobalDotCursorAgents(projectRoot, results, normalize) {
   });
 }
 async function importGlobalMcp(projectRoot, results) {
-  const mcpPath = join17(projectRoot, CURSOR_GLOBAL_MCP_EXPORT);
+  const mcpPath = join(projectRoot, CURSOR_GLOBAL_MCP_EXPORT);
   const content = await readFileSafe(mcpPath);
   if (content === null || content.trim() === "") return;
   let parsed;
@@ -3455,8 +3461,8 @@ async function importGlobalMcp(projectRoot, results) {
     return;
   }
   if (!parsed || typeof parsed !== "object" || !("mcpServers" in parsed)) return;
-  const destPath = join17(projectRoot, CURSOR_CANONICAL_MCP);
-  await mkdirp(dirname11(destPath));
+  const destPath = join(projectRoot, CURSOR_CANONICAL_MCP);
+  await mkdirp(dirname(destPath));
   await writeFileAtomic(destPath, content);
   results.push({
     fromTool: CURSOR_TARGET2,
@@ -3466,8 +3472,8 @@ async function importGlobalMcp(projectRoot, results) {
   });
 }
 async function importGlobalAgents(projectRoot, results, normalize) {
-  const agentsDir = join17(projectRoot, CURSOR_GLOBAL_AGENTS_DIR);
-  const destDir = join17(projectRoot, CURSOR_CANONICAL_AGENTS_DIR);
+  const agentsDir = join(projectRoot, CURSOR_GLOBAL_AGENTS_DIR);
+  const destDir = join(projectRoot, CURSOR_CANONICAL_AGENTS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: agentsDir,
@@ -3480,8 +3486,8 @@ async function importGlobalAgents(projectRoot, results, normalize) {
   );
 }
 async function importGlobalCommands(projectRoot, results, normalize) {
-  const commandsDir = join17(projectRoot, CURSOR_COMMANDS_DIR);
-  const destDir = join17(projectRoot, CURSOR_CANONICAL_COMMANDS_DIR);
+  const commandsDir = join(projectRoot, CURSOR_COMMANDS_DIR);
+  const destDir = join(projectRoot, CURSOR_CANONICAL_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: commandsDir,
@@ -3528,8 +3534,8 @@ async function importFromCursor(projectRoot, options = {}) {
   return results;
 }
 async function importCommands2(projectRoot, results, normalize) {
-  const destDir = join18(projectRoot, CURSOR_CANONICAL_COMMANDS_DIR);
-  const commandsDir = join18(projectRoot, CURSOR_COMMANDS_DIR);
+  const destDir = join(projectRoot, CURSOR_CANONICAL_COMMANDS_DIR);
+  const commandsDir = join(projectRoot, CURSOR_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: commandsDir,
@@ -3542,8 +3548,8 @@ async function importCommands2(projectRoot, results, normalize) {
   );
 }
 async function importAgents2(projectRoot, results, normalize) {
-  const destDir = join18(projectRoot, CURSOR_CANONICAL_AGENTS_DIR);
-  const agentsDir = join18(projectRoot, CURSOR_AGENTS_DIR);
+  const destDir = join(projectRoot, CURSOR_CANONICAL_AGENTS_DIR);
+  const agentsDir = join(projectRoot, CURSOR_AGENTS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: agentsDir,
@@ -3556,7 +3562,7 @@ async function importAgents2(projectRoot, results, normalize) {
   );
 }
 async function importMcp(projectRoot, results) {
-  const mcpPath = join18(projectRoot, CURSOR_MCP);
+  const mcpPath = join(projectRoot, CURSOR_MCP);
   const content = await readFileSafe(mcpPath);
   if (!content) return;
   let parsed;
@@ -3566,8 +3572,8 @@ async function importMcp(projectRoot, results) {
     return;
   }
   if (!parsed || typeof parsed !== "object" || !("mcpServers" in parsed)) return;
-  const destPath = join18(projectRoot, CURSOR_CANONICAL_MCP);
-  await mkdirp(dirname12(destPath));
+  const destPath = join(projectRoot, CURSOR_CANONICAL_MCP);
+  await mkdirp(dirname(destPath));
   await writeFileAtomic(destPath, content);
   results.push({
     fromTool: "cursor",
@@ -3800,9 +3806,6 @@ var descriptor2 = {
   detectionPaths: [".cursor/rules", ".cursor/mcp.json"]
 };
-// src/targets/copilot/generator.ts
-import { basename as basename12 } from "path";
 // src/targets/copilot/constants.ts
 var COPILOT_TARGET = "copilot";
 var COPILOT_INSTRUCTIONS = ".github/copilot-instructions.md";
@@ -3825,9 +3828,6 @@ var COPILOT_GLOBAL_PROMPTS_DIR = ".copilot/prompts";
 var COPILOT_GLOBAL_AGENTS_MD = ".copilot/AGENTS.md";
 var COPILOT_GLOBAL_CLAUDE_SKILLS_DIR = ".claude/skills";
 var COPILOT_GLOBAL_AGENTS_SKILLS_DIR = ".agents/skills";
-// src/targets/copilot/command-prompt.ts
-import { basename as basename11 } from "path";
 function toStringArray6(value) {
   if (Array.isArray(value)) {
     return value.filter((entry) => typeof entry === "string" && entry.length > 0);
@@ -3856,7 +3856,7 @@ function serializeCommandPrompt(command) {
 }
 function parseCommandPromptFrontmatter(frontmatter, promptPath) {
   const nameFromMetadata = typeof frontmatter["x-agentsmesh-name"] === "string" ? frontmatter["x-agentsmesh-name"] : "";
-  const name = (nameFromMetadata || basename11(promptPath, ".prompt.md")).trim();
+  const name = (nameFromMetadata || basename(promptPath, ".prompt.md")).trim();
   const allowedToolsFromMetadata = toStringArray6(frontmatter["x-agentsmesh-allowed-tools"]);
   const allowedTools = allowedToolsFromMetadata.length > 0 ? allowedToolsFromMetadata : toStringArray6(frontmatter.tools);
   return {
@@ -3873,7 +3873,7 @@ function hasHookCommand2(entry) {
 // src/targets/copilot/generator.ts
 function ruleSlug(source) {
-  const name = basename12(source, ".md");
+  const name = basename(source, ".md");
   return name === "_root" ? "root" : name;
 }
 function mapHookEvent(event) {
@@ -4008,13 +4008,6 @@ function generateHooks3(canonical) {
     }
   ];
 }
-// src/targets/copilot/importer.ts
-import { join as join23 } from "path";
-// src/targets/copilot/hook-parser.ts
-import { join as join19, dirname as dirname13, basename as basename13 } from "path";
-import { stringify as yamlStringify4 } from "yaml";
 function mapCopilotHookEvent(event) {
   switch (event) {
     case "preToolUse":
@@ -4040,7 +4033,7 @@ function extractWrapperCommand(content) {
   return content.replace(/^#!.*\n/, "").replace(/^#.*\n/gm, "").replace(/^HOOK_DIR=.*\n/gm, "").replace(/^set -e\n?/m, "").trim();
 }
 async function importHooks(projectRoot, results) {
-  const hooksDir = join19(projectRoot, COPILOT_HOOKS_DIR);
+  const hooksDir = join(projectRoot, COPILOT_HOOKS_DIR);
   const allFiles = await readDirRecursive(hooksDir).catch(() => []);
   const jsonFiles = allFiles.filter((file) => file.endsWith(".json"));
   const hooks = {};
@@ -4062,7 +4055,7 @@ async function importHooks(projectRoot, results) {
         const entryRecord = entry;
         const bashPath = typeof entryRecord.bash === "string" ? entryRecord.bash : "";
         if (!bashPath) continue;
-        const scriptPath = join19(hooksDir, bashPath.replace(/^\.\//, ""));
+        const scriptPath = join(hooksDir, bashPath.replace(/^\.\//, ""));
         const scriptContent = await readFileSafe(scriptPath);
         if (!scriptContent) continue;
         const command = extractWrapperCommand(scriptContent);
@@ -4076,37 +4069,34 @@ async function importHooks(projectRoot, results) {
       }
     }
   }
-  const legacyDir = join19(projectRoot, COPILOT_LEGACY_HOOKS_DIR);
+  const legacyDir = join(projectRoot, COPILOT_LEGACY_HOOKS_DIR);
   const legacyFiles = await readDirRecursive(legacyDir).catch(() => []);
   const shFiles = legacyFiles.filter(
-    (file) => dirname13(file) === legacyDir && /^[^-]+-\d+\.sh$/i.test(basename13(file))
+    (file) => dirname(file) === legacyDir && /^[^-]+-\d+\.sh$/i.test(basename(file))
   );
   for (const srcPath of shFiles) {
     const content = await readFileSafe(srcPath);
     if (!content) continue;
-    const name = basename13(srcPath, ".sh");
+    const name = basename(srcPath, ".sh");
     const dashIdx = name.lastIndexOf("-");
     const phase = dashIdx > 0 ? name.slice(0, dashIdx) : name;
     if (!hooks[phase]) hooks[phase] = [];
     hooks[phase].push({ matcher: "*", command: extractWrapperCommand(content), type: "command" });
   }
   if (Object.keys(hooks).length === 0) return;
-  const destPath = join19(projectRoot, COPILOT_CANONICAL_HOOKS);
-  await mkdirp(dirname13(destPath));
-  await writeFileAtomic(destPath, yamlStringify4(hooks));
+  const destPath = join(projectRoot, COPILOT_CANONICAL_HOOKS);
+  await mkdirp(dirname(destPath));
+  await writeFileAtomic(destPath, stringify(hooks));
   results.push({
     fromTool: COPILOT_TARGET,
-    fromPath: join19(projectRoot, COPILOT_HOOKS_DIR),
+    fromPath: join(projectRoot, COPILOT_HOOKS_DIR),
     toPath: COPILOT_CANONICAL_HOOKS,
     feature: "hooks"
   });
 }
-// src/targets/copilot/importer-commands.ts
-import { join as join20 } from "path";
 async function importCopilotCommands(projectRoot, results, normalize, promptsDirRel = COPILOT_PROMPTS_DIR) {
-  const promptsDir = join20(projectRoot, promptsDirRel);
-  const destDir = join20(projectRoot, COPILOT_CANONICAL_COMMANDS_DIR);
+  const promptsDir = join(projectRoot, promptsDirRel);
+  const destDir = join(projectRoot, COPILOT_CANONICAL_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: promptsDir,
@@ -4116,13 +4106,13 @@ async function importCopilotCommands(projectRoot, results, normalize, promptsDir
       normalize,
       mapEntry: async ({ srcPath, relativePath, content }) => {
         const previewRelativePath = relativePath.replace(/\.prompt\.md$/i, ".md");
-        const previewDest = join20(destDir, previewRelativePath);
+        const previewDest = join(destDir, previewRelativePath);
         const { frontmatter, body } = parseFrontmatter(normalize(content, srcPath, previewDest));
         const command = parseCommandPromptFrontmatter(frontmatter, srcPath);
         const relDir = previewRelativePath.includes("/") ? previewRelativePath.slice(0, previewRelativePath.lastIndexOf("/")) : "";
         const fileName = `${command.name}.md`;
         const relativeCommandPath = relDir ? `${relDir}/${fileName}` : fileName;
-        const destPath = join20(destDir, relativeCommandPath);
+        const destPath = join(destDir, relativeCommandPath);
         return {
           destPath,
           toPath: `${COPILOT_CANONICAL_COMMANDS_DIR}/${relativeCommandPath}`,
@@ -4142,11 +4132,8 @@ async function importCopilotCommands(projectRoot, results, normalize, promptsDir
     })
   );
 }
-// src/targets/copilot/importer-agents.ts
-import { join as join21, basename as basename14, dirname as dirname14, relative as relative6 } from "path";
 async function importAgents3(projectRoot, results, normalize, agentsDirRel = COPILOT_AGENTS_DIR) {
-  const agentsDir = join21(projectRoot, agentsDirRel);
+  const agentsDir = join(projectRoot, agentsDirRel);
   let files;
   try {
     files = await readDirRecursive(agentsDir);
@@ -4154,15 +4141,15 @@ async function importAgents3(projectRoot, results, normalize, agentsDirRel = COP
     return;
   }
   const agentFiles = files.filter((f) => f.endsWith(".agent.md"));
-  const destDir = join21(projectRoot, COPILOT_CANONICAL_AGENTS_DIR);
+  const destDir = join(projectRoot, COPILOT_CANONICAL_AGENTS_DIR);
   for (const srcPath of agentFiles) {
     const content = await readFileSafe(srcPath);
     if (!content) continue;
-    const relativePath = relative6(agentsDir, srcPath).replace(/\\/g, "/");
+    const relativePath = relative(agentsDir, srcPath).replace(/\\/g, "/");
     const relativeMdPath = relativePath.replace(/\.agent\.md$/i, ".md");
-    const base = basename14(relativeMdPath, ".md");
-    const destPath = join21(destDir, relativeMdPath);
-    await mkdirp(dirname14(destPath));
+    const base = basename(relativeMdPath, ".md");
+    const destPath = join(destDir, relativeMdPath);
+    await mkdirp(dirname(destPath));
     const { frontmatter, body } = parseFrontmatter(normalize(content, srcPath, destPath));
     const outContent = await serializeImportedAgentWithFallback(
       destPath,
@@ -4181,11 +4168,8 @@ async function importAgents3(projectRoot, results, normalize, agentsDirRel = COP
     });
   }
 }
-// src/targets/copilot/skills-adapter.ts
-import { join as join22 } from "path";
 async function importSkills2(projectRoot, results, normalize, skillsDirRel = COPILOT_SKILLS_DIR) {
-  const skillsDir = join22(projectRoot, skillsDirRel);
+  const skillsDir = join(projectRoot, skillsDirRel);
   const directorySkills = await findDirectorySkills(skillsDir);
   const options = {
     projectRoot,
@@ -4205,13 +4189,13 @@ async function importFromCopilot(projectRoot, options = {}) {
   const scope = options.scope ?? "project";
   const results = [];
   const normalize = await createImportReferenceNormalizer(COPILOT_TARGET, projectRoot, scope);
-  const destDir = join23(projectRoot, COPILOT_CANONICAL_RULES_DIR);
+  const destDir = join(projectRoot, COPILOT_CANONICAL_RULES_DIR);
   const instructionsRel = scope === "global" ? COPILOT_GLOBAL_INSTRUCTIONS : COPILOT_INSTRUCTIONS;
-  const instructionsPath = join23(projectRoot, instructionsRel);
+  const instructionsPath = join(projectRoot, instructionsRel);
   const instructionsContent = await readFileSafe(instructionsPath);
   if (instructionsContent !== null) {
     await mkdirp(destDir);
-    const destPath = join23(destDir, "_root.md");
+    const destPath = join(destDir, "_root.md");
     const { frontmatter, body } = parseFrontmatter(
       normalize(instructionsContent, instructionsPath, destPath)
     );
@@ -4227,7 +4211,7 @@ async function importFromCopilot(projectRoot, options = {}) {
     });
   }
   if (scope === "project") {
-    const copilotDir = join23(projectRoot, COPILOT_CONTEXT_DIR);
+    const copilotDir = join(projectRoot, COPILOT_CONTEXT_DIR);
     results.push(
       ...await importFileDirectory({
         srcDir: copilotDir,
@@ -4237,7 +4221,7 @@ async function importFromCopilot(projectRoot, options = {}) {
         normalize,
         mapEntry: async ({ relativePath, normalizeTo }) => {
           const destFileName = relativePath.replace(/\.instructions\.md$/i, ".md");
-          const destPath = join23(destDir, destFileName);
+          const destPath = join(destDir, destFileName);
           const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
           const globs = toGlobsArray(frontmatter.globs);
           const canonicalFm = {
@@ -4257,7 +4241,7 @@ async function importFromCopilot(projectRoot, options = {}) {
         }
       })
     );
-    const newInstDir = join23(projectRoot, COPILOT_INSTRUCTIONS_DIR);
+    const newInstDir = join(projectRoot, COPILOT_INSTRUCTIONS_DIR);
     results.push(
       ...await importFileDirectory({
         srcDir: newInstDir,
@@ -4267,7 +4251,7 @@ async function importFromCopilot(projectRoot, options = {}) {
         normalize,
         mapEntry: async ({ relativePath, normalizeTo }) => {
           const relativeMdPath = relativePath.endsWith(".instructions.md") ? relativePath.replace(/\.instructions\.md$/i, ".md") : relativePath;
-          const destPath = join23(destDir, relativeMdPath);
+          const destPath = join(destDir, relativeMdPath);
           const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
           const globs = toGlobsArray(
             frontmatter.applyTo !== void 0 ? frontmatter.applyTo : frontmatter.globs
@@ -4350,15 +4334,12 @@ function lintHooks(canonical) {
     })
   );
 }
-// src/targets/copilot/hook-assets.ts
-import { join as join24, relative as relative7 } 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();
 }
 function toRepoRelative(projectRoot, sourcePath) {
-  const repoRelative = relative7(projectRoot, sourcePath).replace(/\\/g, "/");
+  const repoRelative = relative(projectRoot, sourcePath).replace(/\\/g, "/");
   if (!repoRelative || repoRelative.startsWith("../")) return null;
   return repoRelative;
 }
@@ -4373,7 +4354,7 @@ async function buildAssetOutput(projectRoot, command) {
   const match = command.match(SCRIPT_PREFIX_RE);
   const sourceToken = match?.groups?.["path"];
   if (!sourceToken) return null;
-  const sourcePath = join24(projectRoot, sourceToken);
+  const sourcePath = join(projectRoot, sourceToken);
   const assetContent = await readFileSafe(sourcePath);
   if (assetContent === null) return null;
   const repoRelative = toRepoRelative(projectRoot, sourcePath);
@@ -4425,9 +4406,6 @@ async function addHookScriptAssets(projectRoot, canonical, outputs) {
   }
   return [...outputs, ...wrapperOutputs, ...assetOutputs.values()];
 }
-// src/targets/copilot/scope-extras.ts
-import { join as join25 } from "path";
 function computeStatus2(existing, content) {
   if (existing === null) return "created";
   if (existing !== content) return "updated";
@@ -4438,7 +4416,7 @@ var generateCopilotGlobalExtras = async (canonical, projectRoot, scope, enabledF
   const root = canonical.rules.find((r) => r.root);
   if (!root) return [];
   const content = root.body.trim();
-  const existing = await readFileSafe(join25(projectRoot, COPILOT_GLOBAL_AGENTS_MD));
+  const existing = await readFileSafe(join(projectRoot, COPILOT_GLOBAL_AGENTS_MD));
   return [
     {
       target: "copilot",
@@ -4603,10 +4581,6 @@ var descriptor3 = {
     ".github/hooks"
   ]
 };
-// src/targets/import/embedded-skill.ts
-import { readdir as readdir2 } from "fs/promises";
-import { dirname as dirname15, join as join26, relative as relative8 } from "path";
 var AB_SKILLS2 = ".agentsmesh/skills";
 function generateEmbeddedSkills(canonical, skillsDir) {
   const outputs = [];
@@ -4631,19 +4605,19 @@ function generateEmbeddedSkills(canonical, skillsDir) {
   return outputs;
 }
 async function importEmbeddedSkills(projectRoot, skillsDir, fromTool, results, normalize) {
-  const entries = await readdir2(join26(projectRoot, skillsDir), {
+  const entries = await readdir(join(projectRoot, skillsDir), {
     encoding: "utf8",
     withFileTypes: true
   }).catch(() => null);
   if (entries === null) return;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const sourceSkillDir = join26(projectRoot, skillsDir, entry.name);
-    const sourceSkillFile = join26(sourceSkillDir, "SKILL.md");
+    const sourceSkillDir = join(projectRoot, skillsDir, entry.name);
+    const sourceSkillFile = join(sourceSkillDir, "SKILL.md");
     const sourceSkillContent = await readFileSafe(sourceSkillFile);
     if (sourceSkillContent === null) continue;
-    const destinationSkillDir = join26(projectRoot, AB_SKILLS2, entry.name);
-    const destinationSkillFile = join26(destinationSkillDir, "SKILL.md");
+    const destinationSkillDir = join(projectRoot, AB_SKILLS2, entry.name);
+    const destinationSkillFile = join(destinationSkillDir, "SKILL.md");
     const { frontmatter, body } = parseFrontmatter(
       normalize(sourceSkillContent, sourceSkillFile, destinationSkillFile)
     );
@@ -4663,11 +4637,11 @@ async function importEmbeddedSkills(projectRoot, skillsDir, fromTool, results, n
     const sourceFiles = await readDirRecursive(sourceSkillDir);
     for (const sourcePath of sourceFiles) {
       if (sourcePath === sourceSkillFile) continue;
-      const relativePath = relative8(sourceSkillDir, sourcePath).replace(/\\/g, "/");
+      const relativePath = relative(sourceSkillDir, sourcePath).replace(/\\/g, "/");
       const sourceContent = await readFileSafe(sourcePath);
       if (sourceContent === null) continue;
-      const destinationPath = join26(destinationSkillDir, relativePath);
-      await mkdirp(dirname15(destinationPath));
+      const destinationPath = join(destinationSkillDir, relativePath);
+      await mkdirp(dirname(destinationPath));
       await writeFileAtomic(destinationPath, normalize(sourceContent, sourcePath, destinationPath));
       results.push({
         fromTool,
@@ -4678,9 +4652,6 @@ async function importEmbeddedSkills(projectRoot, skillsDir, fromTool, results, n
     }
   }
 }
-// src/targets/continue/command-rule.ts
-import { basename as basename15 } from "path";
 function toStringArray7(value) {
   if (Array.isArray(value)) {
     return value.filter((entry) => typeof entry === "string" && entry.length > 0);
@@ -4707,7 +4678,7 @@ function serializeCommandRule(command) {
   return serializeFrontmatter(frontmatter, command.body.trim() || "");
 }
 function parseCommandRuleFrontmatter(frontmatter, filePath) {
-  const fileName = basename15(filePath, ".md");
+  const fileName = basename(filePath, ".md");
   const fromMetadata = typeof frontmatter["x-agentsmesh-name"] === "string" ? frontmatter["x-agentsmesh-name"] : "";
   const name = (fromMetadata || fileName).trim();
   return {
@@ -4770,15 +4741,11 @@ function generateMcp3(canonical) {
 function generateSkills4(canonical) {
   return generateEmbeddedSkills(canonical, CONTINUE_SKILLS_DIR);
 }
-// src/targets/continue/importer.ts
-import { basename as basename16, extname, join as join27, relative as relative9 } from "path";
-import { parse as parseYaml } from "yaml";
 function isContinueRootRuleRelativePath(relativePath) {
   return relativePath === "general.md" || relativePath === "_root.md";
 }
 function readMcpServers(content, extension) {
-  const parsed = extension === ".json" ? JSON.parse(content) : parseYaml(content) ?? {};
+  const parsed = extension === ".json" ? JSON.parse(content) : parse(content) ?? {};
   const rawServers = parsed.mcpServers;
   if (rawServers && typeof rawServers === "object" && !Array.isArray(rawServers)) {
     const servers = {};
@@ -4809,16 +4776,16 @@ async function importFromContinue(projectRoot) {
   return results;
 }
 async function importRules2(projectRoot, results, normalize) {
-  const files = (await readDirRecursive(join27(projectRoot, CONTINUE_RULES_DIR))).filter(
+  const files = (await readDirRecursive(join(projectRoot, CONTINUE_RULES_DIR))).filter(
     (file) => file.endsWith(".md")
   );
-  const rulesRoot = join27(projectRoot, CONTINUE_RULES_DIR);
+  const rulesRoot = join(projectRoot, CONTINUE_RULES_DIR);
   for (const srcPath of files) {
     const source = await readFileSafe(srcPath);
     if (!source) continue;
-    const relativePath = relative9(rulesRoot, srcPath).replace(/\\/g, "/");
+    const relativePath = relative(rulesRoot, srcPath).replace(/\\/g, "/");
     const canonicalRelative = isContinueRootRuleRelativePath(relativePath) ? "_root.md" : relativePath;
-    const destPath = join27(projectRoot, CONTINUE_CANONICAL_RULES_DIR, canonicalRelative);
+    const destPath = join(projectRoot, CONTINUE_CANONICAL_RULES_DIR, canonicalRelative);
     const { frontmatter, body } = parseFrontmatter(normalize(source, srcPath, destPath));
     const canonicalFrontmatter = {
       description: typeof frontmatter.description === "string" ? frontmatter.description : void 0,
@@ -4838,21 +4805,21 @@ async function importRules2(projectRoot, results, normalize) {
   }
 }
 async function importCommands3(projectRoot, results, normalize) {
-  const files = (await readDirRecursive(join27(projectRoot, CONTINUE_PROMPTS_DIR))).filter(
+  const files = (await readDirRecursive(join(projectRoot, CONTINUE_PROMPTS_DIR))).filter(
     (file) => file.endsWith(".md")
   );
-  const promptsRoot = join27(projectRoot, CONTINUE_PROMPTS_DIR);
+  const promptsRoot = join(projectRoot, CONTINUE_PROMPTS_DIR);
   for (const srcPath of files) {
     const source = await readFileSafe(srcPath);
     if (!source) continue;
-    const relativePath = relative9(promptsRoot, srcPath).replace(/\\/g, "/");
-    const destPath = join27(projectRoot, CONTINUE_CANONICAL_COMMANDS_DIR, relativePath);
+    const relativePath = relative(promptsRoot, srcPath).replace(/\\/g, "/");
+    const destPath = join(projectRoot, CONTINUE_CANONICAL_COMMANDS_DIR, relativePath);
     const { frontmatter, body } = parseFrontmatter(normalize(source, srcPath, destPath));
     const command = parseCommandRuleFrontmatter(frontmatter, srcPath);
-    const commandName = command.name || basename16(relativePath, ".md");
+    const commandName = command.name || basename(relativePath, ".md");
     const relativeDir = relativePath.includes("/") ? relativePath.slice(0, relativePath.lastIndexOf("/")) : "";
     const relativeCommandPath = relativeDir ? `${relativeDir}/${commandName}.md` : `${commandName}.md`;
-    const commandPath = join27(projectRoot, CONTINUE_CANONICAL_COMMANDS_DIR, relativeCommandPath);
+    const commandPath = join(projectRoot, CONTINUE_CANONICAL_COMMANDS_DIR, relativeCommandPath);
     const content = await serializeImportedCommandWithFallback(
       commandPath,
       {
@@ -4873,7 +4840,7 @@ async function importCommands3(projectRoot, results, normalize) {
   }
 }
 async function importMcp2(projectRoot, results) {
-  const files = (await readDirRecursive(join27(projectRoot, CONTINUE_MCP_DIR))).filter(
+  const files = (await readDirRecursive(join(projectRoot, CONTINUE_MCP_DIR))).filter(
     (file) => [".json", ".yaml", ".yml"].includes(extname(file))
   );
   const mergedServers = {};
@@ -4885,7 +4852,7 @@ async function importMcp2(projectRoot, results) {
     importedFrom.push(srcPath);
   }
   if (Object.keys(mergedServers).length === 0) return;
-  const destPath = join27(projectRoot, CONTINUE_CANONICAL_MCP);
+  const destPath = join(projectRoot, CONTINUE_CANONICAL_MCP);
   await writeFileAtomic(destPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
   for (const fromPath of importedFrom) {
     results.push({
@@ -4917,13 +4884,6 @@ function lintCommands3(canonical) {
     )
   );
 }
-// src/targets/continue/scope-extras.ts
-import { join as join29 } from "path";
-// src/targets/continue/global-config.ts
-import { join as join28, basename as basename17 } from "path";
-import { stringify as yamlStringify5 } from "yaml";
 function computeStatus3(existing, content) {
   if (existing === null) return "created";
   if (existing !== content) return "updated";
@@ -4943,7 +4903,7 @@ var generateContinueGlobalConfig = async (canonical, projectRoot, scope, enabled
   };
   if (hasRules && canonical.rules.length > 0) {
     config.rules = canonical.rules.map((rule) => ({
-      name: rule.description || basename17(rule.source, ".md"),
+      name: rule.description || basename(rule.source, ".md"),
       rule: rule.body.trim()
     }));
   }
@@ -4961,8 +4921,8 @@ var generateContinueGlobalConfig = async (canonical, projectRoot, scope, enabled
       config.mcpServers = servers.map(([name, server]) => ({ name, ...server }));
     }
   }
-  const content = yamlStringify5(config);
-  const existing = await readFileSafe(join28(projectRoot, CONTINUE_GLOBAL_CONFIG));
+  const content = stringify(config);
+  const existing = await readFileSafe(join(projectRoot, CONTINUE_GLOBAL_CONFIG));
   return [
     {
       target: "continue",
@@ -4991,7 +4951,7 @@ var generateContinueScopeExtras = async (canonical, projectRoot, scope, enabledF
   const root = canonical.rules.find((r) => r.root);
   if (!root) return configResults;
   const content = root.body.trim();
-  const existing = await readFileSafe(join29(projectRoot, CONTINUE_GLOBAL_AGENTS_MD));
+  const existing = await readFileSafe(join(projectRoot, CONTINUE_GLOBAL_AGENTS_MD));
   return [
     ...configResults,
     {
@@ -5109,9 +5069,6 @@ var descriptor4 = {
   detectionPaths: [".continue/rules", ".continue/skills", ".continue/mcpServers"]
 };
-// src/targets/junie/generator.ts
-import { basename as basename18 } from "path";
 // src/core/mcp-servers.ts
 function isStdioMcpServer(server) {
   return "command" in server;
@@ -5133,7 +5090,7 @@ function generateRules5(canonical) {
   for (const rule of canonical.rules) {
     if (rule.root) continue;
     if (rule.targets.length > 0 && !rule.targets.includes("junie")) continue;
-    const slug = basename18(rule.source, ".md");
+    const slug = basename(rule.source, ".md");
     outputs.push({
       path: `${JUNIE_RULES_DIR}/${slug}.md`,
       content: rule.body.trim() || ""
@@ -5208,12 +5165,6 @@ function renderJunieGlobalInstructions(canonical) {
   });
   return appendEmbeddedRulesBlock(root?.body.trim() ?? "", nonRootRules);
 }
-// src/targets/junie/importer.ts
-import { join as join31 } from "path";
-// src/targets/junie/importer-commands-agents-mcp-ignore.ts
-import { join as join30 } from "path";
 function readMcpServers2(content) {
   const parsed = JSON.parse(content);
   const rawServers = parsed.mcpServers;
@@ -5245,13 +5196,13 @@ function readMcpServers2(content) {
   return servers;
 }
 async function importJunieMcp(projectRoot, results) {
-  const srcPath = join30(projectRoot, JUNIE_MCP_FILE);
+  const srcPath = join(projectRoot, JUNIE_MCP_FILE);
   const content = await readFileSafe(srcPath);
   if (content === null) return;
   const servers = readMcpServers2(content);
   if (Object.keys(servers).length === 0) return;
   await writeFileAtomic(
-    join30(projectRoot, JUNIE_CANONICAL_MCP),
+    join(projectRoot, JUNIE_CANONICAL_MCP),
     JSON.stringify({ mcpServers: servers }, null, 2)
   );
   results.push({
@@ -5262,8 +5213,8 @@ async function importJunieMcp(projectRoot, results) {
   });
 }
 async function importJunieCommands(projectRoot, results, normalize) {
-  const srcDir = join30(projectRoot, JUNIE_COMMANDS_DIR);
-  const destDir = join30(projectRoot, JUNIE_CANONICAL_COMMANDS_DIR);
+  const srcDir = join(projectRoot, JUNIE_COMMANDS_DIR);
+  const destDir = join(projectRoot, JUNIE_CANONICAL_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir,
@@ -5272,7 +5223,7 @@ async function importJunieCommands(projectRoot, results, normalize) {
       fromTool: "junie",
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
-        const destPath = join30(destDir, relativePath);
+        const destPath = join(destDir, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         const normalized = await serializeImportedCommandWithFallback(
           destPath,
@@ -5295,8 +5246,8 @@ async function importJunieCommands(projectRoot, results, normalize) {
   );
 }
 async function importJunieAgents(projectRoot, results, normalize) {
-  const srcDir = join30(projectRoot, JUNIE_AGENTS_DIR);
-  const destDir = join30(projectRoot, JUNIE_CANONICAL_AGENTS_DIR);
+  const srcDir = join(projectRoot, JUNIE_AGENTS_DIR);
+  const destDir = join(projectRoot, JUNIE_CANONICAL_AGENTS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir,
@@ -5305,7 +5256,7 @@ async function importJunieAgents(projectRoot, results, normalize) {
       fromTool: "junie",
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
-        const destPath = join30(destDir, relativePath);
+        const destPath = join(destDir, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         return {
           destPath,
@@ -5318,10 +5269,10 @@ async function importJunieAgents(projectRoot, results, normalize) {
   );
 }
 async function importJunieIgnore(projectRoot, results) {
-  const srcPath = join30(projectRoot, JUNIE_IGNORE);
+  const srcPath = join(projectRoot, JUNIE_IGNORE);
   const content = await readFileSafe(srcPath);
   if (content === null) return;
-  await writeFileAtomic(join30(projectRoot, JUNIE_CANONICAL_IGNORE), content.trimEnd());
+  await writeFileAtomic(join(projectRoot, JUNIE_CANONICAL_IGNORE), content.trimEnd());
   results.push({
     fromTool: JUNIE_TARGET,
     fromPath: srcPath,
@@ -5333,9 +5284,9 @@ async function importJunieIgnore(projectRoot, results) {
 // src/targets/junie/importer.ts
 async function importRules3(projectRoot, results, normalize) {
   const sources = [JUNIE_DOT_AGENTS, JUNIE_GUIDELINES, JUNIE_CI_GUIDELINES, JUNIE_AGENTS_FALLBACK];
-  const destPath = join31(projectRoot, JUNIE_CANONICAL_ROOT_RULE);
+  const destPath = join(projectRoot, JUNIE_CANONICAL_ROOT_RULE);
   for (const relPath of sources) {
-    const srcPath = join31(projectRoot, relPath);
+    const srcPath = join(projectRoot, relPath);
     const content = await readFileSafe(srcPath);
     if (content === null) continue;
     const split = await splitEmbeddedRulesToCanonical({
@@ -5368,8 +5319,8 @@ async function importRules3(projectRoot, results, normalize) {
   }
 }
 async function importNonRootRules(projectRoot, results, normalize) {
-  const srcDir = join31(projectRoot, JUNIE_RULES_DIR);
-  const destDir = join31(projectRoot, JUNIE_CANONICAL_RULES_DIR);
+  const srcDir = join(projectRoot, JUNIE_RULES_DIR);
+  const destDir = join(projectRoot, JUNIE_CANONICAL_RULES_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir,
@@ -5378,7 +5329,7 @@ async function importNonRootRules(projectRoot, results, normalize) {
       fromTool: "junie",
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
-        const destPath = join31(destDir, relativePath);
+        const destPath = join(destDir, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         const output = await serializeImportedRuleWithFallback(
           destPath,
@@ -5576,12 +5527,6 @@ var descriptor5 = {
     ".aiignore"
   ]
 };
-// src/targets/kiro/generator.ts
-import { basename as basename19 } from "path";
-// src/targets/kiro/hook-format.ts
-import { stringify as yamlStringify6 } from "yaml";
 var CANONICAL_TO_KIRO = {
   UserPromptSubmit: "promptSubmit",
   SubagentStop: "agentStop",
@@ -5667,7 +5612,7 @@ function parseKiroHookFile(content) {
   return toCanonicalEntry(file);
 }
 function serializeCanonicalHooks(hooks) {
-  return yamlStringify6(hooks).trimEnd();
+  return stringify(hooks).trimEnd();
 }
 // src/targets/kiro/generator.ts
@@ -5695,7 +5640,7 @@ function generateRules6(canonical) {
   for (const rule of canonical.rules) {
     if (rule.root) continue;
     if (rule.targets.length > 0 && !rule.targets.includes(KIRO_TARGET)) continue;
-    const slug = basename19(rule.source, ".md");
+    const slug = basename(rule.source, ".md");
     outputs.push({
       path: `${KIRO_STEERING_DIR}/${slug}.md`,
       content: serializeFrontmatter(steeringFrontmatter(rule), rule.body.trim() || "")
@@ -5741,12 +5686,6 @@ function generateIgnore4(canonical) {
   if (canonical.ignore.length === 0) return [];
   return [{ path: KIRO_IGNORE, content: canonical.ignore.join("\n") }];
 }
-// src/targets/kiro/importer.ts
-import { basename as basename20, join as join33 } from "path";
-// src/targets/kiro/importer-agents-mcp-hooks-ignore.ts
-import { join as join32 } from "path";
 function readMcpServers3(content) {
   const parsed = JSON.parse(content);
   const rawServers = parsed.mcpServers;
@@ -5776,8 +5715,8 @@ function readMcpServers3(content) {
   return servers;
 }
 async function importKiroAgents(projectRoot, results, normalize) {
-  const srcDir = join32(projectRoot, KIRO_AGENTS_DIR);
-  const destDir = join32(projectRoot, KIRO_CANONICAL_AGENTS_DIR);
+  const srcDir = join(projectRoot, KIRO_AGENTS_DIR);
+  const destDir = join(projectRoot, KIRO_CANONICAL_AGENTS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir,
@@ -5786,7 +5725,7 @@ async function importKiroAgents(projectRoot, results, normalize) {
       fromTool: KIRO_TARGET,
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
-        const destPath = join32(destDir, relativePath);
+        const destPath = join(destDir, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         return {
           destPath,
@@ -5800,24 +5739,24 @@ async function importKiroAgents(projectRoot, results, normalize) {
 }
 async function importKiroMcp(projectRoot, results, scope) {
   const mcpRel = scope === "global" ? KIRO_GLOBAL_MCP_FILE : KIRO_MCP_FILE;
-  const content = await readFileSafe(join32(projectRoot, mcpRel));
+  const content = await readFileSafe(join(projectRoot, mcpRel));
   if (content === null) return;
   const servers = readMcpServers3(content);
   if (Object.keys(servers).length === 0) return;
   await writeFileAtomic(
-    join32(projectRoot, KIRO_CANONICAL_MCP),
+    join(projectRoot, KIRO_CANONICAL_MCP),
     JSON.stringify({ mcpServers: servers }, null, 2)
   );
   results.push({
     fromTool: KIRO_TARGET,
-    fromPath: join32(projectRoot, mcpRel),
+    fromPath: join(projectRoot, mcpRel),
     toPath: KIRO_CANONICAL_MCP,
     feature: "mcp"
   });
 }
 async function importKiroHooks(projectRoot, results) {
   const hooks = {};
-  for (const absPath of await readDirRecursive(join32(projectRoot, KIRO_HOOKS_DIR))) {
+  for (const absPath of await readDirRecursive(join(projectRoot, KIRO_HOOKS_DIR))) {
     if (!absPath.endsWith(".kiro.hook")) continue;
     const parsed = parseKiroHookFile(await readFileSafe(absPath) ?? "");
     if (!parsed) continue;
@@ -5825,22 +5764,22 @@ async function importKiroHooks(projectRoot, results) {
     hooks[parsed.event].push(parsed.entry);
   }
   if (Object.keys(hooks).length === 0) return;
-  await writeFileAtomic(join32(projectRoot, KIRO_CANONICAL_HOOKS), serializeCanonicalHooks(hooks));
+  await writeFileAtomic(join(projectRoot, KIRO_CANONICAL_HOOKS), serializeCanonicalHooks(hooks));
   results.push({
     fromTool: KIRO_TARGET,
-    fromPath: join32(projectRoot, KIRO_HOOKS_DIR),
+    fromPath: join(projectRoot, KIRO_HOOKS_DIR),
     toPath: KIRO_CANONICAL_HOOKS,
     feature: "hooks"
   });
 }
 async function importKiroIgnore(projectRoot, results, scope) {
   const ignoreRel = scope === "global" ? KIRO_GLOBAL_IGNORE : KIRO_IGNORE;
-  const content = await readFileSafe(join32(projectRoot, ignoreRel));
+  const content = await readFileSafe(join(projectRoot, ignoreRel));
   if (content === null) return;
-  await writeFileAtomic(join32(projectRoot, KIRO_CANONICAL_IGNORE), content.trimEnd());
+  await writeFileAtomic(join(projectRoot, KIRO_CANONICAL_IGNORE), content.trimEnd());
   results.push({
     fromTool: KIRO_TARGET,
-    fromPath: join32(projectRoot, ignoreRel),
+    fromPath: join(projectRoot, ignoreRel),
     toPath: KIRO_CANONICAL_IGNORE,
     feature: "ignore"
   });
@@ -5862,10 +5801,10 @@ function canonicalRuleMeta(frontmatter) {
 async function importRoot(projectRoot, results, normalize, scope) {
   const candidates = scope === "global" ? [KIRO_GLOBAL_STEERING_AGENTS_MD, KIRO_AGENTS_MD] : [KIRO_AGENTS_MD, KIRO_GLOBAL_STEERING_AGENTS_MD];
   for (const rel2 of candidates) {
-    const srcPath = join33(projectRoot, rel2);
+    const srcPath = join(projectRoot, rel2);
     const content = await readFileSafe(srcPath);
     if (content === null) continue;
-    const destPath = join33(projectRoot, KIRO_CANONICAL_ROOT_RULE);
+    const destPath = join(projectRoot, KIRO_CANONICAL_ROOT_RULE);
     const { frontmatter, body } = parseFrontmatter(normalize(content, srcPath, destPath));
     await writeFileAtomic(
       destPath,
@@ -5883,14 +5822,14 @@ async function importRoot(projectRoot, results, normalize, scope) {
 async function importRules4(projectRoot, results, normalize) {
   results.push(
     ...await importFileDirectory({
-      srcDir: join33(projectRoot, KIRO_STEERING_DIR),
-      destDir: join33(projectRoot, KIRO_CANONICAL_RULES_DIR),
+      srcDir: join(projectRoot, KIRO_STEERING_DIR),
+      destDir: join(projectRoot, KIRO_CANONICAL_RULES_DIR),
       extensions: [".md"],
       fromTool: KIRO_TARGET,
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
-        if (basename20(relativePath) === "AGENTS.md") return null;
-        const destPath = join33(projectRoot, KIRO_CANONICAL_RULES_DIR, relativePath);
+        if (basename(relativePath) === "AGENTS.md") return null;
+        const destPath = join(projectRoot, KIRO_CANONICAL_RULES_DIR, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         return {
           destPath,
@@ -6124,9 +6063,6 @@ function generateRules7(canonical) {
   }
   return outputs;
 }
-// src/targets/gemini-cli/command-namespace.ts
-import { relative as relative10 } from "path";
 function canonicalCommandNameToGeminiTomlPath(cmdName, commandsDir) {
   const parts = cmdName.split(":").filter(Boolean);
   const fileBase = parts.length > 0 ? parts.pop() : cmdName;
@@ -6342,19 +6278,6 @@ function generateGeminiPermissionsPolicies(canonical) {
     }
   ];
 }
-// src/targets/gemini-cli/importer.ts
-import { join as join39 } from "path";
-// src/targets/gemini-cli/importer-mappers.ts
-import { join as join36 } from "path";
-import { parse as parseToml2 } from "smol-toml";
-// src/targets/gemini-cli/format-helpers.ts
-import { join as join35 } from "path";
-// src/targets/gemini-cli/format-helpers-shared.ts
-import { parse as parseToml } from "smol-toml";
 function mapGeminiHookEvent(event) {
   switch (event) {
     case "BeforeTool":
@@ -6382,7 +6305,7 @@ function parseFlexibleFrontmatter(content) {
       try {
         const tomlStr = content.slice(3, tomlClose).trim();
         const body = content.slice(tomlClose + 3).trim();
-        const parsed = tomlStr === "" ? {} : parseToml(tomlStr) ?? {};
+        const parsed = tomlStr === "" ? {} : parse$1(tomlStr) ?? {};
         const frontmatter = parsed;
         return { frontmatter, body };
       } catch {
@@ -6392,12 +6315,8 @@ function parseFlexibleFrontmatter(content) {
   }
   return { frontmatter: {}, body: content.trim() };
 }
-// src/targets/gemini-cli/format-helpers-settings.ts
-import { join as join34 } from "path";
-import { stringify as stringifyYaml } from "yaml";
 async function importGeminiSettings(projectRoot, results) {
-  const settingsPath = join34(projectRoot, GEMINI_SETTINGS);
+  const settingsPath = join(projectRoot, GEMINI_SETTINGS);
   const settingsContent = await readFileSafe(settingsPath);
   if (settingsContent === null) return;
   let settings;
@@ -6408,8 +6327,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 = join34(projectRoot, GEMINI_CANONICAL_MCP);
-    await mkdirp(join34(projectRoot, ".agentsmesh"));
+    const mcpPath = join(projectRoot, GEMINI_CANONICAL_MCP);
+    await mkdirp(join(projectRoot, ".agentsmesh"));
     await writeFileAtomic(mcpPath, JSON.stringify({ mcpServers }, null, 2));
     results.push({
       fromTool: "gemini-cli",
@@ -6420,8 +6339,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 = join34(projectRoot, GEMINI_CANONICAL_IGNORE);
-    await mkdirp(join34(projectRoot, ".agentsmesh"));
+    const ignorePath = join(projectRoot, GEMINI_CANONICAL_IGNORE);
+    await mkdirp(join(projectRoot, ".agentsmesh"));
     await writeFileAtomic(ignorePath, ignorePatterns.join("\n") + "\n");
     results.push({
       fromTool: "gemini-cli",
@@ -6463,9 +6382,9 @@ async function importGeminiSettings(projectRoot, results) {
     );
     if (mappedHooks.length > 0) {
       const hooksYaml = Object.fromEntries(mappedHooks);
-      const hooksPath = join34(projectRoot, GEMINI_CANONICAL_HOOKS);
-      await mkdirp(join34(projectRoot, ".agentsmesh"));
-      await writeFileAtomic(hooksPath, stringifyYaml(hooksYaml, { lineWidth: 0 }).trimEnd());
+      const hooksPath = join(projectRoot, GEMINI_CANONICAL_HOOKS);
+      await mkdirp(join(projectRoot, ".agentsmesh"));
+      await writeFileAtomic(hooksPath, stringify(hooksYaml, { lineWidth: 0 }).trimEnd());
       results.push({
         fromTool: "gemini-cli",
         fromPath: settingsPath,
@@ -6478,13 +6397,13 @@ async function importGeminiSettings(projectRoot, results) {
 // src/targets/gemini-cli/format-helpers.ts
 async function importGeminiIgnore(projectRoot, results) {
-  const geminiIgnorePath = join35(projectRoot, GEMINI_IGNORE);
+  const geminiIgnorePath = join(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(join35(projectRoot, ".agentsmesh"));
-      const ignorePath = join35(projectRoot, GEMINI_CANONICAL_IGNORE);
+      await mkdirp(join(projectRoot, ".agentsmesh"));
+      const ignorePath = join(projectRoot, GEMINI_CANONICAL_IGNORE);
       await writeFileAtomic(ignorePath, patterns.join("\n") + "\n");
       results.push({
         fromTool: "gemini-cli",
@@ -6499,7 +6418,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 = join36(destDir, relativeMdPath);
+  const destPath = join(destDir, relativeMdPath);
   const { frontmatter, body } = parseFlexibleFrontmatter(normalizeTo(destPath));
   const globs = toGlobsArray(frontmatter.globs);
   const canonicalFm = {
@@ -6519,7 +6438,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 = join36(destDir, relativeMdPath);
+  const destPath = join(destDir, relativeMdPath);
   const normalized = normalizeTo(destPath);
   const { frontmatter, body } = relativePath.endsWith(".toml") ? parseTomlCommand(normalized) : parseFlexibleFrontmatter(normalized);
   const fromCamel = toToolsArray(frontmatter.allowedTools);
@@ -6543,7 +6462,7 @@ async function mapGeminiCommandFile(relativePath, destDir, normalizeTo) {
 }
 function parseTomlCommand(normalized) {
   try {
-    const parsed = parseToml2(normalized);
+    const parsed = parse$1(normalized);
     return {
       frontmatter: parsed,
       body: typeof parsed.prompt === "string" ? parsed.prompt : ""
@@ -6552,11 +6471,6 @@ function parseTomlCommand(normalized) {
     return { frontmatter: {}, body: normalized.trim() };
   }
 }
-// src/targets/gemini-cli/policies-importer.ts
-import { parse as parseToml3 } from "smol-toml";
-import { stringify as stringifyYaml2 } from "yaml";
-import { join as join37 } from "path";
 function unescapeRegexLiteral(value) {
   return value.replace(/\\(.)/g, "$1");
 }
@@ -6584,7 +6498,7 @@ function argsPatternToReadExpr(argsPattern) {
 }
 async function importGeminiPolicies(projectRoot) {
   const results = [];
-  const policiesDir = join37(projectRoot, GEMINI_POLICIES_DIR);
+  const policiesDir = join(projectRoot, GEMINI_POLICIES_DIR);
   let policyFiles;
   try {
     policyFiles = await readDirRecursive(policiesDir);
@@ -6602,7 +6516,7 @@ async function importGeminiPolicies(projectRoot) {
     if (!content) continue;
     let parsed;
     try {
-      parsed = parseToml3(content);
+      parsed = parse$1(content);
     } catch {
       continue;
     }
@@ -6645,21 +6559,18 @@ async function importGeminiPolicies(projectRoot) {
     }
   }
   if (allow.length === 0 && deny.length === 0) return results;
-  await mkdirp(join37(projectRoot, ".agentsmesh"));
-  const outPath = join37(projectRoot, GEMINI_CANONICAL_PERMISSIONS);
-  const yaml = stringifyYaml2({ allow, deny });
+  await mkdirp(join(projectRoot, ".agentsmesh"));
+  const outPath = join(projectRoot, GEMINI_CANONICAL_PERMISSIONS);
+  const yaml = stringify({ allow, deny });
   await writeFileAtomic(outPath, yaml.trimEnd() + "\n");
   results.push({
     fromTool: GEMINI_TARGET,
-    fromPath: join37(projectRoot, GEMINI_POLICIES_DIR),
+    fromPath: join(projectRoot, GEMINI_POLICIES_DIR),
     toPath: GEMINI_CANONICAL_PERMISSIONS,
     feature: "permissions"
   });
   return results;
 }
-// src/targets/gemini-cli/importer-strip.ts
-import { realpathSync as realpathSync3 } from "fs";
 function stripProjectRootCanonicalPrefix(content, projectRoot) {
   const variants = /* @__PURE__ */ new Set([
     projectRoot,
@@ -6667,8 +6578,8 @@ function stripProjectRootCanonicalPrefix(content, projectRoot) {
     projectRoot.replace(/\//g, "\\")
   ]);
   try {
-    variants.add(realpathSync3(projectRoot));
-    variants.add(realpathSync3.native(projectRoot));
+    variants.add(realpathSync(projectRoot));
+    variants.add(realpathSync.native(projectRoot));
   } catch {
   }
   const stripped = Array.from(variants).reduce((next, variant) => {
@@ -6677,23 +6588,20 @@ function stripProjectRootCanonicalPrefix(content, projectRoot) {
   }, content);
   return stripped.replace(/(?:[A-Za-z]:)?[^\s"'`()<>]+[/\\]\.agentsmesh[/\\]/g, ".agentsmesh/");
 }
-// src/targets/gemini-cli/importer-skills-agents.ts
-import { basename as basename21, dirname as dirname16, join as join38, relative as relative11 } from "path";
 async function importGeminiSkillsAndAgents(projectRoot, results, normalize) {
-  const geminiSkillsPath = join38(projectRoot, GEMINI_SKILLS_DIR);
+  const geminiSkillsPath = join(projectRoot, GEMINI_SKILLS_DIR);
   const skillDirs = await readDirRecursive(geminiSkillsPath);
-  const skillMdFiles = skillDirs.filter((f) => basename21(f) === "SKILL.md");
+  const skillMdFiles = skillDirs.filter((f) => basename(f) === "SKILL.md");
   for (const srcPath of skillMdFiles) {
     const content = await readFileSafe(srcPath);
     if (!content) continue;
-    const skillName = basename21(srcPath.slice(0, -"/SKILL.md".length));
+    const skillName = basename(srcPath.slice(0, -"/SKILL.md".length));
     const rawParsed = parseFrontmatter(content);
     const projectedAgent = parseProjectedAgentSkillFrontmatter(rawParsed.frontmatter, skillName);
     if (projectedAgent) {
-      const agentsDir = join38(projectRoot, GEMINI_CANONICAL_AGENTS_DIR);
+      const agentsDir = join(projectRoot, GEMINI_CANONICAL_AGENTS_DIR);
       await mkdirp(agentsDir);
-      const agentPath = join38(agentsDir, `${projectedAgent.name}.md`);
+      const agentPath = join(agentsDir, `${projectedAgent.name}.md`);
       await writeFileAtomic(
         agentPath,
         serializeImportedAgent(projectedAgent, normalize(rawParsed.body, srcPath, agentPath))
@@ -6706,9 +6614,9 @@ async function importGeminiSkillsAndAgents(projectRoot, results, normalize) {
       });
       continue;
     }
-    const destPath = join38(projectRoot, GEMINI_CANONICAL_SKILLS_DIR, skillName, "SKILL.md");
+    const destPath = join(projectRoot, GEMINI_CANONICAL_SKILLS_DIR, skillName, "SKILL.md");
     const normalized = normalize(content, srcPath, destPath);
-    const skillDir = join38(projectRoot, GEMINI_CANONICAL_SKILLS_DIR, skillName);
+    const skillDir = join(projectRoot, GEMINI_CANONICAL_SKILLS_DIR, skillName);
     await mkdirp(skillDir);
     const { frontmatter, body } = parseFrontmatter(normalized);
     await writeFileAtomic(
@@ -6721,14 +6629,14 @@ async function importGeminiSkillsAndAgents(projectRoot, results, normalize) {
       toPath: `${GEMINI_CANONICAL_SKILLS_DIR}/${skillName}/SKILL.md`,
       feature: "skills"
     });
-    const allSkillFiles = await readDirRecursive(dirname16(srcPath));
+    const allSkillFiles = await readDirRecursive(dirname(srcPath));
     for (const absPath of allSkillFiles) {
       if (absPath === srcPath) continue;
       const supportContent = await readFileSafe(absPath);
       if (supportContent === null) continue;
-      const relPath = relative11(dirname16(srcPath), absPath).replace(/\\/g, "/");
-      const destSupportPath = join38(skillDir, relPath);
-      await mkdirp(dirname16(destSupportPath));
+      const relPath = relative(dirname(srcPath), absPath).replace(/\\/g, "/");
+      const destSupportPath = join(skillDir, relPath);
+      await mkdirp(dirname(destSupportPath));
       await writeFileAtomic(destSupportPath, normalize(supportContent, absPath, destSupportPath));
       results.push({
         fromTool: "gemini-cli",
@@ -6738,7 +6646,7 @@ async function importGeminiSkillsAndAgents(projectRoot, results, normalize) {
       });
     }
   }
-  const geminiAgentsPath = join38(projectRoot, GEMINI_AGENTS_DIR);
+  const geminiAgentsPath = join(projectRoot, GEMINI_AGENTS_DIR);
   try {
     const agentFiles = await readDirRecursive(geminiAgentsPath);
     const agentMdFiles = agentFiles.filter((f) => f.endsWith(".md"));
@@ -6746,11 +6654,11 @@ async function importGeminiSkillsAndAgents(projectRoot, results, normalize) {
       const content = await readFileSafe(srcPath);
       if (!content) continue;
       const { frontmatter, body } = parseFrontmatter(content);
-      const relPath = relative11(geminiAgentsPath, srcPath).replace(/\\/g, "/");
+      const relPath = relative(geminiAgentsPath, srcPath).replace(/\\/g, "/");
       const relativeMdPath = relPath.replace(/\.md$/i, ".md");
-      const agentsDir = join38(projectRoot, GEMINI_CANONICAL_AGENTS_DIR);
+      const agentsDir = join(projectRoot, GEMINI_CANONICAL_AGENTS_DIR);
       await mkdirp(agentsDir);
-      const destPath = join38(agentsDir, relativeMdPath);
+      const destPath = join(agentsDir, relativeMdPath);
       const normalizedBody = normalize(body, srcPath, destPath);
       await writeFileAtomic(
         destPath,
@@ -6758,7 +6666,7 @@ async function importGeminiSkillsAndAgents(projectRoot, results, normalize) {
           destPath,
           {
             ...frontmatter,
-            name: typeof frontmatter.name === "string" ? frontmatter.name : basename21(relativeMdPath, ".md"),
+            name: typeof frontmatter.name === "string" ? frontmatter.name : basename(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
@@ -6782,12 +6690,12 @@ async function importFromGemini(projectRoot) {
   const results = [];
   const normalize = await createImportReferenceNormalizer(GEMINI_TARGET, projectRoot);
   const normalizeCodex = await createImportReferenceNormalizer("codex-cli", projectRoot);
-  const rulesDir = join39(projectRoot, GEMINI_CANONICAL_RULES_DIR);
-  const commandsDir = join39(projectRoot, GEMINI_CANONICAL_COMMANDS_DIR);
-  const geminiRootPath = join39(projectRoot, GEMINI_ROOT);
-  const compatAgentsRootPath = join39(projectRoot, GEMINI_COMPAT_AGENTS);
-  const compatInnerRootPath = join39(projectRoot, GEMINI_COMPAT_INNER_ROOT);
-  const systemPath = join39(projectRoot, GEMINI_SYSTEM);
+  const rulesDir = join(projectRoot, GEMINI_CANONICAL_RULES_DIR);
+  const commandsDir = join(projectRoot, GEMINI_CANONICAL_COMMANDS_DIR);
+  const geminiRootPath = join(projectRoot, GEMINI_ROOT);
+  const compatAgentsRootPath = join(projectRoot, GEMINI_COMPAT_AGENTS);
+  const compatInnerRootPath = join(projectRoot, GEMINI_COMPAT_INNER_ROOT);
+  const systemPath = join(projectRoot, GEMINI_SYSTEM);
   const geminiRootContent = await readFileSafe(geminiRootPath);
   const compatAgentsRootContent = await readFileSafe(compatAgentsRootPath);
   const compatInnerRootContent = await readFileSafe(compatInnerRootPath);
@@ -6802,7 +6710,7 @@ async function importFromGemini(projectRoot) {
   const rootContent = rootCandidate?.content ?? null;
   if (rootContent !== null) {
     await mkdirp(rulesDir);
-    const destPath = join39(rulesDir, "_root.md");
+    const destPath = join(rulesDir, "_root.md");
     const compatContent = rootSourcePath === compatAgentsRootPath || rootSourcePath === compatInnerRootPath ? normalizeCodex(rootContent, rootSourcePath, destPath) : rootContent;
     const split = await splitEmbeddedRulesToCanonical({
       content: compatContent,
@@ -6833,7 +6741,7 @@ async function importFromGemini(projectRoot) {
       feature: "rules"
     });
   }
-  const geminiRulesPath = join39(projectRoot, GEMINI_RULES_DIR);
+  const geminiRulesPath = join(projectRoot, GEMINI_RULES_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: geminiRulesPath,
@@ -6844,7 +6752,7 @@ async function importFromGemini(projectRoot) {
       mapEntry: ({ relativePath, normalizeTo }) => mapGeminiRuleFile(relativePath, rulesDir, normalizeTo)
     })
   );
-  const geminiCommandsPath = join39(projectRoot, GEMINI_COMMANDS_DIR);
+  const geminiCommandsPath = join(projectRoot, GEMINI_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: geminiCommandsPath,
@@ -7052,11 +6960,8 @@ var descriptor7 = {
   buildImportPaths: buildGeminiCliImportPaths,
   detectionPaths: ["GEMINI.md", ".gemini"]
 };
-// src/targets/cline/generator.ts
-import { basename as basename22 } from "path";
 function ruleSlug2(source) {
-  const name = basename22(source, ".md");
+  const name = basename(source, ".md");
   return name === "_root" ? "root" : name;
 }
 function generateRules8(canonical) {
@@ -7162,17 +7067,11 @@ function generateSkills8(canonical) {
   }
   return outputs;
 }
-// src/targets/cline/importer.ts
-import { join as join45 } from "path";
-// src/targets/cline/importer-mappers.ts
-import { join as join40 } 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 = join40(destDir, relativeMdPath);
+  const destPath = join(destDir, relativeMdPath);
   const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
   const globs = toGlobsArray(frontmatter.paths ?? frontmatter.globs);
   const canonicalFm = {
@@ -7191,7 +7090,7 @@ async function mapClineRuleFile(relativePath, destDir, normalizeTo) {
   };
 }
 async function mapClineWorkflowFile(relativePath, destDir, normalizeTo) {
-  const destPath = join40(destDir, relativePath);
+  const destPath = join(destDir, relativePath);
   const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
   const hasFrontmatterDescription = Object.prototype.hasOwnProperty.call(
     frontmatter,
@@ -7227,17 +7126,13 @@ async function mapClineWorkflowFile(relativePath, destDir, normalizeTo) {
     )
   };
 }
-// src/targets/cline/importer-rules.ts
-import { stat as stat2 } from "fs/promises";
-import { join as join41 } from "path";
 async function importClineRules(projectRoot, results, normalize) {
-  const destRulesDir = join41(projectRoot, CLINE_CANONICAL_RULES_DIR);
-  const clineRulesPath = join41(projectRoot, CLINE_RULES_DIR);
-  const clineRulesRaw = join41(projectRoot, CLINE_RULES_DIR);
+  const destRulesDir = join(projectRoot, CLINE_CANONICAL_RULES_DIR);
+  const clineRulesPath = join(projectRoot, CLINE_RULES_DIR);
+  const clineRulesRaw = join(projectRoot, CLINE_RULES_DIR);
   let clineRulesIsFile = false;
   try {
-    const clineRulesStat = await stat2(clineRulesRaw);
+    const clineRulesStat = await stat(clineRulesRaw);
     clineRulesIsFile = clineRulesStat.isFile();
   } catch {
   }
@@ -7245,7 +7140,7 @@ async function importClineRules(projectRoot, results, normalize) {
     const flatContent = await readFileSafe(clineRulesRaw);
     if (flatContent !== null) {
       await mkdirp(destRulesDir);
-      const destPath = join41(destRulesDir, "_root.md");
+      const destPath = join(destRulesDir, "_root.md");
       const { frontmatter, body } = parseFrontmatter(
         normalize(flatContent, clineRulesRaw, destPath)
       );
@@ -7263,15 +7158,15 @@ async function importClineRules(projectRoot, results, normalize) {
     return clineRulesIsFile;
   }
   let rootSourcePath = null;
-  const rootPath = join41(clineRulesPath, "_root.md");
+  const rootPath = join(clineRulesPath, "_root.md");
   const rootContent = await readFileSafe(rootPath);
   if (rootContent === null) {
-    const agentsMdPath = join41(projectRoot, CLINE_AGENTS_MD);
+    const agentsMdPath = join(projectRoot, CLINE_AGENTS_MD);
     const agentsMdContent = await readFileSafe(agentsMdPath);
     if (agentsMdContent !== null) {
       rootSourcePath = agentsMdPath;
       await mkdirp(destRulesDir);
-      const destPath = join41(destRulesDir, "_root.md");
+      const destPath = join(destRulesDir, "_root.md");
       const { frontmatter, body } = parseFrontmatter(
         normalize(agentsMdContent, agentsMdPath, destPath)
       );
@@ -7294,7 +7189,7 @@ async function importClineRules(projectRoot, results, normalize) {
         if (fc !== null) {
           rootSourcePath = first;
           await mkdirp(destRulesDir);
-          const destPath = join41(destRulesDir, "_root.md");
+          const destPath = join(destRulesDir, "_root.md");
           const { frontmatter, body } = parseFrontmatter(normalize(fc, first, destPath));
           const hasRoot = frontmatter.root === true;
           const outFm = hasRoot ? frontmatter : { ...frontmatter, root: true };
@@ -7312,7 +7207,7 @@ async function importClineRules(projectRoot, results, normalize) {
   } else {
     rootSourcePath = rootPath;
     await mkdirp(destRulesDir);
-    const destPath = join41(destRulesDir, "_root.md");
+    const destPath = join(destRulesDir, "_root.md");
     const { frontmatter, body } = parseFrontmatter(normalize(rootContent, rootPath, destPath));
     const hasRoot = frontmatter.root === true;
     const outFm = hasRoot ? frontmatter : { ...frontmatter, root: true };
@@ -7340,9 +7235,6 @@ async function importClineRules(projectRoot, results, normalize) {
   );
   return clineRulesIsFile;
 }
-// src/targets/cline/mcp-mapper.ts
-import { join as join42 } from "path";
 function mapClineServerToCanonical(raw) {
   if (!raw || typeof raw !== "object") return null;
   const obj = raw;
@@ -7367,7 +7259,7 @@ function mapClineServerToCanonical(raw) {
 }
 async function importClineMcp(projectRoot, results) {
   const candidatePaths = [CLINE_MCP_SETTINGS, CLINE_MCP_SETTINGS_LEGACY].map(
-    (path) => join42(projectRoot, path)
+    (path) => join(projectRoot, path)
   );
   let mcpPath = null;
   let mcpContent = null;
@@ -7394,9 +7286,9 @@ async function importClineMcp(projectRoot, results) {
       if (server) mcpServers[n] = server;
     }
     if (Object.keys(mcpServers).length > 0) {
-      await mkdirp(join42(projectRoot, ".agentsmesh"));
+      await mkdirp(join(projectRoot, ".agentsmesh"));
       await writeFileAtomic(
-        join42(projectRoot, CLINE_CANONICAL_MCP),
+        join(projectRoot, CLINE_CANONICAL_MCP),
         JSON.stringify({ mcpServers }, null, 2)
       );
       results.push({
@@ -7408,11 +7300,8 @@ async function importClineMcp(projectRoot, results) {
     }
   }
 }
-// src/targets/cline/skills-adapter.ts
-import { join as join43 } from "path";
 async function importClineSkills(projectRoot, results, normalize, skillsRelDir = CLINE_SKILLS_DIR) {
-  const skillsDir = join43(projectRoot, skillsRelDir);
+  const skillsDir = join(projectRoot, skillsRelDir);
   const directorySkills = await findDirectorySkills(skillsDir);
   const options = {
     projectRoot,
@@ -7423,15 +7312,15 @@ async function importClineSkills(projectRoot, results, normalize, skillsRelDir =
     results
   };
   for (const [skillName, skillDir] of directorySkills) {
-    const skillMdPath = join43(skillDir, "SKILL.md");
+    const skillMdPath = join(skillDir, "SKILL.md");
     const content = await readFileSafe(skillMdPath);
     if (!content) continue;
     const rawParsed = parseFrontmatter(content);
     const projectedAgent = parseProjectedAgentSkillFrontmatter(rawParsed.frontmatter, skillName);
     if (projectedAgent) {
-      const destAgentsDir = join43(projectRoot, CLINE_CANONICAL_AGENTS_DIR);
+      const destAgentsDir = join(projectRoot, CLINE_CANONICAL_AGENTS_DIR);
       await mkdirp(destAgentsDir);
-      const agentPath = join43(destAgentsDir, `${projectedAgent.name}.md`);
+      const agentPath = join(destAgentsDir, `${projectedAgent.name}.md`);
       await writeFileAtomic(
         agentPath,
         serializeImportedAgent(projectedAgent, normalize(rawParsed.body, skillMdPath, agentPath))
@@ -7447,17 +7336,13 @@ async function importClineSkills(projectRoot, results, normalize, skillsRelDir =
     await importDirectorySkill(skillName, skillDir, options);
   }
 }
-// src/targets/cline/hook-importer.ts
-import { join as join44, basename as basename23, dirname as dirname17 } from "path";
-import { stringify as yamlStringify7 } from "yaml";
 function extractMeta(content, key) {
   const match = content.match(new RegExp(`^# agentsmesh-${key}:\\s*(.+)$`, "m"));
   return match?.[1]?.trim() ?? null;
 }
 async function loadHooksFromDir(dir, hooks) {
   const files = await readDirRecursive(dir).catch(() => []);
-  const shFiles = files.filter((f) => basename23(f).endsWith(".sh") && dirname17(f) === dir);
+  const shFiles = files.filter((f) => basename(f).endsWith(".sh") && dirname(f) === dir);
   for (const srcPath of shFiles) {
     const content = await readFileSafe(srcPath);
     if (!content) continue;
@@ -7471,15 +7356,15 @@ async function loadHooksFromDir(dir, hooks) {
 }
 async function importClineHooks(projectRoot, results) {
   const hooks = {};
-  await loadHooksFromDir(join44(projectRoot, CLINE_HOOKS_DIR), hooks);
-  await loadHooksFromDir(join44(projectRoot, CLINE_GLOBAL_HOOKS_DIR), hooks);
+  await loadHooksFromDir(join(projectRoot, CLINE_HOOKS_DIR), hooks);
+  await loadHooksFromDir(join(projectRoot, CLINE_GLOBAL_HOOKS_DIR), hooks);
   if (Object.keys(hooks).length === 0) return;
-  const destPath = join44(projectRoot, CLINE_CANONICAL_HOOKS);
-  await mkdirp(dirname17(destPath));
-  await writeFileAtomic(destPath, yamlStringify7(hooks));
+  const destPath = join(projectRoot, CLINE_CANONICAL_HOOKS);
+  await mkdirp(dirname(destPath));
+  await writeFileAtomic(destPath, stringify(hooks));
   results.push({
     fromTool: CLINE_TARGET,
-    fromPath: join44(projectRoot, CLINE_GLOBAL_HOOKS_DIR),
+    fromPath: join(projectRoot, CLINE_GLOBAL_HOOKS_DIR),
     toPath: CLINE_CANONICAL_HOOKS,
     feature: "hooks"
   });
@@ -7490,7 +7375,7 @@ async function importFromCline(projectRoot) {
   const results = [];
   const normalize = await createImportReferenceNormalizer(CLINE_TARGET, projectRoot);
   const clineRulesIsFile = await importClineRules(projectRoot, results, normalize);
-  const ignorePath = join45(projectRoot, CLINE_IGNORE);
+  const ignorePath = join(projectRoot, CLINE_IGNORE);
   const ignoreContent = await readFileSafe(ignorePath);
   if (ignoreContent !== null && ignoreContent.trim()) {
     const lines = ignoreContent.split(/\r?\n/);
@@ -7500,8 +7385,8 @@ async function importFromCline(projectRoot) {
       if (t && !t.startsWith("#")) patterns.push(t);
     }
     if (patterns.length > 0) {
-      await mkdirp(join45(projectRoot, ".agentsmesh"));
-      const destIgnorePath = join45(projectRoot, CLINE_CANONICAL_IGNORE);
+      await mkdirp(join(projectRoot, ".agentsmesh"));
+      const destIgnorePath = join(projectRoot, CLINE_CANONICAL_IGNORE);
       await writeFileAtomic(destIgnorePath, patterns.join("\n"));
       results.push({
         fromTool: "cline",
@@ -7512,11 +7397,11 @@ async function importFromCline(projectRoot) {
     }
   }
   await importClineMcp(projectRoot, results);
-  const destCommandsDir = join45(projectRoot, CLINE_CANONICAL_COMMANDS_DIR);
+  const destCommandsDir = join(projectRoot, CLINE_CANONICAL_COMMANDS_DIR);
   if (!clineRulesIsFile) {
     results.push(
       ...await importFileDirectory({
-        srcDir: join45(projectRoot, CLINE_WORKFLOWS_DIR),
+        srcDir: join(projectRoot, CLINE_WORKFLOWS_DIR),
         destDir: destCommandsDir,
         extensions: [".md"],
         fromTool: "cline",
@@ -7679,9 +7564,6 @@ var descriptor8 = {
   detectionPaths: [".clinerules", ".cline"]
 };
-// src/targets/codex-cli/generator/rules.ts
-import { basename as basename25 } from "path";
 // src/targets/codex-cli/constants.ts
 var CODEX_TARGET = "codex-cli";
 var CODEX_MD = "codex.md";
@@ -7706,11 +7588,8 @@ var CODEX_RULE_EMBED_B64_END = "# am-body-b64-end";
 var CODEX_RULE_EMBED_B64_LINE = "# am64:";
 var CODEX_RULE_INDEX_START = "<!-- agentsmesh:codex-rule-index:start -->";
 var CODEX_RULE_INDEX_END = "<!-- agentsmesh:codex-rule-index:end -->";
-// src/targets/codex-cli/instruction-mirror.ts
-import { basename as basename24 } from "path";
 function ruleSlug3(source) {
-  return basename24(source, ".md");
+  return basename(source, ".md");
 }
 function codexInstructionMirrorPath(rule) {
   return `${CODEX_INSTRUCTIONS_DIR}/${ruleSlug3(rule.source)}.md`;
@@ -7810,7 +7689,7 @@ function generateRules9(canonical) {
   }
   for (const rule of canonical.rules) {
     if (rule.root) continue;
-    const slug = basename25(rule.source, ".md");
+    const slug = basename(rule.source, ".md");
     if (rule.targets.length > 0 && !rule.targets.includes("codex-cli")) continue;
     if (rule.codexEmit === "execution") {
       outputs.push({
@@ -7937,10 +7816,6 @@ function serializeMcpToToml(mcpServers) {
 function needsTomlQuoting(key) {
   return !/^[A-Za-z0-9_-]+$/.test(key);
 }
-// src/targets/codex-cli/mcp-helpers.ts
-import { join as join46 } from "path";
-import { parse as parseToml4 } from "smol-toml";
 function mapTomlServerToCanonical(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
   const obj = raw;
@@ -7961,12 +7836,12 @@ function mapTomlServerToCanonical(raw) {
   };
 }
 async function importMcp3(projectRoot, results) {
-  const configPath = join46(projectRoot, CODEX_CONFIG_TOML);
+  const configPath = join(projectRoot, CODEX_CONFIG_TOML);
   const content = await readFileSafe(configPath);
   if (content === null) return;
   let parsed;
   try {
-    parsed = parseToml4(content);
+    parsed = parse$1(content);
   } catch {
     return;
   }
@@ -7980,9 +7855,9 @@ async function importMcp3(projectRoot, results) {
     if (server) mcpServers[name] = server;
   }
   if (Object.keys(mcpServers).length === 0) return;
-  await mkdirp(join46(projectRoot, ".agentsmesh"));
+  await mkdirp(join(projectRoot, ".agentsmesh"));
   await writeFileAtomic(
-    join46(projectRoot, CODEX_CANONICAL_MCP),
+    join(projectRoot, CODEX_CANONICAL_MCP),
     JSON.stringify({ mcpServers }, null, 2)
   );
   results.push({
@@ -7992,13 +7867,6 @@ async function importMcp3(projectRoot, results) {
     feature: "mcp"
   });
 }
-// src/targets/codex-cli/skills-adapter.ts
-import { readdir as readdir3 } from "fs/promises";
-import { join as join47 } from "path";
-// src/targets/import/scoped-agents-import.ts
-import { rm } from "fs/promises";
 function shouldImportScopedAgentsRule(relDir) {
   const segments = relDir.split("/").filter(Boolean);
   if (segments.length === 0) return false;
@@ -8021,8 +7889,8 @@ async function importSkills3(projectRoot, results, normalize) {
     results
   };
   for (const skillsRoot of [CODEX_SKILLS_DIR, CODEX_SKILLS_FALLBACK_DIR]) {
-    const skillsDir = join47(projectRoot, skillsRoot);
-    const entries = await readdir3(skillsDir, {
+    const skillsDir = join(projectRoot, skillsRoot);
+    const entries = await readdir(skillsDir, {
       encoding: "utf8",
       withFileTypes: true
     }).catch(() => null);
@@ -8030,21 +7898,21 @@ async function importSkills3(projectRoot, results, normalize) {
     let importedAny = false;
     for (const ent of entries) {
       if (!ent.isDirectory() && !ent.isSymbolicLink()) continue;
-      const skillPath = join47(skillsDir, ent.name);
-      const skillMdPath = join47(skillPath, "SKILL.md");
+      const skillPath = join(skillsDir, ent.name);
+      const skillMdPath = join(skillPath, "SKILL.md");
       const skillMdContent = await readFileSafe(skillMdPath);
       if (!skillMdContent) continue;
       importedAny = true;
       const skillName = ent.name;
-      const destSkillPath = join47(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName, "SKILL.md");
+      const destSkillPath = join(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName, "SKILL.md");
       const normalized = normalize(skillMdContent, skillMdPath, destSkillPath);
       const { frontmatter, body } = parseFrontmatter(normalized);
       const command = parseCommandSkillFrontmatter(frontmatter, ent.name);
       if (command) {
-        await removePathIfExists(join47(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName));
-        const destCommandsDir = join47(projectRoot, CODEX_CANONICAL_COMMANDS_DIR);
+        await removePathIfExists(join(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName));
+        const destCommandsDir = join(projectRoot, CODEX_CANONICAL_COMMANDS_DIR);
         await mkdirp(destCommandsDir);
-        const commandPath = join47(destCommandsDir, `${command.name}.md`);
+        const commandPath = join(destCommandsDir, `${command.name}.md`);
         await writeFileAtomic(
           commandPath,
           serializeImportedCommand(command, normalize(body, skillMdPath, commandPath))
@@ -8059,10 +7927,10 @@ async function importSkills3(projectRoot, results, normalize) {
       }
       const projectedAgent = parseProjectedAgentSkillFrontmatter(frontmatter, ent.name);
       if (projectedAgent) {
-        await removePathIfExists(join47(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName));
-        const destAgentsDir = join47(projectRoot, CODEX_CANONICAL_AGENTS_DIR);
+        await removePathIfExists(join(projectRoot, CODEX_CANONICAL_SKILLS_DIR, skillName));
+        const destAgentsDir = join(projectRoot, CODEX_CANONICAL_AGENTS_DIR);
         await mkdirp(destAgentsDir);
-        const agentPath = join47(destAgentsDir, `${projectedAgent.name}.md`);
+        const agentPath = join(destAgentsDir, `${projectedAgent.name}.md`);
         await writeFileAtomic(
           agentPath,
           serializeImportedAgent(projectedAgent, normalize(body, skillMdPath, agentPath))
@@ -8080,22 +7948,18 @@ async function importSkills3(projectRoot, results, normalize) {
     if (importedAny) return;
   }
 }
-// src/targets/codex-cli/importer-agents.ts
-import { basename as basename26, join as join48 } from "path";
-import { parse as parseToml5 } from "smol-toml";
 async function importCodexAgentsFromToml(projectRoot, results, normalize) {
-  const agentsPath = join48(projectRoot, CODEX_AGENTS_DIR);
-  const agentsDestDir = join48(projectRoot, CODEX_CANONICAL_AGENTS_DIR);
+  const agentsPath = join(projectRoot, CODEX_AGENTS_DIR);
+  const agentsDestDir = join(projectRoot, CODEX_CANONICAL_AGENTS_DIR);
   try {
     const agentFiles = await readDirRecursive(agentsPath);
     const tomlFiles = agentFiles.filter((f) => f.endsWith(".toml"));
     for (const srcPath of tomlFiles) {
       const content = await readFileSafe(srcPath);
       if (!content) continue;
-      const parsed = parseToml5(content);
+      const parsed = parse$1(content);
       if (!parsed || typeof parsed !== "object") continue;
-      const name = typeof parsed.name === "string" ? parsed.name : basename26(srcPath, ".toml");
+      const name = typeof parsed.name === "string" ? parsed.name : basename(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 : "";
@@ -8103,7 +7967,7 @@ async function importCodexAgentsFromToml(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 = join48(agentsDestDir, `${name}.md`);
+      const destPath = join(agentsDestDir, `${name}.md`);
       const normalizedBody = normalize(body, srcPath, destPath);
       const agent = {
         name,
@@ -8130,15 +7994,6 @@ async function importCodexAgentsFromToml(projectRoot, results, normalize) {
   } catch {
   }
 }
-// src/targets/codex-cli/importer-rules.ts
-import { dirname as dirname18, join as join50, relative as relative13 } from "path";
-// src/targets/codex-cli/import-codex-non-root-rules.ts
-import { join as join49, relative as relative12 } from "path";
-// src/targets/codex-cli/codex-rules-embed.ts
-import { Buffer } from "buffer";
 function tryParseEmbeddedCanonicalFromCodexRules(content) {
   if (!content.includes(CODEX_RULE_EMBED_MARKER)) return null;
   const jsonLine = content.split("\n").find((l) => l.startsWith(CODEX_RULE_EMBED_JSON_PREFIX));
@@ -8181,15 +8036,15 @@ function tryParseEmbeddedCanonicalFromCodexRules(content) {
 // src/targets/codex-cli/import-codex-non-root-rules.ts
 async function importCodexNonRootRuleFiles(projectRoot, destDir, normalize) {
   const results = [];
-  const codexRulesPath = join49(projectRoot, CODEX_RULES_DIR);
+  const codexRulesPath = join(projectRoot, CODEX_RULES_DIR);
   try {
     const ruleFiles = await readDirRecursive(codexRulesPath);
     const mdFiles = ruleFiles.filter((f) => f.endsWith(".md"));
     for (const srcPath of mdFiles) {
       const content = await readFileSafe(srcPath);
       if (!content) continue;
-      const relativePath = relative12(codexRulesPath, srcPath).replace(/\\/g, "/");
-      const destPath = join49(destDir, relativePath);
+      const relativePath = relative(codexRulesPath, srcPath).replace(/\\/g, "/");
+      const destPath = join(destDir, relativePath);
       const { frontmatter, body } = parseFrontmatter(normalize(content, srcPath, destPath));
       await mkdirp(destDir);
       const outFm = frontmatter.root === true ? frontmatter : { ...frontmatter, root: false };
@@ -8206,8 +8061,8 @@ async function importCodexNonRootRuleFiles(projectRoot, destDir, normalize) {
     for (const srcPath of starlarkFiles) {
       const raw = await readFileSafe(srcPath);
       if (!raw) continue;
-      const relativePath = relative12(codexRulesPath, srcPath).replace(/\\/g, "/").replace(/\.rules$/i, ".md");
-      const destPath = join49(destDir, relativePath);
+      const relativePath = relative(codexRulesPath, srcPath).replace(/\\/g, "/").replace(/\.rules$/i, ".md");
+      const destPath = join(destDir, relativePath);
       await mkdirp(destDir);
       const embedded = tryParseEmbeddedCanonicalFromCodexRules(raw);
       if (embedded) {
@@ -8248,20 +8103,20 @@ async function importCodexNonRootRuleFiles(projectRoot, destDir, normalize) {
 // src/targets/codex-cli/importer-rules.ts
 async function importCodexRules(projectRoot, results, normalize, normalizeWindsurf, layoutScope) {
-  const codexPath = join50(projectRoot, CODEX_MD);
-  const agentsPath = join50(projectRoot, AGENTS_MD);
-  const globalOverridePath = join50(projectRoot, CODEX_GLOBAL_AGENTS_OVERRIDE_MD);
-  const globalAgentsPath = join50(projectRoot, CODEX_GLOBAL_AGENTS_MD);
+  const codexPath = join(projectRoot, CODEX_MD);
+  const agentsPath = join(projectRoot, AGENTS_MD);
+  const globalOverridePath = join(projectRoot, CODEX_GLOBAL_AGENTS_OVERRIDE_MD);
+  const globalAgentsPath = join(projectRoot, CODEX_GLOBAL_AGENTS_MD);
   const globalOverrideContent = layoutScope === "global" ? await readFileSafe(globalOverridePath) : null;
   const globalAgentsContent = layoutScope === "global" ? await readFileSafe(globalAgentsPath) : null;
   const agentsContent = layoutScope === "project" ? await readFileSafe(agentsPath) : null;
   const codexContent = layoutScope === "project" ? await readFileSafe(codexPath) : null;
   const sourcePath = globalOverrideContent !== null ? globalOverridePath : globalAgentsContent !== null ? globalAgentsPath : agentsContent !== null ? agentsPath : codexPath;
-  const destDir = join50(projectRoot, CODEX_CANONICAL_RULES_DIR);
+  const destDir = join(projectRoot, CODEX_CANONICAL_RULES_DIR);
   const content = globalOverrideContent ?? globalAgentsContent ?? agentsContent ?? codexContent;
   if (content !== null) {
     await mkdirp(destDir);
-    const destPath = join50(destDir, "_root.md");
+    const destPath = join(destDir, "_root.md");
     const stripped = sourcePath === agentsPath || sourcePath === globalAgentsPath || sourcePath === globalOverridePath ? stripCodexRuleIndex(content) : content;
     const split = await splitEmbeddedRulesToCanonical({
       content: stripped,
@@ -8299,16 +8154,16 @@ async function importCodexRules(projectRoot, results, normalize, normalizeWindsu
         fromTool: "codex-cli",
         normalize,
         mapEntry: async ({ srcPath, normalizeTo }) => {
-          const relDir = relative13(projectRoot, dirname18(srcPath)).replace(/\\/g, "/");
+          const relDir = relative(projectRoot, dirname(srcPath)).replace(/\\/g, "/");
           const isOverride = srcPath.endsWith("/AGENTS.override.md");
           if (!relDir || relDir === ".") return null;
           if (!isOverride && !srcPath.endsWith("/AGENTS.md")) return null;
           const ruleName = relDir.replace(/\//g, "-");
           if (!shouldImportScopedAgentsRule(relDir)) {
-            await removePathIfExists(join50(destDir, `${ruleName}.md`));
+            await removePathIfExists(join(destDir, `${ruleName}.md`));
             return null;
           }
-          const destPath = join50(destDir, `${ruleName}.md`);
+          const destPath = join(destDir, `${ruleName}.md`);
           const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
           return {
             destPath,
@@ -8332,15 +8187,15 @@ async function importCodexRules(projectRoot, results, normalize, normalizeWindsu
 }
 async function importInstructionMirrors(projectRoot, destDir, results, normalize) {
   try {
-    const files = await readDirRecursive(join50(projectRoot, CODEX_INSTRUCTIONS_DIR));
+    const files = await readDirRecursive(join(projectRoot, CODEX_INSTRUCTIONS_DIR));
     const instructionFiles = files.filter((file) => file.endsWith(".md"));
-    const instructionsRoot = join50(projectRoot, CODEX_INSTRUCTIONS_DIR);
+    const instructionsRoot = join(projectRoot, CODEX_INSTRUCTIONS_DIR);
     for (const srcPath of instructionFiles) {
-      const relativePath = relative13(instructionsRoot, srcPath).replace(/\\/g, "/");
+      const relativePath = relative(instructionsRoot, srcPath).replace(/\\/g, "/");
       if (relativePath === "_root.md") continue;
       const content = await readFileSafe(srcPath);
       if (!content) continue;
-      const destPath = join50(destDir, relativePath);
+      const destPath = join(destDir, relativePath);
       const { frontmatter, body } = parseFrontmatter(normalize(content, srcPath, destPath));
       await mkdirp(destDir);
       const outFm = frontmatter.root === true ? frontmatter : { ...frontmatter, root: false };
@@ -8373,9 +8228,6 @@ async function importFromCodex(projectRoot, options) {
   await importMcp3(projectRoot, results);
   return results;
 }
-// src/targets/codex-cli/linter.ts
-import { relative as relative14 } from "path";
 function lintRules9(canonical, projectRoot, _projectFiles) {
   const { rules } = canonical;
   if (rules.length === 0) return [];
@@ -8384,7 +8236,7 @@ function lintRules9(canonical, projectRoot, _projectFiles) {
     return [
       {
         level: "warning",
-        file: relative14(projectRoot, rules[0].source),
+        file: relative(projectRoot, rules[0].source),
         target: CODEX_TARGET,
         message: "Codex needs a root rule to generate AGENTS.md. Add root: true to a rule."
       }
@@ -8541,9 +8393,6 @@ var descriptor9 = {
   ]
 };
-// src/targets/windsurf/generator/rules.ts
-import { basename as basename27 } from "path";
 // src/targets/windsurf/constants.ts
 var WINDSURF_TARGET = "windsurf";
 var WINDSURF_RULES_ROOT = ".windsurfrules";
@@ -8573,7 +8422,7 @@ var WINDSURF_GLOBAL_AGENTS_SKILLS_DIR = ".agents/skills";
 // src/targets/windsurf/generator/rules.ts
 function ruleSlug4(source) {
-  const name = basename27(source, ".md");
+  const name = basename(source, ".md");
   return name === "_root" ? "root" : name;
 }
 function directoryScopedRuleDir(globs) {
@@ -8717,12 +8566,6 @@ function generateSkills10(canonical) {
   }
   return outputs;
 }
-// src/targets/windsurf/importer.ts
-import { join as join54, dirname as dirname20, relative as relative16 } from "path";
-// src/targets/windsurf/importer-workflows.ts
-import { join as join51, relative as relative15 } from "path";
 function toStringArray8(value) {
   if (Array.isArray(value)) {
     return value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
@@ -8733,16 +8576,16 @@ function toStringArray8(value) {
   return [];
 }
 async function importWorkflows(projectRoot, results, normalize) {
-  const workflowsDir = join51(projectRoot, WINDSURF_WORKFLOWS_DIR);
+  const workflowsDir = join(projectRoot, WINDSURF_WORKFLOWS_DIR);
   const workflowFiles = await readDirRecursive(workflowsDir);
   const workflowMdFiles = workflowFiles.filter((f) => f.endsWith(".md"));
-  const destCommandsDir = join51(projectRoot, WINDSURF_CANONICAL_COMMANDS_DIR);
+  const destCommandsDir = join(projectRoot, WINDSURF_CANONICAL_COMMANDS_DIR);
   for (const srcPath of workflowMdFiles) {
     const content = await readFileSafe(srcPath);
     if (!content) continue;
-    const relativePath = relative15(workflowsDir, srcPath).replace(/\\/g, "/");
+    const relativePath = relative(workflowsDir, srcPath).replace(/\\/g, "/");
     await mkdirp(destCommandsDir);
-    const destPath = join51(destCommandsDir, relativePath);
+    const destPath = join(destCommandsDir, relativePath);
     const normalized = normalize(content, srcPath, destPath);
     const { frontmatter, body } = parseFrontmatter(normalized);
     const outContent = await serializeImportedCommandWithFallback(
@@ -8767,11 +8610,8 @@ async function importWorkflows(projectRoot, results, normalize) {
     });
   }
 }
-// src/targets/windsurf/skills-adapter.ts
-import { join as join52 } from "path";
 async function importSkills4(projectRoot, results, normalize, skillsRelDir = WINDSURF_SKILLS_DIR) {
-  const skillsDir = join52(projectRoot, skillsRelDir);
+  const skillsDir = join(projectRoot, skillsRelDir);
   const directorySkills = await findDirectorySkills(skillsDir);
   const options = {
     projectRoot,
@@ -8782,16 +8622,16 @@ async function importSkills4(projectRoot, results, normalize, skillsRelDir = WIN
     results
   };
   for (const [skillName, skillDir] of directorySkills) {
-    const skillMdPath = join52(skillDir, "SKILL.md");
+    const skillMdPath = join(skillDir, "SKILL.md");
     const content = await readFileSafe(skillMdPath);
     if (!content) continue;
     const rawParsed = parseFrontmatter(content);
     const projectedAgent = parseProjectedAgentSkillFrontmatter(rawParsed.frontmatter, skillName);
     if (projectedAgent) {
-      await removePathIfExists(join52(projectRoot, WINDSURF_CANONICAL_SKILLS_DIR, skillName));
-      const destAgentsDir = join52(projectRoot, WINDSURF_CANONICAL_AGENTS_DIR);
+      await removePathIfExists(join(projectRoot, WINDSURF_CANONICAL_SKILLS_DIR, skillName));
+      const destAgentsDir = join(projectRoot, WINDSURF_CANONICAL_AGENTS_DIR);
       await mkdirp(destAgentsDir);
-      const agentPath = join52(destAgentsDir, `${projectedAgent.name}.md`);
+      const agentPath = join(destAgentsDir, `${projectedAgent.name}.md`);
       await writeFileAtomic(
         agentPath,
         serializeImportedAgent(projectedAgent, normalize(rawParsed.body, skillMdPath, agentPath))
@@ -8807,12 +8647,8 @@ async function importSkills4(projectRoot, results, normalize, skillsRelDir = WIN
     await importDirectorySkill(skillName, skillDir, options);
   }
 }
-// src/targets/windsurf/importer-hooks-mcp.ts
-import { dirname as dirname19, join as join53 } from "path";
-import { stringify as yamlStringify8 } from "yaml";
 async function importWindsurfHooks(projectRoot, results) {
-  const hooksPath = join53(projectRoot, WINDSURF_HOOKS_FILE);
+  const hooksPath = join(projectRoot, WINDSURF_HOOKS_FILE);
   const hooksContent = await readFileSafe(hooksPath);
   if (!hooksContent) return;
   try {
@@ -8820,9 +8656,9 @@ async function importWindsurfHooks(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 = join53(projectRoot, WINDSURF_CANONICAL_HOOKS);
-    await mkdirp(dirname19(destPath));
-    await writeFileAtomic(destPath, yamlStringify8(canonical));
+    const destPath = join(projectRoot, WINDSURF_CANONICAL_HOOKS);
+    await mkdirp(dirname(destPath));
+    await writeFileAtomic(destPath, stringify(canonical));
     results.push({
       fromTool: WINDSURF_TARGET,
       fromPath: hooksPath,
@@ -8883,14 +8719,14 @@ function windsurfHooksToCanonical(hooks) {
 async function importWindsurfMcp(projectRoot, results) {
   const sourceCandidates = [WINDSURF_MCP_EXAMPLE_FILE, WINDSURF_MCP_CONFIG_FILE];
   for (const relPath of sourceCandidates) {
-    const srcPath = join53(projectRoot, relPath);
+    const srcPath = join(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 = join53(projectRoot, WINDSURF_CANONICAL_MCP);
-      await mkdirp(dirname19(destPath));
+      const destPath = join(projectRoot, WINDSURF_CANONICAL_MCP);
+      await mkdirp(dirname(destPath));
       await writeFileAtomic(destPath, JSON.stringify({ mcpServers: parsed.mcpServers }, null, 2));
       results.push({
         fromTool: WINDSURF_TARGET,
@@ -8910,12 +8746,12 @@ async function importFromWindsurf(projectRoot, options) {
   const results = [];
   const normalize = await createImportReferenceNormalizer(WINDSURF_TARGET, projectRoot);
   const normalizeCodex = await createImportReferenceNormalizer("codex-cli", projectRoot);
-  const destRulesDir = join54(projectRoot, WINDSURF_CANONICAL_RULES_DIR);
-  const rootPath = join54(projectRoot, WINDSURF_RULES_ROOT);
+  const destRulesDir = join(projectRoot, WINDSURF_CANONICAL_RULES_DIR);
+  const rootPath = join(projectRoot, WINDSURF_RULES_ROOT);
   const rootContent = await readFileSafe(rootPath);
   if (rootContent !== null) {
     await mkdirp(destRulesDir);
-    const destPath = join54(destRulesDir, "_root.md");
+    const destPath = join(destRulesDir, "_root.md");
     const body = normalize(rootContent, rootPath, destPath).trim();
     const outContent = await serializeImportedRuleWithFallback(destPath, { root: true }, body);
     await writeFileAtomic(destPath, outContent);
@@ -8927,11 +8763,11 @@ async function importFromWindsurf(projectRoot, options) {
     });
   }
   if (rootContent === null) {
-    const agentsMdPath = join54(projectRoot, WINDSURF_AGENTS_MD);
+    const agentsMdPath = join(projectRoot, WINDSURF_AGENTS_MD);
     const agentsMdContent = await readFileSafe(agentsMdPath);
     if (agentsMdContent !== null) {
       await mkdirp(destRulesDir);
-      const destPath = join54(destRulesDir, "_root.md");
+      const destPath = join(destRulesDir, "_root.md");
       const body = normalize(
         normalizeCodex(agentsMdContent, agentsMdPath, destPath),
         agentsMdPath,
@@ -8956,14 +8792,14 @@ async function importFromWindsurf(projectRoot, options) {
         fromTool: "windsurf",
         normalize,
         mapEntry: async ({ srcPath, normalizeTo }) => {
-          const relDir = relative16(projectRoot, dirname20(srcPath)).replace(/\\/g, "/");
+          const relDir = relative(projectRoot, dirname(srcPath)).replace(/\\/g, "/");
           if (!relDir || relDir === "." || !srcPath.endsWith("/AGENTS.md")) return null;
           const ruleName = relDir.replace(/\//g, "-");
           if (!shouldImportScopedAgentsRule(relDir)) {
-            await removePathIfExists(join54(destRulesDir, `${ruleName}.md`));
+            await removePathIfExists(join(destRulesDir, `${ruleName}.md`));
             return null;
           }
-          const destPath = join54(destRulesDir, `${ruleName}.md`);
+          const destPath = join(destRulesDir, `${ruleName}.md`);
           return {
             destPath,
             toPath: `${WINDSURF_CANONICAL_RULES_DIR}/${ruleName}.md`,
@@ -8978,7 +8814,7 @@ async function importFromWindsurf(projectRoot, options) {
       })
     );
   }
-  const rulesDir = join54(projectRoot, WINDSURF_RULES_DIR);
+  const rulesDir = join(projectRoot, WINDSURF_RULES_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir: rulesDir,
@@ -8988,7 +8824,7 @@ async function importFromWindsurf(projectRoot, options) {
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
         if (relativePath === "_root.md" && rootContent !== null) return null;
-        const destPath = join54(destRulesDir, relativePath);
+        const destPath = join(destRulesDir, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         const normalizedFrontmatter = { ...frontmatter };
         if (typeof normalizedFrontmatter.glob === "string" && normalizedFrontmatter.glob.trim()) {
@@ -9008,10 +8844,10 @@ async function importFromWindsurf(projectRoot, options) {
       }
     })
   );
-  let ignorePath = join54(projectRoot, WINDSURF_IGNORE);
+  let ignorePath = join(projectRoot, WINDSURF_IGNORE);
   let ignoreContent = await readFileSafe(ignorePath);
   if (ignoreContent === null || !ignoreContent.trim()) {
-    ignorePath = join54(projectRoot, CODEIUM_IGNORE);
+    ignorePath = join(projectRoot, CODEIUM_IGNORE);
     ignoreContent = await readFileSafe(ignorePath);
   }
   if (ignoreContent !== null && ignoreContent.trim()) {
@@ -9022,8 +8858,8 @@ async function importFromWindsurf(projectRoot, options) {
       if (t && !t.startsWith("#")) patterns.push(t);
     }
     if (patterns.length > 0) {
-      await mkdirp(join54(projectRoot, ".agentsmesh"));
-      const destIgnorePath = join54(projectRoot, WINDSURF_CANONICAL_IGNORE);
+      await mkdirp(join(projectRoot, ".agentsmesh"));
+      const destIgnorePath = join(projectRoot, WINDSURF_CANONICAL_IGNORE);
       await writeFileAtomic(destIgnorePath, patterns.join("\n"));
       results.push({
         fromTool: "windsurf",
@@ -9039,9 +8875,6 @@ async function importFromWindsurf(projectRoot, options) {
   await importWindsurfMcp(projectRoot, results);
   return results;
 }
-// src/targets/windsurf/linter.ts
-import { relative as relative17 } from "path";
 function lintRules10(canonical, projectRoot, _projectFiles) {
   const diags = [];
   const { rules } = canonical;
@@ -9050,7 +8883,7 @@ function lintRules10(canonical, projectRoot, _projectFiles) {
     if (!hasRoot) {
       diags.push({
         level: "warning",
-        file: relative17(projectRoot, rules[0].source),
+        file: relative(projectRoot, rules[0].source),
         target: WINDSURF_TARGET,
         message: "Windsurf needs a root rule to generate AGENTS.md. Add root: true to a rule."
       });
@@ -9233,9 +9066,6 @@ var descriptor10 = {
   buildImportPaths: buildWindsurfImportPaths,
   detectionPaths: [".windsurfrules", ".windsurf"]
 };
-// src/targets/antigravity/generator.ts
-import { basename as basename28 } from "path";
 function generateRules11(canonical) {
   const root = canonical.rules.find((r) => r.root);
   if (!root) return [];
@@ -9245,7 +9075,7 @@ function generateRules11(canonical) {
   for (const rule of canonical.rules) {
     if (rule.root) continue;
     if (rule.targets.length > 0 && !rule.targets.includes("antigravity")) continue;
-    const slug = basename28(rule.source, ".md");
+    const slug = basename(rule.source, ".md");
     outputs.push({
       path: `${ANTIGRAVITY_RULES_DIR}/${slug}.md`,
       content: rule.body.trim() || ""
@@ -9286,12 +9116,9 @@ function renderAntigravityGlobalInstructions(canonical) {
   });
   return appendEmbeddedRulesBlock(root?.body.trim() ?? "", nonRootRules);
 }
-// src/targets/antigravity/importer.ts
-import { basename as basename29, join as join55 } from "path";
 async function importRootRule(projectRoot, results, normalize, scope) {
-  const primary = scope === "global" ? join55(projectRoot, ANTIGRAVITY_GLOBAL_ROOT) : join55(projectRoot, ANTIGRAVITY_RULES_ROOT);
-  const legacy = join55(projectRoot, ANTIGRAVITY_RULES_ROOT_LEGACY);
+  const primary = scope === "global" ? join(projectRoot, ANTIGRAVITY_GLOBAL_ROOT) : join(projectRoot, ANTIGRAVITY_RULES_ROOT);
+  const legacy = join(projectRoot, ANTIGRAVITY_RULES_ROOT_LEGACY);
   let srcPath = primary;
   let content = await readFileSafe(primary);
   if (scope === "project" && content === null) {
@@ -9299,7 +9126,7 @@ async function importRootRule(projectRoot, results, normalize, scope) {
     content = await readFileSafe(legacy);
   }
   if (content === null) return;
-  const destPath = join55(projectRoot, ANTIGRAVITY_CANONICAL_ROOT_RULE);
+  const destPath = join(projectRoot, ANTIGRAVITY_CANONICAL_ROOT_RULE);
   const split = await splitEmbeddedRulesToCanonical({
     content,
     projectRoot,
@@ -9311,7 +9138,7 @@ async function importRootRule(projectRoot, results, normalize, scope) {
   results.push(...split.results);
   const { body } = parseFrontmatter(normalize(split.rootContent, srcPath, destPath));
   const output = await serializeImportedRuleWithFallback(destPath, { root: true }, body);
-  await mkdirp(join55(projectRoot, ANTIGRAVITY_CANONICAL_RULES_DIR));
+  await mkdirp(join(projectRoot, ANTIGRAVITY_CANONICAL_RULES_DIR));
   await writeFileAtomic(destPath, output);
   results.push({
     fromTool: ANTIGRAVITY_TARGET,
@@ -9321,8 +9148,8 @@ async function importRootRule(projectRoot, results, normalize, scope) {
   });
 }
 async function importNonRootRules2(projectRoot, results, normalize) {
-  const srcDir = join55(projectRoot, ANTIGRAVITY_RULES_DIR);
-  const destDir = join55(projectRoot, ANTIGRAVITY_CANONICAL_RULES_DIR);
+  const srcDir = join(projectRoot, ANTIGRAVITY_RULES_DIR);
+  const destDir = join(projectRoot, ANTIGRAVITY_CANONICAL_RULES_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir,
@@ -9331,9 +9158,9 @@ async function importNonRootRules2(projectRoot, results, normalize) {
       fromTool: ANTIGRAVITY_TARGET,
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
-        if (basename29(relativePath) === "general.md" || basename29(relativePath) === "_root.md")
+        if (basename(relativePath) === "general.md" || basename(relativePath) === "_root.md")
           return null;
-        const destPath = join55(destDir, relativePath);
+        const destPath = join(destDir, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         const output = await serializeImportedRuleWithFallback(
           destPath,
@@ -9356,8 +9183,8 @@ async function importNonRootRules2(projectRoot, results, normalize) {
 }
 async function importWorkflows2(projectRoot, results, normalize, scope) {
   const workflowsRel = scope === "global" ? ANTIGRAVITY_GLOBAL_WORKFLOWS_DIR : ANTIGRAVITY_WORKFLOWS_DIR;
-  const srcDir = join55(projectRoot, workflowsRel);
-  const destDir = join55(projectRoot, ANTIGRAVITY_CANONICAL_COMMANDS_DIR);
+  const srcDir = join(projectRoot, workflowsRel);
+  const destDir = join(projectRoot, ANTIGRAVITY_CANONICAL_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir,
@@ -9366,7 +9193,7 @@ async function importWorkflows2(projectRoot, results, normalize, scope) {
       fromTool: ANTIGRAVITY_TARGET,
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
-        const destPath = join55(destDir, relativePath);
+        const destPath = join(destDir, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         const normalized = await serializeImportedCommandWithFallback(
           destPath,
@@ -9389,7 +9216,7 @@ async function importWorkflows2(projectRoot, results, normalize, scope) {
   );
 }
 async function importMcp4(projectRoot, results) {
-  const mcpPath = join55(projectRoot, ANTIGRAVITY_GLOBAL_MCP_CONFIG);
+  const mcpPath = join(projectRoot, ANTIGRAVITY_GLOBAL_MCP_CONFIG);
   const content = await readFileSafe(mcpPath);
   if (!content) return;
   let parsed;
@@ -9399,8 +9226,8 @@ async function importMcp4(projectRoot, results) {
     return;
   }
   if (!parsed || typeof parsed !== "object" || !("mcpServers" in parsed)) return;
-  const destPath = join55(projectRoot, ANTIGRAVITY_CANONICAL_MCP);
-  await mkdirp(join55(projectRoot, ".agentsmesh"));
+  const destPath = join(projectRoot, ANTIGRAVITY_CANONICAL_MCP);
+  await mkdirp(join(projectRoot, ".agentsmesh"));
   await writeFileAtomic(destPath, content);
   results.push({
     fromTool: ANTIGRAVITY_TARGET,
@@ -9549,14 +9376,6 @@ var descriptor11 = {
     ".agents/workflows/"
   ]
 };
-// src/targets/roo-code/index.ts
-import { join as join58, basename as basename31 } from "path";
-import { stringify as yamlStringify10 } from "yaml";
-// src/targets/roo-code/generator.ts
-import { basename as basename30 } from "path";
-import { stringify as yamlStringify9 } from "yaml";
 function generateRules12(canonical) {
   const outputs = [];
   const root = canonical.rules.find((rule) => rule.root);
@@ -9569,7 +9388,7 @@ function generateRules12(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 = basename30(rule.source, ".md");
+    const slug = basename(rule.source, ".md");
     outputs.push({
       path: `${ROO_CODE_RULES_DIR}/${slug}.md`,
       content: rule.body.trim() || ""
@@ -9606,21 +9425,14 @@ function generateSkills12(canonical) {
 function generateAgents10(canonical) {
   if (canonical.agents.length === 0) return [];
   const customModes = canonical.agents.map((agent) => {
-    const slug = basename30(agent.source, ".md");
+    const slug = basename(agent.source, ".md");
     const mode = { slug, name: agent.name };
     if (agent.description) mode.description = agent.description;
     if (agent.body.trim()) mode.roleDefinition = agent.body.trim();
     return mode;
   });
-  return [{ path: ROO_CODE_MODES_FILE, content: yamlStringify9({ customModes }) }];
+  return [{ path: ROO_CODE_MODES_FILE, content: stringify({ customModes }) }];
 }
-// src/targets/roo-code/importer.ts
-import { readdir as readdir4 } from "fs/promises";
-import { join as join57 } from "path";
-// src/targets/roo-code/importer-commands-mcp-ignore.ts
-import { join as join56 } from "path";
 function readMcpServers4(content) {
   const parsed = JSON.parse(content);
   const rawServers = parsed.mcpServers;
@@ -9652,8 +9464,8 @@ function readMcpServers4(content) {
   return servers;
 }
 async function importRooCommands(projectRoot, results, normalize) {
-  const srcDir = join56(projectRoot, ROO_CODE_COMMANDS_DIR);
-  const destDir = join56(projectRoot, ROO_CODE_CANONICAL_COMMANDS_DIR);
+  const srcDir = join(projectRoot, ROO_CODE_COMMANDS_DIR);
+  const destDir = join(projectRoot, ROO_CODE_CANONICAL_COMMANDS_DIR);
   results.push(
     ...await importFileDirectory({
       srcDir,
@@ -9662,7 +9474,7 @@ async function importRooCommands(projectRoot, results, normalize) {
       fromTool: ROO_CODE_TARGET,
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
-        const destPath = join56(destDir, relativePath);
+        const destPath = join(destDir, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         const output = await serializeImportedCommandWithFallback(
           destPath,
@@ -9685,13 +9497,13 @@ async function importRooCommands(projectRoot, results, normalize) {
   );
 }
 async function importRooMcp(projectRoot, results, scope) {
-  const srcPath = scope === "global" ? join56(projectRoot, ROO_CODE_GLOBAL_MCP_FILE) : join56(projectRoot, ROO_CODE_MCP_FILE);
+  const srcPath = scope === "global" ? join(projectRoot, ROO_CODE_GLOBAL_MCP_FILE) : join(projectRoot, ROO_CODE_MCP_FILE);
   const content = await readFileSafe(srcPath);
   if (content === null) return;
   const servers = readMcpServers4(content);
   if (Object.keys(servers).length === 0) return;
   await writeFileAtomic(
-    join56(projectRoot, ROO_CODE_CANONICAL_MCP),
+    join(projectRoot, ROO_CODE_CANONICAL_MCP),
     JSON.stringify({ mcpServers: servers }, null, 2)
   );
   results.push({
@@ -9702,10 +9514,10 @@ async function importRooMcp(projectRoot, results, scope) {
   });
 }
 async function importRooIgnore(projectRoot, results) {
-  const srcPath = join56(projectRoot, ROO_CODE_IGNORE);
+  const srcPath = join(projectRoot, ROO_CODE_IGNORE);
   const content = await readFileSafe(srcPath);
   if (content === null) return;
-  await writeFileAtomic(join56(projectRoot, ROO_CODE_CANONICAL_IGNORE), content.trimEnd());
+  await writeFileAtomic(join(projectRoot, ROO_CODE_CANONICAL_IGNORE), content.trimEnd());
   results.push({
     fromTool: ROO_CODE_TARGET,
     fromPath: srcPath,
@@ -9716,10 +9528,10 @@ async function importRooIgnore(projectRoot, results) {
 // src/targets/roo-code/importer.ts
 async function importRootRule2(projectRoot, results, normalize, scope) {
-  const destPath = join57(projectRoot, ROO_CODE_CANONICAL_ROOT_RULE);
+  const destPath = join(projectRoot, ROO_CODE_CANONICAL_ROOT_RULE);
   const sources = scope === "global" ? [ROO_CODE_GLOBAL_AGENTS_MD, ROO_CODE_ROOT_RULE, ROO_CODE_ROOT_RULE_FALLBACK] : [ROO_CODE_ROOT_RULE, ROO_CODE_ROOT_RULE_FALLBACK];
   for (const relPath of sources) {
-    const srcPath = join57(projectRoot, relPath);
+    const srcPath = join(projectRoot, relPath);
     const content = await readFileSafe(srcPath);
     if (content === null) continue;
     const { frontmatter, body } = parseFrontmatter(normalize(content, srcPath, destPath));
@@ -9743,8 +9555,8 @@ async function importRootRule2(projectRoot, results, normalize, scope) {
   }
 }
 async function importNonRootRules3(projectRoot, results, normalize) {
-  const srcDir = join57(projectRoot, ROO_CODE_RULES_DIR);
-  const destDir = join57(projectRoot, ROO_CODE_CANONICAL_RULES_DIR);
+  const srcDir = join(projectRoot, ROO_CODE_RULES_DIR);
+  const destDir = join(projectRoot, ROO_CODE_CANONICAL_RULES_DIR);
   const rootRuleName = "00-root.md";
   results.push(
     ...await importFileDirectory({
@@ -9755,7 +9567,7 @@ async function importNonRootRules3(projectRoot, results, normalize) {
       normalize,
       mapEntry: async ({ relativePath, normalizeTo }) => {
         if (relativePath === rootRuleName) return null;
-        const destPath = join57(destDir, relativePath);
+        const destPath = join(destDir, relativePath);
         const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
         const output = await serializeImportedRuleWithFallback(
           destPath,
@@ -9777,17 +9589,17 @@ async function importNonRootRules3(projectRoot, results, normalize) {
   );
 }
 async function importPerModeRules(projectRoot, results, normalize) {
-  const rooDir = join57(projectRoot, ROO_CODE_DIR);
+  const rooDir = join(projectRoot, ROO_CODE_DIR);
   let entries;
   try {
-    entries = await readdir4(rooDir, { withFileTypes: true });
+    entries = await readdir(rooDir, { withFileTypes: true });
   } catch {
     return;
   }
   const modeRuleDirs = entries.filter((e) => e.isDirectory() && e.name.startsWith("rules-")).map((e) => e.name);
   for (const dirName of modeRuleDirs) {
-    const srcDir = join57(rooDir, dirName);
-    const destDir = join57(projectRoot, ROO_CODE_CANONICAL_RULES_DIR);
+    const srcDir = join(rooDir, dirName);
+    const destDir = join(projectRoot, ROO_CODE_CANONICAL_RULES_DIR);
     results.push(
       ...await importFileDirectory({
         srcDir,
@@ -9796,7 +9608,7 @@ async function importPerModeRules(projectRoot, results, normalize) {
         fromTool: ROO_CODE_TARGET,
         normalize,
         mapEntry: async ({ relativePath, normalizeTo }) => {
-          const destPath = join57(destDir, relativePath);
+          const destPath = join(destDir, relativePath);
           const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
           const output = await serializeImportedRuleWithFallback(
             destPath,
@@ -9882,14 +9694,14 @@ var generateRooGlobalExtras = async (canonical, projectRoot, scope, enabledFeatu
   if (scope !== "global") return [];
   if (!enabledFeatures.has("agents") || canonical.agents.length === 0) return [];
   const customModes = canonical.agents.map((agent) => {
-    const slug = basename31(agent.source, ".md");
+    const slug = basename(agent.source, ".md");
     const mode = { slug, name: agent.name };
     if (agent.description) mode.description = agent.description;
     if (agent.body.trim()) mode.roleDefinition = agent.body.trim();
     return mode;
   });
-  const content = yamlStringify10({ customModes });
-  const existing = await readFileSafe(join58(projectRoot, ROO_CODE_GLOBAL_MODES_FILE));
+  const content = stringify({ customModes });
+  const existing = await readFileSafe(join(projectRoot, ROO_CODE_GLOBAL_MODES_FILE));
   return [
     {
       target: "roo-code",
@@ -10030,6 +9842,7 @@ var BUILTIN_TARGETS = [
 var _builtinTargetsMap;
 function builtinTargetsMap() {
   if (!_builtinTargetsMap) {
+    assertSharedArtifactOwnersUnique(BUILTIN_TARGETS);
     _builtinTargetsMap = new Map(BUILTIN_TARGETS.map((d) => [d.id, d]));
   }
   return _builtinTargetsMap;
@@ -10038,33 +9851,17 @@ function getBuiltinTargetDefinition(target13) {
   return builtinTargetsMap().get(target13);
 }
 function getTargetCapabilities(target13, scope = "project") {
-  const descriptor13 = getBuiltinTargetDefinition(target13);
+  const descriptor13 = getBuiltinTargetDefinition(target13) ?? getDescriptor(target13);
   if (!descriptor13) return void 0;
   const raw = scope === "global" ? descriptor13.globalSupport?.capabilities ?? descriptor13.globalCapabilities ?? descriptor13.capabilities : descriptor13.capabilities;
   return normalizeTargetCapabilities(raw);
 }
-// src/targets/catalog/registry.ts
-var descriptorRegistry = /* @__PURE__ */ new Map();
-var builtinDescriptors = new Map(BUILTIN_TARGETS.map((d) => [d.id, d]));
-function registerTargetDescriptor(descriptor13) {
-  descriptorRegistry.set(descriptor13.id, descriptor13);
-}
-function getDescriptor(name) {
-  return descriptorRegistry.get(name) ?? builtinDescriptors.get(name);
-}
-function getAllDescriptors() {
-  return [...descriptorRegistry.values()];
-}
 // src/public/targets.ts
 function getTargetCatalog() {
   return BUILTIN_TARGETS;
 }
-export {
-  getAllDescriptors,
-  getDescriptor,
-  getTargetCatalog,
-  registerTargetDescriptor
-};
+export { getAllDescriptors, getDescriptor, getTargetCatalog, registerTargetDescriptor };
+//# sourceMappingURL=targets.js.map
 //# sourceMappingURL=targets.js.map