@alessandroraffa/tangyr 0.16.0 → 0.16.1

package/dist/index.js

@@ -17834,8 +17834,8 @@ async function runCacheClearCommand(options, logger) {
 }
 
 // src/commands/cleanup.ts
-import fs23 from "fs";
-import path21 from "path";
+import fs24 from "fs";
+import path22 from "path";
 
 // node_modules/glob/dist/esm/index.min.js
 import { fileURLToPath as Wi } from "url";
@@ -20832,6 +20832,7 @@ var KNOWN_COMPONENTS = /* @__PURE__ */ new Set([
   "hooks",
   "output-styles"
 ]);
+var KNOWN_INSTRUCTION_FILES = /* @__PURE__ */ new Set(["AGENTS.md", "CLAUDE.md"]);
 var LEGACY_SOURCE_DIRECTORIES = /* @__PURE__ */ new Set([
   "operational-framework",
   "operational-machinery"
@@ -20891,7 +20892,7 @@ function isOurStaleSymlink(linkPath, managedPaths, config) {
     const lastSegment = path17.basename(linkTarget);
     const parentSegment = path17.basename(path17.dirname(linkTarget));
     if (isBroken) {
-      return KNOWN_COMPONENTS.has(lastSegment) || KNOWN_COMPONENTS.has(parentSegment) || knownFiles.has(lastSegment);
+      return KNOWN_COMPONENTS.has(lastSegment) || KNOWN_COMPONENTS.has(parentSegment) || KNOWN_INSTRUCTION_FILES.has(lastSegment) || knownFiles.has(lastSegment);
     }
     const targetSegments = absoluteTarget.split(path17.sep);
     const traversesLegacyRoot = targetSegments.some(
@@ -20980,8 +20981,8 @@ function removeManagedEntries(filePath, parser, serializer, removeManaged, logge
 }
 
 // src/commands/uninstall.ts
-import fs22 from "fs";
-import path20 from "path";
+import fs23 from "fs";
+import path21 from "path";
 
 // src/core/managed-sources.ts
 var import_yaml5 = __toESM(require_dist(), 1);
@@ -21047,38 +21048,195 @@ function normalizeManagedSourcePath(rawPath) {
   return normalized.startsWith("./") ? normalized.slice(2) : normalized;
 }
 
-// src/core/remove.ts
+// src/compiler/hook-components.ts
+var import_yaml6 = __toESM(require_dist(), 1);
 import fs21 from "fs";
+import path20 from "path";
+function parseHookDeclaration(filePath) {
+  let raw;
+  try {
+    raw = fs21.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  const fm = extractFrontmatter(raw);
+  if (!fm) {
+    return null;
+  }
+  const { name, description, events } = fm;
+  if (typeof name !== "string" || !name.trim()) {
+    return null;
+  }
+  if (typeof description !== "string" || !description.trim()) {
+    return null;
+  }
+  if (!Array.isArray(events) || events.length === 0) {
+    return null;
+  }
+  const parsedEvents = [];
+  for (const entry of events) {
+    if (!entry || typeof entry !== "object") {
+      return null;
+    }
+    const ev = entry;
+    if (typeof ev.event !== "string" || !ev.event.trim()) {
+      return null;
+    }
+    if (typeof ev.timeout !== "number") {
+      return null;
+    }
+    if (typeof ev.statusMessage !== "string" || !ev.statusMessage.trim()) {
+      return null;
+    }
+    const parsed = {
+      event: ev.event,
+      timeout: ev.timeout,
+      statusMessage: ev.statusMessage
+    };
+    if (typeof ev.matcher === "string" && ev.matcher.trim()) {
+      parsed.matcher = ev.matcher;
+    }
+    parsedEvents.push(parsed);
+  }
+  return {
+    name: name.trim(),
+    description: description.trim(),
+    events: parsedEvents
+  };
+}
+function hookCommand(name) {
+  return `npx tsx ~/.agents/hooks/scripts/${name}.ts`;
+}
+function synthesizeHooksJson(declarations) {
+  const hooks = {};
+  for (const decl of declarations) {
+    for (const ev of decl.events) {
+      if (!hooks[ev.event]) {
+        hooks[ev.event] = [];
+      }
+      const entry = {
+        hooks: [
+          {
+            type: "command",
+            command: hookCommand(decl.name),
+            timeout: ev.timeout,
+            statusMessage: ev.statusMessage
+          }
+        ]
+      };
+      if (ev.matcher !== void 0) {
+        const ordered = {
+          matcher: ev.matcher,
+          hooks: entry.hooks
+        };
+        hooks[ev.event].push(ordered);
+      } else {
+        hooks[ev.event].push(entry);
+      }
+    }
+  }
+  return { hooks };
+}
+function loadSourceHooks(hooksDir, hookNames) {
+  const hooksJsonPath = path20.join(hooksDir, "hooks.json");
+  if (fs21.existsSync(hooksJsonPath)) {
+    const raw = fs21.readFileSync(hooksJsonPath, "utf8");
+    return JSON.parse(raw);
+  }
+  const declarations = loadHookDeclarations(hooksDir, hookNames);
+  return synthesizeHooksJson(declarations);
+}
+function loadHookDeclarations(hooksDir, hookNames) {
+  let names;
+  if (hookNames && hookNames.length > 0) {
+    names = hookNames;
+  } else {
+    if (!fs21.existsSync(hooksDir) || !fs21.statSync(hooksDir).isDirectory()) {
+      return [];
+    }
+    names = fs21.readdirSync(hooksDir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).map((f) => f.slice(0, -3)).sort();
+  }
+  const declarations = [];
+  for (const name of names) {
+    const filePath = path20.join(hooksDir, `${name}.md`);
+    const decl = parseHookDeclaration(filePath);
+    if (decl) {
+      declarations.push(decl);
+    }
+  }
+  return declarations;
+}
+function extractFrontmatter(content) {
+  if (!content.startsWith("---\n")) {
+    return null;
+  }
+  const endIndex = content.indexOf("\n---", 4);
+  if (endIndex === -1) {
+    return null;
+  }
+  const rawFm = content.slice(4, endIndex);
+  let parsed;
+  try {
+    parsed = (0, import_yaml6.parse)(rawFm);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
+  }
+  return parsed;
+}
+
+// src/core/remove.ts
+import fs22 from "fs";
 function removeManagedPath(managedPath) {
   let stat;
   try {
-    stat = fs21.lstatSync(managedPath);
+    stat = fs22.lstatSync(managedPath);
   } catch {
     return;
   }
   if (stat.isSymbolicLink() || stat.isFile()) {
-    fs21.unlinkSync(managedPath);
+    fs22.unlinkSync(managedPath);
     return;
   }
   if (stat.isDirectory()) {
-    fs21.rmSync(managedPath, { recursive: true, force: true });
+    fs22.rmSync(managedPath, { recursive: true, force: true });
   }
 }
 
 // src/commands/uninstall.ts
 var codexManagedMcpStart = "# tangyr: managed mcp start";
 var codexManagedMcpEnd = "# tangyr: managed mcp end";
+var legacyClaudeSharedPermission = "Read(~/.agents/**)";
+var legacyOperatingGuideSignature = "# Agent Coding \u2014 Operating Guide\n\n_Structured authoring with LLM agents across the full artifact continuum._";
 var SHARED_CLAUDE_SLOTS = /* @__PURE__ */ new Set([
   "mcp_shared_file",
   "hooks"
 ]);
+function resolveClaudeCodePathsForRoots(roots, mappings) {
+  return roots.map((root) => resolveClaudeCodeProfileForRoot(root, mappings));
+}
 async function runUninstallCommand(options, logger) {
   const scope = options.scope === "global" ? "global" : "project";
   const scopePath = resolveScopePath(
     scope,
     scope === "project" ? process.cwd() : void 0
   );
-  const manifest = readStrictManifest(scopePath);
+  const runtime = resolveRuntimeIfAvailable(options, logger);
+  const persistedManifest = readStrictManifest(scopePath);
+  const manifestWasPresent = persistedManifest !== null;
+  let manifest = persistedManifest;
+  if (!manifest && scope === "global" && runtime?.kitInfo) {
+    manifest = createEmptyManifest(
+      runtime.kitInfo.archetype,
+      runtime.kitInfo.kitFormat,
+      "global"
+    );
+    logger.warn(
+      `No Tangyr manifest found in ${scope} scope; reconciling ownership evidence on disk.`
+    );
+  }
   if (!manifest) {
     logger.error(
       `No Tangyr installation found in ${scope} scope (${scopePath}).`
@@ -21086,15 +21244,25 @@ async function runUninstallCommand(options, logger) {
     logger.info("Nothing to uninstall.");
     process.exit(1);
   }
-  const runtime = resolveRuntimeIfAvailable(options, logger);
   const selectedTools = resolveSelectedTools(options.tools, manifest, runtime);
   const manifestArtifacts = manifest.artifacts.filter(
     (file) => shouldRemoveManifestFile(file.relativePath, selectedTools)
   );
-  const kitArtifacts = runtime ? resolveKitManagedArtifacts(runtime, scope, selectedTools) : [];
-  logger.info(
-    `Found Tangyr installation: archetype ${manifest.archetype}, version ${manifest.version}`
-  );
+  const kitArtifacts = runtime ? resolveKitManagedArtifacts(
+    runtime,
+    scope,
+    selectedTools,
+    manifest,
+    options.claudeConfigDir
+  ).filter((artifact) => isKitManagedArtifact(artifact, runtime)) : [];
+  const useManifestPathRemoval = scope !== "global" || runtime === void 0;
+  if (manifestWasPresent) {
+    logger.info(
+      `Found Tangyr installation: archetype ${manifest.archetype}, version ${manifest.version}`
+    );
+  } else {
+    logger.info(`Scanning Tangyr residue for archetype ${manifest.archetype}`);
+  }
   logger.info(`Scope: ${scope} (${scopePath})`);
   logger.info(
     `Tools: ${Array.from(selectedTools).join(", ") || manifest.tools.join(", ") || "(none)"}`
@@ -21105,8 +21273,10 @@ async function runUninstallCommand(options, logger) {
   }
   if (options.dryRun) {
     logger.info("\n[dry-run] Would remove:");
-    for (const file of manifestArtifacts) {
-      logger.info(`  ${file.relativePath}`);
+    if (useManifestPathRemoval) {
+      for (const file of manifestArtifacts) {
+        logger.info(`  ${file.relativePath}`);
+      }
     }
     for (const artifact of kitArtifacts) {
       logger.info(`  ${artifact.path}`);
@@ -21121,7 +21291,7 @@ async function runUninstallCommand(options, logger) {
   }
   if (!options.yes) {
     const proceed = await dist_default5({
-      message: `Remove Tangyr from ${scope} scope? This will delete ${manifestArtifacts.length + kitArtifacts.length} managed file(s).`
+      message: `Remove Tangyr from ${scope} scope? This will delete ${(useManifestPathRemoval ? manifestArtifacts.length : 0) + kitArtifacts.length} managed file(s).`
     });
     if (!proceed) {
       logger.info("Uninstallation aborted.");
@@ -21130,7 +21300,7 @@ async function runUninstallCommand(options, logger) {
   }
   const claudeRoots = scope === "global" && selectedTools.has("claude-code") ? resolveClaudeRootsForUninstall(manifest, runtime) : [];
   let removedCount = 0;
-  for (const file of manifestArtifacts) {
+  for (const file of useManifestPathRemoval ? manifestArtifacts : []) {
     const isClaudeGlobal = file.relativePath.startsWith("claude-code/") && scope === "global";
     if (isClaudeGlobal && claudeRoots.length > 0) {
       const paths = resolveManifestKeyToMultiPaths(
@@ -21139,7 +21309,7 @@ async function runUninstallCommand(options, logger) {
         runtime
       );
       for (const actualPath of paths) {
-        if (actualPath && (fs22.existsSync(actualPath) || isSymlink(actualPath))) {
+        if (actualPath && (fs23.existsSync(actualPath) || isSymlink(actualPath))) {
           removeManagedPath(actualPath);
           logger.verbose(`  removed: ${actualPath}`);
           removedCount++;
@@ -21153,7 +21323,7 @@ async function runUninstallCommand(options, logger) {
         scope,
         runtime
       );
-      if (actualPath && (fs22.existsSync(actualPath) || isSymlink(actualPath))) {
+      if (actualPath && (fs23.existsSync(actualPath) || isSymlink(actualPath))) {
         removeManagedPath(actualPath);
         logger.verbose(`  removed: ${actualPath}`);
         removedCount++;
@@ -21168,32 +21338,46 @@ async function runUninstallCommand(options, logger) {
         removedCount++;
       }
     }
+    const residuals = resolveKitManagedArtifacts(
+      runtime,
+      scope,
+      selectedTools,
+      manifest,
+      options.claudeConfigDir
+    ).filter((artifact) => isKitManagedArtifact(artifact, runtime));
+    if (residuals.length > 0) {
+      throw new Error(
+        `Uninstall incomplete: ${residuals.length} managed artifact(s) remain: ${residuals.map((artifact) => artifact.path).join(", ")}`
+      );
+    }
   }
   const fullUninstall = isFullToolUninstall(manifest, selectedTools);
   if (fullUninstall) {
     for (const backup of manifest.backups) {
       restoreBackup(backup, logger);
     }
-    const manifestPath = path20.join(scopePath, "manifest.json");
-    if (fs22.existsSync(manifestPath)) {
-      fs22.unlinkSync(manifestPath);
+    const manifestPath = path21.join(scopePath, "manifest.json");
+    if (fs23.existsSync(manifestPath)) {
+      fs23.unlinkSync(manifestPath);
       logger.verbose(`  removed manifest: ${manifestPath}`);
     }
     try {
-      const remaining = fs22.readdirSync(scopePath);
+      const remaining = fs23.readdirSync(scopePath);
       if (remaining.length === 0) {
-        fs22.rmdirSync(scopePath);
+        fs23.rmdirSync(scopePath);
         logger.verbose(`  removed empty scope directory: ${scopePath}`);
       }
     } catch {
     }
-  } else {
+  } else if (manifestWasPresent) {
     manifest.artifacts = manifest.artifacts.filter(
       (file) => !shouldRemoveManifestFile(file.relativePath, selectedTools)
     );
     manifest.tools = manifest.tools.filter((tool) => !selectedTools.has(tool));
     writeManifest(scopePath, manifest);
     logger.verbose("  updated manifest for partial uninstall");
+  } else {
+    logger.verbose("  no manifest to update after partial residue cleanup");
   }
   logger.info(`
 Uninstallation complete: ${removedCount} file(s) removed.`);
@@ -21220,7 +21404,7 @@ function resolveManifestKeyToPath(key, scope, runtime) {
     if (!slotPath) {
       return null;
     }
-    return subPath ? path20.join(slotPath, subPath) : slotPath;
+    return subPath ? path21.join(slotPath, subPath) : slotPath;
   }
   if (tool === "copilot") {
     const copilotPaths = resolveCopilotPaths(runtime, scope, projectRoot);
@@ -21228,18 +21412,18 @@ function resolveManifestKeyToPath(key, scope, runtime) {
       return copilotPaths.skills;
     }
     if (component.startsWith("agents/")) {
-      return path20.join(copilotPaths.agents, component.slice("agents/".length));
+      return path21.join(copilotPaths.agents, component.slice("agents/".length));
     }
     if (component.startsWith("prompts/")) {
-      return path20.join(
+      return path21.join(
         copilotPaths.prompts,
         component.slice("prompts/".length)
       );
     }
     if (component.startsWith("hooks/")) {
-      return path20.join(copilotPaths.hooks, component.slice("hooks/".length));
+      return path21.join(copilotPaths.hooks, component.slice("hooks/".length));
     }
-    if (component === path20.basename(copilotPaths.mcpSharedFile)) {
+    if (component === path21.basename(copilotPaths.mcpSharedFile)) {
       return copilotPaths.mcpSharedFile;
     }
     return null;
@@ -21253,15 +21437,15 @@ function resolveManifestKeyToPath(key, scope, runtime) {
       return codexPaths.skills;
     }
     if (component.startsWith("agents/")) {
-      return path20.join(codexPaths.agents, component.slice("agents/".length));
+      return path21.join(codexPaths.agents, component.slice("agents/".length));
     }
     if (component.startsWith("rules/")) {
-      return path20.join(codexPaths.rules, component.slice("rules/".length));
+      return path21.join(codexPaths.rules, component.slice("rules/".length));
     }
-    if (component === path20.basename(codexPaths.hooksSharedFile)) {
+    if (component === path21.basename(codexPaths.hooksSharedFile)) {
       return codexPaths.hooksSharedFile;
     }
-    if (component === path20.basename(codexPaths.mcpSharedFile)) {
+    if (component === path21.basename(codexPaths.mcpSharedFile)) {
       return codexPaths.mcpSharedFile;
     }
     return null;
@@ -21278,15 +21462,15 @@ function resolveManifestKeyToPath(key, scope, runtime) {
       return opencodePaths.skillsShared;
     }
     if (component.startsWith("agents/")) {
-      return path20.join(opencodePaths.agents, component.slice("agents/".length));
+      return path21.join(opencodePaths.agents, component.slice("agents/".length));
     }
     if (component.startsWith("commands/")) {
-      return path20.join(
+      return path21.join(
         opencodePaths.commands,
         component.slice("commands/".length)
       );
     }
-    if (component === path20.basename(opencodePaths.configDoc)) {
+    if (component === path21.basename(opencodePaths.configDoc)) {
       return opencodePaths.configDoc;
     }
     return null;
@@ -21312,13 +21496,13 @@ function resolveManifestKeyToPath(key, scope, runtime) {
       return cursorPaths.permissionsFile;
     }
     if (component.startsWith("agents/")) {
-      return path20.join(cursorPaths.agents, component.slice("agents/".length));
+      return path21.join(cursorPaths.agents, component.slice("agents/".length));
     }
     if (component.startsWith("rules/")) {
-      return path20.join(cursorPaths.rules, component.slice("rules/".length));
+      return path21.join(cursorPaths.rules, component.slice("rules/".length));
     }
     if (component.startsWith("skills/")) {
-      return path20.join(cursorPaths.skills, component.slice("skills/".length));
+      return path21.join(cursorPaths.skills, component.slice("skills/".length));
     }
     return null;
   }
@@ -21334,10 +21518,10 @@ function resolveManifestKeyToPath(key, scope, runtime) {
       return clinePaths.mcpFile;
     }
     if (component.startsWith("rules/")) {
-      return path20.join(clinePaths.rules, component.slice("rules/".length));
+      return path21.join(clinePaths.rules, component.slice("rules/".length));
     }
     if (component.startsWith("workflows/")) {
-      return path20.join(
+      return path21.join(
         clinePaths.workflows,
         component.slice("workflows/".length)
       );
@@ -21371,22 +21555,22 @@ function resolveClaudeCodePaths(runtime, scope, projectRoot) {
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
   if (scope === "global") {
     return {
-      instructions: path20.join(home, ".claude", "CLAUDE.md"),
-      agents: path20.join(home, ".claude", "agents"),
-      skills: path20.join(home, ".claude", "skills"),
-      commands: path20.join(home, ".claude", "commands"),
-      rules: path20.join(home, ".claude", "rules"),
-      output_styles: path20.join(home, ".claude", "output-styles")
+      instructions: path21.join(home, ".claude", "CLAUDE.md"),
+      agents: path21.join(home, ".claude", "agents"),
+      skills: path21.join(home, ".claude", "skills"),
+      commands: path21.join(home, ".claude", "commands"),
+      rules: path21.join(home, ".claude", "rules"),
+      output_styles: path21.join(home, ".claude", "output-styles")
     };
   }
   const root = projectRoot ?? process.cwd();
   return {
-    instructions: path20.join(root, "CLAUDE.md"),
-    agents: path20.join(root, ".claude", "agents"),
-    skills: path20.join(root, ".claude", "skills"),
-    commands: path20.join(root, ".claude", "commands"),
-    rules: path20.join(root, ".claude", "rules"),
-    output_styles: path20.join(root, ".claude", "output-styles")
+    instructions: path21.join(root, "CLAUDE.md"),
+    agents: path21.join(root, ".claude", "agents"),
+    skills: path21.join(root, ".claude", "skills"),
+    commands: path21.join(root, ".claude", "commands"),
+    rules: path21.join(root, ".claude", "rules"),
+    output_styles: path21.join(root, ".claude", "output-styles")
   };
 }
 function resolveClaudeRootsForUninstall(manifest, runtime) {
@@ -21405,12 +21589,36 @@ function resolveClaudeRootsForUninstall(manifest, runtime) {
         projectRoot: void 0,
         mappings: mappings.platformPaths
       })["claude-code"];
-      return [path20.dirname(profile.agents)];
+      return [path21.dirname(profile.agents)];
     } catch {
     }
   }
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return [path20.resolve(expandHome(`${home}/.claude`))];
+  return [path21.resolve(expandHome(`${home}/.claude`))];
+}
+function resolveAllClaudeRoots(manifest, runtime, claudeConfigDirs) {
+  const home = process.env.HOME ?? process.env.USERPROFILE;
+  const roots = new Set(
+    [
+      ...resolveClaudeRootsForUninstall(manifest, runtime),
+      ...resolveClaudeGlobalRoots({
+        flag: claudeConfigDirs,
+        env: process.env.TANGYR_CLAUDE_CONFIG_DIRS,
+        config: runtime.config.claudeCodeGlobalPaths
+      })
+    ].map((root) => path21.resolve(root))
+  );
+  if (home && fs23.existsSync(home)) {
+    try {
+      for (const entry of fs23.readdirSync(home, { withFileTypes: true })) {
+        if (entry.isDirectory() && entry.name.startsWith(".claude-")) {
+          roots.add(path21.resolve(home, entry.name));
+        }
+      }
+    } catch {
+    }
+  }
+  return Array.from(roots).sort();
 }
 function resolveManifestKeyToMultiPaths(key, claudeRoots, runtime) {
   if (claudeRoots.length === 0) {
@@ -21423,13 +21631,13 @@ function resolveManifestKeyToMultiPaths(key, claudeRoots, runtime) {
   const rootsToResolve = isShared ? [claudeRoots[0]] : claudeRoots;
   if (!runtime) {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    const defaultRoot = path20.resolve(expandHome(`${home}/.claude`));
+    const defaultRoot = path21.resolve(expandHome(`${home}/.claude`));
     return rootsToResolve.flatMap((root) => {
       const hardcoded = resolveHardcodedClaudeSlot(root, defaultRoot, slotName);
       if (!hardcoded) {
         return [];
       }
-      return [subPath ? path20.join(hardcoded, subPath) : hardcoded];
+      return [subPath ? path21.join(hardcoded, subPath) : hardcoded];
     });
   }
   try {
@@ -21448,17 +21656,17 @@ function resolveManifestKeyToMultiPaths(key, claudeRoots, runtime) {
       if (!slotPath) {
         return [];
       }
-      return [subPath ? path20.join(slotPath, subPath) : slotPath];
+      return [subPath ? path21.join(slotPath, subPath) : slotPath];
     });
   } catch {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    const defaultRoot = path20.resolve(expandHome(`${home}/.claude`));
+    const defaultRoot = path21.resolve(expandHome(`${home}/.claude`));
     return rootsToResolve.flatMap((root) => {
       const hardcoded = resolveHardcodedClaudeSlot(root, defaultRoot, slotName);
       if (!hardcoded) {
         return [];
       }
-      return [subPath ? path20.join(hardcoded, subPath) : hardcoded];
+      return [subPath ? path21.join(hardcoded, subPath) : hardcoded];
     });
   }
 }
@@ -21481,9 +21689,9 @@ function resolveHardcodedClaudeSlot(root, defaultRoot, slotName) {
     return null;
   }
   if (root === defaultRoot) {
-    return path20.join(root, relative);
+    return path21.join(root, relative);
   }
-  return path20.join(root, relative);
+  return path21.join(root, relative);
 }
 function resolveRuntimeIfAvailable(options, logger) {
   try {
@@ -21502,6 +21710,9 @@ function resolveSelectedTools(rawTools, manifest, runtime) {
     );
   }
   const selectedTools = new Set(manifest.tools);
+  if (selectedTools.size === 0) {
+    return new Set(ALL_TARGETS);
+  }
   if (runtime) {
     for (const tool of activeTargets(runtime.config)) {
       selectedTools.add(tool);
@@ -21514,9 +21725,93 @@ function shouldRemoveManifestFile(relativePath, selectedTools) {
   return selectedTools.has(tool);
 }
 function isFullToolUninstall(manifest, selectedTools) {
+  if (manifest.tools.length === 0) {
+    return ALL_TARGETS.every((tool) => selectedTools.has(tool));
+  }
   return manifest.tools.every((tool) => selectedTools.has(tool));
 }
-function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
+function addCompiledPathPlan(artifacts, artifactPath, expectedTarget, component) {
+  addCompiledGlobPlans(artifacts, artifactPath, expectedTarget, component);
+}
+function addCompiledGlobPlans(artifacts, pattern, expectedTarget, component) {
+  for (const artifactPath of ts(pattern).sort()) {
+    let marker = null;
+    try {
+      marker = extractProvenanceMarker(fs23.readFileSync(artifactPath, "utf8"));
+    } catch {
+      continue;
+    }
+    if (marker?.target !== expectedTarget) {
+      continue;
+    }
+    artifacts.push({
+      component,
+      path: artifactPath,
+      kind: "compiled",
+      expectedTarget,
+      expectedSource: marker.source,
+      observed: true
+    });
+  }
+}
+function addManagedSymlinkChildren(artifacts, directory, runtime, component) {
+  let entries;
+  try {
+    entries = fs23.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const artifactPath = path21.join(directory, entry.name);
+    const artifactClass = classifyArtifact(
+      artifactPath,
+      runtime.config,
+      runtime.sourceRoot
+    );
+    if (artifactClass === "managed-symlink" || artifactClass === "managed-stale") {
+      artifacts.push({ component, path: artifactPath, kind: "direct" });
+    }
+  }
+}
+function resolveLegacyClaudeHookCommands(runtime) {
+  const parsed = loadSourceHooks(
+    resolveHooksSourceDir(runtime.sourceRoot, runtime.config),
+    resolveKitHookNames(runtime.sourceRoot)
+  );
+  const commands = /* @__PURE__ */ new Set();
+  collectStringValuesByKey(parsed, "command", commands);
+  return Array.from(commands).sort();
+}
+function collectStringValuesByKey(value, keyName, values) {
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      collectStringValuesByKey(entry, keyName, values);
+    }
+    return;
+  }
+  if (!isRecord(value)) {
+    return;
+  }
+  if (typeof value[keyName] === "string") {
+    values.add(value[keyName]);
+  }
+  for (const entry of Object.values(value)) {
+    collectStringValuesByKey(entry, keyName, values);
+  }
+}
+function addLegacyOperatingGuideCopies(artifacts, claudeRoot) {
+  for (const artifactPath of [
+    ...ts(path21.join(claudeRoot, "CLAUDE.md.bak.*")),
+    ...ts(path21.join(claudeRoot, "AGENTS.md.bak.*"))
+  ].sort()) {
+    artifacts.push({
+      component: "claude-code legacy operating guide backup",
+      path: artifactPath,
+      kind: "legacy-kit-copy"
+    });
+  }
+}
+function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, claudeConfigDirs) {
   if (!runtime.kitInfo || scope !== "global") {
     return [];
   }
@@ -21526,11 +21821,97 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
   const opencodePaths = resolveOpenCodePaths(runtime);
   const cursorPaths = resolveCursorPaths(runtime);
   const clinePaths = resolveClinePaths(runtime);
+  if (selectedTools.has("claude-code")) {
+    const mappings = loadMappings(
+      runtime.sourceRoot,
+      runtime.config,
+      runtime.configDir
+    );
+    const claudeRoots = resolveAllClaudeRoots(
+      manifest,
+      runtime,
+      claudeConfigDirs
+    );
+    const profiles = resolveClaudeCodePathsForRoots(
+      claudeRoots,
+      mappings.platformPaths
+    );
+    const legacyHookCommands = resolveLegacyClaudeHookCommands(runtime);
+    for (const profile of profiles) {
+      for (const [component, artifactPath] of [
+        ["instructions", profile.instructions],
+        ["instructions shim", profile.instructions_shim],
+        ["agents", profile.agents],
+        ["commands", profile.commands],
+        ["rules", profile.rules],
+        ["output styles", profile.output_styles],
+        ["skills", profile.skills]
+      ]) {
+        artifacts.push({
+          component: `claude-code ${component}`,
+          path: artifactPath,
+          kind: "direct"
+        });
+      }
+      for (const skill of runtime.kitInfo.components.skills.declared) {
+        artifacts.push({
+          component: "claude-code skill",
+          path: path21.join(profile.skills, skill),
+          kind: "direct"
+        });
+      }
+      addManagedSymlinkChildren(
+        artifacts,
+        profile.skills,
+        runtime,
+        "claude-code skill residue"
+      );
+      artifacts.push({
+        component: "claude-code settings",
+        path: profile.hooks_shared_file,
+        kind: "claude-hooks",
+        legacyHookCommands
+      });
+      if (isFullToolUninstall(manifest, selectedTools)) {
+        addLegacyOperatingGuideCopies(
+          artifacts,
+          path21.dirname(profile.instructions)
+        );
+      }
+    }
+    const sharedProfile = profiles[0];
+    if (sharedProfile) {
+      artifacts.push(
+        {
+          component: "claude-code hooks bridge",
+          path: sharedProfile.hooks,
+          kind: "direct"
+        },
+        {
+          component: "claude-code mcp",
+          path: sharedProfile.mcp_shared_file,
+          kind: "claude-mcp"
+        }
+      );
+    }
+  }
   if (selectedTools.has("copilot")) {
+    addCompiledGlobPlans(
+      artifacts,
+      path21.join(copilotPaths.agents, "*.agent.md"),
+      "copilot",
+      "copilot agent residue"
+    );
+    addCompiledGlobPlans(
+      artifacts,
+      path21.join(copilotPaths.prompts, "*.prompt.md"),
+      "copilot",
+      "copilot prompt residue"
+    );
     for (const agentEntry of runtime.kitInfo.components.agents.declared) {
       artifacts.push({
         component: "copilot agent",
-        path: path20.join(copilotPaths.agents, `${agentEntry}.agent.md`),
+        path: path21.join(copilotPaths.agents, `${agentEntry}.agent.md`),
         kind: "compiled",
         expectedTarget: "copilot",
         expectedSource: `agents/${agentEntry}.md`
@@ -21539,7 +21920,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
     for (const commandEntry of runtime.kitInfo.components.commands.declared) {
       artifacts.push({
         component: "copilot prompt",
-        path: path20.join(copilotPaths.prompts, `${commandEntry}.prompt.md`),
+        path: path21.join(copilotPaths.prompts, `${commandEntry}.prompt.md`),
         kind: "compiled",
         expectedTarget: "copilot",
         expectedSource: `commands/${commandEntry}.md`
@@ -21552,15 +21933,29 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
         kind: "direct"
       });
     }
+    artifacts.push(
+      {
+        component: "copilot hooks",
+        path: path21.join(copilotPaths.hooks, "tangyr-managed.json"),
+        kind: "managed-json",
+        expectedTarget: "copilot"
+      },
+      {
+        component: "copilot legacy hooks",
+        path: path21.join(copilotPaths.hooks, "proteus-managed.json"),
+        kind: "managed-json",
+        expectedTarget: "copilot"
+      }
+    );
     const hooksSourcePath = resolveHooksSourceFile(
       runtime.sourceRoot,
       runtime.config
     );
     const hooksSource = hooksSourceLabel(runtime.config);
-    if (fs22.existsSync(hooksSourcePath)) {
+    if (fs23.existsSync(hooksSourcePath)) {
       artifacts.push({
         component: "copilot hooks",
-        path: path20.join(copilotPaths.hooks, "tangyr-managed.json"),
+        path: path21.join(copilotPaths.hooks, "tangyr-managed.json"),
         kind: "compiled",
         expectedTarget: "copilot",
         expectedSource: hooksSource
@@ -21571,7 +21966,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
       runtime.config
     );
     const mcpSource = mcpSourceLabel(runtime.config);
-    if (fs22.existsSync(mcpSourcePath)) {
+    if (fs23.existsSync(mcpSourcePath)) {
       artifacts.push({
         component: "copilot mcp",
         path: copilotPaths.mcpSharedFile,
@@ -21582,6 +21977,24 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
     }
   }
   if (selectedTools.has("codex")) {
+    addCompiledPathPlan(
+      artifacts,
+      codexPaths.instructions,
+      "codex",
+      "codex instruction residue"
+    );
+    addCompiledGlobPlans(
+      artifacts,
+      path21.join(codexPaths.agents, "*.toml"),
+      "codex",
+      "codex agent residue"
+    );
+    addCompiledGlobPlans(
+      artifacts,
+      path21.join(codexPaths.rules, "*.rules"),
+      "codex",
+      "codex rule residue"
+    );
     artifacts.push({
       component: "codex instructions",
       path: codexPaths.instructions,
@@ -21592,7 +22005,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
     for (const agentEntry of runtime.kitInfo.components.agents.declared) {
       artifacts.push({
         component: "codex agent",
-        path: path20.join(codexPaths.agents, `${agentEntry}.toml`),
+        path: path21.join(codexPaths.agents, `${agentEntry}.toml`),
         kind: "compiled",
         expectedTarget: "codex",
         expectedSource: `agents/${agentEntry}.md`
@@ -21601,7 +22014,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
     for (const ruleEntry of runtime.kitInfo.components.rules.declared) {
       artifacts.push({
         component: "codex rule",
-        path: path20.join(codexPaths.rules, `${ruleEntry}.rules`),
+        path: path21.join(codexPaths.rules, `${ruleEntry}.rules`),
         kind: "compiled",
         expectedTarget: "codex",
         expectedSource: `rules/${ruleEntry}.md`
@@ -21619,7 +22032,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
       runtime.config
     );
     const hooksSource = hooksSourceLabel(runtime.config);
-    if (fs22.existsSync(hooksSourcePath)) {
+    if (fs23.existsSync(hooksSourcePath)) {
       artifacts.push({
         component: "codex hooks",
         path: codexPaths.hooksSharedFile,
@@ -21632,7 +22045,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
       runtime.config
     );
     const mcpSource = mcpSourceLabel(runtime.config);
-    if (fs22.existsSync(mcpSourcePath)) {
+    if (fs23.existsSync(mcpSourcePath)) {
       artifacts.push({
         component: "codex mcp",
         path: codexPaths.mcpSharedFile,
@@ -21643,8 +22056,37 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
     }
   }
   if (selectedTools.has("opencode")) {
-    artifacts.push({
-      component: "opencode instructions",
+    addCompiledPathPlan(
+      artifacts,
+      opencodePaths.instructions,
+      "opencode",
+      "opencode instruction residue"
+    );
+    addCompiledPathPlan(
+      artifacts,
+      opencodePaths.configDoc,
+      "opencode",
+      "opencode config residue"
+    );
+    addCompiledGlobPlans(
+      artifacts,
+      path21.join(opencodePaths.agents, "*.md"),
+      "opencode",
+      "opencode agent residue"
+    );
+    addCompiledGlobPlans(
+      artifacts,
+      path21.join(opencodePaths.commands, "*.md"),
+      "opencode",
+      "opencode command residue"
+    );
+    artifacts.push({
+      component: "opencode shared skills",
+      path: opencodePaths.skillsShared,
+      kind: "direct"
+    });
+    artifacts.push({
+      component: "opencode instructions",
       path: opencodePaths.instructions,
       kind: "compiled",
       expectedTarget: "opencode",
@@ -21653,7 +22095,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
     for (const agentEntry of runtime.kitInfo.components.agents.declared) {
       artifacts.push({
         component: "opencode agent",
-        path: path20.join(opencodePaths.agents, `${agentEntry}.md`),
+        path: path21.join(opencodePaths.agents, `${agentEntry}.md`),
         kind: "compiled",
         expectedTarget: "opencode",
         expectedSource: `agents/${agentEntry}.md`
@@ -21662,7 +22104,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
     for (const commandEntry of runtime.kitInfo.components.commands.declared) {
       artifacts.push({
         component: "opencode command",
-        path: path20.join(opencodePaths.commands, `${commandEntry}.md`),
+        path: path21.join(opencodePaths.commands, `${commandEntry}.md`),
         kind: "compiled",
         expectedTarget: "opencode",
         expectedSource: `commands/${commandEntry}.md`
@@ -21680,7 +22122,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
       runtime.config
     );
     const mcpSource = mcpSourceLabel(runtime.config);
-    if (fs22.existsSync(mcpSourcePath)) {
+    if (fs23.existsSync(mcpSourcePath)) {
       artifacts.push({
         component: "opencode config",
         path: opencodePaths.configDoc,
@@ -21691,6 +22133,48 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
     }
   }
   if (selectedTools.has("cursor")) {
+    addCompiledPathPlan(
+      artifacts,
+      cursorPaths.instructions,
+      "cursor",
+      "cursor instruction residue"
+    );
+    addCompiledPathPlan(
+      artifacts,
+      cursorPaths.mcpFile,
+      "cursor",
+      "cursor mcp residue"
+    );
+    artifacts.push(
+      {
+        component: "cursor agent directory residue",
+        path: cursorPaths.agents,
+        kind: "direct"
+      },
+      {
+        component: "cursor shared skills",
+        path: cursorPaths.skillsShared,
+        kind: "direct"
+      }
+    );
+    addCompiledGlobPlans(
+      artifacts,
+      path21.join(cursorPaths.agents, "*.md"),
+      "cursor",
+      "cursor agent residue"
+    );
+    addCompiledGlobPlans(
+      artifacts,
+      path21.join(cursorPaths.rules, "*.mdc"),
+      "cursor",
+      "cursor rule residue"
+    );
+    addCompiledGlobPlans(
+      artifacts,
+      path21.join(cursorPaths.skills, "*", "SKILL.md"),
+      "cursor",
+      "cursor command residue"
+    );
     artifacts.push({
       component: "cursor instructions",
       path: cursorPaths.instructions,
@@ -21701,7 +22185,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
     for (const agentEntry of runtime.kitInfo.components.agents.declared) {
       artifacts.push({
         component: "cursor agent",
-        path: path20.join(cursorPaths.agents, `${agentEntry}.md`),
+        path: path21.join(cursorPaths.agents, `${agentEntry}.md`),
         kind: "compiled",
         expectedTarget: "cursor",
         expectedSource: `agents/${agentEntry}.md`
@@ -21719,7 +22203,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
       runtime.config
     );
     const mcpSource = mcpSourceLabel(runtime.config);
-    if (fs22.existsSync(mcpSourcePath)) {
+    if (fs23.existsSync(mcpSourcePath)) {
       artifacts.push({
         component: "cursor mcp",
         path: cursorPaths.mcpFile,
@@ -21730,6 +22214,36 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
     }
   }
   if (selectedTools.has("cline")) {
+    addCompiledPathPlan(
+      artifacts,
+      clinePaths.mcpFile,
+      "cline",
+      "cline mcp residue"
+    );
+    addCompiledGlobPlans(
+      artifacts,
+      path21.join(clinePaths.rules, "*.md"),
+      "cline",
+      "cline rule residue"
+    );
+    addCompiledGlobPlans(
+      artifacts,
+      path21.join(clinePaths.workflows, "*.md"),
+      "cline",
+      "cline workflow residue"
+    );
+    addManagedSymlinkChildren(
+      artifacts,
+      clinePaths.rules,
+      runtime,
+      "cline rule symlink residue"
+    );
+    addManagedSymlinkChildren(
+      artifacts,
+      clinePaths.workflows,
+      runtime,
+      "cline workflow symlink residue"
+    );
     if (clinePaths.instructions !== null) {
       artifacts.push({
         component: "cline instructions",
@@ -21742,7 +22256,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
     for (const ruleEntry of runtime.kitInfo.components.rules.declared) {
       artifacts.push({
         component: "cline rule",
-        path: path20.join(clinePaths.rules, `${ruleEntry}.md`),
+        path: path21.join(clinePaths.rules, `${ruleEntry}.md`),
         kind: "compiled",
         expectedTarget: "cline",
         expectedSource: `rules/${ruleEntry}.md`
@@ -21751,7 +22265,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
     for (const commandEntry of runtime.kitInfo.components.commands.declared) {
       artifacts.push({
         component: "cline workflow",
-        path: path20.join(clinePaths.workflows, `${commandEntry}.md`),
+        path: path21.join(clinePaths.workflows, `${commandEntry}.md`),
         kind: "compiled",
         expectedTarget: "cline",
         expectedSource: `commands/${commandEntry}.md`
@@ -21769,7 +22283,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
       runtime.config
     );
     const mcpSource = mcpSourceLabel(runtime.config);
-    if (fs22.existsSync(mcpSourcePath)) {
+    if (fs23.existsSync(mcpSourcePath)) {
       artifacts.push({
         component: "cline mcp",
         path: clinePaths.mcpFile,
@@ -21779,12 +22293,57 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools) {
       });
     }
   }
+  if (isFullToolUninstall(manifest, selectedTools)) {
+    for (const pointerName of [".operating-kit-root", ".framework-root"]) {
+      artifacts.push({
+        component: `shared kit pointer ${pointerName}`,
+        path: resolveTargetPath(`~/.agents/${pointerName}`),
+        kind: "kit-pointer",
+        expectedPath: runtime.sourceRoot
+      });
+    }
+  }
+  addRecordedManifestPlans(artifacts, manifest, selectedTools, runtime);
   return dedupeArtifacts(artifacts);
 }
+function addRecordedManifestPlans(artifacts, manifest, selectedTools, runtime) {
+  for (const file of manifest.artifacts) {
+    if (file.origin !== "tangyr-managed" || !shouldRemoveManifestFile(file.relativePath, selectedTools)) {
+      continue;
+    }
+    const artifactPath = resolveManifestKeyToPath(
+      file.relativePath,
+      "global",
+      runtime
+    );
+    if (artifactPath) {
+      artifacts.push({
+        component: `${file.relativePath} (manifest)`,
+        path: artifactPath,
+        kind: "recorded"
+      });
+    }
+  }
+}
 function removeKitManagedArtifact(artifact, runtime, logger) {
   if (artifact.kind === "compiled") {
     return removeManagedCompiledArtifact(artifact, logger);
   }
+  if (artifact.kind === "claude-hooks") {
+    return removeManagedClaudeHooksArtifact(artifact, logger);
+  }
+  if (artifact.kind === "claude-mcp") {
+    return removeManagedClaudeMcpArtifact(artifact, logger);
+  }
+  if (artifact.kind === "managed-json") {
+    return removeManagedJsonArtifact(artifact, logger);
+  }
+  if (artifact.kind === "recorded") {
+    return removeRecordedArtifact(artifact, logger);
+  }
+  if (artifact.kind === "kit-pointer" || artifact.kind === "legacy-kit-copy") {
+    return removeExactManagedFile(artifact, logger);
+  }
   if (artifact.kind === "copilot-mcp") {
     return removeManagedCopilotMcpArtifact(artifact, logger);
   }
@@ -21796,17 +22355,78 @@ function removeKitManagedArtifact(artifact, runtime, logger) {
   }
   return removeManagedDirectArtifact(artifact, runtime, logger);
 }
+function isKitManagedArtifact(artifact, runtime) {
+  if (artifact.kind === "direct") {
+    const artifactClass = classifyArtifact(
+      artifact.path,
+      runtime.config,
+      runtime.sourceRoot
+    );
+    return artifactClass === "managed-symlink" || artifactClass === "managed-stale" || artifactClass === "managed-compiled";
+  }
+  if (artifact.kind === "compiled") {
+    if (!fs23.existsSync(artifact.path)) {
+      return false;
+    }
+    try {
+      const marker = extractProvenanceMarker(
+        fs23.readFileSync(artifact.path, "utf8")
+      );
+      return marker?.target === artifact.expectedTarget && marker?.source === artifact.expectedSource;
+    } catch {
+      return false;
+    }
+  }
+  if (artifact.kind === "recorded") {
+    return fs23.existsSync(artifact.path) || isSymlink(artifact.path);
+  }
+  if (artifact.kind === "kit-pointer") {
+    return isKitPointer(artifact);
+  }
+  if (artifact.kind === "legacy-kit-copy") {
+    return isLegacyOperatingGuideCopy(artifact.path);
+  }
+  if (artifact.kind === "codex-mcp") {
+    if (!fs23.existsSync(artifact.path)) {
+      return false;
+    }
+    const section = readManagedTomlSection(
+      fs23.readFileSync(artifact.path, "utf8")
+    );
+    const marker = section ? extractProvenanceMarker(section) : null;
+    return marker?.target === artifact.expectedTarget && marker?.source === artifact.expectedSource;
+  }
+  const parsed = readJsonObject2(artifact.path);
+  if (!parsed) {
+    return false;
+  }
+  if (artifact.kind === "claude-hooks") {
+    return containsValueByKey(parsed.hooks, "_tangyr", true) || containsValueByKey(parsed.hooks, "_proteus", true) || (artifact.legacyHookCommands ?? []).some(
+      (command) => containsValueByKey(parsed.hooks, "command", command)
+    ) || hasLegacyClaudeSharedPermission(parsed);
+  }
+  if (artifact.kind === "claude-mcp") {
+    return hasManagedClaudeMcpServer(parsed);
+  }
+  if (artifact.kind === "managed-json") {
+    return hasManagedRootMetadata(parsed, artifact.expectedTarget);
+  }
+  if (artifact.kind === "copilot-mcp") {
+    return matchesManagedMetadata(metadataRecord(parsed._tangyr), artifact) || matchesManagedMetadata(metadataRecord(parsed._proteus), artifact);
+  }
+  return hasManagedCodexHooks(parsed, artifact.expectedSource);
+}
 function removeManagedCompiledArtifact(artifact, logger) {
-  if (!fs22.existsSync(artifact.path)) {
+  if (!fs23.existsSync(artifact.path)) {
     return false;
   }
   const marker = extractProvenanceMarker(
-    fs22.readFileSync(artifact.path, "utf8")
+    fs23.readFileSync(artifact.path, "utf8")
   );
   if (marker?.target !== artifact.expectedTarget || marker?.source !== artifact.expectedSource) {
     return false;
   }
-  fs22.rmSync(artifact.path, { force: true });
+  fs23.rmSync(artifact.path, { force: true });
   logger.verbose(`  removed ${artifact.component}: ${artifact.path}`);
   return true;
 }
@@ -21823,6 +22443,80 @@ function removeManagedDirectArtifact(artifact, runtime, logger) {
   logger.verbose(`  removed ${artifact.component}: ${artifact.path}`);
   return true;
 }
+function removeManagedClaudeHooksArtifact(artifact, logger) {
+  const parsed = readJsonObject2(artifact.path);
+  if (!parsed) {
+    return false;
+  }
+  const legacyHookCommands = new Set(artifact.legacyHookCommands ?? []);
+  const hooks = removeManagedClaudeHookEntries(parsed.hooks, (entry) => {
+    return entry._tangyr === true || entry._proteus === true || typeof entry.command === "string" && legacyHookCommands.has(entry.command);
+  });
+  const permissions = removeLegacyClaudeSharedPermission(parsed.permissions);
+  const cleaned = { ...parsed };
+  if (hooks === void 0) {
+    delete cleaned.hooks;
+  } else {
+    cleaned.hooks = hooks;
+  }
+  if (permissions === void 0) {
+    delete cleaned.permissions;
+  } else {
+    cleaned.permissions = permissions;
+  }
+  if (JSON.stringify(cleaned) === JSON.stringify(parsed)) {
+    return false;
+  }
+  writeJsonOrRemove(artifact.path, cleaned);
+  logger.verbose(`  removed ${artifact.component}: ${artifact.path}`);
+  return true;
+}
+function removeManagedClaudeMcpArtifact(artifact, logger) {
+  const parsed = readJsonObject2(artifact.path);
+  if (!parsed || !isRecord(parsed.mcpServers)) {
+    return false;
+  }
+  const retainedServers = Object.fromEntries(
+    Object.entries(parsed.mcpServers).filter(([, server]) => {
+      if (!isRecord(server)) {
+        return true;
+      }
+      return !isRecord(server._tangyr) && !isRecord(server._proteus);
+    })
+  );
+  if (Object.keys(retainedServers).length === Object.keys(parsed.mcpServers).length) {
+    return false;
+  }
+  const cleaned = { ...parsed, mcpServers: retainedServers };
+  writeJsonOrRemove(artifact.path, cleaned);
+  logger.verbose(`  removed ${artifact.component}: ${artifact.path}`);
+  return true;
+}
+function removeManagedJsonArtifact(artifact, logger) {
+  const parsed = readJsonObject2(artifact.path);
+  if (!parsed || !hasManagedRootMetadata(parsed, artifact.expectedTarget)) {
+    return false;
+  }
+  fs23.rmSync(artifact.path, { force: true });
+  logger.verbose(`  removed ${artifact.component}: ${artifact.path}`);
+  return true;
+}
+function removeRecordedArtifact(artifact, logger) {
+  if (!fs23.existsSync(artifact.path) && !isSymlink(artifact.path)) {
+    return false;
+  }
+  removeManagedPath(artifact.path);
+  logger.verbose(`  removed ${artifact.component}: ${artifact.path}`);
+  return true;
+}
+function removeExactManagedFile(artifact, logger) {
+  if (!fs23.existsSync(artifact.path)) {
+    return false;
+  }
+  fs23.rmSync(artifact.path, { force: true });
+  logger.verbose(`  removed ${artifact.component}: ${artifact.path}`);
+  return true;
+}
 function removeManagedCopilotMcpArtifact(artifact, logger) {
   const parsed = readJsonObject2(artifact.path);
   if (!parsed) {
@@ -21853,10 +22547,10 @@ function removeManagedCodexHooksArtifact(artifact, logger) {
   return true;
 }
 function removeManagedCodexMcpArtifact(artifact, logger) {
-  if (!fs22.existsSync(artifact.path)) {
+  if (!fs23.existsSync(artifact.path)) {
     return false;
   }
-  const content = fs22.readFileSync(artifact.path, "utf8");
+  const content = fs23.readFileSync(artifact.path, "utf8");
   const managedSection = readManagedTomlSection(content);
   if (!managedSection) {
     return false;
@@ -21871,9 +22565,9 @@ function removeManagedCodexMcpArtifact(artifact, logger) {
     codexManagedMcpEnd
   );
   if (cleaned.trim().length === 0) {
-    fs22.rmSync(artifact.path, { force: true });
+    fs23.rmSync(artifact.path, { force: true });
   } else {
-    fs22.writeFileSync(artifact.path, cleaned);
+    fs23.writeFileSync(artifact.path, cleaned);
   }
   logger.verbose(`  removed ${artifact.component}: ${artifact.path}`);
   return true;
@@ -22046,16 +22740,31 @@ function resolveClinePaths(runtime, scope = "global", projectRoot) {
 function dedupeArtifacts(artifacts) {
   const byPath = /* @__PURE__ */ new Map();
   for (const artifact of artifacts) {
-    byPath.set(artifact.path, artifact);
+    const current = byPath.get(artifact.path);
+    if (!current || managedArtifactPlanPriority(artifact) > managedArtifactPlanPriority(current)) {
+      byPath.set(artifact.path, artifact);
+    }
   }
   return Array.from(byPath.values());
 }
+function managedArtifactPlanPriority(artifact) {
+  if (artifact.observed) {
+    return 3;
+  }
+  if (artifact.kind === "compiled") {
+    return 0;
+  }
+  if (artifact.kind === "recorded") {
+    return 1;
+  }
+  return 2;
+}
 function readJsonObject2(filePath) {
-  if (!fs22.existsSync(filePath)) {
+  if (!fs23.existsSync(filePath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(fs22.readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(fs23.readFileSync(filePath, "utf8"));
     return isRecord(parsed) ? parsed : null;
   } catch {
     return null;
@@ -22064,15 +22773,86 @@ function readJsonObject2(filePath) {
 function metadataRecord(value) {
   return isRecord(value) ? value : void 0;
 }
+function containsValueByKey(value, keyName, keyValue) {
+  if (Array.isArray(value)) {
+    return value.some((entry) => containsValueByKey(entry, keyName, keyValue));
+  }
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (value[keyName] === keyValue) {
+    return true;
+  }
+  return Object.values(value).some(
+    (entry) => containsValueByKey(entry, keyName, keyValue)
+  );
+}
+function hasLegacyClaudeSharedPermission(parsed) {
+  if (!isRecord(parsed.permissions) || !Array.isArray(parsed.permissions.allow)) {
+    return false;
+  }
+  return parsed.permissions.allow.includes(legacyClaudeSharedPermission);
+}
+function removeLegacyClaudeSharedPermission(value) {
+  if (!isRecord(value) || !Array.isArray(value.allow)) {
+    return value;
+  }
+  const retainedAllow = value.allow.filter(
+    (entry) => entry !== legacyClaudeSharedPermission
+  );
+  if (retainedAllow.length === value.allow.length) {
+    return value;
+  }
+  const cleaned = { ...value };
+  if (retainedAllow.length === 0) {
+    delete cleaned.allow;
+  } else {
+    cleaned.allow = retainedAllow;
+  }
+  return Object.keys(cleaned).length === 0 ? void 0 : cleaned;
+}
+function isKitPointer(artifact) {
+  if (!artifact.expectedPath || !fs23.existsSync(artifact.path)) {
+    return false;
+  }
+  try {
+    const recordedPath = fs23.readFileSync(artifact.path, "utf8").trim();
+    return recordedPath.length > 0 && path21.resolve(recordedPath) === path21.resolve(artifact.expectedPath);
+  } catch {
+    return false;
+  }
+}
+function isLegacyOperatingGuideCopy(filePath) {
+  if (!fs23.existsSync(filePath)) {
+    return false;
+  }
+  try {
+    return fs23.readFileSync(filePath, "utf8").startsWith(legacyOperatingGuideSignature);
+  } catch {
+    return false;
+  }
+}
+function hasManagedClaudeMcpServer(parsed) {
+  if (!isRecord(parsed.mcpServers)) {
+    return false;
+  }
+  return Object.values(parsed.mcpServers).some(
+    (server) => isRecord(server) && (isRecord(server._tangyr) || isRecord(server._proteus))
+  );
+}
+function hasManagedRootMetadata(parsed, expectedTarget) {
+  const metadata = [parsed._tangyr, parsed._proteus].map(metadataRecord).find((entry) => entry?.target === expectedTarget);
+  return metadata !== void 0;
+}
 function matchesManagedMetadata(metadata, artifact) {
   return metadata?.source === artifact.expectedSource && metadata?.target === artifact.expectedTarget;
 }
 function writeJsonOrRemove(filePath, parsed) {
   if (isEmptyJsonValue(parsed)) {
-    fs22.rmSync(filePath, { force: true });
+    fs23.rmSync(filePath, { force: true });
     return;
   }
-  fs22.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
+  fs23.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
 `);
 }
 function isEmptyJsonValue(value) {
@@ -22152,6 +22932,31 @@ function removeManagedValueByKey(value, keyName, keyValue) {
   });
   return entries.length > 0 ? Object.fromEntries(entries) : void 0;
 }
+function removeManagedClaudeHookEntries(value, isManagedEntry) {
+  if (Array.isArray(value)) {
+    const retained = value.flatMap((entry) => {
+      const cleaned2 = removeManagedClaudeHookEntries(entry, isManagedEntry);
+      return cleaned2 === void 0 ? [] : [cleaned2];
+    });
+    return retained.length > 0 ? retained : void 0;
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  if (isManagedEntry(value)) {
+    return void 0;
+  }
+  const hadHookChildren = Object.hasOwn(value, "hooks");
+  const entries = Object.entries(value).flatMap(([key, entry]) => {
+    const cleaned2 = removeManagedClaudeHookEntries(entry, isManagedEntry);
+    return cleaned2 === void 0 ? [] : [[key, cleaned2]];
+  });
+  const cleaned = entries.length > 0 ? Object.fromEntries(entries) : void 0;
+  if (hadHookChildren && (!cleaned || !("hooks" in cleaned))) {
+    return void 0;
+  }
+  return cleaned;
+}
 function readManagedTomlSection(content) {
   const start = content.indexOf(codexManagedMcpStart);
   const end = content.indexOf(codexManagedMcpEnd);
@@ -22173,20 +22978,20 @@ function removeDelimitedManagedSection(content, startMarker, endMarker) {
   return `${content.slice(0, start)}${content.slice(removalEnd)}`;
 }
 function restoreBackup(backup, logger) {
-  if (!fs22.existsSync(backup.backupLocation)) {
+  if (!fs23.existsSync(backup.backupLocation)) {
     logger.warn(`  backup not found: ${backup.backupLocation}`);
     return;
   }
-  const destDir = path20.dirname(backup.originalPath);
-  fs22.mkdirSync(destDir, { recursive: true });
-  fs22.renameSync(backup.backupLocation, backup.originalPath);
+  const destDir = path21.dirname(backup.originalPath);
+  fs23.mkdirSync(destDir, { recursive: true });
+  fs23.renameSync(backup.backupLocation, backup.originalPath);
   logger.verbose(
     `  restored: ${backup.backupLocation} \u2192 ${backup.originalPath}`
   );
 }
 function isSymlink(p) {
   try {
-    return fs22.lstatSync(p).isSymbolicLink();
+    return fs23.lstatSync(p).isSymbolicLink();
   } catch {
     return false;
   }
@@ -22260,7 +23065,7 @@ function cleanupClaudeCode(config, sourceRoot, configDir, logger, scope) {
   )) {
     const artifactClass = classifyArtifact(artifact.path, config, sourceRoot);
     if (artifactClass === "managed-symlink" || artifactClass === "managed-compiled" || artifactClass === "managed-stale") {
-      fs23.rmSync(artifact.path, { recursive: true, force: true });
+      fs24.rmSync(artifact.path, { recursive: true, force: true });
       logger.info(`${artifact.component}: removed ${artifact.path}`);
     }
   }
@@ -22316,7 +23121,7 @@ function cleanupCopilot(config, sourceRoot, configDir, logger) {
     logger
   );
   removeManagedJsonFile(
-    path21.join(resolveTargetPath(paths.hooks ?? ""), "tangyr-managed.json"),
+    path22.join(resolveTargetPath(paths.hooks ?? ""), "tangyr-managed.json"),
     "_tangyr",
     logger
   );
@@ -22473,40 +23278,40 @@ function removeManagedValueByKey2(value, keyName, keyValue) {
 function removeManagedDirectPath(artifactPath, config, sourceRoot, component, logger) {
   const artifactClass = classifyArtifact(artifactPath, config, sourceRoot);
   if (artifactClass === "managed-symlink" || artifactClass === "managed-compiled" || artifactClass === "managed-stale") {
-    fs23.rmSync(artifactPath, { recursive: true, force: true });
+    fs24.rmSync(artifactPath, { recursive: true, force: true });
     logger.info(`${component}: removed ${artifactPath}`);
   }
 }
 function removeManagedCompiledFiles(dir, pattern, expectedTarget, logger) {
-  for (const filePath of ts(path21.join(dir, pattern)).sort()) {
+  for (const filePath of ts(path22.join(dir, pattern)).sort()) {
     removeManagedCompiledFile(filePath, expectedTarget, logger);
   }
 }
 function removeManagedCompiledFile(filePath, expectedTarget, logger) {
-  if (!fs23.existsSync(filePath)) {
+  if (!fs24.existsSync(filePath)) {
     return;
   }
-  const marker = extractProvenanceMarker(fs23.readFileSync(filePath, "utf8"));
+  const marker = extractProvenanceMarker(fs24.readFileSync(filePath, "utf8"));
   if (marker?.target === expectedTarget) {
-    fs23.rmSync(filePath, { force: true });
+    fs24.rmSync(filePath, { force: true });
     logger.info(`removed ${filePath}`);
   }
 }
 function removeManagedJsonFile(filePath, markerKey, logger) {
-  if (!fs23.existsSync(filePath)) {
+  if (!fs24.existsSync(filePath)) {
     return;
   }
   const parsed = readJsonObject(filePath);
   if (isRecord(parsed[markerKey])) {
-    fs23.rmSync(filePath, { force: true });
+    fs24.rmSync(filePath, { force: true });
     logger.info(`removed ${filePath}`);
   }
 }
 function removeCodexManagedTomlSection(filePath, logger) {
-  if (!fs23.existsSync(filePath)) {
+  if (!fs24.existsSync(filePath)) {
     return;
   }
-  const content = fs23.readFileSync(filePath, "utf8");
+  const content = fs24.readFileSync(filePath, "utf8");
   const next = removeDelimitedManagedSection2(
     content,
     codexManagedMcpStart2,
@@ -22515,7 +23320,7 @@ function removeCodexManagedTomlSection(filePath, logger) {
   if (next === content) {
     return;
   }
-  fs23.writeFileSync(filePath, next);
+  fs24.writeFileSync(filePath, next);
   logger.info(`mcp: removed managed section from ${filePath}`);
 }
 function removeDelimitedManagedSection2(content, startMarker, endMarker) {
@@ -22587,9 +23392,9 @@ function toVerbosity(value) {
 }
 
 // src/commands/detect.ts
-import fs24 from "fs";
+import fs25 from "fs";
 import os5 from "os";
-import path22 from "path";
+import path23 from "path";
 import { spawnSync } from "child_process";
 var copilotEditorCommands = [
   "code",
@@ -22623,18 +23428,27 @@ var bundledCopilotManifestPathsByPlatform = {
     "/Applications/Windsurf.app/Contents/Resources/app/extensions/copilot/package.json"
   ]
 };
-function detectTargets(logger) {
+var bundledCursorExecutablePathsByPlatform = {
+  darwin: ["/Applications/Cursor.app/Contents/Resources/app/bin/cursor"]
+};
+function detectTargets(logger, dependencies = {}) {
+  const spawnSyncImpl = dependencies.spawnSyncImpl ?? defaultSpawnSync;
+  const pathExists = dependencies.pathExists ?? fs25.existsSync;
+  const homeDirectory = dependencies.homeDirectory ?? os5.homedir();
+  const platform = dependencies.platform ?? process.platform;
+  const locator = platform === "win32" ? "where.exe" : "which";
+  const hasCommand = (command) => commandExists(locator, [command], logger, spawnSyncImpl);
   const result = {
-    "claude-code": commandExists(
-      process.platform === "win32" ? "where.exe" : "which",
-      ["claude"],
-      logger
-    ),
-    copilot: detectsCopilot(logger),
-    codex: commandExists(
-      process.platform === "win32" ? "where.exe" : "which",
-      ["codex"],
-      logger
+    "claude-code": hasCommand("claude"),
+    copilot: detectsCopilot(logger, dependencies),
+    codex: hasCommand("codex"),
+    opencode: hasCommand("opencode"),
+    cursor: hasCommand("cursor") || cursorExecutablePaths(platform, homeDirectory).some(pathExists),
+    cline: hasCommand("cline") || detectEditorExtension(
+      "Cline",
+      isClineExtensionEntry,
+      logger,
+      dependencies
     )
   };
   return result;
@@ -22650,14 +23464,41 @@ function runDetectCommand(options, logger) {
   }
   process.exitCode = Object.values(result).some(Boolean) ? 0 : 3;
 }
-function detectsCopilot(logger) {
-  return detectCopilot(logger);
+function detectsCopilot(logger, dependencies = {}) {
+  return detectCopilot(logger, dependencies);
 }
 function detectCopilot(logger, dependencies = {}) {
+  const pathExists = dependencies.pathExists ?? fs25.existsSync;
+  const readFile = dependencies.readFile ?? ((filePath) => fs25.readFileSync(filePath, "utf8"));
+  const platform = dependencies.platform ?? process.platform;
+  if (detectEditorExtension(
+    "Copilot",
+    isCopilotExtensionEntry,
+    logger,
+    dependencies
+  )) {
+    return true;
+  }
+  for (const manifestPath of bundledCopilotManifestPathsByPlatform[platform] ?? []) {
+    if (!pathExists(manifestPath)) {
+      continue;
+    }
+    try {
+      if (isBundledCopilotManifest(readFile(manifestPath))) {
+        return true;
+      }
+    } catch (error) {
+      logger?.verbose(
+        `${manifestPath}: failed to inspect bundled Copilot runtime (${formatReadError(error)})`
+      );
+    }
+  }
+  return false;
+}
+function detectEditorExtension(label, matchesExtension, logger, dependencies = {}) {
   const spawnSyncImpl = dependencies.spawnSyncImpl ?? defaultSpawnSync;
-  const pathExists = dependencies.pathExists ?? fs24.existsSync;
-  const readDirectory = dependencies.readDirectory ?? fs24.readdirSync;
-  const readFile = dependencies.readFile ?? ((filePath) => fs24.readFileSync(filePath, "utf8"));
+  const pathExists = dependencies.pathExists ?? fs25.existsSync;
+  const readDirectory = dependencies.readDirectory ?? fs25.readdirSync;
   const homeDirectory = dependencies.homeDirectory ?? os5.homedir();
   const platform = dependencies.platform ?? process.platform;
   const commandCandidates = [
@@ -22680,41 +23521,40 @@ function detectCopilot(logger, dependencies = {}) {
     if (result.status !== 0) {
       continue;
     }
-    if (splitOutputEntries(result.stdout).some(isCopilotExtensionEntry)) {
+    if (splitOutputEntries(result.stdout).some(matchesExtension)) {
       return true;
     }
   }
   for (const relativeDirectory of copilotExtensionDirectories) {
-    const extensionDirectory = path22.join(homeDirectory, relativeDirectory);
+    const extensionDirectory = path23.join(homeDirectory, relativeDirectory);
     if (!pathExists(extensionDirectory)) {
       continue;
     }
     try {
-      if (readDirectory(extensionDirectory).some(isCopilotExtensionEntry)) {
-        return true;
-      }
-    } catch (error) {
-      logger?.verbose(
-        `${extensionDirectory}: failed to inspect Copilot extensions (${formatReadError(error)})`
-      );
-    }
-  }
-  for (const manifestPath of bundledCopilotManifestPathsByPlatform[platform] ?? []) {
-    if (!pathExists(manifestPath)) {
-      continue;
-    }
-    try {
-      if (isBundledCopilotManifest(readFile(manifestPath))) {
+      if (readDirectory(extensionDirectory).some(matchesExtension)) {
         return true;
       }
     } catch (error) {
       logger?.verbose(
-        `${manifestPath}: failed to inspect bundled Copilot runtime (${formatReadError(error)})`
+        `${extensionDirectory}: failed to inspect ${label} extensions (${formatReadError(error)})`
       );
     }
   }
   return false;
 }
+function cursorExecutablePaths(platform, homeDirectory) {
+  const systemPaths = bundledCursorExecutablePathsByPlatform[platform] ?? [];
+  if (platform !== "darwin") {
+    return [...systemPaths];
+  }
+  return [
+    ...systemPaths,
+    path23.join(
+      homeDirectory,
+      "Applications/Cursor.app/Contents/Resources/app/bin/cursor"
+    )
+  ];
+}
 function defaultSpawnSync(command, args) {
   return spawnSync(command, args, { encoding: "utf8" });
 }
@@ -22727,6 +23567,9 @@ function splitOutputEntries(stdout) {
 function isCopilotExtensionEntry(entry) {
   return /^github\.copilot(?:-chat)?(?:@|-)/u.test(entry);
 }
+function isClineExtensionEntry(entry) {
+  return /^saoudrizwan\.claude-dev(?:@|-)/u.test(entry);
+}
 function isBundledCopilotManifest(rawManifest) {
   const parsed = JSON.parse(rawManifest);
   if (!isRecord2(parsed)) {
@@ -22745,8 +23588,8 @@ function formatReadError(error) {
   }
   return String(error);
 }
-function commandExists(command, args, logger) {
-  const result = spawnSync(command, args, { encoding: "utf8" });
+function commandExists(command, args, logger, spawnSyncImpl = defaultSpawnSync) {
+  const result = spawnSyncImpl(command, args);
   if (result.error) {
     logDetectionError(`${command} ${args.join(" ")}`, result.error, logger);
     return false;
@@ -22766,25 +23609,25 @@ function logDetectionError(attemptedCommand, error, logger) {
 }
 
 // src/commands/doctor.ts
-import fs26 from "fs";
-import path24 from "path";
+import fs27 from "fs";
+import path25 from "path";
 
 // src/utils/fs.ts
-import fs25 from "fs";
-import path23 from "path";
+import fs26 from "fs";
+import path24 from "path";
 function ensureDir(dirPath) {
-  fs25.mkdirSync(dirPath, { recursive: true });
+  fs26.mkdirSync(dirPath, { recursive: true });
 }
 function createRelativeSymlink(source, destination, type, options) {
-  const absoluteSource = path23.resolve(source);
-  const relative = path23.relative(realPathOrInput(path23.dirname(destination)), absoluteSource);
+  const absoluteSource = path24.resolve(source);
+  const relative = path24.relative(realPathOrInput(path24.dirname(destination)), absoluteSource);
   if (process.platform === "win32" && type === "dir") {
-    fs25.symlinkSync(absoluteSource, destination, "junction");
+    fs26.symlinkSync(absoluteSource, destination, "junction");
     return;
   }
   if (process.platform === "win32" && type === "file") {
     try {
-      fs25.symlinkSync(relative, destination, "file");
+      fs26.symlinkSync(relative, destination, "file");
     } catch (error) {
       if (!hasErrorCode(error, "EPERM")) {
         throw error;
@@ -22799,12 +23642,12 @@ function createRelativeSymlink(source, destination, type, options) {
     }
     return;
   }
-  fs25.symlinkSync(relative, destination, type);
+  fs26.symlinkSync(relative, destination, type);
 }
 function createManagedCopy(source, destination, provenanceMarker, _logger) {
-  ensureDir(path23.dirname(destination));
-  const content = fs25.readFileSync(source, "utf8");
-  fs25.writeFileSync(destination, `${provenanceMarker}
+  ensureDir(path24.dirname(destination));
+  const content = fs26.readFileSync(source, "utf8");
+  fs26.writeFileSync(destination, `${provenanceMarker}
 ${content}`);
 }
 function hasErrorCode(error, expectedCode) {
@@ -22812,7 +23655,7 @@ function hasErrorCode(error, expectedCode) {
 }
 function realPathOrInput(filePath) {
   try {
-    return fs25.realpathSync(filePath);
+    return fs26.realpathSync(filePath);
   } catch {
     return filePath;
   }
@@ -22825,17 +23668,17 @@ function runDoctorCommand(options, logger) {
     import.meta.url
   );
   const findings = [];
-  if (!fs26.existsSync(configPath)) {
+  if (!fs27.existsSync(configPath)) {
     findings.push(`${configPath}: missing`);
   }
-  const hooksJsonPath = path24.join(
+  const hooksJsonPath = path25.join(
     sourceRoot,
     config.source.hooks,
     "hooks.json"
   );
-  if (fs26.existsSync(hooksJsonPath)) {
+  if (fs27.existsSync(hooksJsonPath)) {
     try {
-      JSON.parse(fs26.readFileSync(hooksJsonPath, "utf8"));
+      JSON.parse(fs27.readFileSync(hooksJsonPath, "utf8"));
     } catch (err) {
       findings.push(
         `hooks/hooks.json: ${err instanceof Error ? err.message : String(err)}`
@@ -22900,19 +23743,19 @@ function checkClaudeCode(options, findings, config, sourceRoot, configDir, logge
     projectRoot
   )) {
     const artifactClass = classifyArtifact(artifact.path, config, sourceRoot);
-    const sourcePath = artifact.sourceKey ? path24.resolve(sourceRoot, config.source[artifact.sourceKey]) : void 0;
+    const sourcePath = artifact.sourceKey ? path25.resolve(sourceRoot, config.source[artifact.sourceKey]) : void 0;
     if (artifactClass === "managed-stale") {
       findings.push(
         `${artifact.component}: managed stale artifact at ${artifact.path}`
       );
       if (options.fix && sourcePath && isOurStaleSymlink(
         artifact.path,
-        /* @__PURE__ */ new Set([path24.resolve(artifact.path)]),
+        /* @__PURE__ */ new Set([path25.resolve(artifact.path)]),
         config
       )) {
-        fs26.unlinkSync(artifact.path);
-        ensureDir(path24.dirname(artifact.path));
-        const symlinkType = fs26.statSync(sourcePath).isDirectory() ? "dir" : "file";
+        fs27.unlinkSync(artifact.path);
+        ensureDir(path25.dirname(artifact.path));
+        const symlinkType = fs27.statSync(sourcePath).isDirectory() ? "dir" : "file";
         createRelativeSymlink(sourcePath, artifact.path, symlinkType, {
           logger,
           provenanceMarker: symlinkType === "file" && artifact.sourceKey ? formatProvenanceMarker(
@@ -22925,8 +23768,8 @@ function checkClaudeCode(options, findings, config, sourceRoot, configDir, logge
         logger.info(`${artifact.component}: recreated managed symlink`);
       }
     }
-    if (options.fix && !fs26.existsSync(path24.dirname(artifact.path))) {
-      ensureDir(path24.dirname(artifact.path));
+    if (options.fix && !fs27.existsSync(path25.dirname(artifact.path))) {
+      ensureDir(path25.dirname(artifact.path));
     }
     checkParentWritablePath(artifact.path, artifact.component, findings);
   }
@@ -22941,7 +23784,7 @@ function checkCopilot(config, sourceRoot, configDir, findings) {
       continue;
     }
     const label = `copilot: ${rawPath}`;
-    if (key.endsWith("_shared_file") || path24.extname(rawPath).length > 0) {
+    if (key.endsWith("_shared_file") || path25.extname(rawPath).length > 0) {
       checkParentWritablePath(resolveTargetPath(rawPath), label, findings);
       continue;
     }
@@ -22961,7 +23804,7 @@ function checkCodex(config, sourceRoot, configDir, findings, logger) {
       continue;
     }
     const label = `codex: ${rawPath}`;
-    if (key.endsWith("_shared_file") || path24.extname(rawPath).length > 0) {
+    if (key.endsWith("_shared_file") || path25.extname(rawPath).length > 0) {
       checkParentWritablePath(resolveTargetPath(rawPath), label, findings);
       continue;
     }
@@ -22978,33 +23821,33 @@ function resolveHooksScriptPath(config, sourceRoot, configDir) {
       scope: "global",
       mappings: mappings.platformPaths
     });
-    return path24.join(profile["claude-code"].hooks, "scripts");
+    return path25.join(profile["claude-code"].hooks, "scripts");
   } catch {
     return resolveTargetPath("~/.agents/hooks/scripts");
   }
 }
 function checkParentWritablePath(targetPath, label, findings) {
-  checkWritablePath(path24.dirname(targetPath), `${label} parent`, findings);
+  checkWritablePath(path25.dirname(targetPath), `${label} parent`, findings);
 }
 function checkWritablePath(checkPath, label, findings) {
-  if (!fs26.existsSync(checkPath)) {
+  if (!fs27.existsSync(checkPath)) {
     findings.push(`${label}: path does not exist`);
     return;
   }
   try {
-    fs26.accessSync(checkPath, fs26.constants.R_OK | fs26.constants.W_OK);
+    fs27.accessSync(checkPath, fs27.constants.R_OK | fs27.constants.W_OK);
   } catch {
     findings.push(`${label}: path is not readable and writable`);
   }
 }
 function walkHookScripts(dir) {
-  if (!fs26.existsSync(dir)) {
+  if (!fs27.existsSync(dir)) {
     return [];
   }
-  return fs26.readdirSync(dir).map((entry) => path24.join(dir, entry)).filter((entryPath) => fs26.statSync(entryPath).isFile());
+  return fs27.readdirSync(dir).map((entry) => path25.join(dir, entry)).filter((entryPath) => fs27.statSync(entryPath).isFile());
 }
 function fixManagedHookScriptModes(scriptRoot, sourceRoot, logger) {
-  if (!fs26.existsSync(scriptRoot)) {
+  if (!fs27.existsSync(scriptRoot)) {
     return;
   }
   if (hasSymlinkAncestor(scriptRoot, resolveTargetPath("~/.agents")) || isInside(realPathOrInput2(scriptRoot), realPathOrInput2(sourceRoot))) {
@@ -23014,49 +23857,49 @@ function fixManagedHookScriptModes(scriptRoot, sourceRoot, logger) {
     return;
   }
   for (const scriptPath of walkHookScripts(scriptRoot)) {
-    fs26.chmodSync(scriptPath, 493);
+    fs27.chmodSync(scriptPath, 493);
   }
 }
 function hasSymlinkAncestor(targetPath, stopAt) {
-  const relative = path24.relative(
-    path24.resolve(stopAt),
-    path24.resolve(targetPath)
+  const relative = path25.relative(
+    path25.resolve(stopAt),
+    path25.resolve(targetPath)
   );
-  if (relative.startsWith("..") || path24.isAbsolute(relative)) {
+  if (relative.startsWith("..") || path25.isAbsolute(relative)) {
     return false;
   }
-  return relative.split(path24.sep).some((_segment, index, segments) => {
-    const candidate = path24.join(
-      path24.resolve(stopAt),
+  return relative.split(path25.sep).some((_segment, index, segments) => {
+    const candidate = path25.join(
+      path25.resolve(stopAt),
       ...segments.slice(0, index + 1)
     );
     try {
-      return fs26.lstatSync(candidate).isSymbolicLink();
+      return fs27.lstatSync(candidate).isSymbolicLink();
     } catch {
       return false;
     }
   });
 }
 function isInside(childPath, parentPath) {
-  const relative = path24.relative(parentPath, childPath);
-  return relative.length === 0 || !relative.startsWith("..") && !path24.isAbsolute(relative);
+  const relative = path25.relative(parentPath, childPath);
+  return relative.length === 0 || !relative.startsWith("..") && !path25.isAbsolute(relative);
 }
 function realPathOrInput2(filePath) {
   try {
-    return fs26.realpathSync(filePath);
+    return fs27.realpathSync(filePath);
   } catch {
     return filePath;
   }
 }
 
 // src/commands/init.ts
-import fs27 from "fs";
-import path25 from "path";
-var import_yaml6 = __toESM(require_dist(), 1);
+import fs28 from "fs";
+import path26 from "path";
+var import_yaml7 = __toESM(require_dist(), 1);
 async function runInitCommand(_options, logger) {
   const sourceRoot = await dist_default6({
     message: "Canonical Tangyr kit root",
-    default: path25.resolve("projects/tangyr/agent-coding")
+    default: path26.resolve("projects/tangyr/agent-coding")
   });
   const componentCount = [
     "CLAUDE.md",
@@ -23066,7 +23909,7 @@ async function runInitCommand(_options, logger) {
     "rules",
     "hooks"
   ].filter(
-    (relativePath) => fs27.existsSync(path25.join(sourceRoot, relativePath))
+    (relativePath) => fs28.existsSync(path26.join(sourceRoot, relativePath))
   ).length;
   const detectedTargets = detectTargets(logger);
   const enabledTargets = await dist_default4({
@@ -23084,8 +23927,8 @@ async function runInitCommand(_options, logger) {
       value
     }))
   });
-  const configPath = path25.join(sourceRoot, "tangyr.config.yaml");
-  if (fs27.existsSync(configPath)) {
+  const configPath = path26.join(sourceRoot, "tangyr.config.yaml");
+  if (fs28.existsSync(configPath)) {
     const overwrite = await dist_default5({
       message: `${configPath} exists. Overwrite?`,
       default: false
@@ -23095,9 +23938,9 @@ async function runInitCommand(_options, logger) {
       return;
     }
   }
-  fs27.writeFileSync(
+  fs28.writeFileSync(
     configPath,
-    (0, import_yaml6.stringify)({
+    (0, import_yaml7.stringify)({
       schema: 1,
       kitPath: ".",
       source: {
@@ -23138,15 +23981,15 @@ function toConflictPolicy2(value) {
 }
 
 // src/commands/install.ts
-import fs36 from "fs";
-import path36 from "path";
+import fs37 from "fs";
+import path37 from "path";
 
 // src/core/channel-state.ts
-import fs28 from "fs";
-import path26 from "path";
+import fs29 from "fs";
+import path27 from "path";
 var CHANNEL_STATE_FILENAME = ".tangyr-channels.json";
 function stateFilePath(cacheRoot) {
-  return path26.join(cacheRoot, CHANNEL_STATE_FILENAME);
+  return path27.join(cacheRoot, CHANNEL_STATE_FILENAME);
 }
 function channelKey(kit, channel) {
   return `${kit}/${channel}`;
@@ -23155,7 +23998,7 @@ function readState(cacheRoot) {
   const filePath = stateFilePath(cacheRoot);
   let raw;
   try {
-    raw = fs28.readFileSync(filePath, "utf8");
+    raw = fs29.readFileSync(filePath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { state: {} };
@@ -23202,13 +24045,13 @@ function writeChannelSequence(params) {
     [key]: { sequence, version, seenAt: now.toISOString() }
   };
   const filePath = stateFilePath(cacheRoot);
-  fs28.mkdirSync(path26.dirname(filePath), { recursive: true, mode: 448 });
+  fs29.mkdirSync(path27.dirname(filePath), { recursive: true, mode: 448 });
   const tempPath = `${filePath}.${process.pid}.tmp`;
-  fs28.writeFileSync(tempPath, `${JSON.stringify(state, null, 2)}
+  fs29.writeFileSync(tempPath, `${JSON.stringify(state, null, 2)}
 `, {
     mode: 384
   });
-  fs28.renameSync(tempPath, filePath);
+  fs29.renameSync(tempPath, filePath);
 }
 function assertChannelNotRolledBack(params) {
   const { originUrl, kit, channel, seen, seenVersion, incoming } = params;
@@ -23224,8 +24067,8 @@ var CHANNEL_POINTER_TYPE = "tangyr.channel-pointer.v1";
 var DEFAULT_CHANNEL = "stable";
 
 // src/core/materialize.ts
-import fs29 from "fs";
-import path27 from "path";
+import fs30 from "fs";
+import path28 from "path";
 
 // src/core/integrity.ts
 import crypto3 from "crypto";
@@ -23561,7 +24404,7 @@ function assertFileWithinCeiling(entryPath, byteLength) {
 }
 var WINDOWS_DRIVE_ABSOLUTE = /^[a-zA-Z]:[\\/]/u;
 function sanitizeBundleFilePath(entryPath, stagingDir) {
-  if (path27.isAbsolute(entryPath) || WINDOWS_DRIVE_ABSOLUTE.test(entryPath)) {
+  if (path28.isAbsolute(entryPath) || WINDOWS_DRIVE_ABSOLUTE.test(entryPath)) {
     throw new IntegrityError(
       `Bundle file path "${entryPath}" is absolute \u2014 every file inside a bundle must use a relative path (REQ-INT-004).`
     );
@@ -23577,13 +24420,13 @@ function sanitizeBundleFilePath(entryPath, stagingDir) {
       `Bundle file path "${entryPath}" contains a ".." segment \u2014 directory traversal is rejected (REQ-INT-004).`
     );
   }
-  const resolved = path27.resolve(stagingDir, entryPath);
+  const resolved = path28.resolve(stagingDir, entryPath);
   if (resolved === stagingDir) {
     throw new IntegrityError(
       `Bundle file path "${entryPath}" resolves to the staging directory itself \u2014 every entry must be a file inside it (REQ-INT-004).`
     );
   }
-  if (!resolved.startsWith(stagingDir + path27.sep)) {
+  if (!resolved.startsWith(stagingDir + path28.sep)) {
     throw new IntegrityError(
       `Bundle file path "${entryPath}" escapes the staging directory \u2014 refusing to write (REQ-INT-004).`
     );
@@ -23635,10 +24478,10 @@ function verifyBundleFileHashes(bundle) {
 function writeStagedFiles(stagingDir, decoded) {
   for (const [rawPath, bytes] of decoded) {
     const target = sanitizeBundleFilePath(rawPath, stagingDir);
-    fs29.mkdirSync(path27.dirname(target), { recursive: true, mode: 448 });
+    fs30.mkdirSync(path28.dirname(target), { recursive: true, mode: 448 });
     let existingStat;
     try {
-      existingStat = fs29.lstatSync(target);
+      existingStat = fs30.lstatSync(target);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -23649,7 +24492,7 @@ function writeStagedFiles(stagingDir, decoded) {
         `Refusing to write "${rawPath}" \u2014 a symbolic link already exists at the target path.`
       );
     }
-    fs29.writeFileSync(target, bytes, { mode: 384, flag: "wx" });
+    fs30.writeFileSync(target, bytes, { mode: 384, flag: "wx" });
   }
 }
 function verifyWarmCacheEntry(entryDir, reference, keys, now) {
@@ -23705,14 +24548,14 @@ async function materializeRemoteKit(params) {
     writeStagedFiles(stagingDir, decoded);
     writeBundleDocument(stagingDir, bundle);
     writeCompletionMarker(stagingDir, reference);
-    if (replace && fs29.existsSync(entryDir)) {
-      fs29.rmSync(entryDir, { recursive: true, force: true });
+    if (replace && fs30.existsSync(entryDir)) {
+      fs30.rmSync(entryDir, { recursive: true, force: true });
     }
     publishCacheEntry(stagingDir, entryDir);
     return entryDir;
   } catch (error) {
     if (stagingDir !== void 0) {
-      fs29.rmSync(stagingDir, { recursive: true, force: true });
+      fs30.rmSync(stagingDir, { recursive: true, force: true });
     }
     throw error;
   }
@@ -24048,13 +24891,13 @@ function sleep(ms2) {
 // src/adapters/codex.ts
 var TOML3 = __toESM(require_toml(), 1);
 import crypto5 from "crypto";
-import fs31 from "fs";
-import path30 from "path";
+import fs32 from "fs";
+import path31 from "path";
 
 // src/compiler/agents.ts
 var TOML = __toESM(require_toml(), 1);
-var import_yaml7 = __toESM(require_dist(), 1);
-import path28 from "path";
+var import_yaml8 = __toESM(require_dist(), 1);
+import path29 from "path";
 
 // src/compiler/loss-report.ts
 function createLossReport() {
@@ -24118,7 +24961,7 @@ var copilotToolAliasesByClass = {
 };
 function compileAgent(sourceFile, target, mappings, extensions, lossReport) {
   const { data, body } = parseMarkdownFrontmatter(sourceFile);
-  const relativeSource = `agents/${path28.basename(sourceFile)}`;
+  const relativeSource = `agents/${path29.basename(sourceFile)}`;
   if (target === "opencode") {
     return compileOpenCodeAgent(
       sourceFile,
@@ -24159,7 +25002,7 @@ function compileAgent(sourceFile, target, mappings, extensions, lossReport) {
     mappings,
     lossReport
   );
-  const overlayKey = `agents/${path28.basename(sourceFile, ".md")}.${target}.yaml`;
+  const overlayKey = `agents/${path29.basename(sourceFile, ".md")}.${target}.yaml`;
   const targetFields = {
     ...translated.fields,
     ...extensions[overlayKey] ?? {}
@@ -24179,7 +25022,7 @@ function compileAgent(sourceFile, target, mappings, extensions, lossReport) {
   if (target === "copilot") {
     return `${marker}
 ---
-${(0, import_yaml7.stringify)(targetFields).trim()}
+${(0, import_yaml8.stringify)(targetFields).trim()}
 ---
 
 ${body}`;
@@ -24193,7 +25036,7 @@ ${TOML.stringify({
 function compileOpenCodeAgent(sourceFile, data, body, relativeSource, lossReport) {
   if (typeof data.description !== "string" || data.description.trim() === "") {
     throw new Error(
-      `${path28.basename(sourceFile)}: OpenCode agent requires a non-empty description field`
+      `${path29.basename(sourceFile)}: OpenCode agent requires a non-empty description field`
     );
   }
   const frontmatter = {
@@ -24247,7 +25090,7 @@ function compileOpenCodeAgent(sourceFile, data, body, relativeSource, lossReport
                 "permission",
                 "permission-coarsening"
               ),
-              detail: `${path28.basename(sourceFile)}: per-tool permission '${tool}' mapped to coarse allow|deny action`
+              detail: `${path29.basename(sourceFile)}: per-tool permission '${tool}' mapped to coarse allow|deny action`
             }
           ]
         });
@@ -24265,14 +25108,14 @@ function compileOpenCodeAgent(sourceFile, data, body, relativeSource, lossReport
   );
   return `${marker}
 ---
-${(0, import_yaml7.stringify)(frontmatter).trim()}
+${(0, import_yaml8.stringify)(frontmatter).trim()}
 ---
 `;
 }
 function compileCursorAgent(sourceFile, data, body, relativeSource, lossReport) {
   if (typeof data.description !== "string" || data.description.trim() === "") {
     throw new Error(
-      `${path28.basename(sourceFile)}: Cursor agent requires a non-empty description field`
+      `${path29.basename(sourceFile)}: Cursor agent requires a non-empty description field`
     );
   }
   const frontmatter = {
@@ -24309,7 +25152,7 @@ function compileCursorAgent(sourceFile, data, body, relativeSource, lossReport)
             "permission",
             "permission-coarsening"
           ),
-          detail: `${path28.basename(sourceFile)}: per-agent tool allow set coarsened to readonly=${readonly} boolean (Cursor only exposes readonly control)`
+          detail: `${path29.basename(sourceFile)}: per-agent tool allow set coarsened to readonly=${readonly} boolean (Cursor only exposes readonly control)`
         }
       ]
     });
@@ -24328,7 +25171,7 @@ function compileCursorAgent(sourceFile, data, body, relativeSource, lossReport)
             "provider",
             "provider-not-representable"
           ),
-          detail: `${path28.basename(sourceFile)}: custom provider cannot be expressed in Cursor subagent frontmatter \u2014 configure manually via Cursor settings`
+          detail: `${path29.basename(sourceFile)}: custom provider cannot be expressed in Cursor subagent frontmatter \u2014 configure manually via Cursor settings`
         }
       ]
     });
@@ -24344,7 +25187,7 @@ ${body.trim()}
 ` : "";
   return `${marker}
 ---
-${(0, import_yaml7.stringify)(frontmatter).trim()}
+${(0, import_yaml8.stringify)(frontmatter).trim()}
 ---
 ${bodySection}`;
 }
@@ -24360,7 +25203,7 @@ function compileClineAgent(sourceFile, _data, _body, relativeSource, lossReport)
           "persona",
           "persona-not-representable"
         ),
-        detail: `${path28.basename(sourceFile)}: Cline has no committable per-agent persona file for the VSCode extension target; configure the agent through Cline Settings \u2192 Agent.`
+        detail: `${path29.basename(sourceFile)}: Cline has no committable per-agent persona file for the VSCode extension target; configure the agent through Cline Settings \u2192 Agent.`
       }
     ]
   });
@@ -24408,7 +25251,7 @@ function applyFieldAction(sourceFile, field, value, action, target, mappings, tr
           field,
           "model-not-representable"
         ),
-        detail: `${path28.basename(sourceFile)}: model tier '${String(value)}' has no stable Copilot model literal; omitted so VS Code uses the selected model.`
+        detail: `${path29.basename(sourceFile)}: model tier '${String(value)}' has no stable Copilot model literal; omitted so VS Code uses the selected model.`
       });
       return;
     }
@@ -24426,9 +25269,9 @@ function applyFieldAction(sourceFile, field, value, action, target, mappings, tr
       lossReport,
       target,
       "agents",
-      `agents/${path28.basename(sourceFile)}`,
+      `agents/${path29.basename(sourceFile)}`,
       "info",
-      `${path28.basename(sourceFile)}: ${field} is delivered through another managed surface.`
+      `${path29.basename(sourceFile)}: ${field} is delivered through another managed surface.`
     );
     return;
   }
@@ -24437,7 +25280,7 @@ function applyFieldAction(sourceFile, field, value, action, target, mappings, tr
     field,
     action: entryType,
     severity: resolveLossSeverity("agent-field", field, entryType),
-    detail: `${path28.basename(sourceFile)}: ${field} has no emitted field for this target.`
+    detail: `${path29.basename(sourceFile)}: ${field} has no emitted field for this target.`
   });
 }
 function mapToolsToCapabilities(value, mappings) {
@@ -25034,9 +25877,9 @@ function compileOpenCodeMcp(sourceMcpJson, lossReport, sourceLabel) {
 }
 
 // src/compiler/rules.ts
-import path29 from "path";
-var import_yaml8 = __toESM(require_dist(), 1);
-import fs30 from "fs";
+import path30 from "path";
+var import_yaml9 = __toESM(require_dist(), 1);
+import fs31 from "fs";
 function compileRules(sourceRulesDir, target, _mappings, lossReport) {
   if (target === "copilot") {
     addLoss(lossReport, "copilot", "rules", {
@@ -25073,13 +25916,13 @@ function compileRules(sourceRulesDir, target, _mappings, lossReport) {
   }
   const appendixParts = [];
   const dotRulesFiles = [];
-  for (const ruleFile of ts(path29.join(sourceRulesDir, "*.md")).sort()) {
+  for (const ruleFile of ts(path30.join(sourceRulesDir, "*.md")).sort()) {
     const parsed = parseRule(ruleFile);
-    const name = path29.basename(ruleFile, ".md");
+    const name = path30.basename(ruleFile, ".md");
     if (parsed.mode === "exec-policy") {
       dotRulesFiles.push({
         name: `${name}.rules`,
-        content: `${formatProvenanceMarker("toml", `rules/${path29.basename(ruleFile)}`, computeSourceHash(ruleFile), "codex")}
+        content: `${formatProvenanceMarker("toml", `rules/${path30.basename(ruleFile)}`, computeSourceHash(ruleFile), "codex")}
 ${parsed.body}`
       });
       continue;
@@ -25088,7 +25931,7 @@ ${parsed.body}`
 
 ${parsed.body.trim()}`);
     addLoss(lossReport, "codex", "rules", {
-      source: `rules/${path29.basename(ruleFile)}`,
+      source: `rules/${path30.basename(ruleFile)}`,
       fields: [
         {
           field: "mode",
@@ -25098,7 +25941,7 @@ ${parsed.body.trim()}`);
             "mode",
             "rule-as-instruction"
           ),
-          detail: `${path29.basename(ruleFile)} is appended to the managed Codex instructions file as guidance.`
+          detail: `${path30.basename(ruleFile)} is appended to the managed Codex instructions file as guidance.`
         }
       ]
     });
@@ -25106,7 +25949,7 @@ ${parsed.body.trim()}`);
   return { agentsAppendix: appendixParts.join("\n\n"), dotRulesFiles };
 }
 function parseRule(ruleFile) {
-  const content = fs30.readFileSync(ruleFile, "utf8");
+  const content = fs31.readFileSync(ruleFile, "utf8");
   if (!content.startsWith("---\n")) {
     return { mode: "guidance", body: content };
   }
@@ -25114,7 +25957,7 @@ function parseRule(ruleFile) {
   if (endIndex === -1) {
     throw new Error(`${ruleFile}: frontmatter is not closed`);
   }
-  const frontmatter = (0, import_yaml8.parse)(content.slice(4, endIndex));
+  const frontmatter = (0, import_yaml9.parse)(content.slice(4, endIndex));
   const mode = isRuleMode(frontmatter) ? frontmatter.mode : "guidance";
   return {
     mode,
@@ -25130,14 +25973,14 @@ function isRuleMode(value) {
 }
 function compileOpenCodeRules(sourceRulesDir, lossReport) {
   const appendixParts = [];
-  for (const ruleFile of ts(path29.join(sourceRulesDir, "*.md")).sort()) {
+  for (const ruleFile of ts(path30.join(sourceRulesDir, "*.md")).sort()) {
     const parsed = parseRule(ruleFile);
-    const name = path29.basename(ruleFile, ".md");
+    const name = path30.basename(ruleFile, ".md");
     appendixParts.push(`## ${name}
 
 ${parsed.body.trim()}`);
     addLoss(lossReport, "opencode", "rules", {
-      source: `rules/${path29.basename(ruleFile)}`,
+      source: `rules/${path30.basename(ruleFile)}`,
       fields: [
         {
           field: "rule",
@@ -25147,7 +25990,7 @@ ${parsed.body.trim()}`);
             "rule",
             "rule-path-scoping"
           ),
-          detail: `${path29.basename(ruleFile)}: OpenCode has no per-agent rule scoping \u2014 rule appended to AGENTS.md instructions`
+          detail: `${path30.basename(ruleFile)}: OpenCode has no per-agent rule scoping \u2014 rule appended to AGENTS.md instructions`
         }
       ]
     });
@@ -25156,9 +25999,9 @@ ${parsed.body.trim()}`);
 }
 function compileCursorRules(sourceRulesDir, _lossReport) {
   const dotRulesFiles = [];
-  for (const ruleFile of ts(path29.join(sourceRulesDir, "*.md")).sort()) {
-    const content = fs30.readFileSync(ruleFile, "utf8");
-    const name = path29.basename(ruleFile, ".md");
+  for (const ruleFile of ts(path30.join(sourceRulesDir, "*.md")).sort()) {
+    const content = fs31.readFileSync(ruleFile, "utf8");
+    const name = path30.basename(ruleFile, ".md");
     let frontmatterData = {};
     let body = content;
     if (content.startsWith("---\n")) {
@@ -25166,7 +26009,7 @@ function compileCursorRules(sourceRulesDir, _lossReport) {
       if (endIndex !== -1) {
         const frontmatterStr = content.slice(4, endIndex);
         try {
-          frontmatterData = (0, import_yaml8.parse)(frontmatterStr) ?? {};
+          frontmatterData = (0, import_yaml9.parse)(frontmatterStr) ?? {};
         } catch {
           frontmatterData = {};
         }
@@ -25187,7 +26030,7 @@ function compileCursorRules(sourceRulesDir, _lossReport) {
     }
     const marker = formatProvenanceMarker(
       "markdown",
-      `rules/${path29.basename(ruleFile)}`,
+      `rules/${path30.basename(ruleFile)}`,
       computeSourceHash(ruleFile),
       "cursor"
     );
@@ -25203,9 +26046,9 @@ ${body}`;
 }
 function compileClineRules(sourceRulesDir, lossReport) {
   const dotRulesFiles = [];
-  for (const ruleFile of ts(path29.join(sourceRulesDir, "*.md")).sort()) {
-    const content = fs30.readFileSync(ruleFile, "utf8");
-    const name = path29.basename(ruleFile, ".md");
+  for (const ruleFile of ts(path30.join(sourceRulesDir, "*.md")).sort()) {
+    const content = fs31.readFileSync(ruleFile, "utf8");
+    const name = path30.basename(ruleFile, ".md");
     let frontmatterData = {};
     let body = content;
     if (content.startsWith("---\n")) {
@@ -25213,7 +26056,7 @@ function compileClineRules(sourceRulesDir, lossReport) {
       if (endIndex !== -1) {
         const frontmatterStr = content.slice(4, endIndex);
         try {
-          frontmatterData = (0, import_yaml8.parse)(frontmatterStr) ?? {};
+          frontmatterData = (0, import_yaml9.parse)(frontmatterStr) ?? {};
         } catch {
           frontmatterData = {};
         }
@@ -25222,13 +26065,13 @@ function compileClineRules(sourceRulesDir, lossReport) {
     }
     const marker = formatProvenanceMarker(
       "markdown",
-      `rules/${path29.basename(ruleFile)}`,
+      `rules/${path30.basename(ruleFile)}`,
       computeSourceHash(ruleFile),
       "cline"
     );
     if (frontmatterData.mode === "exec-policy") {
       addLoss(lossReport, "cline", "rules", {
-        source: `rules/${path29.basename(ruleFile)}`,
+        source: `rules/${path30.basename(ruleFile)}`,
         fields: [
           {
             field: "mode",
@@ -25238,7 +26081,7 @@ function compileClineRules(sourceRulesDir, lossReport) {
               "mode",
               "rule-mode-downgrade"
             ),
-            detail: `${path29.basename(ruleFile)}: Cline rules have no exec-policy mode; rule emitted as guidance.`
+            detail: `${path30.basename(ruleFile)}: Cline rules have no exec-policy mode; rule emitted as guidance.`
           }
         ]
       });
@@ -25283,7 +26126,7 @@ function syncCodex(config, sourceRoot, mappings, extensions, options, lossReport
     rules: profile.rules
   };
   const rules = compileRules(
-    path30.join(sourceRoot, config.source.rules),
+    path31.join(sourceRoot, config.source.rules),
     "codex",
     mappings,
     lossReport
@@ -25428,9 +26271,9 @@ function syncCodex(config, sourceRoot, mappings, extensions, options, lossReport
 function buildProviderTomlSection(config, sourceRoot, mappings, scope, lossReport) {
   const cp = mappings.modelTiers.custom_provider;
   if (!cp) return "";
-  const agentsDir = path30.join(sourceRoot, config.source.agents);
-  if (!fs31.existsSync(agentsDir)) return "";
-  const agentFiles = ts(path30.join(agentsDir, "*.md")).sort();
+  const agentsDir = path31.join(sourceRoot, config.source.agents);
+  if (!fs32.existsSync(agentsDir)) return "";
+  const agentFiles = ts(path31.join(agentsDir, "*.md")).sort();
   const hasProviderAgent = agentFiles.some((agentFile) => {
     const { data } = parseMarkdownFrontmatter(agentFile);
     return typeof data.provider === "string" || typeof data.provider === "object" && data.provider !== null && Object.keys(data.provider).length > 0;
@@ -25495,7 +26338,7 @@ function syncRules(config, sourceRoot, paths, rules, options, logger, manifest,
     }
   ];
   for (const ruleFile of rules.dotRulesFiles) {
-    const destination = path30.join(rulesRoot, ruleFile.name);
+    const destination = path31.join(rulesRoot, ruleFile.name);
     if (options.dryRun) {
       logger.info(`[dry-run] rules: write ${destination}`);
       outcomes.push({
@@ -25523,15 +26366,15 @@ function syncRules(config, sourceRoot, paths, rules, options, logger, manifest,
   return outcomes;
 }
 function syncInstructions(config, sourceRoot, paths, agentsAppendix, options, logger, manifest, scopePath) {
-  const source = path30.join(sourceRoot, config.source.instructions);
+  const source = path31.join(sourceRoot, config.source.instructions);
   const destination = resolveTargetPath(paths.instructions);
-  const composed = `${fs31.readFileSync(source, "utf8").trim()}
+  const composed = `${fs32.readFileSync(source, "utf8").trim()}
 
 --- tangyr managed rules ---
 ${agentsAppendix}`.trim();
   const marker = formatProvenanceMarker(
     "markdown",
-    path30.basename(config.source.instructions),
+    path31.basename(config.source.instructions),
     hashString(composed),
     "codex"
   );
@@ -25558,9 +26401,9 @@ ${composed}
   );
 }
 function syncSkills(config, sourceRoot, paths, options, logger, manifest, scopePath) {
-  const source = path30.resolve(sourceRoot, config.source.skills);
+  const source = path31.resolve(sourceRoot, config.source.skills);
   const destination = resolveTargetPath(paths.skills);
-  if (!fs31.existsSync(source)) {
+  if (!fs32.existsSync(source)) {
     return skippedMissingSource("skills", source);
   }
   if (options.dryRun) {
@@ -25576,29 +26419,29 @@ function syncSkills(config, sourceRoot, paths, options, logger, manifest, scopeP
     };
   }
   if (artifactClass === "managed-stale" && isOurStaleSymlink(destination, /* @__PURE__ */ new Set([destination]), config)) {
-    fs31.unlinkSync(destination);
+    fs32.unlinkSync(destination);
     logger.verbose(`Skills: created skills path ${destination}`);
   } else if (artifactClass === "unmanaged-conflict" && !handleConflict(destination, config, options, logger, manifest, scopePath)) {
     return { component: "skills", status: "conflict", path: destination };
   } else if (artifactClass === "managed-symlink") {
-    fs31.unlinkSync(destination);
+    fs32.unlinkSync(destination);
   }
-  ensureDir(path30.dirname(destination));
+  ensureDir(path31.dirname(destination));
   createRelativeSymlink(source, destination, "dir");
   logger.verbose(`Skills: created skills path ${destination}`);
   return { component: "skills", status: "success", path: destination };
 }
 function syncAgents(config, sourceRoot, paths, mappings, extensions, options, lossReport, logger, manifest, scopePath) {
-  const sourceAgentsRoot = path30.join(sourceRoot, config.source.agents);
-  if (!fs31.existsSync(sourceAgentsRoot)) {
+  const sourceAgentsRoot = path31.join(sourceRoot, config.source.agents);
+  if (!fs32.existsSync(sourceAgentsRoot)) {
     return [skippedMissingSource("agents", sourceAgentsRoot)];
   }
-  const sourceAgents = ts(path30.join(sourceAgentsRoot, "*.md")).sort();
+  const sourceAgents = ts(path31.join(sourceAgentsRoot, "*.md")).sort();
   const agentsRoot = resolveTargetPath(paths.agents);
   return sourceAgents.map((agentFile) => {
-    const destination = path30.join(
+    const destination = path31.join(
       agentsRoot,
-      `${path30.basename(agentFile, ".md")}.toml`
+      `${path31.basename(agentFile, ".md")}.toml`
     );
     const compiled = compileAgent(
       agentFile,
@@ -25634,10 +26477,10 @@ function syncHooks(config, sourceRoot, paths, mappings, options, lossReport, log
   }
   const source = resolveHooksSourceFile(sourceRoot, config);
   const sourceLabel = hooksSourceLabel(config);
-  if (!fs31.existsSync(source)) {
+  if (!fs32.existsSync(source)) {
     return skippedMissingSource("hooks", source);
   }
-  const sourceHooksJson = JSON.parse(fs31.readFileSync(source, "utf8"));
+  const sourceHooksJson = JSON.parse(fs32.readFileSync(source, "utf8"));
   const compiled = compileHooks(
     sourceHooksJson,
     "codex",
@@ -25659,7 +26502,7 @@ function syncHooks(config, sourceRoot, paths, mappings, options, lossReport, log
     destination,
     hostHooks,
     stringifyJson2,
-    !fs31.existsSync(destination),
+    !fs32.existsSync(destination),
     logger
   );
   return {
@@ -25672,7 +26515,7 @@ function syncMcp(config, sourceRoot, paths, options, lossReport, logger, provide
   const source = resolveMcpSourceFile(sourceRoot, config);
   const sourceLabel = mcpSourceLabel(config);
   const destination = resolveTargetPath(paths.mcp_shared_file);
-  if (!fs31.existsSync(source)) {
+  if (!fs32.existsSync(source)) {
     if (providerToml && !options.dryRun) {
       const changed2 = writeTomlManagedSection(
         destination,
@@ -25687,7 +26530,7 @@ function syncMcp(config, sourceRoot, paths, options, lossReport, logger, provide
     }
     return skippedMissingSource("mcp", source);
   }
-  const sourceMcpJson = JSON.parse(fs31.readFileSync(source, "utf8"));
+  const sourceMcpJson = JSON.parse(fs32.readFileSync(source, "utf8"));
   const compiled = compileMcp(sourceMcpJson, "codex", lossReport, sourceLabel);
   const managedContent = providerToml ? `${compiled.trimEnd()}${providerToml}` : compiled;
   if (options.dryRun) {
@@ -25709,12 +26552,12 @@ function writeCompiledArtifact(component, destination, content, expectedHash, co
   if (artifactClass === "unmanaged-conflict" && !handleConflict(destination, config, options, logger, manifest, scopePath)) {
     return { component, status: "conflict", path: destination };
   }
-  ensureDir(path30.dirname(destination));
-  fs31.writeFileSync(destination, content);
+  ensureDir(path31.dirname(destination));
+  fs32.writeFileSync(destination, content);
   return { component, status: "success", path: destination };
 }
 function writeTomlManagedSection(destination, managedContent, logger) {
-  const current = fs31.existsSync(destination) ? fs31.readFileSync(destination, "utf8") : "";
+  const current = fs32.existsSync(destination) ? fs32.readFileSync(destination, "utf8") : "";
   const isFirstWrite = current.length > 0 && !current.includes(managedMcpStart);
   if (isFirstWrite) {
     logger.warn(
@@ -25730,8 +26573,8 @@ ${managedMcpEnd}
   if (current === next.trimStart()) {
     return false;
   }
-  ensureDir(path30.dirname(destination));
-  fs31.writeFileSync(destination, next.trimStart());
+  ensureDir(path31.dirname(destination));
+  fs32.writeFileSync(destination, next.trimStart());
   return true;
 }
 function removeManagedTomlSection(content) {
@@ -25758,16 +26601,16 @@ function handleConflict(destination, config, options, logger, manifest, scopePat
       backupFile(destination, manifest);
       writeManifest(scopePath, manifest);
     } else {
-      fs31.renameSync(destination, `${destination}.bak.${Date.now()}`);
+      fs32.renameSync(destination, `${destination}.bak.${Date.now()}`);
     }
     return true;
   }
-  fs31.rmSync(destination, { recursive: true, force: true });
+  fs32.rmSync(destination, { recursive: true, force: true });
   return true;
 }
 function isCompiledCurrent(destination, expectedContent, expectedHash) {
   try {
-    const current = fs31.readFileSync(destination, "utf8");
+    const current = fs32.readFileSync(destination, "utf8");
     const marker = extractProvenanceMarker(current);
     return expectedHash ? marker?.hash === expectedHash && marker.target === "codex" && current === expectedContent : current === expectedContent;
   } catch {
@@ -25786,16 +26629,16 @@ function shouldSkipComponent(options, component) {
 }
 function isSymlinkTo(linkPath, source) {
   try {
-    return fs31.realpathSync(linkPath) === fs31.realpathSync(source);
+    return fs32.realpathSync(linkPath) === fs32.realpathSync(source);
   } catch {
     return false;
   }
 }
 function readJsonObject3(filePath) {
-  if (!fs31.existsSync(filePath)) {
+  if (!fs32.existsSync(filePath)) {
     return {};
   }
-  const parsed = JSON.parse(fs31.readFileSync(filePath, "utf8"));
+  const parsed = JSON.parse(fs32.readFileSync(filePath, "utf8"));
   return isRecord4(parsed) ? parsed : {};
 }
 function stringifyJson2(value) {
@@ -25811,16 +26654,16 @@ function hashString(value) {
 
 // src/adapters/copilot.ts
 import crypto6 from "crypto";
-import fs32 from "fs";
-import path32 from "path";
+import fs33 from "fs";
+import path33 from "path";
 
 // src/compiler/commands.ts
-var import_yaml9 = __toESM(require_dist(), 1);
-import path31 from "path";
+var import_yaml10 = __toESM(require_dist(), 1);
+import path32 from "path";
 function compileCommandPrompt(sourceFile) {
   const { data, body } = parseMarkdownFrontmatter(sourceFile);
-  const relativeSource = `commands/${path31.basename(sourceFile)}`;
-  const fields = promptFrontmatter(data, path31.basename(sourceFile, ".md"));
+  const relativeSource = `commands/${path32.basename(sourceFile)}`;
+  const fields = promptFrontmatter(data, path32.basename(sourceFile, ".md"));
   const marker = formatProvenanceMarker(
     "markdown",
     relativeSource,
@@ -25829,7 +26672,7 @@ function compileCommandPrompt(sourceFile) {
   );
   return `${marker}
 ---
-${(0, import_yaml9.stringify)(fields).trim()}
+${(0, import_yaml10.stringify)(fields).trim()}
 ---
 
 ${body.trimEnd()}
@@ -25995,13 +26838,13 @@ function syncCopilot(config, sourceRoot, mappings, extensions, options, lossRepo
 }
 function syncProviderLoss(config, sourceRoot, mappings, lossReport) {
   if (!mappings.modelTiers.custom_provider) return;
-  const agentsDir = path32.join(sourceRoot, config.source.agents);
-  if (!fs32.existsSync(agentsDir)) return;
-  for (const agentFile of ts(path32.join(agentsDir, "*.md")).sort()) {
+  const agentsDir = path33.join(sourceRoot, config.source.agents);
+  if (!fs33.existsSync(agentsDir)) return;
+  for (const agentFile of ts(path33.join(agentsDir, "*.md")).sort()) {
     const { data } = parseMarkdownFrontmatter(agentFile);
     const hasProvider = typeof data.provider === "string" || typeof data.provider === "object" && data.provider !== null && Object.keys(data.provider).length > 0;
     if (hasProvider) {
-      const basename = path32.basename(agentFile);
+      const basename = path33.basename(agentFile);
       addLoss(lossReport, "copilot", "agents", {
         source: `agents/${basename}`,
         fields: [
@@ -26026,23 +26869,23 @@ function syncCopilotInstructions(config, sourceRoot, options, lossReport, logger
     logger.verbose(message);
     return [{ component: "instructions", status: "skipped", path: message }];
   }
-  const source = path32.resolve(sourceRoot, config.source.instructions);
-  if (!fs32.existsSync(source)) {
+  const source = path33.resolve(sourceRoot, config.source.instructions);
+  if (!fs33.existsSync(source)) {
     return [skippedMissingSource2("instructions", source)];
   }
-  const rawContent = fs32.readFileSync(source, "utf8");
+  const rawContent = fs33.readFileSync(source, "utf8");
   const contentHash = hashString2(rawContent);
   const marker = formatProvenanceMarker(
     "markdown",
-    path32.basename(config.source.instructions),
+    path33.basename(config.source.instructions),
     contentHash,
     "copilot"
   );
   const composedContent = `${marker}
 ${rawContent}`;
   const projectRoot = options.projectRoot ?? process.cwd();
-  const agentsMdDest = path32.resolve(projectRoot, "AGENTS.md");
-  const mirrorDest = path32.resolve(
+  const agentsMdDest = path33.resolve(projectRoot, "AGENTS.md");
+  const mirrorDest = path33.resolve(
     projectRoot,
     ".github",
     "copilot-instructions.md"
@@ -26096,17 +26939,17 @@ function writeInstructionsFile(component, destination, content, contentHash, con
   if (artifactClass === "unmanaged-conflict" && !handleConflict2(destination, config, options, logger, manifest, scopePath)) {
     return { component, status: "conflict", path: destination };
   }
-  ensureDir(path32.dirname(destination));
-  fs32.writeFileSync(destination, content);
+  ensureDir(path33.dirname(destination));
+  fs33.writeFileSync(destination, content);
   return { component, status: "success", path: destination };
 }
 function hashString2(value) {
   return `sha256:${crypto6.createHash("sha256").update(value).digest("hex")}`;
 }
 function syncSkills2(config, sourceRoot, paths, options, logger, manifest, scopePath) {
-  const source = path32.resolve(sourceRoot, config.source.skills);
+  const source = path33.resolve(sourceRoot, config.source.skills);
   const destination = resolveTargetPath(paths.skills);
-  if (!fs32.existsSync(source)) {
+  if (!fs33.existsSync(source)) {
     return skippedMissingSource2("skills", source);
   }
   if (options.dryRun) {
@@ -26122,27 +26965,27 @@ function syncSkills2(config, sourceRoot, paths, options, logger, manifest, scope
     };
   }
   if (artifactClass === "managed-stale" && isOurStaleSymlink(destination, /* @__PURE__ */ new Set([destination]), config)) {
-    fs32.unlinkSync(destination);
+    fs33.unlinkSync(destination);
   } else if (artifactClass === "unmanaged-conflict" && !handleConflict2(destination, config, options, logger, manifest, scopePath)) {
     return { component: "skills", status: "conflict", path: destination };
   } else if (artifactClass === "managed-symlink") {
-    fs32.unlinkSync(destination);
+    fs33.unlinkSync(destination);
   }
-  ensureDir(path32.dirname(destination));
+  ensureDir(path33.dirname(destination));
   createRelativeSymlink(source, destination, "dir");
   return { component: "skills", status: "success", path: destination };
 }
 function syncAgents2(config, sourceRoot, paths, mappings, extensions, options, lossReport, logger, manifest, scopePath) {
-  const sourceAgentsRoot = path32.join(sourceRoot, config.source.agents);
-  if (!fs32.existsSync(sourceAgentsRoot)) {
+  const sourceAgentsRoot = path33.join(sourceRoot, config.source.agents);
+  if (!fs33.existsSync(sourceAgentsRoot)) {
     return [skippedMissingSource2("agents", sourceAgentsRoot)];
   }
-  const sourceAgents = ts(path32.join(sourceAgentsRoot, "*.md")).sort();
+  const sourceAgents = ts(path33.join(sourceAgentsRoot, "*.md")).sort();
   const agentsRoot = resolveTargetPath(paths.agents);
   return sourceAgents.map((agentFile) => {
-    const destination = path32.join(
+    const destination = path33.join(
       agentsRoot,
-      `${path32.basename(agentFile, ".md")}.agent.md`
+      `${path33.basename(agentFile, ".md")}.agent.md`
     );
     const compiled = compileAgent(
       agentFile,
@@ -26170,16 +27013,16 @@ function syncAgents2(config, sourceRoot, paths, mappings, extensions, options, l
   });
 }
 function syncCommands(config, sourceRoot, paths, options, logger, manifest, scopePath) {
-  const sourceCommandsRoot = path32.join(sourceRoot, config.source.commands);
-  if (!fs32.existsSync(sourceCommandsRoot)) {
+  const sourceCommandsRoot = path33.join(sourceRoot, config.source.commands);
+  if (!fs33.existsSync(sourceCommandsRoot)) {
     return [skippedMissingSource2("commands", sourceCommandsRoot)];
   }
-  const sourceCommands = ts(path32.join(sourceCommandsRoot, "*.md")).sort();
+  const sourceCommands = ts(path33.join(sourceCommandsRoot, "*.md")).sort();
   const promptsRoot = resolveTargetPath(paths.prompts);
   return sourceCommands.map((commandFile) => {
-    const destination = path32.join(
+    const destination = path33.join(
       promptsRoot,
-      `${path32.basename(commandFile, ".md")}.prompt.md`
+      `${path33.basename(commandFile, ".md")}.prompt.md`
     );
     const compiled = compileCommandPrompt(commandFile);
     if (options.dryRun) {
@@ -26205,14 +27048,14 @@ function syncCommands(config, sourceRoot, paths, options, logger, manifest, scop
 function syncHooks2(config, sourceRoot, paths, mappings, options, lossReport, logger) {
   const source = resolveHooksSourceFile(sourceRoot, config);
   const sourceLabel = hooksSourceLabel(config);
-  const destination = path32.join(
+  const destination = path33.join(
     resolveTargetPath(paths.hooks),
     "tangyr-managed.json"
   );
-  if (!fs32.existsSync(source)) {
+  if (!fs33.existsSync(source)) {
     return skippedMissingSource2("hooks", source);
   }
-  const sourceHooksJson = JSON.parse(fs32.readFileSync(source, "utf8"));
+  const sourceHooksJson = JSON.parse(fs33.readFileSync(source, "utf8"));
   const compiled = compileHooks(
     sourceHooksJson,
     "copilot",
@@ -26249,10 +27092,10 @@ function syncMcp2(config, sourceRoot, paths, options, lossReport, logger) {
   const source = resolveMcpSourceFile(sourceRoot, config);
   const sourceLabel = mcpSourceLabel(config);
   const destination = resolveTargetPath(paths.mcp_shared_file);
-  if (!fs32.existsSync(source)) {
+  if (!fs33.existsSync(source)) {
     return skippedMissingSource2("mcp", source);
   }
-  const sourceMcpJson = JSON.parse(fs32.readFileSync(source, "utf8"));
+  const sourceMcpJson = JSON.parse(fs33.readFileSync(source, "utf8"));
   const compiled = compileMcp(
     sourceMcpJson,
     "copilot",
@@ -26282,13 +27125,13 @@ function writeCompiledArtifact2(component, destination, content, expectedHash, c
   if (artifactClass === "unmanaged-conflict" && !handleConflict2(destination, config, options, logger, manifest, scopePath)) {
     return { component, status: "conflict", path: destination };
   }
-  ensureDir(path32.dirname(destination));
-  fs32.writeFileSync(destination, content);
+  ensureDir(path33.dirname(destination));
+  fs33.writeFileSync(destination, content);
   return { component, status: "success", path: destination };
 }
 function isCompiledCurrent2(destination, expectedContent, expectedHash) {
   try {
-    const current = fs32.readFileSync(destination, "utf8");
+    const current = fs33.readFileSync(destination, "utf8");
     const marker = extractProvenanceMarker(current);
     return expectedHash ? marker?.hash === expectedHash && marker.target === "copilot" && current === expectedContent : current === expectedContent;
   } catch {
@@ -26311,11 +27154,11 @@ function handleConflict2(destination, config, options, logger, manifest, scopePa
       backupFile(destination, manifest);
       writeManifest(scopePath, manifest);
     } else {
-      fs32.renameSync(destination, `${destination}.bak.${Date.now()}`);
+      fs33.renameSync(destination, `${destination}.bak.${Date.now()}`);
     }
     return true;
   }
-  fs32.rmSync(destination, { recursive: true, force: true });
+  fs33.rmSync(destination, { recursive: true, force: true });
   return true;
 }
 function shouldSkipComponent2(options, component) {
@@ -26324,12 +27167,12 @@ function shouldSkipComponent2(options, component) {
 function cleanupLegacyAgents(paths, options, logger) {
   const currentAgentsRoot = resolveTargetPath(paths.agents);
   const legacyAgentsRoot = resolveTargetPath(legacyCopilotAgentsPath);
-  if (path32.resolve(currentAgentsRoot) === path32.resolve(legacyAgentsRoot)) {
+  if (path33.resolve(currentAgentsRoot) === path33.resolve(legacyAgentsRoot)) {
     return [];
   }
   const outcomes = [];
   for (const filePath of ts(
-    path32.join(legacyAgentsRoot, "*.agent.md")
+    path33.join(legacyAgentsRoot, "*.agent.md")
   ).sort()) {
     if (!isCopilotManagedCompiledFile(filePath)) {
       continue;
@@ -26339,14 +27182,14 @@ function cleanupLegacyAgents(paths, options, logger) {
       outcomes.push({ component: "agents", status: "dry-run", path: filePath });
       continue;
     }
-    fs32.rmSync(filePath, { force: true });
+    fs33.rmSync(filePath, { force: true });
     outcomes.push({ component: "agents", status: "success", path: filePath });
   }
   return outcomes;
 }
 function isCopilotManagedCompiledFile(filePath) {
   try {
-    return extractProvenanceMarker(fs32.readFileSync(filePath, "utf8"))?.target === "copilot";
+    return extractProvenanceMarker(fs33.readFileSync(filePath, "utf8"))?.target === "copilot";
   } catch {
     return false;
   }
@@ -26360,7 +27203,7 @@ function skippedMissingSource2(component, source) {
 }
 function isSymlinkTo2(linkPath, source) {
   try {
-    return fs32.realpathSync(linkPath) === fs32.realpathSync(source);
+    return fs33.realpathSync(linkPath) === fs33.realpathSync(source);
   } catch {
     return false;
   }
@@ -26368,8 +27211,8 @@ function isSymlinkTo2(linkPath, source) {
 
 // src/adapters/cursor.ts
 import crypto7 from "crypto";
-import fs33 from "fs";
-import path33 from "path";
+import fs34 from "fs";
+import path34 from "path";
 function syncCursor(config, sourceRoot, mappings, extensions, options, lossReport, logger, manifest, scopePath) {
   const scope = options.scope ?? "global";
   const profile = resolveTargetPaths({
@@ -26520,9 +27363,9 @@ function syncCursor(config, sourceRoot, mappings, extensions, options, lossRepor
   return { target: "cursor", outcomes };
 }
 function syncInstructions2(config, sourceRoot, paths, options, lossReport, logger, manifest, scopePath) {
-  const source = path33.join(sourceRoot, config.source.instructions);
+  const source = path34.join(sourceRoot, config.source.instructions);
   const destination = resolveTargetPath(paths.instructions);
-  const baseContent = fs33.existsSync(source) ? fs33.readFileSync(source, "utf8").trim() : "";
+  const baseContent = fs34.existsSync(source) ? fs34.readFileSync(source, "utf8").trim() : "";
   const personaContent = extractPrimaryPersonaContent(
     config,
     sourceRoot,
@@ -26535,7 +27378,7 @@ function syncInstructions2(config, sourceRoot, paths, options, lossReport, logge
 ${personaContent}`.trim() : baseContent;
   const marker = formatProvenanceMarker(
     "markdown",
-    path33.basename(config.source.instructions),
+    path34.basename(config.source.instructions),
     hashString3(composed),
     "cursor"
   );
@@ -26560,11 +27403,11 @@ ${composed}
   );
 }
 function extractPrimaryPersonaContent(config, sourceRoot, lossReport) {
-  const agentsDir = path33.join(sourceRoot, config.source.agents);
-  if (!fs33.existsSync(agentsDir)) {
+  const agentsDir = path34.join(sourceRoot, config.source.agents);
+  if (!fs34.existsSync(agentsDir)) {
     return null;
   }
-  const agentFiles = ts(path33.join(agentsDir, "*.md")).sort();
+  const agentFiles = ts(path34.join(agentsDir, "*.md")).sort();
   if (agentFiles.length === 0) {
     return null;
   }
@@ -26587,7 +27430,7 @@ function extractPrimaryPersonaContent(config, sourceRoot, lossReport) {
     return null;
   }
   addLoss(lossReport, "cursor", "instructions", {
-    source: `agents/${path33.basename(primaryFile)}`,
+    source: `agents/${path34.basename(primaryFile)}`,
     fields: [
       {
         field: "persona",
@@ -26597,23 +27440,23 @@ function extractPrimaryPersonaContent(config, sourceRoot, lossReport) {
           "persona",
           "instructions-shim"
         ),
-        detail: `Primary persona from ${path33.basename(primaryFile)} folded into AGENTS.md (Cursor has no custom modes surface)`
+        detail: `Primary persona from ${path34.basename(primaryFile)} folded into AGENTS.md (Cursor has no custom modes surface)`
       }
     ]
   });
   return body.trim();
 }
 function syncAgents3(config, sourceRoot, paths, mappings, extensions, options, lossReport, logger, manifest, scopePath) {
-  const sourceAgentsRoot = path33.join(sourceRoot, config.source.agents);
-  if (!fs33.existsSync(sourceAgentsRoot)) {
+  const sourceAgentsRoot = path34.join(sourceRoot, config.source.agents);
+  if (!fs34.existsSync(sourceAgentsRoot)) {
     return [skippedMissingSource3("agents", sourceAgentsRoot)];
   }
-  const sourceAgents = ts(path33.join(sourceAgentsRoot, "*.md")).sort();
+  const sourceAgents = ts(path34.join(sourceAgentsRoot, "*.md")).sort();
   const agentsRoot = resolveTargetPath(paths.agents);
   return sourceAgents.map((agentFile) => {
-    const destination = path33.join(
+    const destination = path34.join(
       agentsRoot,
-      `${path33.basename(agentFile, ".md")}.md`
+      `${path34.basename(agentFile, ".md")}.md`
     );
     let compiled;
     try {
@@ -26654,14 +27497,14 @@ function syncAgents3(config, sourceRoot, paths, mappings, extensions, options, l
   });
 }
 function syncRules2(config, sourceRoot, paths, mappings, options, lossReport, logger, manifest, scopePath) {
-  const sourceRulesDir = path33.join(sourceRoot, config.source.rules);
-  if (!fs33.existsSync(sourceRulesDir)) {
+  const sourceRulesDir = path34.join(sourceRoot, config.source.rules);
+  if (!fs34.existsSync(sourceRulesDir)) {
     return [skippedMissingSource3("rules", sourceRulesDir)];
   }
   const compiled = compileRules(sourceRulesDir, "cursor", mappings, lossReport);
   const rulesDir = resolveTargetPath(paths.rules);
   return compiled.dotRulesFiles.map(({ name, content }) => {
-    const destination = path33.join(rulesDir, name);
+    const destination = path34.join(rulesDir, name);
     if (options.dryRun) {
       logger.info(`[dry-run] rules: write ${destination}`);
       return {
@@ -26685,17 +27528,17 @@ function syncRules2(config, sourceRoot, paths, mappings, options, lossReport, lo
   });
 }
 function syncCommands2(config, sourceRoot, paths, options, logger, manifest, scopePath) {
-  const sourceCommandsRoot = path33.join(sourceRoot, config.source.commands);
-  if (!fs33.existsSync(sourceCommandsRoot)) {
+  const sourceCommandsRoot = path34.join(sourceRoot, config.source.commands);
+  if (!fs34.existsSync(sourceCommandsRoot)) {
     return [skippedMissingSource3("commands", sourceCommandsRoot)];
   }
-  const sourceCommands = ts(path33.join(sourceCommandsRoot, "*.md")).sort();
+  const sourceCommands = ts(path34.join(sourceCommandsRoot, "*.md")).sort();
   const skillsRoot = resolveTargetPath(paths.skills);
   return sourceCommands.map((commandFile) => {
-    const baseName = path33.basename(commandFile, ".md");
-    const destination = path33.join(skillsRoot, baseName, "SKILL.md");
-    const commandContent = fs33.readFileSync(commandFile, "utf8");
-    const relativeSource = `commands/${path33.basename(commandFile)}`;
+    const baseName = path34.basename(commandFile, ".md");
+    const destination = path34.join(skillsRoot, baseName, "SKILL.md");
+    const commandContent = fs34.readFileSync(commandFile, "utf8");
+    const relativeSource = `commands/${path34.basename(commandFile)}`;
     const marker = formatProvenanceMarker(
       "markdown",
       relativeSource,
@@ -26733,9 +27576,9 @@ ${commandContent.trim()}
     );
   });
 }
-function syncSkills3(config, sourceRoot, options, logger, manifest, scopePath, component = "skills", destination = "", asSymlink = false) {
-  const source = path33.resolve(sourceRoot, config.source.skills);
-  if (!fs33.existsSync(source)) {
+function syncSkills3(config, sourceRoot, options, logger, manifest, scopePath, component = "skills", destination = "", asSymlink = false) {
+  const source = path34.resolve(sourceRoot, config.source.skills);
+  if (!fs34.existsSync(source)) {
     return skippedMissingSource3(component, source);
   }
   if (options.dryRun) {
@@ -26749,18 +27592,18 @@ function syncSkills3(config, sourceRoot, options, logger, manifest, scopePath, c
       return { component, status: "skipped-current", path: destination };
     }
     if (artifactClass === "managed-stale" && isOurStaleSymlink(destination, /* @__PURE__ */ new Set([destination]), config)) {
-      fs33.unlinkSync(destination);
+      fs34.unlinkSync(destination);
     } else if (artifactClass === "unmanaged-conflict" && !handleConflict3(destination, config, options, logger, manifest, scopePath)) {
       return { component, status: "conflict", path: destination };
     } else if (artifactClass === "managed-symlink") {
-      fs33.unlinkSync(destination);
+      fs34.unlinkSync(destination);
     }
-    ensureDir(path33.dirname(destination));
+    ensureDir(path34.dirname(destination));
     createRelativeSymlink(source, destination, "dir");
     logger.verbose(`Skills: created shared skills symlink ${destination}`);
     return { component, status: "success", path: destination };
   }
-  if (fs33.existsSync(destination)) {
+  if (fs34.existsSync(destination)) {
     return { component, status: "skipped-current", path: destination };
   }
   ensureDir(destination);
@@ -26771,7 +27614,7 @@ function syncHooks3(config, sourceRoot, paths, mappings, options, lossReport, lo
   const source = resolveHooksSourceFile(sourceRoot, config);
   const sourceLabel = hooksSourceLabel(config);
   const destination = resolveTargetPath(paths.hooks_file);
-  const sourceHooksJson = fs33.existsSync(source) ? JSON.parse(fs33.readFileSync(source, "utf8")) : { hooks: {} };
+  const sourceHooksJson = fs34.existsSync(source) ? JSON.parse(fs34.readFileSync(source, "utf8")) : { hooks: {} };
   const compiled = compileHooks(
     sourceHooksJson,
     "cursor",
@@ -26785,18 +27628,18 @@ function syncHooks3(config, sourceRoot, paths, mappings, options, lossReport, lo
   }
   const hooksFileContent = `${JSON.stringify({ version: 1, hooks: compiled.payload }, null, 2)}
 `;
-  ensureDir(path33.dirname(destination));
-  fs33.writeFileSync(destination, hooksFileContent);
+  ensureDir(path34.dirname(destination));
+  fs34.writeFileSync(destination, hooksFileContent);
   return { component: "hooks", status: "success", path: destination };
 }
 function syncMcp3(config, sourceRoot, paths, options, lossReport, logger, manifest, scopePath) {
   const source = resolveMcpSourceFile(sourceRoot, config);
   const sourceLabel = mcpSourceLabel(config);
   const destination = resolveTargetPath(paths.mcp_file);
-  if (!fs33.existsSync(source)) {
+  if (!fs34.existsSync(source)) {
     return skippedMissingSource3("mcp", source);
   }
-  const sourceMcpJson = JSON.parse(fs33.readFileSync(source, "utf8"));
+  const sourceMcpJson = JSON.parse(fs34.readFileSync(source, "utf8"));
   const mcpJson = compileMcp(sourceMcpJson, "cursor", lossReport, sourceLabel);
   if (options.dryRun) {
     logger.info(`[dry-run] mcp: compile ${source} -> ${destination}`);
@@ -26847,13 +27690,13 @@ function syncPermissions(config, paths, options, _lossReport, logger, manifest,
   );
 }
 function syncProviderPin(config, sourceRoot, lossReport) {
-  const agentsDir = path33.join(sourceRoot, config.source.agents);
-  if (!fs33.existsSync(agentsDir)) return;
-  for (const agentFile of ts(path33.join(agentsDir, "*.md")).sort()) {
+  const agentsDir = path34.join(sourceRoot, config.source.agents);
+  if (!fs34.existsSync(agentsDir)) return;
+  for (const agentFile of ts(path34.join(agentsDir, "*.md")).sort()) {
     const { data } = parseMarkdownFrontmatter(agentFile);
     const hasCustomProvider = typeof data.provider === "string" || typeof data.provider === "object" && data.provider !== null && Object.keys(data.provider).length > 0;
     if (hasCustomProvider) {
-      const relativeSource = `agents/${path33.basename(agentFile)}`;
+      const relativeSource = `agents/${path34.basename(agentFile)}`;
       addLoss(lossReport, "cursor", "agents", {
         source: relativeSource,
         fields: [
@@ -26865,7 +27708,7 @@ function syncProviderPin(config, sourceRoot, lossReport) {
               "provider",
               "provider-not-representable"
             ),
-            detail: `${path33.basename(agentFile)}: custom provider cannot be expressed in Cursor subagent frontmatter \u2014 configure manually via Cursor settings`
+            detail: `${path34.basename(agentFile)}: custom provider cannot be expressed in Cursor subagent frontmatter \u2014 configure manually via Cursor settings`
           }
         ]
       });
@@ -26880,8 +27723,8 @@ function writeCompiledArtifact3(component, destination, content, expectedHash, c
   if (artifactClass === "unmanaged-conflict" && !handleConflict3(destination, config, options, logger, manifest, scopePath)) {
     return { component, status: "conflict", path: destination };
   }
-  ensureDir(path33.dirname(destination));
-  fs33.writeFileSync(destination, content);
+  ensureDir(path34.dirname(destination));
+  fs34.writeFileSync(destination, content);
   return { component, status: "success", path: destination };
 }
 function handleConflict3(destination, config, options, logger, manifest, scopePath) {
@@ -26900,16 +27743,16 @@ function handleConflict3(destination, config, options, logger, manifest, scopePa
       backupFile(destination, manifest);
       writeManifest(scopePath, manifest);
     } else {
-      fs33.renameSync(destination, `${destination}.bak.${Date.now()}`);
+      fs34.renameSync(destination, `${destination}.bak.${Date.now()}`);
     }
     return true;
   }
-  fs33.rmSync(destination, { recursive: true, force: true });
+  fs34.rmSync(destination, { recursive: true, force: true });
   return true;
 }
 function isCompiledCurrent3(destination, expectedContent, expectedHash) {
   try {
-    const current = fs33.readFileSync(destination, "utf8");
+    const current = fs34.readFileSync(destination, "utf8");
     const marker = extractProvenanceMarker(current);
     return expectedHash ? marker?.hash === expectedHash && marker.target === "cursor" && current === expectedContent : current === expectedContent;
   } catch {
@@ -26928,7 +27771,7 @@ function shouldSkipComponent3(options, component) {
 }
 function isSymlinkTo3(linkPath, source) {
   try {
-    return fs33.realpathSync(linkPath) === fs33.realpathSync(source);
+    return fs34.realpathSync(linkPath) === fs34.realpathSync(source);
   } catch {
     return false;
   }
@@ -26939,8 +27782,8 @@ function hashString3(value) {
 
 // src/adapters/cline.ts
 import crypto8 from "crypto";
-import fs34 from "fs";
-import path34 from "path";
+import fs35 from "fs";
+import path35 from "path";
 function syncCline(config, sourceRoot, mappings, extensions, options, lossReport, logger, manifest, scopePath) {
   const scope = options.scope ?? "global";
   const profile = resolveTargetPaths({
@@ -27053,7 +27896,7 @@ function syncCline(config, sourceRoot, mappings, extensions, options, lossReport
 function syncInstructions3(config, sourceRoot, paths, scope, options, lossReport, logger, manifest, scopePath) {
   if (scope === "global" || paths.instructions === null) {
     addLoss(lossReport, "cline", "instructions", {
-      source: path34.basename(config.source.instructions),
+      source: path35.basename(config.source.instructions),
       fields: [
         {
           field: "instructions",
@@ -27073,12 +27916,12 @@ function syncInstructions3(config, sourceRoot, paths, scope, options, lossReport
       path: "cline/global/instructions: no committable global path"
     };
   }
-  const source = path34.join(sourceRoot, config.source.instructions);
+  const source = path35.join(sourceRoot, config.source.instructions);
   const destination = resolveTargetPath(paths.instructions);
-  const baseContent = fs34.existsSync(source) ? fs34.readFileSync(source, "utf8").trim() : "";
+  const baseContent = fs35.existsSync(source) ? fs35.readFileSync(source, "utf8").trim() : "";
   const marker = formatProvenanceMarker(
     "markdown",
-    path34.basename(config.source.instructions),
+    path35.basename(config.source.instructions),
     hashString4(baseContent),
     "cline"
   );
@@ -27103,11 +27946,11 @@ ${baseContent}
   );
 }
 function syncAgents4(config, sourceRoot, mappings, extensions, options, lossReport, logger) {
-  const sourceAgentsRoot = path34.join(sourceRoot, config.source.agents);
-  if (!fs34.existsSync(sourceAgentsRoot)) {
+  const sourceAgentsRoot = path35.join(sourceRoot, config.source.agents);
+  if (!fs35.existsSync(sourceAgentsRoot)) {
     return [skippedMissingSource4("agents", sourceAgentsRoot)];
   }
-  const sourceAgents = ts(path34.join(sourceAgentsRoot, "*.md")).sort();
+  const sourceAgents = ts(path35.join(sourceAgentsRoot, "*.md")).sort();
   return sourceAgents.map((agentFile) => {
     compileAgent(agentFile, "cline", mappings, extensions, lossReport);
     if (options.dryRun) {
@@ -27123,14 +27966,14 @@ function syncAgents4(config, sourceRoot, mappings, extensions, options, lossRepo
   });
 }
 function syncRules3(config, sourceRoot, paths, mappings, options, lossReport, logger, manifest, scopePath) {
-  const sourceRulesDir = path34.join(sourceRoot, config.source.rules);
-  if (!fs34.existsSync(sourceRulesDir)) {
+  const sourceRulesDir = path35.join(sourceRoot, config.source.rules);
+  if (!fs35.existsSync(sourceRulesDir)) {
     return [skippedMissingSource4("rules", sourceRulesDir)];
   }
   const compiled = compileRules(sourceRulesDir, "cline", mappings, lossReport);
   const rulesDir = resolveTargetPath(paths.rules);
   return compiled.dotRulesFiles.map(({ name, content }) => {
-    const destination = path34.join(rulesDir, name);
+    const destination = path35.join(rulesDir, name);
     if (options.dryRun) {
       logger.info(`[dry-run] rules: write ${destination}`);
       return {
@@ -27154,17 +27997,17 @@ function syncRules3(config, sourceRoot, paths, mappings, options, lossReport, lo
   });
 }
 function syncCommands3(config, sourceRoot, paths, options, logger, manifest, scopePath) {
-  const sourceCommandsRoot = path34.join(sourceRoot, config.source.commands);
-  if (!fs34.existsSync(sourceCommandsRoot)) {
+  const sourceCommandsRoot = path35.join(sourceRoot, config.source.commands);
+  if (!fs35.existsSync(sourceCommandsRoot)) {
     return [skippedMissingSource4("commands", sourceCommandsRoot)];
   }
-  const sourceCommands = ts(path34.join(sourceCommandsRoot, "*.md")).sort();
+  const sourceCommands = ts(path35.join(sourceCommandsRoot, "*.md")).sort();
   const workflowsRoot = resolveTargetPath(paths.workflows);
   return sourceCommands.map((commandFile) => {
-    const baseName = path34.basename(commandFile);
-    const destination = path34.join(workflowsRoot, baseName);
-    const commandContent = fs34.readFileSync(commandFile, "utf8");
-    const relativeSource = `commands/${path34.basename(commandFile)}`;
+    const baseName = path35.basename(commandFile);
+    const destination = path35.join(workflowsRoot, baseName);
+    const commandContent = fs35.readFileSync(commandFile, "utf8");
+    const relativeSource = `commands/${path35.basename(commandFile)}`;
     const marker = formatProvenanceMarker(
       "markdown",
       relativeSource,
@@ -27199,9 +28042,9 @@ ${commandContent.trim()}
   });
 }
 function syncSkills4(config, sourceRoot, paths, options, logger, manifest, scopePath) {
-  const source = path34.resolve(sourceRoot, config.source.skills);
+  const source = path35.resolve(sourceRoot, config.source.skills);
   const destination = resolveTargetPath(paths.skills);
-  if (!fs34.existsSync(source)) {
+  if (!fs35.existsSync(source)) {
     return skippedMissingSource4("skills", source);
   }
   if (options.dryRun) {
@@ -27221,9 +28064,9 @@ function syncSkills4(config, sourceRoot, paths, options, logger, manifest, scope
       return { component: "skills", status: "conflict", path: destination };
     }
   } else if (artifactClass === "managed-symlink") {
-    fs34.unlinkSync(destination);
+    fs35.unlinkSync(destination);
   }
-  ensureDir(path34.dirname(destination));
+  ensureDir(path35.dirname(destination));
   createRelativeSymlink(source, destination, "dir");
   logger.verbose(`Skills: created Cline skills symlink ${destination}`);
   return { component: "skills", status: "success", path: destination };
@@ -27231,7 +28074,7 @@ function syncSkills4(config, sourceRoot, paths, options, logger, manifest, scope
 function syncHooks4(config, sourceRoot, mappings, options, lossReport, logger) {
   const source = resolveHooksSourceFile(sourceRoot, config);
   const sourceLabel = hooksSourceLabel(config);
-  const sourceHooksJson = fs34.existsSync(source) ? JSON.parse(fs34.readFileSync(source, "utf8")) : { hooks: {} };
+  const sourceHooksJson = fs35.existsSync(source) ? JSON.parse(fs35.readFileSync(source, "utf8")) : { hooks: {} };
   compileHooks(sourceHooksJson, "cline", mappings, lossReport, sourceLabel);
   if (options.dryRun) {
     logger.info(`[dry-run] hooks: record hook-as-plugin loss for ${source}`);
@@ -27246,10 +28089,10 @@ function syncMcp4(config, sourceRoot, paths, options, lossReport, logger, manife
   const source = resolveMcpSourceFile(sourceRoot, config);
   const sourceLabel = mcpSourceLabel(config);
   const destination = resolveTargetPath(paths.mcp_file);
-  if (!fs34.existsSync(source)) {
+  if (!fs35.existsSync(source)) {
     return skippedMissingSource4("mcp", source);
   }
-  const sourceMcpJson = JSON.parse(fs34.readFileSync(source, "utf8"));
+  const sourceMcpJson = JSON.parse(fs35.readFileSync(source, "utf8"));
   const mcpJson = compileMcp(sourceMcpJson, "cline", lossReport, sourceLabel);
   if (options.dryRun) {
     logger.info(`[dry-run] mcp: compile ${source} -> ${destination}`);
@@ -27292,11 +28135,11 @@ function syncSettings(lossReport) {
   };
 }
 function syncProviderAndModel(config, sourceRoot, lossReport) {
-  const agentsDir = path34.join(sourceRoot, config.source.agents);
-  if (!fs34.existsSync(agentsDir)) return;
-  for (const agentFile of ts(path34.join(agentsDir, "*.md")).sort()) {
+  const agentsDir = path35.join(sourceRoot, config.source.agents);
+  if (!fs35.existsSync(agentsDir)) return;
+  for (const agentFile of ts(path35.join(agentsDir, "*.md")).sort()) {
     const { data } = parseMarkdownFrontmatter(agentFile);
-    const relativeSource = `agents/${path34.basename(agentFile)}`;
+    const relativeSource = `agents/${path35.basename(agentFile)}`;
     const hasCustomProvider = typeof data.provider === "string" || typeof data.provider === "object" && data.provider !== null && Object.keys(data.provider).length > 0;
     if (hasCustomProvider) {
       addLoss(lossReport, "cline", "agents", {
@@ -27310,7 +28153,7 @@ function syncProviderAndModel(config, sourceRoot, lossReport) {
               "provider",
               "provider-not-representable"
             ),
-            detail: `${path34.basename(agentFile)}: Cline provider is interface-only (Settings \u2192 API Provider); configure manually.`
+            detail: `${path35.basename(agentFile)}: Cline provider is interface-only (Settings \u2192 API Provider); configure manually.`
           }
         ]
       });
@@ -27328,7 +28171,7 @@ function syncProviderAndModel(config, sourceRoot, lossReport) {
               "model",
               "model-not-representable"
             ),
-            detail: `${path34.basename(agentFile)}: Cline model pin is interface-only (Settings \u2192 Model); configure manually.`
+            detail: `${path35.basename(agentFile)}: Cline model pin is interface-only (Settings \u2192 Model); configure manually.`
           }
         ]
       });
@@ -27343,8 +28186,8 @@ function writeCompiledArtifact4(component, destination, content, expectedHash, c
   if (artifactClass === "unmanaged-conflict" && !handleConflict4(destination, config, options, logger, manifest, scopePath)) {
     return { component, status: "conflict", path: destination };
   }
-  ensureDir(path34.dirname(destination));
-  fs34.writeFileSync(destination, content);
+  ensureDir(path35.dirname(destination));
+  fs35.writeFileSync(destination, content);
   return { component, status: "success", path: destination };
 }
 function handleConflict4(destination, config, options, logger, manifest, scopePath) {
@@ -27363,16 +28206,16 @@ function handleConflict4(destination, config, options, logger, manifest, scopePa
       backupFile(destination, manifest);
       writeManifest(scopePath, manifest);
     } else {
-      fs34.renameSync(destination, `${destination}.bak.${Date.now()}`);
+      fs35.renameSync(destination, `${destination}.bak.${Date.now()}`);
     }
     return true;
   }
-  fs34.rmSync(destination, { recursive: true, force: true });
+  fs35.rmSync(destination, { recursive: true, force: true });
   return true;
 }
 function isCompiledCurrent4(destination, expectedContent, expectedHash) {
   try {
-    const current = fs34.readFileSync(destination, "utf8");
+    const current = fs35.readFileSync(destination, "utf8");
     const marker = extractProvenanceMarker(current);
     return expectedHash ? marker?.hash === expectedHash && marker.target === "cline" && current === expectedContent : current === expectedContent;
   } catch {
@@ -27391,7 +28234,7 @@ function shouldSkipComponent4(options, component) {
 }
 function isSymlinkTo4(linkPath, source) {
   try {
-    return fs34.realpathSync(linkPath) === fs34.realpathSync(source);
+    return fs35.realpathSync(linkPath) === fs35.realpathSync(source);
   } catch {
     return false;
   }
@@ -27402,10 +28245,10 @@ function hashString4(value) {
 
 // src/adapters/opencode.ts
 import crypto9 from "crypto";
-import fs35 from "fs";
+import fs36 from "fs";
 import os6 from "os";
-import path35 from "path";
-var import_yaml10 = __toESM(require_dist(), 1);
+import path36 from "path";
+var import_yaml11 = __toESM(require_dist(), 1);
 function syncOpenCode(config, sourceRoot, mappings, extensions, options, lossReport, logger, manifest, scopePath) {
   const scope = options.scope ?? "global";
   const profile = resolveTargetPaths({
@@ -27422,7 +28265,7 @@ function syncOpenCode(config, sourceRoot, mappings, extensions, options, lossRep
     config_doc: profile.config_doc
   };
   const rules = compileRules(
-    path35.join(sourceRoot, config.source.rules),
+    path36.join(sourceRoot, config.source.rules),
     "opencode",
     mappings,
     lossReport
@@ -27524,16 +28367,16 @@ function syncOpenCode(config, sourceRoot, mappings, extensions, options, lossRep
   return { target: "opencode", outcomes };
 }
 function syncInstructions4(config, sourceRoot, paths, agentsAppendix, options, logger, manifest, scopePath) {
-  const source = path35.join(sourceRoot, config.source.instructions);
+  const source = path36.join(sourceRoot, config.source.instructions);
   const destination = resolveTargetPath(paths.instructions);
-  const baseContent = fs35.existsSync(source) ? fs35.readFileSync(source, "utf8").trim() : "";
+  const baseContent = fs36.existsSync(source) ? fs36.readFileSync(source, "utf8").trim() : "";
   const composed = agentsAppendix ? `${baseContent}
 
 --- tangyr managed rules ---
 ${agentsAppendix}`.trim() : baseContent;
   const marker = formatProvenanceMarker(
     "markdown",
-    path35.basename(config.source.instructions),
+    path36.basename(config.source.instructions),
     hashString5(composed),
     "opencode"
   );
@@ -27560,16 +28403,16 @@ ${composed}
   );
 }
 function syncAgents5(config, sourceRoot, paths, mappings, extensions, options, lossReport, logger, manifest, scopePath) {
-  const sourceAgentsRoot = path35.join(sourceRoot, config.source.agents);
-  if (!fs35.existsSync(sourceAgentsRoot)) {
+  const sourceAgentsRoot = path36.join(sourceRoot, config.source.agents);
+  if (!fs36.existsSync(sourceAgentsRoot)) {
     return [skippedMissingSource5("agents", sourceAgentsRoot)];
   }
-  const sourceAgents = ts(path35.join(sourceAgentsRoot, "*.md")).sort();
+  const sourceAgents = ts(path36.join(sourceAgentsRoot, "*.md")).sort();
   const agentsRoot = resolveTargetPath(paths.agents);
   return sourceAgents.map((agentFile) => {
-    const destination = path35.join(
+    const destination = path36.join(
       agentsRoot,
-      `${path35.basename(agentFile, ".md")}.md`
+      `${path36.basename(agentFile, ".md")}.md`
     );
     let compiled;
     try {
@@ -27625,19 +28468,19 @@ function applyProviderModelBinding(compiled, mappings) {
   const after = compiled.slice(fmEnd);
   let fields;
   try {
-    fields = (0, import_yaml10.parse)(yamlBlock) ?? {};
+    fields = (0, import_yaml11.parse)(yamlBlock) ?? {};
   } catch {
     return compiled;
   }
   fields.model = modelValue;
-  return `${before}${(0, import_yaml10.stringify)(fields).trim()}${after}`;
+  return `${before}${(0, import_yaml11.stringify)(fields).trim()}${after}`;
 }
 function syncCommands4(config, sourceRoot, paths, options, logger, manifest, scopePath) {
-  const sourceCommandsRoot = path35.join(sourceRoot, config.source.commands);
-  if (!fs35.existsSync(sourceCommandsRoot)) {
+  const sourceCommandsRoot = path36.join(sourceRoot, config.source.commands);
+  if (!fs36.existsSync(sourceCommandsRoot)) {
     return [skippedMissingSource5("commands", sourceCommandsRoot)];
   }
-  const sourceCommands = ts(path35.join(sourceCommandsRoot, "*.md")).sort();
+  const sourceCommands = ts(path36.join(sourceCommandsRoot, "*.md")).sort();
   const commandsRoot = resolveTargetPath(paths.commands);
   return sourceCommands.map((commandFile) => {
     const { data, body } = parseCommandFile(commandFile);
@@ -27651,7 +28494,7 @@ function syncCommands4(config, sourceRoot, paths, options, logger, manifest, sco
     if (typeof data.model === "string") {
       frontmatter.model = data.model;
     }
-    const relativeSource = `commands/${path35.basename(commandFile)}`;
+    const relativeSource = `commands/${path36.basename(commandFile)}`;
     const marker = formatProvenanceMarker(
       "markdown",
       relativeSource,
@@ -27660,16 +28503,16 @@ function syncCommands4(config, sourceRoot, paths, options, logger, manifest, sco
     );
     const content = Object.keys(frontmatter).length > 0 ? `${marker}
 ---
-${(0, import_yaml10.stringify)(frontmatter).trim()}
+${(0, import_yaml11.stringify)(frontmatter).trim()}
 ---
 
 ${body.trimEnd()}
 ` : `${marker}
 ${body.trimEnd()}
 `;
-    const destination = path35.join(
+    const destination = path36.join(
       commandsRoot,
-      `${path35.basename(commandFile, ".md")}.md`
+      `${path36.basename(commandFile, ".md")}.md`
     );
     if (options.dryRun) {
       logger.info(
@@ -27696,8 +28539,8 @@ ${body.trimEnd()}
   });
 }
 function syncSkills5(config, sourceRoot, _paths, options, logger, manifest, scopePath, component = "skills", destination = "") {
-  const source = path35.resolve(sourceRoot, config.source.skills);
-  if (!fs35.existsSync(source)) {
+  const source = path36.resolve(sourceRoot, config.source.skills);
+  if (!fs36.existsSync(source)) {
     return skippedMissingSource5(component, source);
   }
   if (options.dryRun) {
@@ -27709,13 +28552,13 @@ function syncSkills5(config, sourceRoot, _paths, options, logger, manifest, scop
     return { component, status: "skipped-current", path: destination };
   }
   if (artifactClass === "managed-stale" && isOurStaleSymlink(destination, /* @__PURE__ */ new Set([destination]), config)) {
-    fs35.unlinkSync(destination);
+    fs36.unlinkSync(destination);
   } else if (artifactClass === "unmanaged-conflict" && !handleConflict5(destination, config, options, logger, manifest, scopePath)) {
     return { component, status: "conflict", path: destination };
   } else if (artifactClass === "managed-symlink") {
-    fs35.unlinkSync(destination);
+    fs36.unlinkSync(destination);
   }
-  ensureDir(path35.dirname(destination));
+  ensureDir(path36.dirname(destination));
   createRelativeSymlink(source, destination, "dir");
   logger.verbose(`Skills: created skills path ${destination}`);
   return { component, status: "success", path: destination };
@@ -27724,13 +28567,13 @@ function syncMcp5(config, sourceRoot, paths, mappings, options, lossReport, logg
   const source = resolveMcpSourceFile(sourceRoot, config);
   const sourceLabel = mcpSourceLabel(config);
   const destination = resolveTargetPath(paths.config_doc);
-  if (!fs35.existsSync(source)) {
+  if (!fs36.existsSync(source)) {
     if (!options.dryRun) {
       syncConfigDoc(paths, {}, lossReport, {}, mappings);
     }
     return skippedMissingSource5("mcp", source);
   }
-  const sourceMcpJson = JSON.parse(fs35.readFileSync(source, "utf8"));
+  const sourceMcpJson = JSON.parse(fs36.readFileSync(source, "utf8"));
   const mcpJson = compileMcp(
     sourceMcpJson,
     "opencode",
@@ -27761,7 +28604,7 @@ function syncPermissions2(config, _sourceRoot, paths, options, lossReport, logge
 function syncHooks5(config, sourceRoot, mappings, options, lossReport) {
   const source = resolveHooksSourceFile(sourceRoot, config);
   const sourceLabel = hooksSourceLabel(config);
-  const sourceHooksJson = fs35.existsSync(source) ? JSON.parse(fs35.readFileSync(source, "utf8")) : { hooks: {} };
+  const sourceHooksJson = fs36.existsSync(source) ? JSON.parse(fs36.readFileSync(source, "utf8")) : { hooks: {} };
   compileHooks(sourceHooksJson, "opencode", mappings, lossReport, sourceLabel);
   const message = "hooks: Skip \u2014 OpenCode exposes hooks only as plugin code (hook-as-plugin loss recorded)";
   return { component: "hooks", status: "skipped", path: message };
@@ -27795,9 +28638,9 @@ function syncProviderBlock(mappings) {
 function syncConfigDoc(paths, mcpEntries, _lossReport, permissionMap, mappings) {
   const destination = resolveTargetPath(paths.config_doc);
   let existing = {};
-  if (fs35.existsSync(destination)) {
+  if (fs36.existsSync(destination)) {
     try {
-      existing = JSON.parse(fs35.readFileSync(destination, "utf8"));
+      existing = JSON.parse(fs36.readFileSync(destination, "utf8"));
     } catch {
       existing = {};
     }
@@ -27822,8 +28665,8 @@ function syncConfigDoc(paths, mcpEntries, _lossReport, permissionMap, mappings)
       };
     }
   }
-  ensureDir(path35.dirname(destination));
-  fs35.writeFileSync(destination, `${JSON.stringify(config, null, 2)}
+  ensureDir(path36.dirname(destination));
+  fs36.writeFileSync(destination, `${JSON.stringify(config, null, 2)}
 `);
 }
 function writeCompiledArtifact5(component, destination, content, expectedHash, config, sourceRoot, options, logger, manifest, scopePath) {
@@ -27834,8 +28677,8 @@ function writeCompiledArtifact5(component, destination, content, expectedHash, c
   if (artifactClass === "unmanaged-conflict" && !handleConflict5(destination, config, options, logger, manifest, scopePath)) {
     return { component, status: "conflict", path: destination };
   }
-  ensureDir(path35.dirname(destination));
-  fs35.writeFileSync(destination, content);
+  ensureDir(path36.dirname(destination));
+  fs36.writeFileSync(destination, content);
   return { component, status: "success", path: destination };
 }
 function handleConflict5(destination, config, options, logger, manifest, scopePath) {
@@ -27854,16 +28697,16 @@ function handleConflict5(destination, config, options, logger, manifest, scopePa
       backupFile(destination, manifest);
       writeManifest(scopePath, manifest);
     } else {
-      fs35.renameSync(destination, `${destination}.bak.${Date.now()}`);
+      fs36.renameSync(destination, `${destination}.bak.${Date.now()}`);
     }
     return true;
   }
-  fs35.rmSync(destination, { recursive: true, force: true });
+  fs36.rmSync(destination, { recursive: true, force: true });
   return true;
 }
 function isCompiledCurrent5(destination, expectedContent, expectedHash) {
   try {
-    const current = fs35.readFileSync(destination, "utf8");
+    const current = fs36.readFileSync(destination, "utf8");
     const marker = extractProvenanceMarker(current);
     return expectedHash ? marker?.hash === expectedHash && marker.target === "opencode" && current === expectedContent : current === expectedContent;
   } catch {
@@ -27882,7 +28725,7 @@ function shouldSkipComponent5(options, component) {
 }
 function isSymlinkTo5(linkPath, source) {
   try {
-    return fs35.realpathSync(linkPath) === fs35.realpathSync(source);
+    return fs36.realpathSync(linkPath) === fs36.realpathSync(source);
   } catch {
     return false;
   }
@@ -27891,7 +28734,7 @@ function hashString5(value) {
   return `sha256:${crypto9.createHash("sha256").update(value).digest("hex")}`;
 }
 function parseCommandFile(commandFile) {
-  const content = fs35.readFileSync(commandFile, "utf8");
+  const content = fs36.readFileSync(commandFile, "utf8");
   if (!content.startsWith("---\n")) {
     return { data: {}, body: content };
   }
@@ -27900,7 +28743,7 @@ function parseCommandFile(commandFile) {
     return { data: {}, body: content };
   }
   try {
-    const data = (0, import_yaml10.parse)(content.slice(4, endIndex)) ?? {};
+    const data = (0, import_yaml11.parse)(content.slice(4, endIndex)) ?? {};
     const body = content.slice(endIndex + "\n---".length).replace(/^\n/u, "");
     return { data, body };
   } catch {
@@ -27911,10 +28754,10 @@ function parseCommandFile(commandFile) {
 // src/commands/install.ts
 function isBackupableFile(targetPath) {
   try {
-    const lstat = fs36.lstatSync(targetPath);
+    const lstat = fs37.lstatSync(targetPath);
     if (lstat.isDirectory()) return false;
     if (lstat.isSymbolicLink()) {
-      const stat = fs36.statSync(targetPath);
+      const stat = fs37.statSync(targetPath);
       return stat.isFile();
     }
     return lstat.isFile();
@@ -27924,10 +28767,10 @@ function isBackupableFile(targetPath) {
 }
 function backupConflictingTarget(targetPath, scopePath) {
   const ts2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/gu, "").replace("T", "T").replace(/\.\d+Z$/u, "Z");
-  const relativeToRoot = path36.relative("/", targetPath).replace(/^\.\.\/+/gu, "");
-  const backupPath = path36.join(scopePath, "backups", ts2, relativeToRoot);
-  fs36.mkdirSync(path36.dirname(backupPath), { recursive: true });
-  fs36.copyFileSync(targetPath, backupPath);
+  const relativeToRoot = path37.relative("/", targetPath).replace(/^\.\.\/+/gu, "");
+  const backupPath = path37.join(scopePath, "backups", ts2, relativeToRoot);
+  fs37.mkdirSync(path37.dirname(backupPath), { recursive: true });
+  fs37.copyFileSync(targetPath, backupPath);
   return backupPath;
 }
 async function runInstallCommand(options, logger) {
@@ -27956,7 +28799,7 @@ async function runInstallCommand(options, logger) {
     );
   }
   const kitName = resolvedKitName ?? config.kit;
-  const kitPath = kitPathOverride ?? (options.kitPath ? path36.resolve(options.kitPath) : config.kitPath);
+  const kitPath = kitPathOverride ?? (options.kitPath ? path37.resolve(options.kitPath) : config.kitPath);
   if (!kitName && !kitPath) {
     logger.error(
       "No kit specified. Use --kit <name>, --kit-path <path>, or set 'kit'/'kitPath' in tangyr.config.yaml."
@@ -28097,7 +28940,7 @@ ACCEPTED CONFLICTS (backup-and-replace applied to ${conflictingFindings.length}
           logger.info(`    source: ${finding.tool}`);
           logger.info(`    action: backup-and-replace`);
           logger.info(`    backup: ${backupLocation}`);
-        } else if (fs36.existsSync(finding.path)) {
+        } else if (fs37.existsSync(finding.path)) {
           logger.info(`  - ${finding.path}`);
           logger.info(`    source: ${finding.tool}`);
           logger.info(
@@ -28208,7 +29051,7 @@ SKIPPED CONFLICTS (${skippedTargetPaths.size} target(s) left unchanged):`
   writeManifest(scopePath, manifest);
   logger.info(`
 Installation complete: ${installedCount} files installed.`);
-  logger.info(`Manifest written to ${path36.join(scopePath, "manifest.json")}`);
+  logger.info(`Manifest written to ${path37.join(scopePath, "manifest.json")}`);
   logger.info(`Kit: ${kitInfo.name} (archetype: ${kitInfo.archetype})`);
   logger.info(`Scope: ${scope}`);
   logger.info(`Tools: ${tools.join(", ")}`);
@@ -28350,13 +29193,13 @@ function applyClaudeCodePlacements(placements, manifest, skippedTargetPaths, log
       logger.verbose(`  skipped (operator choice): ${placement.destination}`);
       continue;
     }
-    const destDir = path36.dirname(placement.destination);
-    fs36.mkdirSync(destDir, { recursive: true });
+    const destDir = path37.dirname(placement.destination);
+    fs37.mkdirSync(destDir, { recursive: true });
     if (placement.type === "symlink") {
-      if (fs36.existsSync(placement.destination) || isSymlink2(placement.destination)) {
+      if (fs37.existsSync(placement.destination) || isSymlink2(placement.destination)) {
         removeManagedPath(placement.destination);
       }
-      fs36.symlinkSync(
+      fs37.symlinkSync(
         placement.source,
         placement.destination,
         placement.isDir ? "dir" : "file"
@@ -28365,12 +29208,12 @@ function applyClaudeCodePlacements(placements, manifest, skippedTargetPaths, log
         `  symlink: ${placement.source} \u2192 ${placement.destination}`
       );
     } else {
-      fs36.copyFileSync(placement.source, placement.destination);
+      fs37.copyFileSync(placement.source, placement.destination);
       logger.verbose(`  copy: ${placement.source} \u2192 ${placement.destination}`);
     }
     addArtifactToManifest(manifest, {
       relativePath: placement.manifestKey,
-      hash: fs36.statSync(placement.source).isDirectory() ? `dir:${placement.source}` : computeSourceHash(placement.source),
+      hash: fs37.statSync(placement.source).isDirectory() ? `dir:${placement.source}` : computeSourceHash(placement.source),
       origin: "tangyr-managed"
     });
     count++;
@@ -28617,11 +29460,11 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
     if (outcome.path === mcpFile2) {
       return "cline/mcp.json";
     }
-    if (outcome.path.startsWith(`${workflowsRoot}${path36.sep}`)) {
-      return `cline/workflows/${path36.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${workflowsRoot}${path37.sep}`)) {
+      return `cline/workflows/${path37.basename(outcome.path)}`;
     }
-    if (outcome.path.startsWith(`${rulesRoot2}${path36.sep}`)) {
-      return `cline/rules/${path36.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${rulesRoot2}${path37.sep}`)) {
+      return `cline/rules/${path37.basename(outcome.path)}`;
     }
     return null;
   }
@@ -28657,14 +29500,14 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
     if (outcome.path === permissionsFile) {
       return "cursor/permissions.json";
     }
-    if (outcome.path.startsWith(`${agentsRoot2}${path36.sep}`)) {
-      return `cursor/agents/${path36.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${agentsRoot2}${path37.sep}`)) {
+      return `cursor/agents/${path37.basename(outcome.path)}`;
     }
-    if (outcome.path.startsWith(`${rulesRoot2}${path36.sep}`)) {
-      return `cursor/rules/${path36.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${rulesRoot2}${path37.sep}`)) {
+      return `cursor/rules/${path37.basename(outcome.path)}`;
     }
-    if (outcome.path.startsWith(`${skillsRoot2}${path36.sep}`)) {
-      const rel = path36.relative(skillsRoot2, outcome.path);
+    if (outcome.path.startsWith(`${skillsRoot2}${path37.sep}`)) {
+      const rel = path37.relative(skillsRoot2, outcome.path);
       return `cursor/skills/${rel}`;
     }
     return null;
@@ -28690,14 +29533,14 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
     if (outcome.path === skillsSharedRoot) {
       return "opencode/skills_shared";
     }
-    if (outcome.path.startsWith(`${agentsRoot2}${path36.sep}`)) {
-      return `opencode/agents/${path36.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${agentsRoot2}${path37.sep}`)) {
+      return `opencode/agents/${path37.basename(outcome.path)}`;
     }
-    if (outcome.path.startsWith(`${commandsRoot}${path36.sep}`)) {
-      return `opencode/commands/${path36.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${commandsRoot}${path37.sep}`)) {
+      return `opencode/commands/${path37.basename(outcome.path)}`;
     }
     if (outcome.path === configDocFile) {
-      return `opencode/${path36.basename(outcome.path)}`;
+      return `opencode/${path37.basename(outcome.path)}`;
     }
     return null;
   }
@@ -28711,17 +29554,17 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
     if (outcome.path === skillsRoot2) {
       return "copilot/skills";
     }
-    if (outcome.path.startsWith(`${agentsRoot2}${path36.sep}`)) {
-      return `copilot/agents/${path36.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${agentsRoot2}${path37.sep}`)) {
+      return `copilot/agents/${path37.basename(outcome.path)}`;
     }
-    if (outcome.path.startsWith(`${promptsRoot}${path36.sep}`)) {
-      return `copilot/prompts/${path36.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${promptsRoot}${path37.sep}`)) {
+      return `copilot/prompts/${path37.basename(outcome.path)}`;
     }
-    if (outcome.path.startsWith(`${hooksRoot}${path36.sep}`)) {
-      return `copilot/hooks/${path36.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${hooksRoot}${path37.sep}`)) {
+      return `copilot/hooks/${path37.basename(outcome.path)}`;
     }
     if (outcome.path === mcpFile2) {
-      return `copilot/${path36.basename(outcome.path)}`;
+      return `copilot/${path37.basename(outcome.path)}`;
     }
     return null;
   }
@@ -28737,17 +29580,17 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
   if (outcome.path === skillsRoot) {
     return "codex/skills";
   }
-  if (outcome.path.startsWith(`${agentsRoot}${path36.sep}`)) {
-    return `codex/agents/${path36.basename(outcome.path)}`;
+  if (outcome.path.startsWith(`${agentsRoot}${path37.sep}`)) {
+    return `codex/agents/${path37.basename(outcome.path)}`;
   }
-  if (outcome.path.startsWith(`${rulesRoot}${path36.sep}`)) {
-    return `codex/rules/${path36.basename(outcome.path)}`;
+  if (outcome.path.startsWith(`${rulesRoot}${path37.sep}`)) {
+    return `codex/rules/${path37.basename(outcome.path)}`;
   }
   if (outcome.path === hooksFile) {
-    return `codex/${path36.basename(outcome.path)}`;
+    return `codex/${path37.basename(outcome.path)}`;
   }
   if (outcome.path === mcpFile) {
-    return `codex/${path36.basename(outcome.path)}`;
+    return `codex/${path37.basename(outcome.path)}`;
   }
   return null;
 }
@@ -28782,8 +29625,8 @@ function getClaudeCodePlacements(kitInfo, scope = "global", projectRoot, mapping
     };
   }
   const placements = [];
-  const claudeMd = path36.join(kitInfo.path, "CLAUDE.md");
-  if (fs36.existsSync(claudeMd)) {
+  const claudeMd = path37.join(kitInfo.path, "CLAUDE.md");
+  if (fs37.existsSync(claudeMd)) {
     placements.push({
       source: claudeMd,
       destination: resolvedPaths.instructions,
@@ -28799,8 +29642,8 @@ function getClaudeCodePlacements(kitInfo, scope = "global", projectRoot, mapping
     rules: resolvedPaths.rules
   };
   for (const [component, targetPath] of Object.entries(componentDirMap)) {
-    const componentDir = path36.join(kitInfo.path, component);
-    if (fs36.existsSync(componentDir) && fs36.statSync(componentDir).isDirectory()) {
+    const componentDir = path37.join(kitInfo.path, component);
+    if (fs37.existsSync(componentDir) && fs37.statSync(componentDir).isDirectory()) {
       placements.push({
         source: componentDir,
         destination: targetPath,
@@ -28814,8 +29657,8 @@ function getClaudeCodePlacements(kitInfo, scope = "global", projectRoot, mapping
 }
 function getClaudeCodePlacementsFromProfile(kitInfo, profile) {
   const placements = [];
-  const claudeMd = path36.join(kitInfo.path, "CLAUDE.md");
-  if (fs36.existsSync(claudeMd)) {
+  const claudeMd = path37.join(kitInfo.path, "CLAUDE.md");
+  if (fs37.existsSync(claudeMd)) {
     placements.push({
       source: claudeMd,
       destination: profile.instructions,
@@ -28831,8 +29674,8 @@ function getClaudeCodePlacementsFromProfile(kitInfo, profile) {
     rules: profile.rules
   };
   for (const [component, targetPath] of Object.entries(componentDirMap)) {
-    const componentDir = path36.join(kitInfo.path, component);
-    if (fs36.existsSync(componentDir) && fs36.statSync(componentDir).isDirectory()) {
+    const componentDir = path37.join(kitInfo.path, component);
+    if (fs37.existsSync(componentDir) && fs37.statSync(componentDir).isDirectory()) {
       placements.push({
         source: componentDir,
         destination: targetPath,
@@ -28846,8 +29689,8 @@ function getClaudeCodePlacementsFromProfile(kitInfo, profile) {
 }
 function collectAllFiles(kitInfo) {
   const files = /* @__PURE__ */ new Map();
-  const claudeMd = path36.join(kitInfo.path, "CLAUDE.md");
-  if (fs36.existsSync(claudeMd)) {
+  const claudeMd = path37.join(kitInfo.path, "CLAUDE.md");
+  if (fs37.existsSync(claudeMd)) {
     files.set("CLAUDE.md", claudeMd);
   }
   for (const [component, reconciliation] of Object.entries(
@@ -28857,15 +29700,15 @@ function collectAllFiles(kitInfo) {
     const missingSet = new Set(reconciliation.missing);
     for (const entry of reconciliation.declared) {
       if (missingSet.has(entry)) continue;
-      const relPath = isSkills ? path36.join(component, entry) : path36.join(component, `${entry}.md`);
-      files.set(relPath, path36.join(kitInfo.path, relPath));
+      const relPath = isSkills ? path37.join(component, entry) : path37.join(component, `${entry}.md`);
+      files.set(relPath, path37.join(kitInfo.path, relPath));
     }
   }
   return files;
 }
 function isSymlink2(p) {
   try {
-    return fs36.lstatSync(p).isSymbolicLink();
+    return fs37.lstatSync(p).isSymbolicLink();
   } catch {
     return false;
   }
@@ -28910,14 +29753,14 @@ async function runKitUpdateCommand(options, logger) {
 }
 
 // src/commands/list.ts
-import path37 from "path";
+import path38 from "path";
 function runListCommand(options, logger) {
   let searchPaths = [];
-  let directKitPath = options.kitPath ? path37.resolve(options.kitPath) : void 0;
+  let directKitPath = options.kitPath ? path38.resolve(options.kitPath) : void 0;
   try {
     const { config, configDir } = resolveConfig(options.config);
     searchPaths = config.kitSearchPaths ?? [
-      path37.join(configDir, "operating-kits")
+      path38.join(configDir, "operating-kits")
     ];
     directKitPath = directKitPath ?? config.kitPath;
   } catch (err) {
@@ -28992,7 +29835,7 @@ function withDirectKit(kits, directKitPath) {
     return kits;
   }
   const directKit = loadKit(directKitPath);
-  if (kits.some((kit) => path37.resolve(kit.path) === directKit.path)) {
+  if (kits.some((kit) => path38.resolve(kit.path) === directKit.path)) {
     return kits;
   }
   return [...kits, directKit];
@@ -29000,12 +29843,12 @@ function withDirectKit(kits, directKitPath) {
 
 // src/commands/probe.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import fs37 from "fs";
-import path38 from "path";
+import fs38 from "fs";
+import path39 from "path";
 function runProbeCommand(options, logger) {
   const { config, configDir, sourceRoot } = resolveRuntime(options, import.meta.url);
   const platformPaths = readYamlObject(
-    path38.join(
+    path39.join(
       resolveConfiguredPath(config.mappings, configDir, sourceRoot, "mappings"),
       "platform-paths.yaml"
     )
@@ -29039,12 +29882,12 @@ function toProbeRow(target, key, rawPath) {
   const resolved = resolveTargetPath(rawPath);
   let accessible = false;
   try {
-    fs37.accessSync(resolved);
+    fs38.accessSync(resolved);
     accessible = true;
   } catch {
     accessible = false;
   }
-  return { target, key, path: resolved, exists: fs37.existsSync(resolved), accessible };
+  return { target, key, path: resolved, exists: fs38.existsSync(resolved), accessible };
 }
 function codexRuntimeProbeRows() {
   const rows = commandProbeRows("codex", "binary", process.platform === "win32" ? "where.exe" : "which", ["codex"]);
@@ -29055,7 +29898,7 @@ function codexRuntimeProbeRows() {
     ["binary_snap", "/snap/bin/codex"],
     ["binary_flatpak", "/var/lib/flatpak/exports/bin/codex"]
   ]) {
-    if (fs37.existsSync(candidatePath)) {
+    if (fs38.existsSync(candidatePath)) {
       rows.push(toProbeRow("codex", key, candidatePath));
     }
   }
@@ -29071,8 +29914,8 @@ function commandProbeRows(target, key, command, args) {
 
 // src/commands/status.ts
 import crypto10 from "crypto";
-import fs38 from "fs";
-import path39 from "path";
+import fs39 from "fs";
+import path40 from "path";
 function runStatusCommand(options, logger) {
   const { config, configDir, sourceRoot } = resolveRuntime(
     options,
@@ -29151,21 +29994,21 @@ function classifyCodexFiles(config, sourceRoot, configDir) {
     rules: paths.rules
   };
   const rules = compileRules(
-    path39.join(sourceRoot, config.source.rules),
+    path40.join(sourceRoot, config.source.rules),
     "codex",
     mappings,
     createLossReport()
   );
-  const instructionsSource = fs38.readFileSync(path39.join(sourceRoot, config.source.instructions), "utf8").trim();
+  const instructionsSource = fs39.readFileSync(path40.join(sourceRoot, config.source.instructions), "utf8").trim();
   const composedInstructions = `${instructionsSource}
 
 --- tangyr managed rules ---
 ${rules.agentsAppendix}`.trim();
   const agentFiles = ts(
-    path39.join(sourceRoot, config.source.agents, "*.md")
+    path40.join(sourceRoot, config.source.agents, "*.md")
   ).sort();
-  const hooksSource = path39.join(sourceRoot, config.source.hooks, "hooks.json");
-  const mcpSource = path39.join(sourceRoot, config.source.mcp);
+  const hooksSource = path40.join(sourceRoot, config.source.hooks, "hooks.json");
+  const mcpSource = path40.join(sourceRoot, config.source.mcp);
   const ruleRows = rules.dotRulesFiles.length === 0 ? [
     {
       component: "rules",
@@ -29176,7 +30019,7 @@ ${rules.agentsAppendix}`.trim();
   ] : rules.dotRulesFiles.map(
     (ruleFile) => classifyCompiledFile(
       `rules/${ruleFile.name}`,
-      path39.join(resolveTargetPath(codexPaths.rules), ruleFile.name),
+      path40.join(resolveTargetPath(codexPaths.rules), ruleFile.name),
       "codex",
       void 0,
       config,
@@ -29194,10 +30037,10 @@ ${rules.agentsAppendix}`.trim();
     ),
     ...agentFiles.map(
       (agentFile) => classifyCompiledFile(
-        `agents/${path39.basename(agentFile, ".md")}`,
-        path39.join(
+        `agents/${path40.basename(agentFile, ".md")}`,
+        path40.join(
           resolveTargetPath(codexPaths.agents),
-          `${path39.basename(agentFile, ".md")}.toml`
+          `${path40.basename(agentFile, ".md")}.toml`
         ),
         "codex",
         computeSourceHash(agentFile),
@@ -29221,11 +30064,11 @@ ${rules.agentsAppendix}`.trim();
       config,
       sourceRoot
     ),
-    fs38.existsSync(hooksSource) ? classifyCodexHooksFile(resolveTargetPath(codexPaths.hooksSharedFile)) : notConfiguredRow(
+    fs39.existsSync(hooksSource) ? classifyCodexHooksFile(resolveTargetPath(codexPaths.hooksSharedFile)) : notConfiguredRow(
       "hooks",
       resolveTargetPath(codexPaths.hooksSharedFile)
     ),
-    fs38.existsSync(mcpSource) ? classifyCompiledFile(
+    fs39.existsSync(mcpSource) ? classifyCompiledFile(
       "mcp",
       resolveTargetPath(codexPaths.mcpSharedFile),
       "codex",
@@ -29245,7 +30088,7 @@ function classifyCodexHooksFile(filePath) {
       conformant: true
     };
   }
-  if (!fs38.existsSync(filePath)) {
+  if (!fs39.existsSync(filePath)) {
     return {
       component: "hooks",
       className: "missing",
@@ -29277,20 +30120,20 @@ function classifyCopilotFiles(config, sourceRoot, configDir) {
     mcpSharedFile: paths.mcp_shared_file
   };
   const agentFiles = ts(
-    path39.join(sourceRoot, config.source.agents, "*.md")
+    path40.join(sourceRoot, config.source.agents, "*.md")
   ).sort();
   const commandFiles = ts(
-    path39.join(sourceRoot, config.source.commands, "*.md")
+    path40.join(sourceRoot, config.source.commands, "*.md")
   ).sort();
-  const hooksSource = path39.join(sourceRoot, config.source.hooks, "hooks.json");
-  const mcpSource = path39.join(sourceRoot, config.source.mcp);
+  const hooksSource = path40.join(sourceRoot, config.source.hooks, "hooks.json");
+  const mcpSource = path40.join(sourceRoot, config.source.mcp);
   return [
     ...agentFiles.map(
       (agentFile) => classifyCompiledFile(
-        `agents/${path39.basename(agentFile, ".md")}`,
-        path39.join(
+        `agents/${path40.basename(agentFile, ".md")}`,
+        path40.join(
           resolveTargetPath(copilotPaths.agents),
-          `${path39.basename(agentFile, ".md")}.agent.md`
+          `${path40.basename(agentFile, ".md")}.agent.md`
         ),
         "copilot",
         computeSourceHash(agentFile),
@@ -29307,10 +30150,10 @@ function classifyCopilotFiles(config, sourceRoot, configDir) {
     ),
     ...commandFiles.map(
       (commandFile) => classifyCompiledFile(
-        `commands/${path39.basename(commandFile, ".md")}`,
-        path39.join(
+        `commands/${path40.basename(commandFile, ".md")}`,
+        path40.join(
           resolveTargetPath(copilotPaths.prompts),
-          `${path39.basename(commandFile, ".md")}.prompt.md`
+          `${path40.basename(commandFile, ".md")}.prompt.md`
         ),
         "copilot",
         computeSourceHash(commandFile),
@@ -29328,9 +30171,9 @@ function classifyCopilotFiles(config, sourceRoot, configDir) {
       config,
       sourceRoot
     ),
-    fs38.existsSync(hooksSource) ? classifyCompiledFile(
+    fs39.existsSync(hooksSource) ? classifyCompiledFile(
       "hooks",
-      path39.join(
+      path40.join(
         resolveTargetPath(copilotPaths.hooks),
         "tangyr-managed.json"
       ),
@@ -29340,12 +30183,12 @@ function classifyCopilotFiles(config, sourceRoot, configDir) {
       sourceRoot
     ) : notConfiguredRow(
       "hooks",
-      path39.join(
+      path40.join(
         resolveTargetPath(copilotPaths.hooks),
         "tangyr-managed.json"
       )
     ),
-    fs38.existsSync(mcpSource) ? classifyCompiledFile(
+    fs39.existsSync(mcpSource) ? classifyCompiledFile(
       "mcp",
       resolveTargetPath(copilotPaths.mcpSharedFile),
       "copilot",
@@ -29365,7 +30208,7 @@ function notConfiguredRow(component, filePath) {
 }
 function classifyDirectArtifact(artifact, config, sourceRoot) {
   const artifactClass = classifyArtifact(artifact.path, config, sourceRoot);
-  const sourcePath = artifact.sourceKey ? path39.resolve(sourceRoot, config.source[artifact.sourceKey]) : void 0;
+  const sourcePath = artifact.sourceKey ? path40.resolve(sourceRoot, config.source[artifact.sourceKey]) : void 0;
   if (artifactClass === "managed-symlink" && sourcePath && !isSymlinkCurrent(artifact.path, sourcePath)) {
     return {
       component: artifact.component,
@@ -29454,9 +30297,9 @@ function classifyClaudeSharedFiles(config, sourceRoot) {
     classifyHooks(settingsPath),
     classifySettings(
       settingsPath,
-      path39.resolve(sourceRoot, config.source.settings)
+      path40.resolve(sourceRoot, config.source.settings)
     ),
-    classifyMcp(claudeJsonPath, path39.resolve(sourceRoot, config.source.mcp))
+    classifyMcp(claudeJsonPath, path40.resolve(sourceRoot, config.source.mcp))
   ];
 }
 function classifyHooks(filePath) {
@@ -29520,14 +30363,14 @@ function classifyMcp(filePath, sourcePath) {
 }
 function isSymlinkCurrent(linkPath, sourcePath) {
   try {
-    return fs38.realpathSync(linkPath) === fs38.realpathSync(sourcePath);
+    return fs39.realpathSync(linkPath) === fs39.realpathSync(sourcePath);
   } catch {
     return false;
   }
 }
 function isCompiledCurrent6(filePath, sourcePath) {
   try {
-    const marker = extractProvenanceMarker(fs38.readFileSync(filePath, "utf8"));
+    const marker = extractProvenanceMarker(fs39.readFileSync(filePath, "utf8"));
     return marker?.hash === computeSourceHash(sourcePath) && marker.target === "claude-code";
   } catch {
     return false;
@@ -29557,7 +30400,7 @@ function classifyCompiledFile(component, filePath, target, expectedHash, config,
 }
 function readCompiledContent(filePath) {
   try {
-    return fs38.readFileSync(filePath, "utf8");
+    return fs39.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -30103,145 +30946,6 @@ function buildAgentsMdShim(shimPath, _agentsMdPath, target) {
 ${SHIM_BODY}`;
 }
 
-// src/compiler/hook-components.ts
-var import_yaml11 = __toESM(require_dist(), 1);
-import fs39 from "fs";
-import path40 from "path";
-function parseHookDeclaration(filePath) {
-  let raw;
-  try {
-    raw = fs39.readFileSync(filePath, "utf8");
-  } catch {
-    return null;
-  }
-  const fm = extractFrontmatter(raw);
-  if (!fm) {
-    return null;
-  }
-  const { name, description, events } = fm;
-  if (typeof name !== "string" || !name.trim()) {
-    return null;
-  }
-  if (typeof description !== "string" || !description.trim()) {
-    return null;
-  }
-  if (!Array.isArray(events) || events.length === 0) {
-    return null;
-  }
-  const parsedEvents = [];
-  for (const entry of events) {
-    if (!entry || typeof entry !== "object") {
-      return null;
-    }
-    const ev = entry;
-    if (typeof ev.event !== "string" || !ev.event.trim()) {
-      return null;
-    }
-    if (typeof ev.timeout !== "number") {
-      return null;
-    }
-    if (typeof ev.statusMessage !== "string" || !ev.statusMessage.trim()) {
-      return null;
-    }
-    const parsed = {
-      event: ev.event,
-      timeout: ev.timeout,
-      statusMessage: ev.statusMessage
-    };
-    if (typeof ev.matcher === "string" && ev.matcher.trim()) {
-      parsed.matcher = ev.matcher;
-    }
-    parsedEvents.push(parsed);
-  }
-  return {
-    name: name.trim(),
-    description: description.trim(),
-    events: parsedEvents
-  };
-}
-function hookCommand(name) {
-  return `npx tsx ~/.agents/hooks/scripts/${name}.ts`;
-}
-function synthesizeHooksJson(declarations) {
-  const hooks = {};
-  for (const decl of declarations) {
-    for (const ev of decl.events) {
-      if (!hooks[ev.event]) {
-        hooks[ev.event] = [];
-      }
-      const entry = {
-        hooks: [
-          {
-            type: "command",
-            command: hookCommand(decl.name),
-            timeout: ev.timeout,
-            statusMessage: ev.statusMessage
-          }
-        ]
-      };
-      if (ev.matcher !== void 0) {
-        const ordered = {
-          matcher: ev.matcher,
-          hooks: entry.hooks
-        };
-        hooks[ev.event].push(ordered);
-      } else {
-        hooks[ev.event].push(entry);
-      }
-    }
-  }
-  return { hooks };
-}
-function loadSourceHooks(hooksDir, hookNames) {
-  const hooksJsonPath = path40.join(hooksDir, "hooks.json");
-  if (fs39.existsSync(hooksJsonPath)) {
-    const raw = fs39.readFileSync(hooksJsonPath, "utf8");
-    return JSON.parse(raw);
-  }
-  const declarations = loadHookDeclarations(hooksDir, hookNames);
-  return synthesizeHooksJson(declarations);
-}
-function loadHookDeclarations(hooksDir, hookNames) {
-  let names;
-  if (hookNames && hookNames.length > 0) {
-    names = hookNames;
-  } else {
-    if (!fs39.existsSync(hooksDir) || !fs39.statSync(hooksDir).isDirectory()) {
-      return [];
-    }
-    names = fs39.readdirSync(hooksDir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).map((f) => f.slice(0, -3)).sort();
-  }
-  const declarations = [];
-  for (const name of names) {
-    const filePath = path40.join(hooksDir, `${name}.md`);
-    const decl = parseHookDeclaration(filePath);
-    if (decl) {
-      declarations.push(decl);
-    }
-  }
-  return declarations;
-}
-function extractFrontmatter(content) {
-  if (!content.startsWith("---\n")) {
-    return null;
-  }
-  const endIndex = content.indexOf("\n---", 4);
-  if (endIndex === -1) {
-    return null;
-  }
-  const rawFm = content.slice(4, endIndex);
-  let parsed;
-  try {
-    parsed = (0, import_yaml11.parse)(rawFm);
-  } catch {
-    return null;
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return null;
-  }
-  return parsed;
-}
-
 // src/adapters/claude-code.ts
 function buildDirectComponents(profile) {
   return [