agentsmesh 0.22.0 → 0.23.0

package/dist/engine.js

@@ -1,8 +1,9 @@
 import { z } from 'zod';
 import { stringify, parse } from 'yaml';
 import { basename, join, dirname, relative, win32, posix, sep, resolve, extname } from 'path';
-import { readFile, rm, mkdir, readdir, stat, lstat, unlink, writeFile, rename, chmod, access, realpath, mkdtemp, cp } from 'fs/promises';
-import { existsSync, readFileSync, constants, realpathSync, statSync } from 'fs';
+import { readFile, rm, mkdir, readdir, stat, lstat, unlink, writeFile, rename, chmod, realpath, access, mkdtemp, cp } from 'fs/promises';
+import { setTimeout } from 'timers/promises';
+import { existsSync, readFileSync, constants, readdirSync, realpathSync, statSync } from 'fs';
 import { parse as parse$1 } from 'smol-toml';
 import { Buffer } from 'buffer';
 import { homedir, tmpdir } from 'os';
@@ -11,6 +12,7 @@ import { execFile } from 'child_process';
 import { fileURLToPath, pathToFileURL, URL } from 'url';
 import { promisify } from 'util';
 import * as tar from 'tar';
+import picomatch from 'picomatch';
 import { createTwoFilesPatch } from 'diff';
 
 var __defProp = Object.defineProperty;
@@ -45,7 +47,7 @@ function validateCapabilityImplementations(descriptor31, capabilities17, ctx, pa
 function validateDescriptor(value) {
   return targetDescriptorSchema.parse(value);
 }
-var capabilityLevelSchema, capabilitiesSchema, generatorsSchema, pathResolversSchema, layoutSchema, globalSupportSchema, legacyGlobalKeys, generatorRequirements, settingsBackedFeatures, conversionDefaultsSchema, metadataSchema, targetDescriptorSchemaBase, targetDescriptorSchema;
+var capabilityLevelSchema, capabilitiesSchema, generatorsSchema, pathResolversSchema, layoutSchema, globalSupportSchema, legacyGlobalKeys, generatorRequirements, settingsBackedFeatures, conversionDefaultsSchema, metadataSchema, nativePickStrategySchema, nativeInstallSchema, targetDescriptorSchemaBase, targetDescriptorSchema;
 var init_target_descriptor_schema = __esm({
   "src/targets/catalog/target-descriptor.schema.ts"() {
     capabilityLevelSchema = z.union([
@@ -119,6 +121,22 @@ var init_target_descriptor_schema = __esm({
       officialUrl: z.string().min(1),
       shortDescription: z.string().min(1)
     }).passthrough();
+    nativePickStrategySchema = z.discriminatedUnion("kind", [
+      z.object({ kind: z.literal("basename"), suffix: z.string().min(1) }),
+      z.object({ kind: z.literal("skillDir") }),
+      z.object({ kind: z.literal("firstSegment") })
+    ]);
+    nativeInstallSchema = z.object({
+      pickPaths: z.array(
+        z.object({
+          prefix: z.string().min(1),
+          feature: z.enum(["commands", "rules", "agents", "skills"]),
+          strategy: nativePickStrategySchema
+        })
+      ).optional(),
+      inferPick: z.function().optional(),
+      dialectHints: z.array(z.object({ frontmatterKey: z.string().min(1) })).optional()
+    }).strict();
     targetDescriptorSchemaBase = z.object({
       id: z.string().regex(/^[a-z][a-z0-9-]*$/, "Target id must be lowercase with hyphens"),
       metadata: metadataSchema,
@@ -130,6 +148,7 @@ var init_target_descriptor_schema = __esm({
       globalSupport: globalSupportSchema.optional(),
       buildImportPaths: z.function(),
       detectionPaths: z.array(z.string()),
+      nativeInstall: nativeInstallSchema.optional(),
       excludeFromStarterInit: z.boolean().optional(),
       conversionDefaults: conversionDefaultsSchema.optional(),
       emitScopedSettings: z.function().optional(),
@@ -630,15 +649,19 @@ var init_errors = __esm({
     LockAcquisitionError = class extends AgentsMeshError {
       lockPath;
       holder;
+      /** Human-readable lock name surfaced in the message, e.g. "lessons lock". */
+      label;
       constructor(lockPath, holder, options) {
+        const label = options?.label ?? "lock";
         super(
           "AM_LOCK_ACQUISITION_FAILED",
-          `Could not acquire generate lock at ${lockPath}: currently held by ${holder}. Wait for the other process to finish, or remove ${lockPath} manually if you are sure no agentsmesh process is running.`,
+          `Could not acquire ${label} at ${lockPath}: currently held by ${holder}. Wait for the other process to finish, or remove ${lockPath} manually if you are sure no agentsmesh process is running.`,
           options
         );
         this.name = "LockAcquisitionError";
         this.lockPath = lockPath;
         this.holder = holder;
+        this.label = label;
       }
     };
     FileSystemError = class extends AgentsMeshError {
@@ -803,6 +826,27 @@ var init_fs_traverse = __esm({
     MAX_SEGMENT_REPETITIONS = 3;
   }
 });
+async function renameWithRetry(from, to, options = {}) {
+  const attempts = options.attempts ?? 5;
+  const delayMs = options.delayMs ?? 50;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await rename(from, to);
+      return;
+    } catch (err) {
+      const code = err.code;
+      const transient = code !== void 0 && TRANSIENT_RENAME_CODES.has(code);
+      if (!transient || attempt >= attempts - 1) throw err;
+      await setTimeout(delayMs * 2 ** attempt);
+    }
+  }
+}
+var TRANSIENT_RENAME_CODES;
+var init_rename_retry = __esm({
+  "src/utils/filesystem/rename-retry.ts"() {
+    TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY", "ENOTEMPTY", "EEXIST"]);
+  }
+});
 async function readFileSafe(path) {
   try {
     const data = await readFile(path, "utf-8");
@@ -889,6 +933,7 @@ var init_fs = __esm({
     init_fs_text_encoding();
     init_fs_traverse();
     init_fs_text_encoding();
+    init_rename_retry();
   }
 });
 function escapeRegExp(value) {
@@ -897,19 +942,24 @@ function escapeRegExp(value) {
 function managedBlockPattern(start, end) {
   return new RegExp(`${escapeRegExp(start)}[\\s\\S]*?${escapeRegExp(end)}`, "g");
 }
-function replaceManagedBlock(content, start, end, block) {
-  const pattern = managedBlockPattern(start, end);
-  if (pattern.test(content)) {
-    return content.replace(pattern, block).trim();
-  }
-  const trimmed = content.trim();
-  return trimmed ? `${trimmed}
-
-${block}` : block;
-}
 function stripManagedBlock(content, start, end) {
   return content.replace(managedBlockPattern(start, end), "").trim();
 }
+function splitFrontmatterPrefix(content) {
+  if (content.indexOf("---") !== 0) return { prefix: "", body: content.trim() };
+  const close = content.indexOf("---", 3);
+  if (close === -1) return { prefix: "", body: content.trim() };
+  return { prefix: content.slice(0, close + 3), body: content.slice(close + 3).trim() };
+}
+function insertAtBodyTop(content, block) {
+  const { prefix, body } = splitFrontmatterPrefix(content);
+  const placed = body ? `${block}
+
+${body}` : block;
+  return prefix ? `${prefix}
+
+${placed}` : placed;
+}
 function ruleSource(source) {
   const normalized = source.replace(/\\/g, "/");
   const meshIndex = normalized.lastIndexOf(".agentsmesh/");
@@ -1011,31 +1061,9 @@ var init_managed_blocks = __esm({
 });
 
 // src/targets/projection/root-instruction-paragraph.ts
-function normalizeWhitespace(value) {
-  return value.replace(/\s+/g, " ").trim();
-}
 function appendAgentsmeshRootInstructionParagraph(content) {
-  const trimmed = content.trim();
-  if (trimmed.includes(ROOT_CONTRACT_START) && trimmed.includes(ROOT_CONTRACT_END)) {
-    return replaceManagedBlock(
-      trimmed,
-      ROOT_CONTRACT_START,
-      ROOT_CONTRACT_END,
-      AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH
-    );
-  }
-  const norm = normalizeWhitespace(trimmed);
-  if (norm.includes(normalizeWhitespace(AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH))) {
-    return trimmed;
-  }
-  for (const legacy of LEGACY_FORMS) {
-    if (norm.includes(normalizeWhitespace(legacy))) {
-      return trimmed.replace(legacy, AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH);
-    }
-  }
-  return trimmed ? `${trimmed}
-
-${AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH}` : AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH;
+  const withoutPrior = stripAgentsmeshRootInstructionParagraph(content);
+  return insertAtBodyTop(withoutPrior, AGENTSMESH_ROOT_INSTRUCTION_PARAGRAPH);
 }
 function stripAgentsmeshRootInstructionParagraph(content) {
   let result = stripManagedBlock(content, ROOT_CONTRACT_START, ROOT_CONTRACT_END);
@@ -2009,9 +2037,8 @@ function shouldRewritePathToken(fullContent, start, end, matchText, rewriteBareP
   const before = fullContent[start - 1];
   const after = fullContent[end];
   if (isMarkdownReferenceDefinitionDestination(fullContent, start, candidateEnd)) return true;
-  if (before === "'" && after === "'" || before === '"' && after === '"' || before === "`" && after === "`") {
-    return true;
-  }
+  if (before === "`" && after === "`") return true;
+  if (before === "'" && after === "'" || before === '"' && after === '"') return false;
   if (before === "<" && after === ">") return true;
   if (before === "[" && after === "]") {
     if (!rewriteBarePathTokens && !isRootRelativePathToken(normalizedCandidate) && markdownBracketLabelDuplicatesDestination(fullContent, start, matchText)) {
@@ -3338,12 +3365,12 @@ var init_augment_code = __esm({
 });
 
 // src/targets/claude-code/constants.ts
-var CLAUDE_CODE_TARGET, CLAUDE_ROOT, CLAUDE_LEGACY_ROOT, CLAUDE_RULES_DIR, CLAUDE_COMMANDS_DIR, CLAUDE_AGENTS_DIR, CLAUDE_SKILLS_DIR, CLAUDE_SETTINGS, CLAUDE_HOOKS_JSON, CLAUDE_OUTPUT_STYLES_DIR, CLAUDE_IGNORE, CLAUDE_MCP_JSON, CLAUDE_GLOBAL_MCP_JSON, CLAUDE_CANONICAL_RULES_DIR, CLAUDE_CANONICAL_COMMANDS_DIR, CLAUDE_CANONICAL_AGENTS_DIR, CLAUDE_CANONICAL_SKILLS_DIR, CLAUDE_CANONICAL_MCP, CLAUDE_CANONICAL_PERMISSIONS, CLAUDE_CANONICAL_HOOKS, CLAUDE_CANONICAL_IGNORE;
+var CLAUDE_CODE_TARGET, CLAUDE_ROOT, CLAUDE_NESTED_ROOT, CLAUDE_RULES_DIR, CLAUDE_COMMANDS_DIR, CLAUDE_AGENTS_DIR, CLAUDE_SKILLS_DIR, CLAUDE_SETTINGS, CLAUDE_HOOKS_JSON, CLAUDE_OUTPUT_STYLES_DIR, CLAUDE_IGNORE, CLAUDE_MCP_JSON, CLAUDE_GLOBAL_MCP_JSON, CLAUDE_CANONICAL_RULES_DIR, CLAUDE_CANONICAL_COMMANDS_DIR, CLAUDE_CANONICAL_AGENTS_DIR, CLAUDE_CANONICAL_SKILLS_DIR, CLAUDE_CANONICAL_MCP, CLAUDE_CANONICAL_PERMISSIONS, CLAUDE_CANONICAL_HOOKS, CLAUDE_CANONICAL_IGNORE;
 var init_constants7 = __esm({
   "src/targets/claude-code/constants.ts"() {
     CLAUDE_CODE_TARGET = "claude-code";
-    CLAUDE_ROOT = ".claude/CLAUDE.md";
-    CLAUDE_LEGACY_ROOT = "CLAUDE.md";
+    CLAUDE_ROOT = "CLAUDE.md";
+    CLAUDE_NESTED_ROOT = ".claude/CLAUDE.md";
     CLAUDE_RULES_DIR = ".claude/rules";
     CLAUDE_COMMANDS_DIR = ".claude/commands";
     CLAUDE_AGENTS_DIR = ".claude/agents";
@@ -5205,7 +5232,8 @@ var init_amp2 = __esm({
           markAsRoot: true
         }
       },
-      emitScopedSettings(canonical, _scope) {
+      emitScopedSettings(canonical, _scope, enabledFeatures) {
+        if (!enabledFeatures.has("mcp")) return [];
         if (!canonical.mcp || Object.keys(canonical.mcp.mcpServers).length === 0) return [];
         return [
           {
@@ -5957,12 +5985,12 @@ function mergeAugmentSettings(existing, newContent) {
   if (overlay.hooks !== void 0) base.hooks = overlay.hooks;
   return JSON.stringify(base, null, 2);
 }
-function buildSettingsContent(canonical) {
+function buildSettingsContent(canonical, enabledFeatures) {
   const settings = {};
-  if (canonical.mcp && Object.keys(canonical.mcp.mcpServers).length > 0) {
+  if (enabledFeatures.has("mcp") && canonical.mcp && Object.keys(canonical.mcp.mcpServers).length > 0) {
     settings.mcpServers = canonical.mcp.mcpServers;
   }
-  if (canonical.hooks && Object.keys(canonical.hooks).length > 0) {
+  if (enabledFeatures.has("hooks") && canonical.hooks && Object.keys(canonical.hooks).length > 0) {
     settings.hooks = serializeHooksForSettings(canonical.hooks);
   }
   if (Object.keys(settings).length === 0) return null;
@@ -6091,8 +6119,8 @@ var init_augment_code2 = __esm({
         ],
         layout: globalLayout5
       },
-      emitScopedSettings(canonical) {
-        const content = buildSettingsContent(canonical);
+      emitScopedSettings(canonical, _scope, enabledFeatures) {
+        const content = buildSettingsContent(canonical, enabledFeatures);
         if (content === null) return [];
         return [{ path: AUGMENT_CODE_SETTINGS_FILE, content }];
       },
@@ -6666,7 +6694,10 @@ var init_claude_code2 = __esm({
       skillDir: ".claude/skills",
       managedOutputs: {
         dirs: [".claude/agents", ".claude/commands", ".claude/rules", ".claude/skills"],
-        files: [".claude/CLAUDE.md", ".claude/settings.json", ".claudeignore", ".mcp.json"]
+        // CLAUDE_NESTED_ROOT is the pre-migration project location; listing it here lets
+        // `cleanupStaleGeneratedOutputs` evict a leftover `.claude/CLAUDE.md` once generation
+        // writes the root `CLAUDE.md`, so Claude Code never concatenates both into context.
+        files: [CLAUDE_ROOT, CLAUDE_NESTED_ROOT, ".claude/settings.json", ".claudeignore", ".mcp.json"]
       },
       paths: {
         rulePath(slug, _rule) {
@@ -6681,7 +6712,7 @@ var init_claude_code2 = __esm({
       }
     };
     globalLayout6 = {
-      rootInstructionPath: CLAUDE_ROOT,
+      rootInstructionPath: CLAUDE_NESTED_ROOT,
       skillDir: ".claude/skills",
       renderPrimaryRootInstruction: renderClaudeGlobalPrimaryInstructions,
       managedOutputs: {
@@ -6694,7 +6725,7 @@ var init_claude_code2 = __esm({
           ".agents/skills"
         ],
         files: [
-          ".claude/CLAUDE.md",
+          CLAUDE_NESTED_ROOT,
           ".claude/settings.json",
           CLAUDE_GLOBAL_MCP_JSON,
           CLAUDE_HOOKS_JSON,
@@ -6702,6 +6733,7 @@ var init_claude_code2 = __esm({
         ]
       },
       rewriteGeneratedPath(path) {
+        if (path === CLAUDE_ROOT) return CLAUDE_NESTED_ROOT;
         if (path === CLAUDE_MCP_JSON) return CLAUDE_GLOBAL_MCP_JSON;
         return path;
       },
@@ -6765,10 +6797,11 @@ var init_claude_code2 = __esm({
       importer: {
         rules: [
           {
-            // Root rule: prefer .claude/CLAUDE.md, fall back to legacy CLAUDE.md (project only).
+            // Root rule: project prefers root CLAUDE.md, falls back to nested .claude/CLAUDE.md;
+            // global reads the nested .claude/CLAUDE.md.
             feature: "rules",
             mode: "singleFile",
-            source: { project: [CLAUDE_ROOT, CLAUDE_LEGACY_ROOT], global: [CLAUDE_ROOT] },
+            source: { project: [CLAUDE_ROOT, CLAUDE_NESTED_ROOT], global: [CLAUDE_NESTED_ROOT] },
             canonicalDir: CLAUDE_CANONICAL_RULES_DIR,
             canonicalRootFilename: "_root.md",
             markAsRoot: true
@@ -6814,7 +6847,23 @@ var init_claude_code2 = __esm({
         }
       },
       buildImportPaths: buildClaudeCodeImportPaths,
-      detectionPaths: ["CLAUDE.md", ".claude/rules", ".claude/commands"]
+      detectionPaths: [CLAUDE_ROOT, CLAUDE_NESTED_ROOT, ".claude/rules", ".claude/commands"],
+      nativeInstall: {
+        pickPaths: [
+          {
+            prefix: ".claude/commands",
+            feature: "commands",
+            strategy: { kind: "basename", suffix: ".md" }
+          },
+          { prefix: ".claude/rules", feature: "rules", strategy: { kind: "basename", suffix: ".md" } },
+          {
+            prefix: ".claude/agents",
+            feature: "agents",
+            strategy: { kind: "basename", suffix: ".md" }
+          },
+          { prefix: ".claude/skills/", feature: "skills", strategy: { kind: "firstSegment" } }
+        ]
+      }
     };
   }
 });
@@ -7693,6 +7742,16 @@ var init_cline2 = __esm({
       },
       buildImportPaths: buildClineImportPaths,
       detectionPaths: [".clinerules", ".cline"],
+      nativeInstall: {
+        pickPaths: [
+          { prefix: CLINE_SKILLS_DIR, feature: "skills", strategy: { kind: "skillDir" } },
+          {
+            prefix: CLINE_WORKFLOWS_DIR,
+            feature: "commands",
+            strategy: { kind: "basename", suffix: ".md" }
+          }
+        ]
+      },
       conversionDefaults: { agentsToSkills: true }
     };
   }
@@ -8611,6 +8670,11 @@ var init_codex_cli2 = __esm({
         ".codex/agents",
         ".codex/rules"
       ],
+      nativeInstall: {
+        pickPaths: [
+          { prefix: ".codex", feature: "rules", strategy: { kind: "basename", suffix: ".md" } }
+        ]
+      },
       excludeFromStarterInit: true,
       conversionDefaults: { commandsToSkills: true, agentsToSkills: false }
     };
@@ -9114,6 +9178,21 @@ var init_continue2 = __esm({
       },
       buildImportPaths: buildContinueImportPaths,
       detectionPaths: [".continue/rules", ".continue/skills", ".continue/mcpServers"],
+      nativeInstall: {
+        pickPaths: [
+          {
+            prefix: ".continue/rules",
+            feature: "rules",
+            strategy: { kind: "basename", suffix: ".md" }
+          },
+          {
+            prefix: ".continue/prompts",
+            feature: "commands",
+            strategy: { kind: "basename", suffix: ".md" }
+          },
+          { prefix: ".continue/skills", feature: "skills", strategy: { kind: "skillDir" } }
+        ]
+      },
       conversionDefaults: { agentsToSkills: true }
     };
   }
@@ -9481,6 +9560,80 @@ var init_importer10 = __esm({
     init_copilot2();
   }
 });
+async function skillNamesFromNativeSkillDir(scanRoot) {
+  const files = await readDirRecursive(scanRoot);
+  const names = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    if (basename(f) === "SKILL.md") {
+      names.add(basename(dirname(f)));
+      continue;
+    }
+    const rel2 = relative(scanRoot, f).replace(/\\/g, "/");
+    if (!rel2.includes("/") && f.toLowerCase().endsWith(".md")) {
+      names.add(basename(f, ".md"));
+    }
+  }
+  return [...names].filter(Boolean).sort();
+}
+var init_native_skill_scan = __esm({
+  "src/install/native/native-skill-scan.ts"() {
+    init_fs();
+  }
+});
+async function inferCopilotPickFromPath(repoRoot, posixPath) {
+  const scan = join(repoRoot, ...posixPath.split("/"));
+  if (posixPath.startsWith(COPILOT_PROMPTS_DIR)) {
+    const files = await readDirRecursive(scan);
+    const commands = [
+      ...new Set(
+        files.filter((f) => f.toLowerCase().endsWith(".prompt.md")).map((f) => basename(f, ".prompt.md"))
+      )
+    ].sort();
+    return commands.length ? { commands } : {};
+  }
+  if (posixPath.startsWith(".github/copilot") && !posixPath.includes("copilot-instructions.md")) {
+    const files = await readDirRecursive(scan);
+    const rules = [
+      ...new Set(
+        files.filter((f) => f.includes(".instructions.md")).map((f) => basename(f).replace(/\.instructions\.md$/i, ""))
+      )
+    ].sort();
+    return rules.length ? { rules } : {};
+  }
+  if (posixPath.startsWith(".github/instructions")) {
+    const files = await readDirRecursive(scan);
+    const names = /* @__PURE__ */ new Set();
+    for (const f of files) {
+      const b = basename(f);
+      if (b.toLowerCase().endsWith(".instructions.md"))
+        names.add(b.replace(/\.instructions\.md$/i, ""));
+      else if (b.toLowerCase().endsWith(".md")) names.add(basename(f, ".md"));
+    }
+    const rules = [...names].sort();
+    return rules.length ? { rules } : {};
+  }
+  if (posixPath.startsWith(".github/skills")) {
+    const skills = await skillNamesFromNativeSkillDir(scan);
+    return skills.length ? { skills } : {};
+  }
+  if (posixPath.startsWith(".github/agents")) {
+    const files = await readDirRecursive(scan);
+    const agents = [
+      ...new Set(
+        files.filter((f) => f.toLowerCase().endsWith(".agent.md")).map((f) => basename(f, ".agent.md"))
+      )
+    ].sort();
+    return agents.length ? { agents } : {};
+  }
+  return {};
+}
+var init_native_path_pick_infer_copilot = __esm({
+  "src/install/native/native-path-pick-infer-copilot.ts"() {
+    init_fs();
+    init_constants29();
+    init_native_skill_scan();
+  }
+});
 function pruneUndefined3(record) {
   for (const key of Object.keys(record)) {
     if (record[key] === void 0) delete record[key];
@@ -9770,6 +9923,7 @@ var init_copilot2 = __esm({
     init_generator11();
     init_constants29();
     init_importer10();
+    init_native_path_pick_infer_copilot();
     init_import_mappers4();
     init_linter10();
     init_import_map_builders();
@@ -9984,7 +10138,8 @@ var init_copilot2 = __esm({
         ".github/skills",
         ".github/agents",
         ".github/hooks"
-      ]
+      ],
+      nativeInstall: { inferPick: inferCopilotPickFromPath }
     };
   }
 });
@@ -11497,6 +11652,23 @@ var init_cursor2 = __esm({
       },
       buildImportPaths: buildCursorImportPaths,
       detectionPaths: [".cursor/rules", ".cursor/mcp.json"],
+      nativeInstall: {
+        pickPaths: [
+          { prefix: ".cursor/rules", feature: "rules", strategy: { kind: "basename", suffix: ".mdc" } },
+          {
+            prefix: ".cursor/commands",
+            feature: "commands",
+            strategy: { kind: "basename", suffix: ".md" }
+          },
+          {
+            prefix: ".cursor/agents",
+            feature: "agents",
+            strategy: { kind: "basename", suffix: ".md" }
+          },
+          { prefix: ".cursor/skills", feature: "skills", strategy: { kind: "skillDir" } }
+        ],
+        dialectHints: [{ frontmatterKey: "alwaysApply" }]
+      },
       preservesManualActivation: true
     };
   }
@@ -12258,18 +12430,18 @@ function mapHookEvent2(event) {
       return null;
   }
 }
-function generateGeminiSettingsFiles(canonical) {
+function generateGeminiSettingsFiles(canonical, enabledFeatures) {
   const settings = {};
   let hasAnyNativeSettings = false;
-  if (canonical.mcp && Object.keys(canonical.mcp.mcpServers).length > 0) {
+  if (enabledFeatures.has("mcp") && canonical.mcp && Object.keys(canonical.mcp.mcpServers).length > 0) {
     settings.mcpServers = canonical.mcp.mcpServers;
     hasAnyNativeSettings = true;
   }
-  if (canonical.agents.length > 0) {
+  if (enabledFeatures.has("agents") && canonical.agents.length > 0) {
     settings.experimental = { enableAgents: true };
     hasAnyNativeSettings = true;
   }
-  if (canonical.hooks) {
+  if (enabledFeatures.has("hooks") && canonical.hooks) {
     const hookEntries = Object.entries(canonical.hooks).flatMap(([event, entries]) => {
       const mappedEvent = mapHookEvent2(event);
       if (!mappedEvent || !Array.isArray(entries)) return [];
@@ -12885,6 +13057,36 @@ var init_importer15 = __esm({
     init_importer_skills_agents();
   }
 });
+function isUnderGeminiCommands(pathInRepoPosix) {
+  const p = pathInRepoPosix.replace(/^\/+|\/+$/g, "");
+  return p === ".gemini/commands" || p.startsWith(".gemini/commands/");
+}
+async function inferGeminiCommandNamesFromFiles(repoRoot, pathInRepoPosix) {
+  const commandsRoot = join(repoRoot, ...GEMINI_COMMANDS_DIR.split("/"));
+  const scanDir = join(repoRoot, ...pathInRepoPosix.split("/"));
+  const files = await readDirRecursive(scanDir);
+  const names = [];
+  for (const f of files) {
+    if (!/\.(toml|md)$/i.test(f)) continue;
+    const rel2 = relative(commandsRoot, f).replace(/\\/g, "/");
+    if (rel2.startsWith("..") || rel2 === "") continue;
+    const noExt = rel2.replace(/\.(toml|md)$/i, "");
+    const name = noExt.split("/").filter(Boolean).join(":");
+    if (name) names.push(name);
+  }
+  return [...new Set(names)].sort();
+}
+async function inferGeminiPick(repoRoot, posixPath) {
+  if (!isUnderGeminiCommands(posixPath)) return {};
+  const commands = await inferGeminiCommandNamesFromFiles(repoRoot, posixPath);
+  return commands.length ? { commands } : {};
+}
+var init_gemini_install_commands = __esm({
+  "src/install/native/gemini-install-commands.ts"() {
+    init_fs();
+    init_constants30();
+  }
+});
 async function mapGeminiRuleFile(relativePath, destDir, normalizeTo) {
   const relativeMdPath = relativePath.replace(/\\/g, "/");
   const destPath = join(destDir, relativeMdPath);
@@ -12996,12 +13198,12 @@ var init_lint12 = __esm({
 });
 
 // src/targets/gemini-cli/scoped-settings-emit.ts
-function emitScopedGeminiSettings(canonical, scope) {
+function emitScopedGeminiSettings(canonical, scope, enabledFeatures) {
   if (scope === "project") {
     const caps = getTargetCapabilities("gemini-cli", scope);
     if (caps?.ignore.flavor !== "settings-embedded") return [];
   }
-  return generateGeminiSettingsFiles(canonical);
+  return generateGeminiSettingsFiles(canonical, enabledFeatures);
 }
 var init_scoped_settings_emit = __esm({
   "src/targets/gemini-cli/scoped-settings-emit.ts"() {
@@ -13019,6 +13221,7 @@ var init_gemini_cli2 = __esm({
     init_policies_generator();
     init_constants30();
     init_importer15();
+    init_gemini_install_commands();
     init_import_mappers6();
     init_linter15();
     init_import_map_builders();
@@ -13214,6 +13417,7 @@ var init_gemini_cli2 = __esm({
       },
       buildImportPaths: buildGeminiCliImportPaths,
       detectionPaths: ["GEMINI.md", ".gemini"],
+      nativeInstall: { inferPick: inferGeminiPick },
       conversionDefaults: { agentsToSkills: false }
     };
   }
@@ -14055,7 +14259,23 @@ var init_junie2 = __esm({
         ".junie/skills",
         ".junie/mcp/mcp.json",
         ".aiignore"
-      ]
+      ],
+      nativeInstall: {
+        pickPaths: [
+          {
+            prefix: ".junie/commands",
+            feature: "commands",
+            strategy: { kind: "basename", suffix: ".md" }
+          },
+          { prefix: ".junie/rules", feature: "rules", strategy: { kind: "basename", suffix: ".md" } },
+          {
+            prefix: ".junie/agents",
+            feature: "agents",
+            strategy: { kind: "basename", suffix: ".md" }
+          },
+          { prefix: ".junie/skills", feature: "skills", strategy: { kind: "skillDir" } }
+        ]
+      }
     };
   }
 });
@@ -18405,6 +18625,16 @@ var init_windsurf2 = __esm({
       },
       buildImportPaths: buildWindsurfImportPaths,
       detectionPaths: [".windsurfrules", ".windsurf"],
+      nativeInstall: {
+        pickPaths: [
+          {
+            prefix: ".windsurf/rules",
+            feature: "rules",
+            strategy: { kind: "basename", suffix: ".md" }
+          }
+        ],
+        dialectHints: [{ frontmatterKey: "trigger" }]
+      },
       conversionDefaults: { agentsToSkills: true }
     };
   }
@@ -18679,7 +18909,8 @@ var init_zed2 = __esm({
           markAsRoot: true
         }
       },
-      emitScopedSettings(canonical, _scope) {
+      emitScopedSettings(canonical, _scope, enabledFeatures) {
+        if (!enabledFeatures.has("mcp")) return [];
         if (!canonical.mcp || Object.keys(canonical.mcp.mcpServers).length === 0) return [];
         const contextServers = {};
         for (const [name, server] of Object.entries(canonical.mcp.mcpServers)) {
@@ -18734,7 +18965,10 @@ function getBuiltinTargetDefinition(target31) {
 function getTargetCapabilities(target31, scope = "project") {
   const descriptor31 = getBuiltinTargetDefinition(target31) ?? getDescriptor(target31);
   if (!descriptor31) return void 0;
-  const raw = scope === "global" ? descriptor31.globalSupport?.capabilities ?? descriptor31.capabilities : descriptor31.capabilities;
+  if (scope === "global" && !descriptor31.globalSupport) {
+    return normalizeTargetCapabilities(ALL_NONE_CAPABILITIES);
+  }
+  const raw = scope === "global" ? descriptor31.globalSupport.capabilities : descriptor31.capabilities;
   return normalizeTargetCapabilities(raw);
 }
 function getTargetDetectionPaths(target31, scope = "project") {
@@ -18790,6 +19024,7 @@ function isConversionUpgrading(descriptor31, feature, config, scope) {
 function getEffectiveTargetSupportLevel(target31, feature, config, scope = "project") {
   const baseLevel = getTargetCapabilities(target31, scope)?.[feature]?.level ?? "none";
   const descriptor31 = getBuiltinTargetDefinition(target31) ?? getDescriptor(target31);
+  if (scope === "global" && descriptor31 && !descriptor31.globalSupport) return "none";
   if (baseLevel === "none" && isConversionUpgrading(descriptor31, feature, config, scope)) {
     return "embedded";
   }
@@ -18803,7 +19038,7 @@ function resolveTargetFeatureGenerator(target31, feature, config, scope = "proje
   const pick = PICK_FEATURE_GENERATOR[feature];
   return pick === null ? void 0 : pick(descriptor31.generators);
 }
-var BUILTIN_TARGETS, _builtinTargetsMap, PICK_FEATURE_GENERATOR;
+var ALL_NONE_CAPABILITIES, BUILTIN_TARGETS, _builtinTargetsMap, PICK_FEATURE_GENERATOR;
 var init_builtin_targets = __esm({
   "src/targets/catalog/builtin-targets.ts"() {
     init_conversions();
@@ -18841,6 +19076,17 @@ var init_builtin_targets = __esm({
     init_warp2();
     init_windsurf2();
     init_zed2();
+    ALL_NONE_CAPABILITIES = {
+      rules: "none",
+      additionalRules: "none",
+      commands: "none",
+      agents: "none",
+      skills: "none",
+      mcp: "none",
+      hooks: "none",
+      ignore: "none",
+      permissions: "none"
+    };
     BUILTIN_TARGETS = [
       descriptor,
       descriptor2,
@@ -19271,6 +19517,23 @@ function rewriteGeneratedReferences(results, canonical, config, projectRoot, sco
 init_path_helpers();
 init_link_rebaser_helpers();
 
+// 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",
@@ -19279,16 +19542,14 @@ var C = {
   cyan: "\x1B[36m",
   reset: "\x1B[0m"
 };
-function out(text) {
-  {
-    process.stdout.write(text);
-  }
+function outStream() {
+  return process.stdout;
 }
-function noColor() {
-  return process.env.NO_COLOR !== void 0 && process.env.NO_COLOR !== "";
+function out(text) {
+  outStream().write(text);
 }
-function c(code, text) {
-  return noColor() ? text : `${code}${text}${C.reset}`;
+function c(code, text, stream) {
+  return colorEnabled(stream) ? `${code}${text}${C.reset}` : text;
 }
 function pad(str, width) {
   const len = [...str].length;
@@ -19296,20 +19557,20 @@ function pad(str, width) {
 }
 var logger = {
   info(msg) {
-    out(c(C.cyan, msg) + "\n");
+    out(c(C.cyan, msg, outStream()) + "\n");
   },
   warn(msg) {
-    process.stderr.write(c(C.yellow, "\u26A0 ") + msg + "\n");
+    process.stderr.write(c(C.yellow, "\u26A0 ", process.stderr) + msg + "\n");
   },
   error(msg) {
-    process.stderr.write(c(C.red, "\u2717 ") + msg + "\n");
+    process.stderr.write(c(C.red, "\u2717 ", process.stderr) + msg + "\n");
   },
   success(msg) {
-    out(c(C.green, "\u2713 ") + msg + "\n");
+    out(c(C.green, "\u2713 ", outStream()) + msg + "\n");
   },
   debug(msg) {
     if (process.env.AGENTSMESH_DEBUG === "1") {
-      out(c(C.cyan, "[debug] ") + msg + "\n");
+      out(c(C.cyan, "[debug] ", outStream()) + msg + "\n");
     }
   },
   table(rows) {
@@ -19804,12 +20065,12 @@ async function generateHooksFeature(results, targets, canonical, projectRoot, sc
     }
   }
 }
-async function generateScopedSettingsFeature(results, targets, canonical, projectRoot, scope) {
+async function generateScopedSettingsFeature(results, targets, canonical, projectRoot, scope, enabledFeatures) {
   for (const target31 of targets) {
     const descriptor31 = getBuiltinTargetDefinition(target31) ?? getDescriptor(target31);
     const emit = descriptor31?.emitScopedSettings;
     if (!emit) continue;
-    const outputs = emit(canonical, scope);
+    const outputs = emit(canonical, scope, enabledFeatures);
     if (outputs.length === 0) continue;
     for (const out2 of outputs) {
       await emitGeneratedOutput(results, target31, out2, projectRoot, scope, {
@@ -19910,7 +20171,14 @@ async function generate(ctx) {
     }
   }
   if (hasMcp || hasIgnore || hasHooks || hasAgents || hasPermissions) {
-    await generateScopedSettingsFeature(results, targets, canonical, projectRoot, scope);
+    await generateScopedSettingsFeature(
+      results,
+      targets,
+      canonical,
+      projectRoot,
+      scope,
+      enabledFeatures
+    );
   }
   const decoratedResults = decoratePrimaryRootInstructions(results, canonical, scope);
   const sharedPaths = computeSharedRootInstructionPaths(decoratedResults, scope);
@@ -20234,7 +20502,7 @@ async function fetchGitRemoteExtend(parsed, extendName, options, cacheDir, build
     await cloneRepo(resolveCloneUrl(parsed), stagedRepoDir);
     if (parsed.ref) await checkoutRef(stagedRepoDir, parsed.ref);
     await rm(cacheRoot, { recursive: true, force: true });
-    await rename(stagedRoot, cacheRoot);
+    await renameWithRetry(stagedRoot, cacheRoot);
     return readCachedRepo(cacheRepoDir);
   } catch (err) {
     await rm(stagedRoot, { recursive: true, force: true });
@@ -22585,87 +22853,964 @@ function lintRuleScopeInversion(input) {
   }
   return out2;
 }
-var TriggersSchema = z.object({
-  file_globs: z.array(z.string()),
-  command_patterns: z.array(z.string()),
-  keywords: z.array(z.string())
-}).refine((t) => t.file_globs.length + t.command_patterns.length + t.keywords.length > 0, {
-  message: "cluster must declare at least one trigger of any type"
-});
-var ClusterSchema = z.object({
-  topic: z.string().regex(/^[a-z0-9-]+$/, "topic must be kebab-case"),
-  /**
-   * Project-relative path (forward slashes) to the cluster's markdown body.
-   * Conventionally `.agentsmesh/lessons/topics/<topic>.md`, but any project
-   * path is accepted — universal across every agent target.
-   */
-  file: z.string().regex(/\.md$/, "file must be a .md path"),
-  summary: z.string().min(1),
-  triggers: TriggersSchema
-});
-var LessonsIndexSchema = z.object({
-  version: z.literal(1),
-  /**
-   * Zero clusters is valid — supports `agentsmesh init --lessons` scaffolding a
-   * fresh project. Topics accumulate via `distill:apply` as failures are
-   * captured.
-   */
-  clusters: z.array(ClusterSchema)
-});
+var CURRENT_GRAPH_VERSION = 1;
+var IdSchema = z.string().regex(/^[a-z0-9-]+$/, "id must be kebab-case");
+var DateSchema = z.string().regex(
+  /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z?)?$/,
+  "createdAt must be ISO-8601 date or datetime"
+);
+var TopicSchema = z.object({
+  summary: z.string().min(1, "topic summary must not be empty")
+}).strict();
+var TriggerKindSchema = z.enum(["file_glob", "command_pattern", "keyword"]);
+var TriggerSchema = z.object({
+  kind: TriggerKindSchema,
+  pattern: z.string().min(1, "trigger pattern must not be empty")
+}).strict();
+var LessonStatusSchema = z.enum(["active", "deprecated", "superseded"]);
+var LessonSchema = z.object({
+  rule: z.string().min(1, "lesson rule must not be empty"),
+  rationale: z.string().min(1).optional(),
+  topics: z.array(IdSchema).min(1, "lesson must reference at least one topic"),
+  triggers: z.array(IdSchema),
+  evidence: z.array(z.string().min(1)),
+  status: LessonStatusSchema,
+  supersededBy: IdSchema.optional(),
+  createdAt: DateSchema
+}).strict();
+var LessonsGraphSchema = z.object({
+  version: z.literal(CURRENT_GRAPH_VERSION),
+  lessons: z.record(IdSchema, LessonSchema),
+  topics: z.record(IdSchema, TopicSchema),
+  triggers: z.record(IdSchema, TriggerSchema)
+}).strict();
+function parseGraph(raw) {
+  return LessonsGraphSchema.parse(raw);
+}
+
+// src/lessons/graph-store.ts
+var GRAPH_REL_PATH = ".agentsmesh/lessons/lessons.json";
+function graphFilePath(projectRoot) {
+  return resolve(projectRoot, GRAPH_REL_PATH);
+}
+function loadLessonsGraph(projectRoot) {
+  const raw = readFileSync(graphFilePath(projectRoot), "utf8");
+  return parseGraph(JSON.parse(raw));
+}
 var BASE_REL = ".agentsmesh/lessons";
 function lessonsPaths(projectRoot) {
   const base = join(projectRoot, BASE_REL);
   return {
     base,
+    graph: join(base, "lessons.json"),
+    config: join(base, "config.json"),
     journal: join(base, "journal.md"),
     index: join(base, "index.yaml"),
-    ledger: join(base, "distill-ledger.yaml"),
-    proposal: join(base, "distill-proposal.md"),
     topicsDir: join(base, "topics")
   };
 }
+function toRelPath(projectRoot, absolute) {
+  return relative(projectRoot, absolute).split(sep).join("/");
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules"]);
+var MAX_FILES = 2e5;
+function listProjectFiles(projectRoot) {
+  const out2 = /* @__PURE__ */ new Set();
+  try {
+    const stack = [projectRoot];
+    while (stack.length > 0) {
+      const dir = stack.pop();
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+          if (!SKIP_DIRS.has(entry.name)) stack.push(join(dir, entry.name));
+        } else if (entry.isFile()) {
+          out2.add(toRelPath(projectRoot, join(dir, entry.name)));
+          if (out2.size > MAX_FILES) return out2;
+        }
+      }
+    }
+  } catch {
+    return null;
+  }
+  return out2;
+}
+
+// src/lessons/validate-checks.ts
+function collectDanglingRefs(graph, findings) {
+  for (const [lessonId, lesson] of Object.entries(graph.lessons)) {
+    for (const topicId of lesson.topics) {
+      if (graph.topics[topicId] === void 0) {
+        findings.push({
+          level: "error",
+          code: "DANGLING_TOPIC",
+          message: `Lesson "${lessonId}" references unknown topic "${topicId}".`,
+          lessonId,
+          topicId
+        });
+      }
+    }
+    for (const triggerId of lesson.triggers) {
+      if (graph.triggers[triggerId] === void 0) {
+        findings.push({
+          level: "error",
+          code: "DANGLING_TRIGGER",
+          message: `Lesson "${lessonId}" references unknown trigger "${triggerId}".`,
+          lessonId,
+          triggerId
+        });
+      }
+    }
+    if (lesson.supersededBy !== void 0 && graph.lessons[lesson.supersededBy] === void 0) {
+      findings.push({
+        level: "error",
+        code: "DANGLING_SUPERSEDER",
+        message: `Lesson "${lessonId}" supersededBy unknown lesson "${lesson.supersededBy}".`,
+        lessonId
+      });
+    }
+  }
+}
+function collectDuplicateRefs(graph, findings) {
+  for (const [lessonId, lesson] of Object.entries(graph.lessons)) {
+    for (const topicId of firstDuplicates(lesson.topics)) {
+      findings.push({
+        level: "error",
+        code: "DUPLICATE_TOPIC_REF",
+        message: `Lesson "${lessonId}" references topic "${topicId}" more than once.`,
+        lessonId,
+        topicId
+      });
+    }
+    for (const triggerId of firstDuplicates(lesson.triggers)) {
+      findings.push({
+        level: "error",
+        code: "DUPLICATE_TRIGGER_REF",
+        message: `Lesson "${lessonId}" references trigger "${triggerId}" more than once.`,
+        lessonId,
+        triggerId
+      });
+    }
+  }
+}
+function firstDuplicates(ids) {
+  const seen = /* @__PURE__ */ new Set();
+  const dup = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (seen.has(id)) dup.add(id);
+    else seen.add(id);
+  }
+  return [...dup];
+}
+function collectStatusInvariants(graph, findings) {
+  for (const [lessonId, lesson] of Object.entries(graph.lessons)) {
+    if (lesson.status === "superseded" && lesson.supersededBy === void 0) {
+      findings.push({
+        level: "error",
+        code: "SUPERSEDED_WITHOUT_TARGET",
+        message: `Lesson "${lessonId}" has status "superseded" but no supersededBy target.`,
+        lessonId
+      });
+    }
+    if (lesson.status === "active" && lesson.supersededBy !== void 0) {
+      findings.push({
+        level: "error",
+        code: "ACTIVE_WITH_SUPERSEDER",
+        message: `Lesson "${lessonId}" has status "active" but declares supersededBy.`,
+        lessonId
+      });
+    }
+  }
+}
+function collectLifecycleInvariants(graph, findings) {
+  for (const [lessonId, lesson] of Object.entries(graph.lessons)) {
+    if (lesson.supersededBy === void 0) continue;
+    if (lesson.supersededBy === lessonId) {
+      findings.push({
+        level: "error",
+        code: "SELF_SUPERSEDED",
+        message: `Lesson "${lessonId}" is superseded by itself.`,
+        lessonId
+      });
+      continue;
+    }
+    const target31 = graph.lessons[lesson.supersededBy];
+    if (target31 !== void 0 && target31.status !== "active") {
+      findings.push({
+        level: "error",
+        code: "INACTIVE_SUPERSEDER",
+        message: `Lesson "${lessonId}" is superseded by "${lesson.supersededBy}", which is itself ${target31.status} \u2014 the chain dead-ends with no live replacement.`,
+        lessonId
+      });
+    }
+  }
+  collectSupersedeCycles(graph, findings);
+}
+function collectSupersedeCycles(graph, findings) {
+  const reported = /* @__PURE__ */ new Set();
+  for (const startId of Object.keys(graph.lessons)) {
+    const seen = /* @__PURE__ */ new Set();
+    let cur = startId;
+    while (cur !== void 0) {
+      if (seen.has(cur)) {
+        if (cur !== startId || reported.has(cur)) break;
+        reported.add(cur);
+        findings.push({
+          level: "error",
+          code: "SUPERSEDE_CYCLE",
+          message: `Lesson "${startId}" is part of a supersededBy cycle.`,
+          lessonId: startId
+        });
+        break;
+      }
+      seen.add(cur);
+      const next = graph.lessons[cur]?.supersededBy;
+      if (next === cur) break;
+      cur = next;
+    }
+  }
+}
+function collectReachability(graph, findings) {
+  for (const [lessonId, lesson] of Object.entries(graph.lessons)) {
+    if (lesson.status === "active" && lesson.triggers.length === 0) {
+      findings.push({
+        level: "warning",
+        code: "UNREACHABLE_LESSON",
+        message: `Active lesson "${lessonId}" has no triggers and can never be recalled.`,
+        lessonId
+      });
+    }
+  }
+}
+function collectOrphans(graph, findings) {
+  const referencedTopics = /* @__PURE__ */ new Set();
+  const referencedTriggers = /* @__PURE__ */ new Set();
+  for (const lesson of Object.values(graph.lessons)) {
+    for (const t of lesson.topics) referencedTopics.add(t);
+    for (const t of lesson.triggers) referencedTriggers.add(t);
+  }
+  for (const topicId of Object.keys(graph.topics)) {
+    if (!referencedTopics.has(topicId)) {
+      findings.push({
+        level: "warning",
+        code: "ORPHAN_TOPIC",
+        message: `Topic "${topicId}" is not referenced by any lesson.`,
+        topicId
+      });
+    }
+  }
+  for (const triggerId of Object.keys(graph.triggers)) {
+    if (!referencedTriggers.has(triggerId)) {
+      findings.push({
+        level: "warning",
+        code: "ORPHAN_TRIGGER",
+        message: `Trigger "${triggerId}" is not referenced by any lesson.`,
+        triggerId
+      });
+    }
+  }
+}
+
+// src/lessons/ranking-text.ts
+var STOP = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "to",
+  "of",
+  "in",
+  "and",
+  "or",
+  "for",
+  "is",
+  "on",
+  "at",
+  "with",
+  "be",
+  "as",
+  "it",
+  "that",
+  "this",
+  "its",
+  "must"
+]);
+function tokenize(text) {
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 2 && !STOP.has(t));
+}
+
+// src/lessons/keyword-signal.ts
+var MAX_RECOMMENDED_KEYWORD_TOKENS = 5;
+function isLowSignalKeyword(pattern) {
+  return tokenize(pattern).length > MAX_RECOMMENDED_KEYWORD_TOKENS;
+}
+function splitRawTokens(pattern) {
+  return pattern.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 0);
+}
+function keywordNeedleLosesTokens(pattern) {
+  const raw = splitRawTokens(pattern);
+  if (raw.length < 2) return false;
+  return tokenize(pattern).length !== raw.length;
+}
+
+// src/lessons/regex-linear/nfa-compile.ts
+var MAX_NFA_STATES = 2e3;
+var Builder = class {
+  states = [];
+  alloc() {
+    if (this.states.length >= MAX_NFA_STATES) {
+      throw new Error(`NFA state limit exceeded (${MAX_NFA_STATES}); pattern expands too large`);
+    }
+    this.states.push({ eps: [], asserts: [], chars: [] });
+    return this.states.length - 1;
+  }
+};
+function isNonLineTerminator(c2) {
+  return c2 !== "\n" && c2 !== "\r" && c2 !== "\u2028" && c2 !== "\u2029";
+}
+function compileNode(b, node) {
+  switch (node.k) {
+    case "empty":
+    case "assert": {
+      const s = b.alloc();
+      const e = b.alloc();
+      if (node.k === "assert") b.states[s].asserts.push({ kind: node.kind, target: e });
+      else b.states[s].eps.push(e);
+      return { start: s, end: e };
+    }
+    case "char":
+    case "any":
+    case "class": {
+      const s = b.alloc();
+      const e = b.alloc();
+      const test = node.k === "char" ? (c2) => c2 === node.ch : node.k === "any" ? isNonLineTerminator : node.test;
+      b.states[s].chars.push({ test, target: e });
+      return { start: s, end: e };
+    }
+    case "concat": {
+      if (node.items.length === 0) return compileNode(b, { k: "empty" });
+      let first = null;
+      let prevEnd = -1;
+      for (const item of node.items) {
+        const frag = compileNode(b, item);
+        if (first === null) first = frag;
+        else b.states[prevEnd].eps.push(frag.start);
+        prevEnd = frag.end;
+      }
+      return { start: first.start, end: prevEnd };
+    }
+    case "alt": {
+      const s = b.alloc();
+      const e = b.alloc();
+      for (const opt of node.opts) {
+        const frag = compileNode(b, opt);
+        b.states[s].eps.push(frag.start);
+        b.states[frag.end].eps.push(e);
+      }
+      return { start: s, end: e };
+    }
+    case "opt": {
+      const s = b.alloc();
+      const e = b.alloc();
+      const frag = compileNode(b, node.node);
+      b.states[s].eps.push(frag.start, e);
+      b.states[frag.end].eps.push(e);
+      return { start: s, end: e };
+    }
+    case "star": {
+      const s = b.alloc();
+      const e = b.alloc();
+      const frag = compileNode(b, node.node);
+      b.states[s].eps.push(frag.start, e);
+      b.states[frag.end].eps.push(frag.start, e);
+      return { start: s, end: e };
+    }
+    case "plus": {
+      const e = b.alloc();
+      const frag = compileNode(b, node.node);
+      b.states[frag.end].eps.push(frag.start, e);
+      return { start: frag.start, end: e };
+    }
+  }
+}
+function compileNfa(ast) {
+  const b = new Builder();
+  const { start, end } = compileNode(b, ast);
+  return { states: b.states, start, accept: end };
+}
+
+// src/lessons/regex-linear/nfa.ts
+function wordBoundary(input, pos) {
+  const before = pos > 0 && /[A-Za-z0-9_]/.test(input[pos - 1]);
+  const after = pos < input.length && /[A-Za-z0-9_]/.test(input[pos]);
+  return before !== after;
+}
+function assertHolds(kind, input, pos) {
+  switch (kind) {
+    case "start":
+      return pos === 0;
+    case "end":
+      return pos === input.length;
+    case "wordB":
+      return wordBoundary(input, pos);
+    case "nonWordB":
+      return !wordBoundary(input, pos);
+  }
+}
+function buildMatcher(ast) {
+  const { states, start, accept } = compileNfa(ast);
+  const closure = (set, idx, input, pos, budget) => {
+    const stack = [idx];
+    while (stack.length > 0) {
+      if (budget.remaining <= 0) return;
+      const cur = stack.pop();
+      if (set.has(cur)) continue;
+      set.add(cur);
+      budget.remaining -= 1;
+      for (const t of states[cur].eps) if (!set.has(t)) stack.push(t);
+      for (const a of states[cur].asserts) {
+        if (assertHolds(a.kind, input, pos) && !set.has(a.target)) stack.push(a.target);
+      }
+    }
+  };
+  return {
+    // The input is matched in full (no truncation — truncation would miss suffix
+    // matches and let `$` falsely match an invented endpoint). Work is bounded by
+    // the shared budget instead: when it runs out we report a safe non-match.
+    test(input, budget) {
+      const b = budget ?? { remaining: Number.POSITIVE_INFINITY };
+      if (b.remaining <= 0) return false;
+      let current = /* @__PURE__ */ new Set();
+      for (let pos = 0; pos <= input.length; pos += 1) {
+        closure(current, start, input, pos, b);
+        if (current.has(accept)) return true;
+        if (b.remaining <= 0) return false;
+        if (pos === input.length) break;
+        const ch = input[pos];
+        const next = /* @__PURE__ */ new Set();
+        for (const s of current) {
+          b.remaining -= 1;
+          for (const t of states[s].chars) {
+            if (t.test(ch)) closure(next, t.target, input, pos + 1, b);
+          }
+        }
+        current = next;
+      }
+      return current.has(accept);
+    }
+  };
+}
+
+// src/lessons/regex-linear/ast.ts
+var UnsupportedRegexError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnsupportedRegexError";
+  }
+};
+
+// src/lessons/regex-linear/parse-helpers.ts
+var MAX_REPEAT = 1e3;
+var isWord = (c2) => /[A-Za-z0-9_]/.test(c2);
+function expandRepeat(atom, min, max) {
+  const items = [];
+  for (let k = 0; k < min; k += 1) items.push(atom);
+  if (max === Infinity) {
+    items.push({ k: "star", node: atom });
+  } else {
+    for (let k = min; k < max; k += 1) items.push({ k: "opt", node: atom });
+  }
+  if (items.length === 0) return { k: "empty" };
+  return items.length === 1 ? items[0] : { k: "concat", items };
+}
+function escapeClass(c2) {
+  switch (c2) {
+    case "d":
+      return (x) => x >= "0" && x <= "9";
+    case "D":
+      return (x) => !(x >= "0" && x <= "9");
+    case "w":
+      return isWord;
+    case "W":
+      return (x) => !isWord(x);
+    case "s":
+      return (x) => /\s/.test(x);
+    case "S":
+      return (x) => !/\s/.test(x);
+    default:
+      return null;
+  }
+}
+var HEX2 = /^[0-9a-fA-F]{2}$/;
+var HEX4 = /^[0-9a-fA-F]{4}$/;
+function readUnicodeEscape(src, i, c2) {
+  if (c2 === "x") {
+    const hex2 = src.slice(i, i + 2);
+    return HEX2.test(hex2) ? { ch: String.fromCharCode(parseInt(hex2, 16)), len: 2 } : { ch: "x", len: 0 };
+  }
+  const hex = src.slice(i, i + 4);
+  return HEX4.test(hex) ? { ch: String.fromCharCode(parseInt(hex, 16)), len: 4 } : { ch: "u", len: 0 };
+}
+function readControlEscape(src, i) {
+  const x = src[i];
+  if (x === void 0 || !/[A-Za-z]/.test(x)) {
+    throw new UnsupportedRegexError("\\c must be followed by a letter");
+  }
+  return { ch: String.fromCharCode(x.charCodeAt(0) & 31), len: 1 };
+}
+function classEscapeChar(src, i, e) {
+  if (e === "b") return { ch: "\b", len: 0 };
+  if (e === "c") return readControlEscape(src, i);
+  if (e === "x" || e === "u") return readUnicodeEscape(src, i, e);
+  return { ch: escapeLiteral(e), len: 0 };
+}
+function escapeLiteral(c2) {
+  switch (c2) {
+    case "t":
+      return "	";
+    case "n":
+      return "\n";
+    case "r":
+      return "\r";
+    case "f":
+      return "\f";
+    case "v":
+      return "\v";
+    case "0":
+      return "\0";
+    default:
+      return c2;
+  }
+}
+
+// src/lessons/regex-linear/parse.ts
+function parseRegex(src) {
+  let i = 0;
+  const peek = () => src[i];
+  const eat = () => src[i++];
+  function parseAlt() {
+    const opts = [parseConcat()];
+    while (peek() === "|") {
+      i += 1;
+      opts.push(parseConcat());
+    }
+    return opts.length === 1 ? opts[0] : { k: "alt", opts };
+  }
+  function parseConcat() {
+    const items = [];
+    while (i < src.length && peek() !== "|" && peek() !== ")") {
+      items.push(parseQuantified());
+    }
+    if (items.length === 0) return { k: "empty" };
+    return items.length === 1 ? items[0] : { k: "concat", items };
+  }
+  function parseQuantified() {
+    const atom = parseAtom();
+    const q = peek();
+    if (q === "*" || q === "+" || q === "?") {
+      i += 1;
+      if (peek() === "?") i += 1;
+      return q === "*" ? { k: "star", node: atom } : q === "+" ? { k: "plus", node: atom } : { k: "opt", node: atom };
+    }
+    if (q === "{") {
+      const repeat = tryParseBrace();
+      if (repeat !== null) return expandRepeat(atom, repeat.min, repeat.max);
+    }
+    return atom;
+  }
+  function tryParseBrace() {
+    const m = /^\{(\d+)(,(\d*)?)?\}/.exec(src.slice(i));
+    if (m === null) return null;
+    i += m[0].length;
+    if (peek() === "?") i += 1;
+    const min = Number(m[1]);
+    const max = m[2] === void 0 ? min : m[3] === "" || m[3] === void 0 ? Infinity : Number(m[3]);
+    if (min > MAX_REPEAT || max !== Infinity && max > MAX_REPEAT) {
+      throw new UnsupportedRegexError(`Repeat count over ${MAX_REPEAT} not supported: {${m[1]}\u2026}`);
+    }
+    return { min, max };
+  }
+  function parseAtom() {
+    const c2 = peek();
+    if (c2 === "(") return parseGroup();
+    if (c2 === "[") return parseClass();
+    if (c2 === "\\") return parseEscape();
+    if (c2 === ".") {
+      i += 1;
+      return { k: "any" };
+    }
+    if (c2 === "^") {
+      i += 1;
+      return { k: "assert", kind: "start" };
+    }
+    if (c2 === "$") {
+      i += 1;
+      return { k: "assert", kind: "end" };
+    }
+    if (c2 === void 0 || c2 === "*" || c2 === "+" || c2 === "?" || c2 === ")") {
+      throw new UnsupportedRegexError(`Unexpected '${c2 ?? "<end>"}' in pattern`);
+    }
+    i += 1;
+    return { k: "char", ch: c2 };
+  }
+  function parseGroup() {
+    i += 1;
+    if (peek() === "?") {
+      const c2 = src[i + 1];
+      if (c2 === "=" || c2 === "!" || c2 === "<") {
+        if (!(c2 === "<" && /[A-Za-z]/.test(src[i + 2] ?? ""))) {
+          throw new UnsupportedRegexError("Lookaround assertions are not supported");
+        }
+      }
+      if (c2 === ":") i += 2;
+      else if (c2 === "<") {
+        i += 2;
+        while (i < src.length && src[i] !== ">") i += 1;
+        i += 1;
+      }
+    }
+    const inner = parseAlt();
+    if (peek() !== ")") throw new UnsupportedRegexError("Unbalanced group");
+    i += 1;
+    return inner;
+  }
+  function parseEscape() {
+    i += 1;
+    const c2 = peek();
+    if (c2 === void 0) throw new UnsupportedRegexError("Trailing backslash");
+    if (/[1-9]/.test(c2) || c2 === "k")
+      throw new UnsupportedRegexError("Backreferences are not supported");
+    i += 1;
+    if (c2 === "b") return { k: "assert", kind: "wordB" };
+    if (c2 === "B") return { k: "assert", kind: "nonWordB" };
+    const cls = escapeClass(c2);
+    if (cls !== null) return { k: "class", test: cls };
+    if (c2 === "x" || c2 === "u" || c2 === "c") {
+      const { ch, len } = c2 === "c" ? readControlEscape(src, i) : readUnicodeEscape(src, i, c2);
+      i += len;
+      return { k: "char", ch };
+    }
+    return { k: "char", ch: escapeLiteral(c2) };
+  }
+  function parseClass() {
+    i += 1;
+    const negate = peek() === "^";
+    if (negate) i += 1;
+    const tests = [];
+    while (i < src.length && peek() !== "]") {
+      tests.push(parseClassMember());
+    }
+    if (peek() !== "]") throw new UnsupportedRegexError("Unterminated character class");
+    i += 1;
+    const base = (c2) => tests.some((t) => t(c2));
+    return { k: "class", test: negate ? (c2) => !base(c2) : base };
+  }
+  function parseClassMember() {
+    let lo;
+    if (peek() === "\\") {
+      i += 1;
+      const e = eat();
+      const cls = escapeClass(e);
+      if (cls !== null) return cls;
+      const r = classEscapeChar(src, i, e);
+      i += r.len;
+      lo = r.ch;
+    } else {
+      lo = eat();
+    }
+    if (peek() === "-" && src[i + 1] !== void 0 && src[i + 1] !== "]") {
+      i += 1;
+      let hi;
+      if (peek() === "\\") {
+        i += 1;
+        const e2 = eat();
+        const r = classEscapeChar(src, i, e2);
+        i += r.len;
+        hi = r.ch;
+      } else {
+        hi = eat();
+      }
+      const a = lo.codePointAt(0);
+      const b = hi.codePointAt(0);
+      return (c2) => {
+        const p = c2.codePointAt(0);
+        return p >= a && p <= b;
+      };
+    }
+    return (c2) => c2 === lo;
+  }
+  const ast = parseAlt();
+  if (i !== src.length) throw new UnsupportedRegexError(`Unexpected '${peek()}' at ${i}`);
+  return ast;
+}
+
+// src/lessons/regex-linear/index.ts
+var cache = /* @__PURE__ */ new Map();
+function compileLinearMatcher(pattern) {
+  const hit = cache.get(pattern);
+  if (hit !== void 0 || cache.has(pattern)) return hit ?? null;
+  let matcher;
+  try {
+    matcher = buildMatcher(parseRegex(pattern));
+  } catch {
+    matcher = null;
+  }
+  cache.set(pattern, matcher);
+  return matcher;
+}
+
+// src/lessons/regex-safety.ts
+var MAX_PATTERN_LENGTH = 1e3;
+function isSafeRegexPattern(pattern) {
+  if (pattern.length > MAX_PATTERN_LENGTH) return false;
+  return compileLinearMatcher(pattern) !== null;
+}
+
+// src/lessons/validate-quality.ts
+function collectDuplicateRules(graph, findings) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const [lessonId, lesson] of Object.entries(graph.lessons)) {
+    if (lesson.status !== "active") continue;
+    const key = normalizeRule(lesson.rule);
+    const bucket = byKey.get(key) ?? [];
+    bucket.push(lessonId);
+    byKey.set(key, bucket);
+  }
+  for (const [key, ids] of byKey) {
+    if (ids.length < 2) continue;
+    const sorted = [...ids].sort();
+    for (const lessonId of sorted) {
+      const others = sorted.filter((other) => other !== lessonId);
+      findings.push({
+        level: "error",
+        code: "DUPLICATE_RULE",
+        message: `Lesson "${lessonId}" duplicates rule text of: ${others.join(", ")} (normalized key: "${key.slice(0, 60)}").`,
+        lessonId
+      });
+    }
+  }
+}
+function collectInvalidTriggerPatterns(graph, findings) {
+  for (const [triggerId, trigger] of Object.entries(graph.triggers)) {
+    if (trigger.kind !== "command_pattern") continue;
+    try {
+      new RegExp(trigger.pattern);
+    } catch (err) {
+      findings.push({
+        level: "error",
+        code: "INVALID_TRIGGER_PATTERN",
+        message: `Trigger "${triggerId}" has an invalid command_pattern regex (${trigger.pattern}): ${err instanceof Error ? err.message : String(err)}.`,
+        triggerId
+      });
+      continue;
+    }
+    if (!isSafeRegexPattern(trigger.pattern)) {
+      findings.push({
+        level: "error",
+        code: "UNSAFE_TRIGGER_PATTERN",
+        message: `Trigger "${triggerId}" has a command_pattern regex outside the provably-linear subset (${trigger.pattern}): it can backtrack catastrophically (e.g. a quantified group like (a+)+ or (a|aa)+, adjacent repetition like a+a+, or a backreference/lookaround). Rewrite using a linear pattern.`,
+        triggerId
+      });
+    }
+  }
+}
+function collectBackslashGlobPatterns(graph, findings) {
+  for (const [triggerId, trigger] of Object.entries(graph.triggers)) {
+    if (trigger.kind !== "file_glob") continue;
+    if (!trigger.pattern.includes("\\")) continue;
+    findings.push({
+      level: "error",
+      code: "BACKSLASH_GLOB_PATTERN",
+      message: `Trigger "${triggerId}" has a file_glob pattern with a backslash (${trigger.pattern}); recall normalizes paths to forward slashes, so it never fires. Replace \\ with /.`,
+      triggerId
+    });
+  }
+}
+function collectDuplicateTriggers(graph, findings) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const [triggerId, trigger] of Object.entries(graph.triggers)) {
+    const key = `${trigger.kind}|${trigger.pattern}`;
+    const bucket = byKey.get(key) ?? [];
+    bucket.push(triggerId);
+    byKey.set(key, bucket);
+  }
+  for (const [key, ids] of byKey) {
+    if (ids.length < 2) continue;
+    const sorted = [...ids].sort();
+    for (const triggerId of sorted) {
+      const others = sorted.filter((other) => other !== triggerId);
+      findings.push({
+        level: "error",
+        code: "DUPLICATE_TRIGGER",
+        message: `Trigger "${triggerId}" duplicates (kind, pattern) of: ${others.join(", ")} (key: "${key}").`,
+        triggerId
+      });
+    }
+  }
+}
+var HIGH_FANOUT_THRESHOLD = 10;
+function collectFanout(graph, findings) {
+  const fanout = /* @__PURE__ */ new Map();
+  for (const lesson of Object.values(graph.lessons)) {
+    if (lesson.status !== "active") continue;
+    for (const t of lesson.triggers) fanout.set(t, (fanout.get(t) ?? 0) + 1);
+  }
+  let over = 0;
+  let max = 0;
+  for (const n of fanout.values()) {
+    if (n > HIGH_FANOUT_THRESHOLD) over += 1;
+    if (n > max) max = n;
+  }
+  if (over > 0) {
+    findings.push({
+      level: "warning",
+      code: "HIGH_FANOUT_TRIGGERS",
+      message: `${over} trigger(s) each match more than ${HIGH_FANOUT_THRESHOLD} active lessons (max ${max}); recall returns the ranked top by default \u2014 consider per-lesson trigger refinement to improve precision.`
+    });
+  }
+}
+function collectLowSignalKeywords(graph, findings) {
+  const activeTriggerIds2 = /* @__PURE__ */ new Set();
+  for (const lesson of Object.values(graph.lessons)) {
+    if (lesson.status !== "active") continue;
+    for (const t of lesson.triggers) activeTriggerIds2.add(t);
+  }
+  for (const [triggerId, trigger] of Object.entries(graph.triggers)) {
+    if (trigger.kind !== "keyword") continue;
+    if (!activeTriggerIds2.has(triggerId)) continue;
+    if (!isLowSignalKeyword(trigger.pattern)) continue;
+    findings.push({
+      level: "warning",
+      code: "LOW_SIGNAL_KEYWORD",
+      message: `Keyword trigger "${triggerId}" carries more than ${MAX_RECOMMENDED_KEYWORD_TOKENS} tokens (${trigger.pattern}); recall matches a keyword only as a substring of --keyword or a contiguous token-run in the file/command, so it rarely fires \u2014 use a short distinctive phrase.`,
+      triggerId
+    });
+  }
+}
+function collectStopwordKeywords(graph, findings) {
+  const activeTriggerIds2 = /* @__PURE__ */ new Set();
+  for (const lesson of Object.values(graph.lessons)) {
+    if (lesson.status !== "active") continue;
+    for (const t of lesson.triggers) activeTriggerIds2.add(t);
+  }
+  for (const [triggerId, trigger] of Object.entries(graph.triggers)) {
+    if (trigger.kind !== "keyword") continue;
+    if (!activeTriggerIds2.has(triggerId)) continue;
+    if (tokenize(trigger.pattern).length !== 0 && !keywordNeedleLosesTokens(trigger.pattern)) {
+      continue;
+    }
+    findings.push({
+      level: "warning",
+      code: "STOPWORD_KEYWORD",
+      message: `Keyword trigger "${triggerId}" (${trigger.pattern}) loses tokens to stopword filtering, so its needle can never appear as a contiguous run on the mandatory --file/--cmd recall path \u2014 drop the stopwords (e.g. "state art" instead of "state of the art"), or detach it with \`lessons untrigger\`.`,
+      triggerId
+    });
+  }
+}
+function normalizeRule(rule) {
+  return rule.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function activeTriggerIds(graph) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const lesson of Object.values(graph.lessons)) {
+    if (lesson.status !== "active") continue;
+    for (const t of lesson.triggers) ids.add(t);
+  }
+  return ids;
+}
+function deadFileGlobIds(graph, knownPaths) {
+  const active = activeTriggerIds(graph);
+  const paths = [...knownPaths];
+  const dead = /* @__PURE__ */ new Set();
+  for (const [triggerId, trigger] of Object.entries(graph.triggers)) {
+    if (trigger.kind !== "file_glob") continue;
+    if (!active.has(triggerId)) continue;
+    const isMatch = picomatch(trigger.pattern, { dot: true });
+    if (!paths.some((p) => isMatch(p))) dead.add(triggerId);
+  }
+  return dead;
+}
+function collectDeadFileGlobs(graph, findings, knownPaths) {
+  for (const triggerId of deadFileGlobIds(graph, knownPaths)) {
+    findings.push({
+      level: "warning",
+      code: "DEAD_FILE_GLOB",
+      message: `file_glob trigger "${triggerId}" (${graph.triggers[triggerId]?.pattern ?? ""}) matches no file in the working tree \u2014 the lesson is unreachable via this trigger (a rename likely moved the path). Re-point it at the current path, or detach it with \`lessons untrigger\`, or run \`lessons prune --apply\`.`,
+      triggerId
+    });
+  }
+}
+var RUNNER_ANCHOR = /^\^(pnpm|npm|npx|yarn|bun)\b/;
+function collectRunnerAnchoredPatterns(graph, findings) {
+  const active = activeTriggerIds(graph);
+  for (const [triggerId, trigger] of Object.entries(graph.triggers)) {
+    if (trigger.kind !== "command_pattern") continue;
+    if (!active.has(triggerId)) continue;
+    if (!RUNNER_ANCHOR.test(trigger.pattern)) continue;
+    findings.push({
+      level: "warning",
+      code: "RUNNER_ANCHORED_PATTERN",
+      message: `command_pattern trigger "${triggerId}" (${trigger.pattern}) is anchored to one runner \u2014 it won't fire for the same task via another runner (e.g. \`npx\` vs \`pnpm\`). Drop the \`^<runner>\` anchor and key on the task (e.g. \`\\bvitest\\b\`).`,
+      triggerId
+    });
+  }
+}
+
+// src/lessons/validate.ts
+function validateLessonsGraph(graph, options = {}) {
+  const findings = [];
+  const schemaResult = LessonsGraphSchema.safeParse(graph);
+  if (!schemaResult.success) {
+    findings.push({
+      level: "error",
+      code: "SCHEMA_INVALID",
+      message: schemaResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")
+    });
+    return { ok: false, findings };
+  }
+  collectDanglingRefs(graph, findings);
+  collectDuplicateRefs(graph, findings);
+  collectStatusInvariants(graph, findings);
+  collectLifecycleInvariants(graph, findings);
+  collectDuplicateRules(graph, findings);
+  collectReachability(graph, findings);
+  collectInvalidTriggerPatterns(graph, findings);
+  collectBackslashGlobPatterns(graph, findings);
+  collectDuplicateTriggers(graph, findings);
+  collectOrphans(graph, findings);
+  collectFanout(graph, findings);
+  collectLowSignalKeywords(graph, findings);
+  collectStopwordKeywords(graph, findings);
+  collectRunnerAnchoredPatterns(graph, findings);
+  if (options.knownPaths !== void 0) collectDeadFileGlobs(graph, findings, options.knownPaths);
+  const ok = findings.every((f) => f.level !== "error");
+  return { ok, findings };
+}
 
 // src/core/lint/shared/lessons.ts
 var LESSONS_TARGET = "lessons";
-var INDEX_REL = ".agentsmesh/lessons/index.yaml";
+var GRAPH_REL = ".agentsmesh/lessons/lessons.json";
 var ROOT_RULE_REL = ".agentsmesh/rules/_root.md";
 var LESSONS_HEADING = /^## Lessons \(/m;
-var RULES_HEADING = /^## Rules\b/m;
 function lintLessonsSubsystem(projectRoot, scope) {
   if (scope === "global") return [];
   const paths = lessonsPaths(projectRoot);
-  if (!existsSync(paths.index)) return [];
+  if (!existsSync(paths.graph)) return [];
   const out2 = [];
-  const parsed = LessonsIndexSchema.safeParse(parse(readFileSync(paths.index, "utf8")));
-  if (!parsed.success) {
-    return [diag("error", INDEX_REL, `index.yaml is invalid: ${parsed.error.issues[0].message}`)];
+  let graph;
+  try {
+    graph = loadLessonsGraph(projectRoot);
+  } catch (err) {
+    return [
+      diag(
+        "error",
+        GRAPH_REL,
+        `lessons.json failed to load: ${err instanceof Error ? err.message : String(err)}`
+      )
+    ];
   }
-  for (const cluster of parsed.data.clusters) {
-    const topicAbs = join(projectRoot, cluster.file);
-    if (!existsSync(topicAbs)) {
-      out2.push(
-        diag("error", cluster.file, `topic file for cluster "${cluster.topic}" does not exist.`)
-      );
-      continue;
-    }
-    if (!RULES_HEADING.test(readFileSync(topicAbs, "utf8"))) {
-      out2.push(
-        diag("warning", cluster.file, `topic "${cluster.topic}" is missing a "## Rules" section.`)
-      );
-    }
-    for (const pattern of cluster.triggers.command_patterns) {
-      try {
-        new RegExp(pattern);
-      } catch {
-        out2.push(
-          diag(
-            "warning",
-            INDEX_REL,
-            `cluster "${cluster.topic}" command_patterns entry is not a valid regex: ${pattern}`
-          )
-        );
-      }
-    }
+  const knownPaths = listProjectFiles(projectRoot) ?? void 0;
+  const report = validateLessonsGraph(graph, { knownPaths });
+  for (const finding of report.findings) {
+    out2.push(diag(finding.level, GRAPH_REL, `[${finding.code}] ${finding.message}`));
   }
   const rootRuleAbs = join(projectRoot, ROOT_RULE_REL);
   const rootRuleBody = existsSync(rootRuleAbs) ? readFileSync(rootRuleAbs, "utf8") : "";