agentsmesh 0.41.0 → 0.42.0

package/dist/canonical.js

@@ -1,5 +1,5 @@
 import { join, basename, dirname, relative, extname, resolve, posix, win32 } from 'path';
-import { access, readdir, readFile, rm, mkdir, lstat, open, stat, realpath, rename, writeFile, mkdtemp, cp } from 'fs/promises';
+import { access, readdir, readFile, lstat, rm, mkdir, open, stat, realpath, rename, writeFile, mkdtemp, cp } from 'fs/promises';
 import { setTimeout } from 'timers/promises';
 import { randomUUID, createHash } from 'crypto';
 import { constants, existsSync, readFileSync, realpathSync, statSync } from 'fs';
@@ -422,6 +422,77 @@ var init_fs = __esm({
     init_rename_retry();
   }
 });
+
+// src/utils/output/color.ts
+function noColorRequested() {
+  const value = process.env.NO_COLOR;
+  return value !== void 0 && value !== "";
+}
+function forceColorRequested() {
+  const value = process.env.FORCE_COLOR;
+  if (value === void 0) return void 0;
+  return value !== "0" && value !== "false";
+}
+function colorEnabled(stream = process.stdout) {
+  const forced = forceColorRequested();
+  if (forced !== void 0) return forced;
+  if (noColorRequested()) return false;
+  return stream.isTTY === true;
+}
+var init_color = __esm({
+  "src/utils/output/color.ts"() {
+  }
+});
+
+// src/utils/output/logger.ts
+function outStream() {
+  return stdoutRedirectedToStderr ? process.stderr : process.stdout;
+}
+function out(text) {
+  outStream().write(text);
+}
+function c(code, text, stream) {
+  return colorEnabled(stream) ? `${code}${text}${C.reset}` : text;
+}
+var C, muted, stdoutRedirectedToStderr, logger;
+var init_logger = __esm({
+  "src/utils/output/logger.ts"() {
+    init_color();
+    C = {
+      green: "\x1B[32m",
+      red: "\x1B[31m",
+      yellow: "\x1B[33m",
+      cyan: "\x1B[36m",
+      reset: "\x1B[0m"
+    };
+    muted = false;
+    stdoutRedirectedToStderr = false;
+    logger = {
+      info(msg) {
+        if (muted) return;
+        out(c(C.cyan, msg, outStream()) + "\n");
+      },
+      warn(msg) {
+        if (muted) return;
+        process.stderr.write(c(C.yellow, "\u26A0 ", process.stderr) + msg + "\n");
+      },
+      error(msg) {
+        if (muted) return;
+        process.stderr.write(c(C.red, "\u2717 ", process.stderr) + msg + "\n");
+      },
+      success(msg) {
+        if (muted) return;
+        out(c(C.green, "\u2713 ", outStream()) + msg + "\n");
+      },
+      debug(msg) {
+        if (muted) return;
+        if (process.env.AGENTSMESH_DEBUG === "1") {
+          out(c(C.cyan, "[debug] ", outStream()) + msg + "\n");
+        }
+      }
+    };
+  }
+});
 function parseFrontmatter(content) {
   const split = splitFrontmatter(content);
   if (split === null) return { frontmatter: {}, body: content.trim() };
@@ -1575,12 +1646,6 @@ var init_no_outputs = __esm({
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function managedBlockPattern(start, end) {
-  return new RegExp(`${escapeRegExp(start)}[\\s\\S]*?${escapeRegExp(end)}`, "g");
-}
-function stripManagedBlock(content, start, end) {
-  return content.replace(managedBlockPattern(start, end), "").trim();
-}
 function ruleSource(source) {
   const normalized = source.replace(/\\/g, "/");
   const meshIndex = normalized.lastIndexOf(".agentsmesh/");
@@ -1588,36 +1653,22 @@ function ruleSource(source) {
   if (normalized.startsWith("rules/")) return normalized;
   return join("rules", basename(normalized)).replace(/\\/g, "/");
 }
-function markerForRule(rule) {
-  return {
+function renderEmbeddedRule(rule) {
+  const marker = {
     source: ruleSource(rule.source),
     description: rule.description,
     globs: rule.globs,
     targets: rule.targets
   };
-}
-function embeddedRuleStart(rule) {
-  return `${EMBEDDED_RULE_START_PREFIX}${JSON.stringify(markerForRule(rule))}${EMBEDDED_RULE_START_SUFFIX}`;
-}
-function renderRule(rule) {
-  const parts = [embeddedRuleStart(rule)];
+  const parts = [`${START_PREFIX}${JSON.stringify(marker)}${START_SUFFIX}`];
   if (rule.description.trim()) {
     parts.push(`## ${rule.description.trim()}`, "");
   }
   parts.push(rule.body.trim(), EMBEDDED_RULE_END);
   return parts.filter((part) => part.length > 0).join("\n");
 }
-function renderEmbeddedRulesBlock(rules) {
-  if (rules.length === 0) return "";
-  return [EMBEDDED_RULES_START, ...rules.map(renderRule), EMBEDDED_RULES_END].join("\n");
-}
-function appendEmbeddedRulesBlock(content, rules) {
-  const block = renderEmbeddedRulesBlock(rules);
-  const withoutExisting = stripManagedBlock(content, EMBEDDED_RULES_START, EMBEDDED_RULES_END);
-  if (!block) return withoutExisting;
-  return withoutExisting ? `${withoutExisting}
-
-${block}` : block;
+function renderEmbeddedRuleEntries(rules) {
+  return rules.map(renderEmbeddedRule).join("\n\n");
 }
 function toStringArray2(value) {
   return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
@@ -1644,26 +1695,54 @@ function stripGeneratedHeading(body, description) {
   const heading = `## ${description.trim()}`;
   return trimmed.startsWith(heading) ? trimmed.slice(heading.length).trim() : trimmed;
 }
+function takeEmbeddedRuleEntries(text) {
+  const rules = [];
+  const entry = new RegExp(
+    `${escapeRegExp(START_PREFIX)}([\\s\\S]*?)${escapeRegExp(START_SUFFIX)}([\\s\\S]*?)${escapeRegExp(EMBEDDED_RULE_END)}`,
+    "g"
+  );
+  const rest = text.replace(entry, (whole, markerText, body) => {
+    const marker = parseMarker(markerText);
+    if (!marker) return whole;
+    rules.push({ ...marker, body: stripGeneratedHeading(body, marker.description) });
+    return "";
+  });
+  return { rest: rest.trim(), rules };
+}
+var EMBEDDED_RULE_END, START_PREFIX, START_SUFFIX;
+var init_embedded_rule_entries = __esm({
+  "src/targets/projection/embedded-rule-entries.ts"() {
+    EMBEDDED_RULE_END = "<!-- agentsmesh:embedded-rule:end -->";
+    START_PREFIX = "<!-- agentsmesh:embedded-rule:start ";
+    START_SUFFIX = " -->";
+  }
+});
+
+// src/targets/projection/managed-blocks.ts
+function managedBlockPattern(start, end) {
+  return new RegExp(`${escapeRegExp(start)}[\\s\\S]*?${escapeRegExp(end)}`, "g");
+}
+function stripManagedBlock(content, start, end) {
+  return content.replace(managedBlockPattern(start, end), "").trim();
+}
+function renderEmbeddedRulesBlock(rules) {
+  if (rules.length === 0) return "";
+  return [EMBEDDED_RULES_START, ...rules.map(renderEmbeddedRule), EMBEDDED_RULES_END].join("\n");
+}
+function appendEmbeddedRulesBlock(content, rules) {
+  const block = renderEmbeddedRulesBlock(rules);
+  const withoutExisting = stripManagedBlock(content, EMBEDDED_RULES_START, EMBEDDED_RULES_END);
+  if (!block) return withoutExisting;
+  return withoutExisting ? `${withoutExisting}
+
+${block}` : block;
+}
 function extractEmbeddedRules(content) {
   const rules = [];
   const outerPattern = managedBlockPattern(EMBEDDED_RULES_START, EMBEDDED_RULES_END);
   const rootContent = content.replace(outerPattern, (block) => {
-    const inner = block.replace(EMBEDDED_RULES_START, "").replace(EMBEDDED_RULES_END, "").trim();
-    const entryPattern = new RegExp(
-      `${escapeRegExp(EMBEDDED_RULE_START_PREFIX)}([\\s\\S]*?)${escapeRegExp(EMBEDDED_RULE_START_SUFFIX)}([\\s\\S]*?)${escapeRegExp(EMBEDDED_RULE_END)}`,
-      "g"
-    );
-    for (const match of inner.matchAll(entryPattern)) {
-      const markerText = match[1];
-      const body = match[2];
-      if (markerText === void 0 || body === void 0) continue;
-      const marker = parseMarker(markerText);
-      if (!marker) continue;
-      rules.push({
-        ...marker,
-        body: stripGeneratedHeading(body, marker.description)
-      });
-    }
+    const inner = block.replace(EMBEDDED_RULES_START, "").replace(EMBEDDED_RULES_END, "");
+    rules.push(...takeEmbeddedRuleEntries(inner).rules);
     return "";
   });
   return { rootContent: rootContent.trim(), rules };
@@ -1676,17 +1755,16 @@ function embeddedRootRule(canonical, target34, rootFile) {
   const content = appendEmbeddedRulesBlock(rootBody, nonRootRules);
   return content ? [{ path: rootFile, content }] : [];
 }
-var ROOT_CONTRACT_START, ROOT_CONTRACT_END, EMBEDDED_RULES_START, EMBEDDED_RULES_END, EMBEDDED_RULE_END, EMBEDDED_RULE_START_PREFIX, EMBEDDED_RULE_START_SUFFIX;
+var ROOT_CONTRACT_START, ROOT_CONTRACT_END, EMBEDDED_RULES_START, EMBEDDED_RULES_END;
 var init_managed_blocks = __esm({
   "src/targets/projection/managed-blocks.ts"() {
     init_markdown();
+    init_embedded_rule_entries();
+    init_embedded_rule_entries();
     ROOT_CONTRACT_START = "<!-- agentsmesh:root-generation-contract:start -->";
     ROOT_CONTRACT_END = "<!-- agentsmesh:root-generation-contract:end -->";
     EMBEDDED_RULES_START = "<!-- agentsmesh:embedded-rules:start -->";
     EMBEDDED_RULES_END = "<!-- agentsmesh:embedded-rules:end -->";
-    EMBEDDED_RULE_END = "<!-- agentsmesh:embedded-rule:end -->";
-    EMBEDDED_RULE_START_PREFIX = "<!-- agentsmesh:embedded-rule:start ";
-    EMBEDDED_RULE_START_SUFFIX = " -->";
   }
 });
 
@@ -2954,6 +3032,8 @@ function rewriteFileLinks(input) {
     const lineNumSuffix = lineNumMatch ? lineNumMatch[0] : "";
     if (!rawCandidate) return match;
     const tokenContext = getTokenContext(fullContent, offset, offset + rawCandidate.length);
+    if (input.markdownLinksOnly === true && tokenContext.role !== "markdown-link-dest")
+      return match;
     const candidate = decodeLinkPath(rawCandidate, tokenContext.role);
     if (tokenContext.role !== "markdown-link-dest" && WINDOWS_ABSOLUTE_PATH.test(candidate)) {
       return match;
@@ -3128,13 +3208,12 @@ var init_import_rewriter = __esm({
 });
 async function writeMcpWithMerge(projectRoot, canonicalPath, imported) {
   const destPath = join(projectRoot, canonicalPath);
-  const existing = await readExistingServers(destPath);
+  const existing = parseMcpServers(await readFileSafe(destPath));
   const merged = { ...existing, ...imported };
   await mkdirp(dirname(destPath));
   await writeFileAtomic(destPath, JSON.stringify({ mcpServers: merged }, null, 2));
 }
-async function readExistingServers(path) {
-  const content = await readFileSafe(path);
+function parseMcpServers(content) {
   if (content === null) return {};
   let parsed;
   try {
@@ -7093,12 +7172,14 @@ function canonicalRulePath(source) {
 }
 async function splitEmbeddedRulesToCanonical(input) {
   const extracted = extractEmbeddedRules(input.content);
+  const results = await writeEmbeddedRules(extracted.rules, input);
+  return { rootContent: extracted.rootContent, results };
+}
+async function writeEmbeddedRules(rules, input) {
   const results = [];
-  if (extracted.rules.length === 0) {
-    return { rootContent: extracted.rootContent, results };
-  }
+  if (rules.length === 0) return results;
   await mkdirp(join(input.projectRoot, input.rulesDir));
-  for (const rule of extracted.rules) {
+  for (const rule of rules) {
     const canonicalSource = canonicalRulePath(rule.source);
     if (canonicalSource === null || canonicalSource === "rules/_root.md") continue;
     const destPath = join(input.projectRoot, ".agentsmesh", canonicalSource);
@@ -7108,6 +7189,7 @@ async function splitEmbeddedRulesToCanonical(input) {
       destPath,
       {
         ...frontmatter,
+        ...input.frontmatter,
         root: false,
         description: rule.description || void 0,
         globs: rule.globs.length > 0 ? rule.globs : void 0,
@@ -7123,13 +7205,19 @@ async function splitEmbeddedRulesToCanonical(input) {
       feature: "rules"
     });
   }
-  return { rootContent: extracted.rootContent, results };
+  return results;
+}
+async function splitNestedAgentsFile(input, into) {
+  const { rest, rules } = takeEmbeddedRuleEntries(input.content);
+  into.push(...await writeEmbeddedRules(rules, input));
+  return rest.length > 0 ? rest : null;
 }
 var init_embedded_rules = __esm({
   "src/targets/import/embedded-rules.ts"() {
     init_fs();
     init_markdown();
     init_managed_blocks();
+    init_embedded_rule_entries();
     init_import_metadata();
   }
 });
@@ -8426,7 +8514,7 @@ function generateRules6(canonical) {
     const slug = basename(rule.source, ".md");
     const frontmatter = {};
     if (rule.description) frontmatter.description = rule.description;
-    if (rule.globs.length > 0) frontmatter.globs = rule.globs;
+    if (rule.globs.length > 0) frontmatter.paths = rule.globs;
     const content = serializeFrontmatter(frontmatter, rule.body.trim() || "");
     outputs.push({ path: `${CLAUDE_RULES_DIR}/${slug}.md`, content });
   }
@@ -8808,12 +8896,14 @@ var init_import_mappers2 = __esm({
     }) => {
       const destPath = join(destDir, relativePath);
       const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
+      const { paths: paths2, ...rest } = frontmatter;
+      const scoped = paths2 === void 0 ? {} : { globs: toToolsArray2(paths2) };
       return {
         destPath,
         toPath: `${AB_RULES}/${relativePath}`,
         content: await serializeImportedRuleWithFallback(
           destPath,
-          { ...frontmatter, root: false },
+          { ...rest, ...scoped, root: false },
           body
         )
       };
@@ -10318,7 +10408,7 @@ function generateRules8(canonical) {
   const rootBody = canonical.rules.find((rule) => rule.root)?.body.trim() ?? "";
   if (rootBody) outputs.push({ path: CODEBUFF_ROOT_FILE, content: rootBody });
   for (const [path, rules] of groupByNestedPath(eligibleRules(canonical))) {
-    const content = rules.map((rule) => rule.body.trim()).filter((body) => body.length > 0).join("\n\n");
+    const content = renderEmbeddedRuleEntries(rules.filter((rule) => rule.body.trim().length > 0));
     if (content) outputs.push({ path, content });
   }
   return outputs;
@@ -10346,6 +10436,7 @@ var init_generator8 = __esm({
     init_no_outputs();
     init_embedded_skill();
     init_managed_blocks();
+    init_embedded_rule_entries();
     init_command_skill();
     init_nested_rules();
     init_mcp_format2();
@@ -10395,33 +10486,47 @@ function isVendored(relDir) {
 }
 async function importNestedRules(projectRoot, normalize) {
   const destDir = join(projectRoot, AB_RULES);
-  return importFileDirectory({
+  const embedded = [];
+  const results = await importFileDirectory({
     srcDir: projectRoot,
     destDir,
     extensions: [CODEBUFF_ROOT_FILE],
     fromTool: CODEBUFF_TARGET,
     normalize,
-    mapEntry: ({ srcPath, normalizeTo }) => {
+    mapEntry: async ({ srcPath, content, normalizeTo }) => {
       if (basename(srcPath) !== CODEBUFF_ROOT_FILE) return null;
       const relDir = relative(projectRoot, dirname(srcPath)).replace(/\\/g, "/");
       if (!relDir || relDir === ".") return null;
       if (!shouldImportScopedAgentsRule(relDir)) return null;
       if (isVendored(relDir)) return null;
+      const ownText = await splitNestedAgentsFile(
+        {
+          content,
+          projectRoot,
+          rulesDir: AB_RULES,
+          sourcePath: srcPath,
+          fromTool: CODEBUFF_TARGET,
+          normalize
+        },
+        embedded
+      );
+      if (ownText === null) return null;
       const ruleName2 = relDir.replace(/\//g, "-");
       const destPath = join(destDir, `${ruleName2}.md`);
-      const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
-      return serializeImportedRuleWithFallback(
-        destPath,
-        { ...frontmatter, root: false, globs: [`${relDir}/**`] },
-        body
-      ).then((content) => ({
+      const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath, ownText));
+      return {
         destPath,
         toPath: `${AB_RULES}/${ruleName2}.md`,
         feature: "rules",
-        content
-      }));
+        content: await serializeImportedRuleWithFallback(
+          destPath,
+          { ...frontmatter, root: false, globs: [`${relDir}/**`] },
+          body
+        )
+      };
     }
   });
+  return [...results, ...embedded];
 }
 async function importCodebuffRules(projectRoot, scope, normalize) {
   const results = await importRootRule2(projectRoot, scope, normalize);
@@ -10854,7 +10959,7 @@ function generateRules9(canonical) {
   }
   const nested = advisory.filter((rule) => !isRootEmbedded(rule));
   for (const [path, rules] of groupByNestedPath2(nested)) {
-    const content = rules.map((rule) => rule.body.trim()).filter((body) => body.length > 0).join("\n\n");
+    const content = renderEmbeddedRuleEntries(rules.filter((rule) => rule.body.trim().length > 0));
     outputs.push({ path, content });
   }
   return outputs;
@@ -10867,6 +10972,7 @@ function renderCodexGlobalInstructions(canonical) {
 var init_rules = __esm({
   "src/targets/codex-cli/generator/rules.ts"() {
     init_managed_blocks();
+    init_embedded_rule_entries();
     init_constants10();
     init_codex_rule_paths();
   }
@@ -11496,6 +11602,7 @@ async function importCodexRules(projectRoot, results, normalize, normalizeWindsu
   await importInstructionMirrors(projectRoot, destDir, results, normalize);
   results.push(...await importCodexNonRootRuleFiles(projectRoot, destDir, normalize));
   if (layoutScope !== "global") {
+    const embedded = [];
     results.push(
       ...await importFileDirectory({
         srcDir: projectRoot,
@@ -11503,7 +11610,7 @@ async function importCodexRules(projectRoot, results, normalize, normalizeWindsu
         extensions: ["AGENTS.md", "AGENTS.override.md"],
         fromTool: "codex-cli",
         normalize,
-        mapEntry: async ({ srcPath, normalizeTo }) => {
+        mapEntry: async ({ srcPath, content: content2, normalizeTo }) => {
           const relDir = relative(projectRoot, dirname(srcPath)).replace(/\\/g, "/");
           const fileName = basename(srcPath);
           const isOverride = fileName === "AGENTS.override.md";
@@ -11514,26 +11621,36 @@ async function importCodexRules(projectRoot, results, normalize, normalizeWindsu
             await removePathIfExists(join(destDir, `${ruleName2}.md`));
             return null;
           }
+          const variant = isOverride ? { codex_instruction: "override" } : {};
+          const ownText = await splitNestedAgentsFile(
+            {
+              content: content2,
+              projectRoot,
+              rulesDir: AB_RULES,
+              sourcePath: srcPath,
+              fromTool: "codex-cli",
+              normalize,
+              frontmatter: variant
+            },
+            embedded
+          );
+          if (ownText === null) return null;
           const destPath = join(destDir, `${ruleName2}.md`);
-          const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
+          const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath, ownText));
           return {
             destPath,
             toPath: `${AB_RULES}/${ruleName2}.md`,
             feature: "rules",
             content: await serializeImportedRuleWithFallback(
               destPath,
-              {
-                ...frontmatter,
-                root: false,
-                globs: [`${relDir}/**`],
-                ...isOverride ? { codex_instruction: "override" } : {}
-              },
+              { ...frontmatter, root: false, globs: [`${relDir}/**`], ...variant },
               body
             )
           };
         }
       })
     );
+    results.push(...embedded);
   }
 }
 async function importInstructionMirrors(projectRoot, destDir, results, normalize) {
@@ -18157,7 +18274,7 @@ function parseExtensions(content) {
   }
   return out2;
 }
-async function readExistingServers2(destPath) {
+async function readExistingServers(destPath) {
   const content = await readFileSafe(destPath);
   if (content === null) return {};
   let parsed;
@@ -18180,7 +18297,7 @@ async function gooseMcpMap(ctx) {
   const imported = ctx.relativePath.endsWith(".mcp.json") ? parsePluginMcpJson(ctx.content) : parseExtensions(ctx.content);
   if (Object.keys(imported).length === 0) return null;
   const destPath = join(ctx.destDir, "mcp.json");
-  const existing = await readExistingServers2(destPath);
+  const existing = await readExistingServers(destPath);
   const merged = { ...existing, ...imported };
   return {
     destPath,
@@ -26735,12 +26852,6 @@ function ruleSlug4(source) {
   const name = basename(source, ".md");
   return name === "_root" ? "root" : name;
 }
-function directoryScopedRuleDir(globs) {
-  if (globs.length === 0) return null;
-  const dirs = globs.map((glob) => glob.split("/")[0] ?? "").filter((segment) => /^[A-Za-z0-9._-]+$/.test(segment));
-  if (dirs.length !== globs.length) return null;
-  return dirs.every((dir) => dir === dirs[0]) ? dirs[0] : null;
-}
 function generateRules32(canonical) {
   const outputs = [];
   const root = canonical.rules.find((r) => r.root);
@@ -26757,21 +26868,14 @@ function generateRules32(canonical) {
     const frontmatter = {
       description: rule.description || void 0,
       trigger: normalizedTrigger,
-      glob: rule.globs.length === 1 ? rule.globs[0] : void 0,
-      globs: rule.globs.length > 1 ? rule.globs : void 0
+      // Windsurf reads `globs` as one comma-joined string; it ignores `glob`.
+      globs: rule.globs.length > 0 ? rule.globs.join(",") : void 0
     };
     Object.keys(frontmatter).forEach((k) => {
       if (frontmatter[k] === void 0) delete frontmatter[k];
     });
     const content = Object.keys(frontmatter).length > 0 ? serializeFrontmatter(frontmatter, rule.body.trim() || "") : rule.body.trim() || "";
     outputs.push({ path: `${WINDSURF_RULES_DIR}/${slug}.md`, content });
-    const dir = directoryScopedRuleDir(rule.globs);
-    if (dir) {
-      if (dir !== slug) {
-        outputs.push({ path: `${WINDSURF_RULES_DIR}/${dir}.md`, content });
-      }
-      outputs.push({ path: `${dir}/AGENTS.md`, content: rule.body.trim() || "" });
-    }
   }
   return outputs;
 }
@@ -26971,6 +27075,114 @@ var init_generator36 = __esm({
     init_generator35();
   }
 });
+
+// src/targets/windsurf/rule-globs.ts
+function splitTopLevelCommas(value) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const char of value) {
+    if (char === "{") depth++;
+    else if (char === "}") depth = Math.max(0, depth - 1);
+    if (char === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  parts.push(current);
+  return parts.map((part) => part.trim()).filter(Boolean);
+}
+function parseWindsurfGlobs(value) {
+  if (typeof value === "string") return splitTopLevelCommas(value);
+  return Array.isArray(value) ? toToolsArray2(value) : [];
+}
+function quoteWindsurfGlobValues(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---") return content;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === "---") break;
+    const match = UNQUOTED_GLOBS_LINE.exec(lines[i]);
+    if (match !== null) lines[i] = `${match[1]}${JSON.stringify(match[2])}${match[3]}`;
+  }
+  return lines.join("\n");
+}
+var UNQUOTED_GLOBS_LINE;
+var init_rule_globs = __esm({
+  "src/targets/windsurf/rule-globs.ts"() {
+    init_shared_import_helpers();
+    UNQUOTED_GLOBS_LINE = /^(\s*globs?\s*:[ \t]*)([^\s"'[{|>#][^\r\n]*?)[ \t]*(\r?)$/;
+  }
+});
+async function windsurfRuleBodies(projectRoot) {
+  const files = await readDirRecursiveNoSymlinks(join(projectRoot, WINDSURF_RULES_DIR));
+  const bodies = /* @__PURE__ */ new Set();
+  for (const file of files.filter((path) => path.endsWith(".md"))) {
+    const content = await readFileSafe(file);
+    if (content !== null) bodies.add(bodyKey(splitFrontmatter(content)?.body ?? content));
+  }
+  return bodies;
+}
+async function importWindsurfNestedAgents(projectRoot, normalize) {
+  const destRulesDir = join(projectRoot, AB_RULES);
+  const embedded = [];
+  const ruleBodies = await windsurfRuleBodies(projectRoot);
+  const results = await importFileDirectory({
+    srcDir: projectRoot,
+    destDir: destRulesDir,
+    extensions: ["AGENTS.md"],
+    fromTool: "windsurf",
+    normalize,
+    mapEntry: async ({ srcPath, content, normalizeTo }) => {
+      const relDir = relative(projectRoot, dirname(srcPath)).replace(/\\/g, "/");
+      if (!relDir || relDir === "." || basename(srcPath) !== "AGENTS.md") return null;
+      const ruleName2 = relDir.replace(/\//g, "-");
+      if (!shouldImportScopedAgentsRule(relDir)) {
+        await removePathIfExists(join(destRulesDir, `${ruleName2}.md`));
+        return null;
+      }
+      const ownText = await splitNestedAgentsFile(
+        {
+          content,
+          projectRoot,
+          rulesDir: AB_RULES,
+          sourcePath: srcPath,
+          fromTool: "windsurf",
+          normalize
+        },
+        embedded
+      );
+      if (ownText === null || ruleBodies.has(bodyKey(ownText))) return null;
+      const destPath = join(destRulesDir, `${ruleName2}.md`);
+      return {
+        destPath,
+        toPath: `${AB_RULES}/${ruleName2}.md`,
+        feature: "rules",
+        content: await serializeImportedRuleWithFallback(
+          destPath,
+          { root: false, globs: [`${relDir}/**`] },
+          normalizeTo(destPath, ownText)
+        )
+      };
+    }
+  });
+  return [...results, ...embedded];
+}
+var bodyKey;
+var init_import_nested_agents = __esm({
+  "src/targets/windsurf/import-nested-agents.ts"() {
+    init_canonical_paths();
+    init_embedded_rules();
+    init_import_metadata();
+    init_import_orchestrator();
+    init_scoped_agents_import();
+    init_fs();
+    init_markdown();
+    init_constants34();
+    bodyKey = (text) => text.replace(/\r\n?/g, "\n").trim();
+  }
+});
 function toStringArray3(value) {
   if (Array.isArray(value)) {
     return value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
@@ -27188,35 +27400,7 @@ async function importFromWindsurf(projectRoot, options) {
     }
   }
   if (layoutScope !== "global") {
-    results.push(
-      ...await importFileDirectory({
-        srcDir: projectRoot,
-        destDir: destRulesDir,
-        extensions: ["AGENTS.md"],
-        fromTool: "windsurf",
-        normalize,
-        mapEntry: async ({ srcPath, normalizeTo }) => {
-          const relDir = relative(projectRoot, dirname(srcPath)).replace(/\\/g, "/");
-          if (!relDir || relDir === "." || basename(srcPath) !== "AGENTS.md") return null;
-          const ruleName2 = relDir.replace(/\//g, "-");
-          if (!shouldImportScopedAgentsRule(relDir)) {
-            await removePathIfExists(join(destRulesDir, `${ruleName2}.md`));
-            return null;
-          }
-          const destPath = join(destRulesDir, `${ruleName2}.md`);
-          return {
-            destPath,
-            toPath: `${AB_RULES}/${ruleName2}.md`,
-            feature: "rules",
-            content: await serializeImportedRuleWithFallback(
-              destPath,
-              { root: false, globs: [`${relDir}/**`] },
-              normalizeTo(destPath)
-            )
-          };
-        }
-      })
-    );
+    results.push(...await importWindsurfNestedAgents(projectRoot, normalize));
   }
   const rulesDir = join(projectRoot, WINDSURF_RULES_DIR);
   results.push(
@@ -27226,15 +27410,22 @@ async function importFromWindsurf(projectRoot, options) {
       extensions: [".md"],
       fromTool: "windsurf",
       normalize,
-      mapEntry: async ({ relativePath, normalizeTo }) => {
+      mapEntry: async ({ relativePath, content, normalizeTo }) => {
         if (relativePath === "_root.md" && rootContent !== null) return null;
         const destPath = join(destRulesDir, relativePath);
-        const { frontmatter, body } = parseFrontmatter(normalizeTo(destPath));
-        const normalizedFrontmatter = { ...frontmatter };
-        if (typeof normalizedFrontmatter.glob === "string" && normalizedFrontmatter.glob.trim()) {
-          normalizedFrontmatter.globs = [normalizedFrontmatter.glob];
-          delete normalizedFrontmatter.glob;
+        const sourceLabel = `${WINDSURF_RULES_DIR}/${relativePath}`;
+        const parsed = tryParseFrontmatter(
+          normalizeTo(destPath, quoteWindsurfGlobValues(content)),
+          sourceLabel
+        );
+        if (!parsed.ok) {
+          logger.warn(`Skipping ${sourceLabel}: ${parsed.error.message}`);
+          return null;
         }
+        const { frontmatter, body } = parsed.value;
+        const { glob, ...normalizedFrontmatter } = frontmatter;
+        const globs = parseWindsurfGlobs(frontmatter.globs ?? glob);
+        if (globs.length > 0) normalizedFrontmatter.globs = globs;
         return {
           destPath,
           toPath: `${AB_RULES}/${relativePath}`,
@@ -27285,9 +27476,11 @@ var init_importer32 = __esm({
     init_import_rewriter();
     init_fs();
     init_markdown();
+    init_logger();
+    init_rule_globs();
     init_import_metadata();
     init_import_orchestrator();
-    init_scoped_agents_import();
+    init_import_nested_agents();
     init_constants34();
     init_importer_workflows();
     init_skills_adapter5();
@@ -27392,12 +27585,6 @@ var init_lint31 = __esm({
 });
 
 // src/targets/windsurf/index.ts
-function directoryScopedRuleDir2(globs) {
-  if (globs.length === 0) return null;
-  const dirs = globs.map((glob) => glob.split("/")[0] ?? "").filter((segment) => /^[A-Za-z0-9._-]+$/.test(segment));
-  if (dirs.length !== globs.length) return null;
-  return dirs.every((dir) => dir === dirs[0]) ? dirs[0] : null;
-}
 var target32, project24, globalLayout30, globalCapabilities25, descriptor32;
 var init_windsurf2 = __esm({
   "src/targets/windsurf/index.ts"() {
@@ -27429,9 +27616,7 @@ var init_windsurf2 = __esm({
     project24 = {
       rootInstructionPath: WINDSURF_AGENTS_MD,
       extraRuleOutputPaths(rule) {
-        if (rule.root) return [WINDSURF_AGENTS_MD];
-        const dir = directoryScopedRuleDir2(rule.globs);
-        return dir !== null ? [`${dir}/AGENTS.md`] : [];
+        return rule.root ? [WINDSURF_AGENTS_MD] : [];
       },
       skillDir: WINDSURF_SKILLS_DIR,
       managedOutputs: {
@@ -29243,61 +29428,8 @@ async function resolveExtendPaths(config, configDir, options = {}) {
   return result2;
 }
 
-// src/utils/output/color.ts
-function noColorRequested() {
-  const value = process.env.NO_COLOR;
-  return value !== void 0 && value !== "";
-}
-function forceColorRequested() {
-  const value = process.env.FORCE_COLOR;
-  if (value === void 0) return void 0;
-  return value !== "0" && value !== "false";
-}
-function colorEnabled(stream = process.stdout) {
-  const forced = forceColorRequested();
-  if (forced !== void 0) return forced;
-  if (noColorRequested()) return false;
-  return stream.isTTY === true;
-}
-
-// src/utils/output/logger.ts
-var C = {
-  green: "\x1B[32m",
-  red: "\x1B[31m",
-  yellow: "\x1B[33m",
-  cyan: "\x1B[36m",
-  reset: "\x1B[0m"
-};
-function outStream() {
-  return process.stdout;
-}
-function out(text) {
-  outStream().write(text);
-}
-function c(code, text, stream) {
-  return colorEnabled(stream) ? `${code}${text}${C.reset}` : text;
-}
-var logger = {
-  info(msg) {
-    out(c(C.cyan, msg, outStream()) + "\n");
-  },
-  warn(msg) {
-    process.stderr.write(c(C.yellow, "\u26A0 ", process.stderr) + msg + "\n");
-  },
-  error(msg) {
-    process.stderr.write(c(C.red, "\u2717 ", process.stderr) + msg + "\n");
-  },
-  success(msg) {
-    out(c(C.green, "\u2713 ", outStream()) + msg + "\n");
-  },
-  debug(msg) {
-    if (process.env.AGENTSMESH_DEBUG === "1") {
-      out(c(C.cyan, "[debug] ", outStream()) + msg + "\n");
-    }
-  }
-};
-
 // src/canonical/features/empty-file.ts
+init_logger();
 function isEmptyCanonicalFile(content, path) {
   if (content.trim() !== "") return false;
   logger.warn(`Skipping empty canonical file ${path.replaceAll("\\", "/")}`);
@@ -29399,6 +29531,9 @@ function assertNoBasenameCollisions(feature, paths2, stripExt) {
     seen.set(key, { path: p, slug });
   }
 }
+
+// src/canonical/features/unrecognized-files-warning.ts
+init_logger();
 var ALTERNATE_RESOURCE_FORMATS = /* @__PURE__ */ new Set([".toml", ".yaml", ".yml", ".json"]);
 function warnIfUnrecognizedResourceFormats(featureLabel, dir, allFiles, parsedFiles, opts = {}) {
   if (allFiles.length === 0) return;
@@ -29607,6 +29742,14 @@ async function readContent(path) {
   return c2 ?? "";
 }
 var SKILL_FILE = "SKILL.md";
+async function readSkillFile(skillPath) {
+  try {
+    if ((await lstat(skillPath)).isSymbolicLink()) return null;
+  } catch {
+    return null;
+  }
+  return readFileSafe(skillPath);
+}
 var DOC_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".rst", ".txt"]);
 function isMarkdownLikeDoc(name) {
   const dot = name.lastIndexOf(".");
@@ -29636,7 +29779,7 @@ async function listSupportingFiles(skillDir) {
 }
 async function parseSkillDirectory(skillDir, opts = {}) {
   const skillPath = join(skillDir, SKILL_FILE);
-  const content = await readFileSafe(skillPath);
+  const content = await readSkillFile(skillPath);
   if (!content) return null;
   const parsed = parseOrSkipFrontmatter(content, skillPath, opts.onParseError);
   if (!parsed) return null;
@@ -29667,7 +29810,7 @@ async function parseSkills(skillsDir, opts = {}) {
     assertCanonicalName("skill", ent.name);
     const skillDir = join(skillsDir, ent.name);
     const skillPath = join(skillDir, SKILL_FILE);
-    const content = await readFileSafe(skillPath);
+    const content = await readSkillFile(skillPath);
     if (!content) continue;
     const parsed = parseOrSkipFrontmatter(content, skillPath, opts.onParseError);
     if (!parsed) continue;
@@ -29697,6 +29840,9 @@ function ensureStringArray(val) {
 async function parsePermissions(permissionsPath, onParseError) {
   const content = await readFileSafe(permissionsPath);
   if (content === null) return null;
+  return parsePermissionsContent(content, permissionsPath, onParseError);
+}
+function parsePermissionsContent(content, permissionsPath, onParseError) {
   if (!content.trim()) return { allow: [], deny: [], ask: [] };
   let parsed;
   try {
@@ -29829,6 +29975,20 @@ function hookEvents(a, b) {
 function hookKey(entry) {
   return JSON.stringify([entry.type ?? "command", entry.matcher, entry.command]);
 }
+function settleRootRule(merged, local, packs) {
+  const roots = merged.filter((rule) => rule.root);
+  const root = roots.find((rule) => local.includes(rule)) ?? roots.find((rule) => packs.includes(rule)) ?? roots[0];
+  const demoted = roots.filter((rule) => rule !== root);
+  return {
+    rules: merged.map((rule) => demoted.includes(rule) ? { ...rule, root: false } : rule),
+    root,
+    demoted
+  };
+}
+function demotedRootMessage(rule, root, baseDir) {
+  const shown = (r) => relative(baseDir, r.source).replaceAll("\\", "/");
+  return `[agentsmesh] Rule "${shown(rule)}" also says root: true, but "${shown(root)}" is the root rule (the project's own root wins over installed packs, and packs over extends), so it is used as a normal rule.`;
+}
 
 // src/config/resolve/native-format-detector.ts
 init_fs();
@@ -29874,6 +30034,7 @@ var KNOWN_NATIVE_PATHS = BUILTIN_TARGETS.map(
 
 // src/canonical/extends/extend-load.ts
 init_fs();
+init_logger();
 
 // src/canonical/extends/native-extends-importer.ts
 init_registry();
@@ -30500,6 +30661,9 @@ Expected one of: .agentsmesh/, ${KNOWN_NATIVE_PATHS.join(", ")}.`
     throw wrapped;
   }
 }
+
+// src/canonical/extends/extend-pick.ts
+init_logger();
 function applyExtendPick(canonical, features, pick, extendName) {
   if (!pick) return canonical;
   let next = { ...canonical };
@@ -30775,6 +30939,7 @@ async function loadPacksCanonical(abDir) {
 }
 
 // src/canonical/extends/extends.ts
+init_logger();
 var FEATURE_TO_KEYS = {
   rules: ["rules"],
   commands: ["commands"],
@@ -30823,12 +30988,22 @@ async function loadCanonicalWithExtends(config, configDir, options = {}, canonic
   merged = mergeCanonicalFiles(merged, packsCanonical, { hooks: "combine" });
   const localCanonical = await loadCanonicalFiles(canonicalDir);
   merged = mergeCanonicalFiles(merged, localCanonical);
+  const { rules, root, demoted } = settleRootRule(
+    merged.rules,
+    localCanonical.rules,
+    packsCanonical.rules
+  );
+  if (root !== void 0) {
+    for (const rule of demoted) logger.warn(demotedRootMessage(rule, root, configDir));
+  }
+  merged = { ...merged, rules };
   merged = { ...merged, hooks: combineHooks(merged.hooks, packsCanonical.hooks) };
   return { canonical: merged, resolvedExtends };
 }
 
 // src/config/core/loader.ts
 init_fs();
+init_logger();
 init_errors();
 var CONFIG_FILENAME = "agentsmesh.yaml";
 var LOCAL_CONFIG_FILENAME = "agentsmesh.local.yaml";