@alessandroraffa/tangyr 0.21.0 → 0.21.2

package/dist/index.js

@@ -17874,8 +17874,8 @@ async function runCacheClearCommand(options, logger) {
 }
 
 // src/commands/cleanup.ts
-import fs25 from "fs";
-import path22 from "path";
+import fs27 from "fs";
+import path24 from "path";
 
 // node_modules/glob/dist/esm/index.min.js
 import { fileURLToPath as Wi } from "url";
@@ -21021,8 +21021,8 @@ function removeManagedEntries(filePath, parser, serializer, removeManaged, logge
 }
 
 // src/commands/uninstall.ts
-import fs24 from "fs";
-import path21 from "path";
+import fs26 from "fs";
+import path23 from "path";
 
 // src/core/managed-sources.ts
 var import_yaml5 = __toESM(require_dist(), 1);
@@ -21491,25 +21491,134 @@ function reportHooksSourceConflict(report, targets, hooksDir, hookNames) {
   return message;
 }
 
-// src/core/remove.ts
+// src/adapters/hook-scripts-bridge.ts
+import fs24 from "fs";
+import path22 from "path";
+
+// src/utils/fs.ts
 import fs23 from "fs";
+import path21 from "path";
+function ensureDir(dirPath) {
+  fs23.mkdirSync(dirPath, { recursive: true });
+}
+function createRelativeSymlink(source, destination, type, options) {
+  const absoluteSource = path21.resolve(source);
+  const relative = path21.relative(
+    realPathOrInput(path21.dirname(destination)),
+    absoluteSource
+  );
+  if (process.platform === "win32" && type === "dir") {
+    fs23.symlinkSync(absoluteSource, destination, "junction");
+    return;
+  }
+  if (process.platform === "win32" && type === "file") {
+    try {
+      fs23.symlinkSync(relative, destination, "file");
+    } catch (error) {
+      if (!hasErrorCode(error, "EPERM")) {
+        throw error;
+      }
+      if (!options?.provenanceMarker) {
+        throw new Error(
+          `${destination}: file symlink unavailable on Windows and no provenance marker was provided.`
+        );
+      }
+      createManagedCopy(
+        source,
+        destination,
+        options.provenanceMarker,
+        options.logger
+      );
+      options.logger?.warn(
+        `${destination}: file symlink unavailable on Windows \u2014 using managed copy with provenance metadata (behavioral contract C-09)`
+      );
+    }
+    return;
+  }
+  fs23.symlinkSync(relative, destination, type);
+}
+function createManagedCopy(source, destination, provenanceMarker, _logger) {
+  ensureDir(path21.dirname(destination));
+  const content = fs23.readFileSync(source, "utf8");
+  fs23.writeFileSync(destination, `${provenanceMarker}
+${content}`);
+}
+function hasErrorCode(error, expectedCode) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === expectedCode;
+}
+function realPathOrInput(filePath) {
+  try {
+    return fs23.realpathSync(filePath);
+  } catch {
+    return filePath;
+  }
+}
+
+// src/adapters/hook-scripts-bridge.ts
+var SHARED_HOOK_SCRIPTS_KEY = "shared/hook_scripts";
+function syncHookScriptsBridge(args) {
+  const { source, destination, config, sourceRoot, options, logger } = args;
+  if (!fs24.existsSync(source)) {
+    return {
+      component: "hooks",
+      status: "skipped",
+      path: `${source}: source not configured`
+    };
+  }
+  if (options.dryRun) {
+    logger.info(`[dry-run] hooks: symlink ${source} -> ${destination}`);
+    return { component: "hooks", status: "dry-run", path: destination };
+  }
+  const artifactClass = classifyArtifact(destination, config, sourceRoot);
+  if (artifactClass === "managed-symlink" && isSymlinkTo(destination, source)) {
+    return { component: "hooks", status: "skipped-current", path: destination };
+  }
+  if (artifactClass === "managed-stale" && isOurStaleSymlink(destination, /* @__PURE__ */ new Set([destination]), config)) {
+    fs24.unlinkSync(destination);
+  } else if (artifactClass === "unmanaged-conflict" && !args.onConflict()) {
+    return { component: "hooks", status: "conflict", path: destination };
+  } else if (artifactClass === "managed-symlink") {
+    fs24.unlinkSync(destination);
+  }
+  ensureDir(path22.dirname(destination));
+  createRelativeSymlink(source, destination, "dir");
+  if (args.manifest) {
+    addArtifactToManifest(args.manifest, {
+      relativePath: SHARED_HOOK_SCRIPTS_KEY,
+      hash: `dir:${source}`,
+      origin: "tangyr-managed"
+    });
+  }
+  return { component: "hooks", status: "success", path: destination };
+}
+function isSymlinkTo(linkPath, source) {
+  try {
+    return fs24.realpathSync(linkPath) === fs24.realpathSync(source);
+  } catch {
+    return false;
+  }
+}
+
+// src/core/remove.ts
+import fs25 from "fs";
 function removeManagedPath(managedPath) {
   let stat;
   try {
-    stat = fs23.lstatSync(managedPath);
+    stat = fs25.lstatSync(managedPath);
   } catch {
     return;
   }
   if (stat.isSymbolicLink() || stat.isFile()) {
-    fs23.unlinkSync(managedPath);
+    fs25.unlinkSync(managedPath);
     return;
   }
   if (stat.isDirectory()) {
-    fs23.rmSync(managedPath, { recursive: true, force: true });
+    fs25.rmSync(managedPath, { recursive: true, force: true });
   }
 }
 
 // src/commands/uninstall.ts
+var SHARED_ARTIFACT_TOOL = SHARED_HOOK_SCRIPTS_KEY.split("/")[0];
 var codexManagedMcpStart = "# tangyr: managed mcp start";
 var codexManagedMcpEnd = "# tangyr: managed mcp end";
 var legacyClaudeSharedPermission = "Read(~/.agents/**)";
@@ -21549,8 +21658,9 @@ async function runUninstallCommand(options, logger) {
     process.exit(1);
   }
   const selectedTools = resolveSelectedTools(options.tools, manifest, runtime);
+  const fullUninstall = isFullToolUninstall(manifest, selectedTools);
   const manifestArtifacts = manifest.artifacts.filter(
-    (file) => shouldRemoveManifestFile(file.relativePath, selectedTools)
+    (file) => shouldRemoveManifestFile(file.relativePath, selectedTools, fullUninstall)
   );
   const kitArtifacts = runtime ? resolveKitManagedArtifacts(
     runtime,
@@ -21613,7 +21723,7 @@ async function runUninstallCommand(options, logger) {
         runtime
       );
       for (const actualPath of paths) {
-        if (actualPath && (fs24.existsSync(actualPath) || isSymlink(actualPath))) {
+        if (actualPath && (fs26.existsSync(actualPath) || isSymlink(actualPath))) {
           removeManagedPath(actualPath);
           logger.verbose(`  removed: ${actualPath}`);
           removedCount++;
@@ -21627,7 +21737,7 @@ async function runUninstallCommand(options, logger) {
         scope,
         runtime
       );
-      if (actualPath && (fs24.existsSync(actualPath) || isSymlink(actualPath))) {
+      if (actualPath && (fs26.existsSync(actualPath) || isSymlink(actualPath))) {
         removeManagedPath(actualPath);
         logger.verbose(`  removed: ${actualPath}`);
         removedCount++;
@@ -21655,27 +21765,30 @@ async function runUninstallCommand(options, logger) {
       );
     }
   }
-  const fullUninstall = isFullToolUninstall(manifest, selectedTools);
   if (fullUninstall) {
     for (const backup of manifest.backups) {
       restoreBackup(backup, logger);
     }
-    const manifestPath = path21.join(scopePath, "manifest.json");
-    if (fs24.existsSync(manifestPath)) {
-      fs24.unlinkSync(manifestPath);
+    const manifestPath = path23.join(scopePath, "manifest.json");
+    if (fs26.existsSync(manifestPath)) {
+      fs26.unlinkSync(manifestPath);
       logger.verbose(`  removed manifest: ${manifestPath}`);
     }
     try {
-      const remaining = fs24.readdirSync(scopePath);
+      const remaining = fs26.readdirSync(scopePath);
       if (remaining.length === 0) {
-        fs24.rmdirSync(scopePath);
+        fs26.rmdirSync(scopePath);
         logger.verbose(`  removed empty scope directory: ${scopePath}`);
       }
     } catch {
     }
   } else if (manifestWasPresent) {
     manifest.artifacts = manifest.artifacts.filter(
-      (file) => !shouldRemoveManifestFile(file.relativePath, selectedTools)
+      (file) => !shouldRemoveManifestFile(
+        file.relativePath,
+        selectedTools,
+        fullUninstall
+      )
     );
     manifest.tools = manifest.tools.filter((tool) => !selectedTools.has(tool));
     writeManifest(scopePath, manifest);
@@ -21694,6 +21807,12 @@ function resolveManifestKeyToPath(key, scope, runtime) {
   const [tool, ...rest] = parts;
   const component = rest.join("/");
   const projectRoot = scope === "project" ? process.cwd() : void 0;
+  if (tool === SHARED_ARTIFACT_TOOL) {
+    if (component === "hook_scripts") {
+      return resolveSharedHookScriptsPath(runtime, scope, projectRoot);
+    }
+    return null;
+  }
   if (tool === "claude-code") {
     const claudePaths = resolveClaudeCodePaths(runtime, scope, projectRoot);
     if (!claudePaths) {
@@ -21708,7 +21827,7 @@ function resolveManifestKeyToPath(key, scope, runtime) {
     if (!slotPath) {
       return null;
     }
-    return subPath ? path21.join(slotPath, subPath) : slotPath;
+    return subPath ? path23.join(slotPath, subPath) : slotPath;
   }
   if (tool === "copilot") {
     const copilotPaths = resolveCopilotPaths(runtime, scope, projectRoot);
@@ -21716,20 +21835,23 @@ function resolveManifestKeyToPath(key, scope, runtime) {
       return copilotPaths.skills;
     }
     if (component.startsWith("agents/")) {
-      return path21.join(copilotPaths.agents, component.slice("agents/".length));
+      return path23.join(copilotPaths.agents, component.slice("agents/".length));
     }
     if (component.startsWith("prompts/")) {
-      return path21.join(
+      return path23.join(
         copilotPaths.prompts,
         component.slice("prompts/".length)
       );
     }
     if (component.startsWith("hooks/")) {
-      return path21.join(copilotPaths.hooks, component.slice("hooks/".length));
+      return path23.join(copilotPaths.hooks, component.slice("hooks/".length));
     }
-    if (component === path21.basename(copilotPaths.mcpSharedFile)) {
+    if (component === path23.basename(copilotPaths.mcpSharedFile)) {
       return copilotPaths.mcpSharedFile;
     }
+    if (copilotPaths.instructions !== null && component === path23.basename(copilotPaths.instructions)) {
+      return copilotPaths.instructions;
+    }
     return null;
   }
   if (tool === "codex") {
@@ -21741,15 +21863,15 @@ function resolveManifestKeyToPath(key, scope, runtime) {
       return codexPaths.skills;
     }
     if (component.startsWith("agents/")) {
-      return path21.join(codexPaths.agents, component.slice("agents/".length));
+      return path23.join(codexPaths.agents, component.slice("agents/".length));
     }
     if (component.startsWith("rules/")) {
-      return path21.join(codexPaths.rules, component.slice("rules/".length));
+      return path23.join(codexPaths.rules, component.slice("rules/".length));
     }
-    if (component === path21.basename(codexPaths.hooksSharedFile)) {
+    if (component === path23.basename(codexPaths.hooksSharedFile)) {
       return codexPaths.hooksSharedFile;
     }
-    if (component === path21.basename(codexPaths.mcpSharedFile)) {
+    if (component === path23.basename(codexPaths.mcpSharedFile)) {
       return codexPaths.mcpSharedFile;
     }
     return null;
@@ -21766,15 +21888,15 @@ function resolveManifestKeyToPath(key, scope, runtime) {
       return opencodePaths.skillsShared;
     }
     if (component.startsWith("agents/")) {
-      return path21.join(opencodePaths.agents, component.slice("agents/".length));
+      return path23.join(opencodePaths.agents, component.slice("agents/".length));
     }
     if (component.startsWith("commands/")) {
-      return path21.join(
+      return path23.join(
         opencodePaths.commands,
         component.slice("commands/".length)
       );
     }
-    if (component === path21.basename(opencodePaths.configDoc)) {
+    if (component === path23.basename(opencodePaths.configDoc)) {
       return opencodePaths.configDoc;
     }
     return null;
@@ -21800,13 +21922,13 @@ function resolveManifestKeyToPath(key, scope, runtime) {
       return cursorPaths.permissionsFile;
     }
     if (component.startsWith("agents/")) {
-      return path21.join(cursorPaths.agents, component.slice("agents/".length));
+      return path23.join(cursorPaths.agents, component.slice("agents/".length));
     }
     if (component.startsWith("rules/")) {
-      return path21.join(cursorPaths.rules, component.slice("rules/".length));
+      return path23.join(cursorPaths.rules, component.slice("rules/".length));
     }
     if (component.startsWith("skills/")) {
-      return path21.join(cursorPaths.skills, component.slice("skills/".length));
+      return path23.join(cursorPaths.skills, component.slice("skills/".length));
     }
     return null;
   }
@@ -21822,10 +21944,10 @@ function resolveManifestKeyToPath(key, scope, runtime) {
       return clinePaths.mcpFile;
     }
     if (component.startsWith("rules/")) {
-      return path21.join(clinePaths.rules, component.slice("rules/".length));
+      return path23.join(clinePaths.rules, component.slice("rules/".length));
     }
     if (component.startsWith("workflows/")) {
-      return path21.join(
+      return path23.join(
         clinePaths.workflows,
         component.slice("workflows/".length)
       );
@@ -21859,22 +21981,22 @@ function resolveClaudeCodePaths(runtime, scope, projectRoot) {
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
   if (scope === "global") {
     return {
-      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")
+      instructions: path23.join(home, ".claude", "CLAUDE.md"),
+      agents: path23.join(home, ".claude", "agents"),
+      skills: path23.join(home, ".claude", "skills"),
+      commands: path23.join(home, ".claude", "commands"),
+      rules: path23.join(home, ".claude", "rules"),
+      output_styles: path23.join(home, ".claude", "output-styles")
     };
   }
   const root = projectRoot ?? process.cwd();
   return {
-    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")
+    instructions: path23.join(root, "CLAUDE.md"),
+    agents: path23.join(root, ".claude", "agents"),
+    skills: path23.join(root, ".claude", "skills"),
+    commands: path23.join(root, ".claude", "commands"),
+    rules: path23.join(root, ".claude", "rules"),
+    output_styles: path23.join(root, ".claude", "output-styles")
   };
 }
 function resolveClaudeRootsForUninstall(manifest, runtime) {
@@ -21893,12 +22015,12 @@ function resolveClaudeRootsForUninstall(manifest, runtime) {
         projectRoot: void 0,
         mappings: mappings.platformPaths
       })["claude-code"];
-      return [path21.dirname(profile.agents)];
+      return [path23.dirname(profile.agents)];
     } catch {
     }
   }
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return [path21.resolve(expandHome(`${home}/.claude`))];
+  return [path23.resolve(expandHome(`${home}/.claude`))];
 }
 function resolveAllClaudeRoots(manifest, runtime, claudeConfigDirs) {
   const home = process.env.HOME ?? process.env.USERPROFILE;
@@ -21910,13 +22032,13 @@ function resolveAllClaudeRoots(manifest, runtime, claudeConfigDirs) {
         env: process.env.TANGYR_CLAUDE_CONFIG_DIRS,
         config: runtime.config.claudeCodeGlobalPaths
       })
-    ].map((root) => path21.resolve(root))
+    ].map((root) => path23.resolve(root))
   );
-  if (home && fs24.existsSync(home)) {
+  if (home && fs26.existsSync(home)) {
     try {
-      for (const entry of fs24.readdirSync(home, { withFileTypes: true })) {
+      for (const entry of fs26.readdirSync(home, { withFileTypes: true })) {
         if (entry.isDirectory() && entry.name.startsWith(".claude-")) {
-          roots.add(path21.resolve(home, entry.name));
+          roots.add(path23.resolve(home, entry.name));
         }
       }
     } catch {
@@ -21935,13 +22057,13 @@ function resolveManifestKeyToMultiPaths(key, claudeRoots, runtime) {
   const rootsToResolve = isShared ? [claudeRoots[0]] : claudeRoots;
   if (!runtime) {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    const defaultRoot = path21.resolve(expandHome(`${home}/.claude`));
+    const defaultRoot = path23.resolve(expandHome(`${home}/.claude`));
     return rootsToResolve.flatMap((root) => {
       const hardcoded = resolveHardcodedClaudeSlot(root, defaultRoot, slotName);
       if (!hardcoded) {
         return [];
       }
-      return [subPath ? path21.join(hardcoded, subPath) : hardcoded];
+      return [subPath ? path23.join(hardcoded, subPath) : hardcoded];
     });
   }
   try {
@@ -21960,17 +22082,17 @@ function resolveManifestKeyToMultiPaths(key, claudeRoots, runtime) {
       if (!slotPath) {
         return [];
       }
-      return [subPath ? path21.join(slotPath, subPath) : slotPath];
+      return [subPath ? path23.join(slotPath, subPath) : slotPath];
     });
   } catch {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    const defaultRoot = path21.resolve(expandHome(`${home}/.claude`));
+    const defaultRoot = path23.resolve(expandHome(`${home}/.claude`));
     return rootsToResolve.flatMap((root) => {
       const hardcoded = resolveHardcodedClaudeSlot(root, defaultRoot, slotName);
       if (!hardcoded) {
         return [];
       }
-      return [subPath ? path21.join(hardcoded, subPath) : hardcoded];
+      return [subPath ? path23.join(hardcoded, subPath) : hardcoded];
     });
   }
 }
@@ -21993,9 +22115,9 @@ function resolveHardcodedClaudeSlot(root, defaultRoot, slotName) {
     return null;
   }
   if (root === defaultRoot) {
-    return path21.join(root, relative);
+    return path23.join(root, relative);
   }
-  return path21.join(root, relative);
+  return path23.join(root, relative);
 }
 function resolveRuntimeIfAvailable(options, logger) {
   try {
@@ -22024,8 +22146,11 @@ function resolveSelectedTools(rawTools, manifest, runtime) {
   }
   return selectedTools;
 }
-function shouldRemoveManifestFile(relativePath, selectedTools) {
+function shouldRemoveManifestFile(relativePath, selectedTools, isFullUninstall) {
   const tool = relativePath.split("/")[0];
+  if (tool === SHARED_ARTIFACT_TOOL) {
+    return isFullUninstall;
+  }
   return selectedTools.has(tool);
 }
 function isFullToolUninstall(manifest, selectedTools) {
@@ -22041,7 +22166,7 @@ function addCompiledGlobPlans(artifacts, pattern, expectedTarget, component) {
   for (const artifactPath of ts(pattern).sort()) {
     let marker = null;
     try {
-      marker = extractProvenanceMarker(fs24.readFileSync(artifactPath, "utf8"));
+      marker = extractProvenanceMarker(fs26.readFileSync(artifactPath, "utf8"));
     } catch {
       continue;
     }
@@ -22061,12 +22186,12 @@ function addCompiledGlobPlans(artifacts, pattern, expectedTarget, component) {
 function addManagedSymlinkChildren(artifacts, directory, runtime, component) {
   let entries;
   try {
-    entries = fs24.readdirSync(directory, { withFileTypes: true });
+    entries = fs26.readdirSync(directory, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const artifactPath = path21.join(directory, entry.name);
+    const artifactPath = path23.join(directory, entry.name);
     const artifactClass = classifyArtifact(
       artifactPath,
       runtime.config,
@@ -22105,8 +22230,8 @@ function collectStringValuesByKey(value, keyName, values) {
 }
 function addLegacyOperatingGuideCopies(artifacts, claudeRoot) {
   for (const artifactPath of [
-    ...ts(path21.join(claudeRoot, "CLAUDE.md.bak.*")),
-    ...ts(path21.join(claudeRoot, "AGENTS.md.bak.*"))
+    ...ts(path23.join(claudeRoot, "CLAUDE.md.bak.*")),
+    ...ts(path23.join(claudeRoot, "AGENTS.md.bak.*"))
   ].sort()) {
     artifacts.push({
       component: "claude-code legacy operating guide backup",
@@ -22160,7 +22285,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
       for (const skill of runtime.kitInfo.components.skills.declared) {
         artifacts.push({
           component: "claude-code skill",
-          path: path21.join(profile.skills, skill),
+          path: path23.join(profile.skills, skill),
           kind: "direct"
         });
       }
@@ -22179,7 +22304,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
       if (isFullToolUninstall(manifest, selectedTools)) {
         addLegacyOperatingGuideCopies(
           artifacts,
-          path21.dirname(profile.instructions)
+          path23.dirname(profile.instructions)
         );
       }
     }
@@ -22202,20 +22327,20 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
   if (selectedTools.has("copilot")) {
     addCompiledGlobPlans(
       artifacts,
-      path21.join(copilotPaths.agents, "*.agent.md"),
+      path23.join(copilotPaths.agents, "*.agent.md"),
       "copilot",
       "copilot agent residue"
     );
     addCompiledGlobPlans(
       artifacts,
-      path21.join(copilotPaths.prompts, "*.prompt.md"),
+      path23.join(copilotPaths.prompts, "*.prompt.md"),
       "copilot",
       "copilot prompt residue"
     );
     for (const agentEntry of runtime.kitInfo.components.agents.declared) {
       artifacts.push({
         component: "copilot agent",
-        path: path21.join(copilotPaths.agents, `${agentEntry}.agent.md`),
+        path: path23.join(copilotPaths.agents, `${agentEntry}.agent.md`),
         kind: "compiled",
         expectedTarget: "copilot",
         expectedSource: `agents/${agentEntry}.md`
@@ -22224,7 +22349,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
     for (const commandEntry of runtime.kitInfo.components.commands.declared) {
       artifacts.push({
         component: "copilot prompt",
-        path: path21.join(copilotPaths.prompts, `${commandEntry}.prompt.md`),
+        path: path23.join(copilotPaths.prompts, `${commandEntry}.prompt.md`),
         kind: "compiled",
         expectedTarget: "copilot",
         expectedSource: `commands/${commandEntry}.md`
@@ -22240,13 +22365,13 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
     artifacts.push(
       {
         component: "copilot hooks",
-        path: path21.join(copilotPaths.hooks, "tangyr-managed.json"),
+        path: path23.join(copilotPaths.hooks, "tangyr-managed.json"),
         kind: "managed-json",
         expectedTarget: "copilot"
       },
       {
         component: "copilot legacy hooks",
-        path: path21.join(copilotPaths.hooks, "proteus-managed.json"),
+        path: path23.join(copilotPaths.hooks, "proteus-managed.json"),
         kind: "managed-json",
         expectedTarget: "copilot"
       }
@@ -22255,7 +22380,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
     if (hooksSourceExists(runtime.sourceRoot, runtime.config)) {
       artifacts.push({
         component: "copilot hooks",
-        path: path21.join(copilotPaths.hooks, "tangyr-managed.json"),
+        path: path23.join(copilotPaths.hooks, "tangyr-managed.json"),
         kind: "compiled",
         expectedTarget: "copilot",
         expectedSource: hooksSource
@@ -22266,7 +22391,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
       runtime.config
     );
     const mcpSource = mcpSourceLabel(runtime.config);
-    if (fs24.existsSync(mcpSourcePath)) {
+    if (fs26.existsSync(mcpSourcePath)) {
       artifacts.push({
         component: "copilot mcp",
         path: copilotPaths.mcpSharedFile,
@@ -22285,13 +22410,13 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
     );
     addCompiledGlobPlans(
       artifacts,
-      path21.join(codexPaths.agents, "*.toml"),
+      path23.join(codexPaths.agents, "*.toml"),
       "codex",
       "codex agent residue"
     );
     addCompiledGlobPlans(
       artifacts,
-      path21.join(codexPaths.rules, "*.rules"),
+      path23.join(codexPaths.rules, "*.rules"),
       "codex",
       "codex rule residue"
     );
@@ -22305,7 +22430,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
     for (const agentEntry of runtime.kitInfo.components.agents.declared) {
       artifacts.push({
         component: "codex agent",
-        path: path21.join(codexPaths.agents, `${agentEntry}.toml`),
+        path: path23.join(codexPaths.agents, `${agentEntry}.toml`),
         kind: "compiled",
         expectedTarget: "codex",
         expectedSource: `agents/${agentEntry}.md`
@@ -22314,7 +22439,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
     for (const ruleEntry of runtime.kitInfo.components.rules.declared) {
       artifacts.push({
         component: "codex rule",
-        path: path21.join(codexPaths.rules, `${ruleEntry}.rules`),
+        path: path23.join(codexPaths.rules, `${ruleEntry}.rules`),
         kind: "compiled",
         expectedTarget: "codex",
         expectedSource: `rules/${ruleEntry}.md`
@@ -22341,7 +22466,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
       runtime.config
     );
     const mcpSource = mcpSourceLabel(runtime.config);
-    if (fs24.existsSync(mcpSourcePath)) {
+    if (fs26.existsSync(mcpSourcePath)) {
       artifacts.push({
         component: "codex mcp",
         path: codexPaths.mcpSharedFile,
@@ -22366,13 +22491,13 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
     );
     addCompiledGlobPlans(
       artifacts,
-      path21.join(opencodePaths.agents, "*.md"),
+      path23.join(opencodePaths.agents, "*.md"),
       "opencode",
       "opencode agent residue"
     );
     addCompiledGlobPlans(
       artifacts,
-      path21.join(opencodePaths.commands, "*.md"),
+      path23.join(opencodePaths.commands, "*.md"),
       "opencode",
       "opencode command residue"
     );
@@ -22391,7 +22516,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
     for (const agentEntry of runtime.kitInfo.components.agents.declared) {
       artifacts.push({
         component: "opencode agent",
-        path: path21.join(opencodePaths.agents, `${agentEntry}.md`),
+        path: path23.join(opencodePaths.agents, `${agentEntry}.md`),
         kind: "compiled",
         expectedTarget: "opencode",
         expectedSource: `agents/${agentEntry}.md`
@@ -22400,7 +22525,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
     for (const commandEntry of runtime.kitInfo.components.commands.declared) {
       artifacts.push({
         component: "opencode command",
-        path: path21.join(opencodePaths.commands, `${commandEntry}.md`),
+        path: path23.join(opencodePaths.commands, `${commandEntry}.md`),
         kind: "compiled",
         expectedTarget: "opencode",
         expectedSource: `commands/${commandEntry}.md`
@@ -22418,7 +22543,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
       runtime.config
     );
     const mcpSource = mcpSourceLabel(runtime.config);
-    if (fs24.existsSync(mcpSourcePath)) {
+    if (fs26.existsSync(mcpSourcePath)) {
       artifacts.push({
         component: "opencode config",
         path: opencodePaths.configDoc,
@@ -22455,19 +22580,19 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
     );
     addCompiledGlobPlans(
       artifacts,
-      path21.join(cursorPaths.agents, "*.md"),
+      path23.join(cursorPaths.agents, "*.md"),
       "cursor",
       "cursor agent residue"
     );
     addCompiledGlobPlans(
       artifacts,
-      path21.join(cursorPaths.rules, "*.mdc"),
+      path23.join(cursorPaths.rules, "*.mdc"),
       "cursor",
       "cursor rule residue"
     );
     addCompiledGlobPlans(
       artifacts,
-      path21.join(cursorPaths.skills, "*", "SKILL.md"),
+      path23.join(cursorPaths.skills, "*", "SKILL.md"),
       "cursor",
       "cursor command residue"
     );
@@ -22481,7 +22606,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
     for (const agentEntry of runtime.kitInfo.components.agents.declared) {
       artifacts.push({
         component: "cursor agent",
-        path: path21.join(cursorPaths.agents, `${agentEntry}.md`),
+        path: path23.join(cursorPaths.agents, `${agentEntry}.md`),
         kind: "compiled",
         expectedTarget: "cursor",
         expectedSource: `agents/${agentEntry}.md`
@@ -22499,7 +22624,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
       runtime.config
     );
     const mcpSource = mcpSourceLabel(runtime.config);
-    if (fs24.existsSync(mcpSourcePath)) {
+    if (fs26.existsSync(mcpSourcePath)) {
       artifacts.push({
         component: "cursor mcp",
         path: cursorPaths.mcpFile,
@@ -22518,13 +22643,13 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
     );
     addCompiledGlobPlans(
       artifacts,
-      path21.join(clinePaths.rules, "*.md"),
+      path23.join(clinePaths.rules, "*.md"),
       "cline",
       "cline rule residue"
     );
     addCompiledGlobPlans(
       artifacts,
-      path21.join(clinePaths.workflows, "*.md"),
+      path23.join(clinePaths.workflows, "*.md"),
       "cline",
       "cline workflow residue"
     );
@@ -22552,7 +22677,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
     for (const ruleEntry of runtime.kitInfo.components.rules.declared) {
       artifacts.push({
         component: "cline rule",
-        path: path21.join(clinePaths.rules, `${ruleEntry}.md`),
+        path: path23.join(clinePaths.rules, `${ruleEntry}.md`),
         kind: "compiled",
         expectedTarget: "cline",
         expectedSource: `rules/${ruleEntry}.md`
@@ -22561,7 +22686,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
     for (const commandEntry of runtime.kitInfo.components.commands.declared) {
       artifacts.push({
         component: "cline workflow",
-        path: path21.join(clinePaths.workflows, `${commandEntry}.md`),
+        path: path23.join(clinePaths.workflows, `${commandEntry}.md`),
         kind: "compiled",
         expectedTarget: "cline",
         expectedSource: `commands/${commandEntry}.md`
@@ -22579,7 +22704,7 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
       runtime.config
     );
     const mcpSource = mcpSourceLabel(runtime.config);
-    if (fs24.existsSync(mcpSourcePath)) {
+    if (fs26.existsSync(mcpSourcePath)) {
       artifacts.push({
         component: "cline mcp",
         path: clinePaths.mcpFile,
@@ -22603,8 +22728,9 @@ function resolveKitManagedArtifacts(runtime, scope, selectedTools, manifest, cla
   return dedupeArtifacts(artifacts);
 }
 function addRecordedManifestPlans(artifacts, manifest, selectedTools, runtime) {
+  const fullUninstall = isFullToolUninstall(manifest, selectedTools);
   for (const file of manifest.artifacts) {
-    if (file.origin !== "tangyr-managed" || !shouldRemoveManifestFile(file.relativePath, selectedTools)) {
+    if (file.origin !== "tangyr-managed" || !shouldRemoveManifestFile(file.relativePath, selectedTools, fullUninstall)) {
       continue;
     }
     const artifactPath = resolveManifestKeyToPath(
@@ -22661,12 +22787,12 @@ function isKitManagedArtifact(artifact, runtime) {
     return artifactClass === "managed-symlink" || artifactClass === "managed-stale" || artifactClass === "managed-compiled";
   }
   if (artifact.kind === "compiled") {
-    if (!fs24.existsSync(artifact.path)) {
+    if (!fs26.existsSync(artifact.path)) {
       return false;
     }
     try {
       const marker = extractProvenanceMarker(
-        fs24.readFileSync(artifact.path, "utf8")
+        fs26.readFileSync(artifact.path, "utf8")
       );
       return marker?.target === artifact.expectedTarget && marker?.source === artifact.expectedSource;
     } catch {
@@ -22674,7 +22800,7 @@ function isKitManagedArtifact(artifact, runtime) {
     }
   }
   if (artifact.kind === "recorded") {
-    return fs24.existsSync(artifact.path) || isSymlink(artifact.path);
+    return fs26.existsSync(artifact.path) || isSymlink(artifact.path);
   }
   if (artifact.kind === "kit-pointer") {
     return isKitPointer(artifact);
@@ -22683,11 +22809,11 @@ function isKitManagedArtifact(artifact, runtime) {
     return isLegacyOperatingGuideCopy(artifact.path);
   }
   if (artifact.kind === "codex-mcp") {
-    if (!fs24.existsSync(artifact.path)) {
+    if (!fs26.existsSync(artifact.path)) {
       return false;
     }
     const section = readManagedTomlSection(
-      fs24.readFileSync(artifact.path, "utf8")
+      fs26.readFileSync(artifact.path, "utf8")
     );
     const marker = section ? extractProvenanceMarker(section) : null;
     return marker?.target === artifact.expectedTarget && marker?.source === artifact.expectedSource;
@@ -22713,16 +22839,16 @@ function isKitManagedArtifact(artifact, runtime) {
   return hasManagedCodexHooks(parsed, artifact.expectedSource);
 }
 function removeManagedCompiledArtifact(artifact, logger) {
-  if (!fs24.existsSync(artifact.path)) {
+  if (!fs26.existsSync(artifact.path)) {
     return false;
   }
   const marker = extractProvenanceMarker(
-    fs24.readFileSync(artifact.path, "utf8")
+    fs26.readFileSync(artifact.path, "utf8")
   );
   if (marker?.target !== artifact.expectedTarget || marker?.source !== artifact.expectedSource) {
     return false;
   }
-  fs24.rmSync(artifact.path, { force: true });
+  fs26.rmSync(artifact.path, { force: true });
   logger.verbose(`  removed ${artifact.component}: ${artifact.path}`);
   return true;
 }
@@ -22793,12 +22919,12 @@ function removeManagedJsonArtifact(artifact, logger) {
   if (!parsed || !hasManagedRootMetadata(parsed, artifact.expectedTarget)) {
     return false;
   }
-  fs24.rmSync(artifact.path, { force: true });
+  fs26.rmSync(artifact.path, { force: true });
   logger.verbose(`  removed ${artifact.component}: ${artifact.path}`);
   return true;
 }
 function removeRecordedArtifact(artifact, logger) {
-  if (!fs24.existsSync(artifact.path) && !isSymlink(artifact.path)) {
+  if (!fs26.existsSync(artifact.path) && !isSymlink(artifact.path)) {
     return false;
   }
   removeManagedPath(artifact.path);
@@ -22806,10 +22932,10 @@ function removeRecordedArtifact(artifact, logger) {
   return true;
 }
 function removeExactManagedFile(artifact, logger) {
-  if (!fs24.existsSync(artifact.path)) {
+  if (!fs26.existsSync(artifact.path)) {
     return false;
   }
-  fs24.rmSync(artifact.path, { force: true });
+  fs26.rmSync(artifact.path, { force: true });
   logger.verbose(`  removed ${artifact.component}: ${artifact.path}`);
   return true;
 }
@@ -22843,10 +22969,10 @@ function removeManagedCodexHooksArtifact(artifact, logger) {
   return true;
 }
 function removeManagedCodexMcpArtifact(artifact, logger) {
-  if (!fs24.existsSync(artifact.path)) {
+  if (!fs26.existsSync(artifact.path)) {
     return false;
   }
-  const content = fs24.readFileSync(artifact.path, "utf8");
+  const content = fs26.readFileSync(artifact.path, "utf8");
   const managedSection = readManagedTomlSection(content);
   if (!managedSection) {
     return false;
@@ -22861,9 +22987,9 @@ function removeManagedCodexMcpArtifact(artifact, logger) {
     codexManagedMcpEnd
   );
   if (cleaned.trim().length === 0) {
-    fs24.rmSync(artifact.path, { force: true });
+    fs26.rmSync(artifact.path, { force: true });
   } else {
-    fs24.writeFileSync(artifact.path, cleaned);
+    fs26.writeFileSync(artifact.path, cleaned);
   }
   logger.verbose(`  removed ${artifact.component}: ${artifact.path}`);
   return true;
@@ -22886,12 +23012,26 @@ function resolveCopilotPaths(runtime, scope = "global", projectRoot) {
         prompts: profile.prompts,
         skills: profile.skills,
         hooks: profile.hooks,
-        mcpSharedFile: profile.mcp_shared_file
+        mcpSharedFile: profile.mcp_shared_file,
+        instructions: profile.instructions
       };
     } catch {
     }
   }
+  if (scope === "project") {
+    const root = projectRoot ?? process.cwd();
+    return {
+      instructions: path23.join(root, ".github", "copilot-instructions.md"),
+      agents: path23.join(root, ".github", "agents"),
+      prompts: path23.join(root, ".github", "prompts"),
+      skills: path23.join(root, ".github", "skills"),
+      hooks: path23.join(root, ".github", "hooks"),
+      mcpSharedFile: path23.join(root, ".vscode", "mcp.json")
+    };
+  }
   return {
+    // null, because Copilot's instructions surface exists only in a project.
+    instructions: null,
     agents: resolveTargetPath("$VSCODE_USER_DATA/agents"),
     prompts: resolveTargetPath("$VSCODE_USER_DATA/prompts"),
     skills: resolveTargetPath("~/.copilot/skills"),
@@ -22923,6 +23063,17 @@ function resolveCodexPaths(runtime, scope = "global", projectRoot) {
     } catch {
     }
   }
+  if (scope === "project") {
+    const root = projectRoot ?? process.cwd();
+    return {
+      instructions: path23.join(root, "AGENTS.md"),
+      agents: path23.join(root, ".codex", "agents"),
+      rules: path23.join(root, ".codex", "rules"),
+      skills: path23.join(root, ".codex", "skills"),
+      hooksSharedFile: path23.join(root, ".codex", "hooks.json"),
+      mcpSharedFile: path23.join(root, ".codex", "config.toml")
+    };
+  }
   return {
     instructions: resolveTargetPath("~/.codex/AGENTS.md"),
     agents: resolveTargetPath("~/.codex/agents"),
@@ -22932,6 +23083,27 @@ function resolveCodexPaths(runtime, scope = "global", projectRoot) {
     mcpSharedFile: resolveTargetPath("~/.codex/config.toml")
   };
 }
+function resolveSharedHookScriptsPath(runtime, scope, projectRoot) {
+  if (runtime) {
+    try {
+      const mappings = loadMappings(
+        runtime.sourceRoot,
+        runtime.config,
+        runtime.configDir
+      );
+      return resolveTargetPaths({
+        scope,
+        projectRoot,
+        mappings: mappings.platformPaths
+      }).codex.hook_scripts;
+    } catch {
+    }
+  }
+  if (scope === "project") {
+    return path23.join(projectRoot ?? process.cwd(), ".agents", "hooks");
+  }
+  return resolveTargetPath("~/.agents/hooks");
+}
 function resolveOpenCodePaths(runtime, scope = "global", projectRoot) {
   if (runtime) {
     try {
@@ -23056,11 +23228,11 @@ function managedArtifactPlanPriority(artifact) {
   return 2;
 }
 function readJsonObject2(filePath) {
-  if (!fs24.existsSync(filePath)) {
+  if (!fs26.existsSync(filePath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(fs24.readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(fs26.readFileSync(filePath, "utf8"));
     return isRecord(parsed) ? parsed : null;
   } catch {
     return null;
@@ -23108,22 +23280,22 @@ function removeLegacyClaudeSharedPermission(value) {
   return Object.keys(cleaned).length === 0 ? void 0 : cleaned;
 }
 function isKitPointer(artifact) {
-  if (!artifact.expectedPath || !fs24.existsSync(artifact.path)) {
+  if (!artifact.expectedPath || !fs26.existsSync(artifact.path)) {
     return false;
   }
   try {
-    const recordedPath = fs24.readFileSync(artifact.path, "utf8").trim();
-    return recordedPath.length > 0 && path21.resolve(recordedPath) === path21.resolve(artifact.expectedPath);
+    const recordedPath = fs26.readFileSync(artifact.path, "utf8").trim();
+    return recordedPath.length > 0 && path23.resolve(recordedPath) === path23.resolve(artifact.expectedPath);
   } catch {
     return false;
   }
 }
 function isLegacyOperatingGuideCopy(filePath) {
-  if (!fs24.existsSync(filePath)) {
+  if (!fs26.existsSync(filePath)) {
     return false;
   }
   try {
-    return fs24.readFileSync(filePath, "utf8").startsWith(legacyOperatingGuideSignature);
+    return fs26.readFileSync(filePath, "utf8").startsWith(legacyOperatingGuideSignature);
   } catch {
     return false;
   }
@@ -23145,10 +23317,10 @@ function matchesManagedMetadata(metadata, artifact) {
 }
 function writeJsonOrRemove(filePath, parsed) {
   if (isEmptyJsonValue(parsed)) {
-    fs24.rmSync(filePath, { force: true });
+    fs26.rmSync(filePath, { force: true });
     return;
   }
-  fs24.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
+  fs26.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
 `);
 }
 function isEmptyJsonValue(value) {
@@ -23274,20 +23446,20 @@ function removeDelimitedManagedSection(content, startMarker, endMarker) {
   return `${content.slice(0, start)}${content.slice(removalEnd)}`;
 }
 function restoreBackup(backup, logger) {
-  if (!fs24.existsSync(backup.backupLocation)) {
+  if (!fs26.existsSync(backup.backupLocation)) {
     logger.warn(`  backup not found: ${backup.backupLocation}`);
     return;
   }
-  const destDir = path21.dirname(backup.originalPath);
-  fs24.mkdirSync(destDir, { recursive: true });
-  fs24.renameSync(backup.backupLocation, backup.originalPath);
+  const destDir = path23.dirname(backup.originalPath);
+  fs26.mkdirSync(destDir, { recursive: true });
+  fs26.renameSync(backup.backupLocation, backup.originalPath);
   logger.verbose(
     `  restored: ${backup.backupLocation} \u2192 ${backup.originalPath}`
   );
 }
 function isSymlink(p) {
   try {
-    return fs24.lstatSync(p).isSymbolicLink();
+    return fs26.lstatSync(p).isSymbolicLink();
   } catch {
     return false;
   }
@@ -23361,7 +23533,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") {
-      fs25.rmSync(artifact.path, { recursive: true, force: true });
+      fs27.rmSync(artifact.path, { recursive: true, force: true });
       logger.info(`${artifact.component}: removed ${artifact.path}`);
     }
   }
@@ -23417,7 +23589,7 @@ function cleanupCopilot(config, sourceRoot, configDir, logger) {
     logger
   );
   removeManagedJsonFile(
-    path22.join(resolveTargetPath(paths.hooks ?? ""), "tangyr-managed.json"),
+    path24.join(resolveTargetPath(paths.hooks ?? ""), "tangyr-managed.json"),
     "_tangyr",
     logger
   );
@@ -23574,40 +23746,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") {
-    fs25.rmSync(artifactPath, { recursive: true, force: true });
+    fs27.rmSync(artifactPath, { recursive: true, force: true });
     logger.info(`${component}: removed ${artifactPath}`);
   }
 }
 function removeManagedCompiledFiles(dir, pattern, expectedTarget, logger) {
-  for (const filePath of ts(path22.join(dir, pattern)).sort()) {
+  for (const filePath of ts(path24.join(dir, pattern)).sort()) {
     removeManagedCompiledFile(filePath, expectedTarget, logger);
   }
 }
 function removeManagedCompiledFile(filePath, expectedTarget, logger) {
-  if (!fs25.existsSync(filePath)) {
+  if (!fs27.existsSync(filePath)) {
     return;
   }
-  const marker = extractProvenanceMarker(fs25.readFileSync(filePath, "utf8"));
+  const marker = extractProvenanceMarker(fs27.readFileSync(filePath, "utf8"));
   if (marker?.target === expectedTarget) {
-    fs25.rmSync(filePath, { force: true });
+    fs27.rmSync(filePath, { force: true });
     logger.info(`removed ${filePath}`);
   }
 }
 function removeManagedJsonFile(filePath, markerKey, logger) {
-  if (!fs25.existsSync(filePath)) {
+  if (!fs27.existsSync(filePath)) {
     return;
   }
   const parsed = readJsonObject(filePath);
   if (isRecord(parsed[markerKey])) {
-    fs25.rmSync(filePath, { force: true });
+    fs27.rmSync(filePath, { force: true });
     logger.info(`removed ${filePath}`);
   }
 }
 function removeCodexManagedTomlSection(filePath, logger) {
-  if (!fs25.existsSync(filePath)) {
+  if (!fs27.existsSync(filePath)) {
     return;
   }
-  const content = fs25.readFileSync(filePath, "utf8");
+  const content = fs27.readFileSync(filePath, "utf8");
   const next = removeDelimitedManagedSection2(
     content,
     codexManagedMcpStart2,
@@ -23616,7 +23788,7 @@ function removeCodexManagedTomlSection(filePath, logger) {
   if (next === content) {
     return;
   }
-  fs25.writeFileSync(filePath, next);
+  fs27.writeFileSync(filePath, next);
   logger.info(`mcp: removed managed section from ${filePath}`);
 }
 function removeDelimitedManagedSection2(content, startMarker, endMarker) {
@@ -23688,9 +23860,9 @@ function toVerbosity(value) {
 }
 
 // src/commands/detect.ts
-import fs26 from "fs";
+import fs28 from "fs";
 import os5 from "os";
-import path23 from "path";
+import path25 from "path";
 import { spawnSync } from "child_process";
 var copilotEditorCommands = [
   "code",
@@ -23729,7 +23901,7 @@ var bundledCursorExecutablePathsByPlatform = {
 };
 function detectTargets(logger, dependencies = {}) {
   const spawnSyncImpl = dependencies.spawnSyncImpl ?? defaultSpawnSync;
-  const pathExists = dependencies.pathExists ?? fs26.existsSync;
+  const pathExists = dependencies.pathExists ?? fs28.existsSync;
   const homeDirectory = dependencies.homeDirectory ?? os5.homedir();
   const platform = dependencies.platform ?? process.platform;
   const locator = platform === "win32" ? "where.exe" : "which";
@@ -23764,8 +23936,8 @@ function detectsCopilot(logger, dependencies = {}) {
   return detectCopilot(logger, dependencies);
 }
 function detectCopilot(logger, dependencies = {}) {
-  const pathExists = dependencies.pathExists ?? fs26.existsSync;
-  const readFile = dependencies.readFile ?? ((filePath) => fs26.readFileSync(filePath, "utf8"));
+  const pathExists = dependencies.pathExists ?? fs28.existsSync;
+  const readFile = dependencies.readFile ?? ((filePath) => fs28.readFileSync(filePath, "utf8"));
   const platform = dependencies.platform ?? process.platform;
   if (detectEditorExtension(
     "Copilot",
@@ -23793,8 +23965,8 @@ function detectCopilot(logger, dependencies = {}) {
 }
 function detectEditorExtension(label, matchesExtension, logger, dependencies = {}) {
   const spawnSyncImpl = dependencies.spawnSyncImpl ?? defaultSpawnSync;
-  const pathExists = dependencies.pathExists ?? fs26.existsSync;
-  const readDirectory = dependencies.readDirectory ?? fs26.readdirSync;
+  const pathExists = dependencies.pathExists ?? fs28.existsSync;
+  const readDirectory = dependencies.readDirectory ?? fs28.readdirSync;
   const homeDirectory = dependencies.homeDirectory ?? os5.homedir();
   const platform = dependencies.platform ?? process.platform;
   const commandCandidates = [
@@ -23822,7 +23994,7 @@ function detectEditorExtension(label, matchesExtension, logger, dependencies = {
     }
   }
   for (const relativeDirectory of copilotExtensionDirectories) {
-    const extensionDirectory = path23.join(homeDirectory, relativeDirectory);
+    const extensionDirectory = path25.join(homeDirectory, relativeDirectory);
     if (!pathExists(extensionDirectory)) {
       continue;
     }
@@ -23845,7 +24017,7 @@ function cursorExecutablePaths(platform, homeDirectory) {
   }
   return [
     ...systemPaths,
-    path23.join(
+    path25.join(
       homeDirectory,
       "Applications/Cursor.app/Contents/Resources/app/bin/cursor"
     )
@@ -23905,86 +24077,25 @@ function logDetectionError(attemptedCommand, error, logger) {
 }
 
 // src/commands/doctor.ts
-import fs28 from "fs";
-import path25 from "path";
-
-// src/utils/fs.ts
-import fs27 from "fs";
-import path24 from "path";
-function ensureDir(dirPath) {
-  fs27.mkdirSync(dirPath, { recursive: true });
-}
-function createRelativeSymlink(source, destination, type, options) {
-  const absoluteSource = path24.resolve(source);
-  const relative = path24.relative(
-    realPathOrInput(path24.dirname(destination)),
-    absoluteSource
-  );
-  if (process.platform === "win32" && type === "dir") {
-    fs27.symlinkSync(absoluteSource, destination, "junction");
-    return;
-  }
-  if (process.platform === "win32" && type === "file") {
-    try {
-      fs27.symlinkSync(relative, destination, "file");
-    } catch (error) {
-      if (!hasErrorCode(error, "EPERM")) {
-        throw error;
-      }
-      if (!options?.provenanceMarker) {
-        throw new Error(
-          `${destination}: file symlink unavailable on Windows and no provenance marker was provided.`
-        );
-      }
-      createManagedCopy(
-        source,
-        destination,
-        options.provenanceMarker,
-        options.logger
-      );
-      options.logger?.warn(
-        `${destination}: file symlink unavailable on Windows \u2014 using managed copy with provenance metadata (behavioral contract C-09)`
-      );
-    }
-    return;
-  }
-  fs27.symlinkSync(relative, destination, type);
-}
-function createManagedCopy(source, destination, provenanceMarker, _logger) {
-  ensureDir(path24.dirname(destination));
-  const content = fs27.readFileSync(source, "utf8");
-  fs27.writeFileSync(destination, `${provenanceMarker}
-${content}`);
-}
-function hasErrorCode(error, expectedCode) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === expectedCode;
-}
-function realPathOrInput(filePath) {
-  try {
-    return fs27.realpathSync(filePath);
-  } catch {
-    return filePath;
-  }
-}
-
-// src/commands/doctor.ts
+import fs29 from "fs";
+import path26 from "path";
 function runDoctorCommand(options, logger) {
   const { config, configDir, configPath, sourceRoot } = resolveRuntime(
     options,
     import.meta.url
   );
   const findings = [];
-  if (!fs28.existsSync(configPath)) {
+  if (!fs29.existsSync(configPath)) {
     findings.push(`${configPath}: missing`);
   }
-  const hooksJsonPath = path25.join(
+  const hooksJsonPath = path26.join(
     sourceRoot,
     config.source.hooks,
     "hooks.json"
   );
-  if (fs28.existsSync(hooksJsonPath)) {
+  if (fs29.existsSync(hooksJsonPath)) {
     try {
-      JSON.parse(fs28.readFileSync(hooksJsonPath, "utf8"));
+      JSON.parse(fs29.readFileSync(hooksJsonPath, "utf8"));
     } catch (err) {
       findings.push(
         `hooks/hooks.json: ${err instanceof Error ? err.message : String(err)}`
@@ -24049,19 +24160,19 @@ function checkClaudeCode(options, findings, config, sourceRoot, configDir, logge
     projectRoot
   )) {
     const artifactClass = classifyArtifact(artifact.path, config, sourceRoot);
-    const sourcePath = artifact.sourceKey ? path25.resolve(sourceRoot, config.source[artifact.sourceKey]) : void 0;
+    const sourcePath = artifact.sourceKey ? path26.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([path25.resolve(artifact.path)]),
+        /* @__PURE__ */ new Set([path26.resolve(artifact.path)]),
         config
       )) {
-        fs28.unlinkSync(artifact.path);
-        ensureDir(path25.dirname(artifact.path));
-        const symlinkType = fs28.statSync(sourcePath).isDirectory() ? "dir" : "file";
+        fs29.unlinkSync(artifact.path);
+        ensureDir(path26.dirname(artifact.path));
+        const symlinkType = fs29.statSync(sourcePath).isDirectory() ? "dir" : "file";
         createRelativeSymlink(sourcePath, artifact.path, symlinkType, {
           logger,
           provenanceMarker: symlinkType === "file" && artifact.sourceKey ? formatProvenanceMarker(
@@ -24074,8 +24185,8 @@ function checkClaudeCode(options, findings, config, sourceRoot, configDir, logge
         logger.info(`${artifact.component}: recreated managed symlink`);
       }
     }
-    if (options.fix && !fs28.existsSync(path25.dirname(artifact.path))) {
-      ensureDir(path25.dirname(artifact.path));
+    if (options.fix && !fs29.existsSync(path26.dirname(artifact.path))) {
+      ensureDir(path26.dirname(artifact.path));
     }
     checkParentWritablePath(artifact.path, artifact.component, findings);
   }
@@ -24090,7 +24201,7 @@ function checkCopilot(config, sourceRoot, configDir, findings) {
       continue;
     }
     const label = `copilot: ${rawPath}`;
-    if (key.endsWith("_shared_file") || path25.extname(rawPath).length > 0) {
+    if (key.endsWith("_shared_file") || path26.extname(rawPath).length > 0) {
       checkParentWritablePath(resolveTargetPath(rawPath), label, findings);
       continue;
     }
@@ -24110,7 +24221,7 @@ function checkCodex(config, sourceRoot, configDir, findings, logger) {
       continue;
     }
     const label = `codex: ${rawPath}`;
-    if (key.endsWith("_shared_file") || path25.extname(rawPath).length > 0) {
+    if (key.endsWith("_shared_file") || path26.extname(rawPath).length > 0) {
       checkParentWritablePath(resolveTargetPath(rawPath), label, findings);
       continue;
     }
@@ -24127,33 +24238,33 @@ function resolveHooksScriptPath(config, sourceRoot, configDir) {
       scope: "global",
       mappings: mappings.platformPaths
     });
-    return path25.join(profile["claude-code"].hooks, "scripts");
+    return path26.join(profile["claude-code"].hooks, "scripts");
   } catch {
     return resolveTargetPath("~/.agents/hooks/scripts");
   }
 }
 function checkParentWritablePath(targetPath, label, findings) {
-  checkWritablePath(path25.dirname(targetPath), `${label} parent`, findings);
+  checkWritablePath(path26.dirname(targetPath), `${label} parent`, findings);
 }
 function checkWritablePath(checkPath, label, findings) {
-  if (!fs28.existsSync(checkPath)) {
+  if (!fs29.existsSync(checkPath)) {
     findings.push(`${label}: path does not exist`);
     return;
   }
   try {
-    fs28.accessSync(checkPath, fs28.constants.R_OK | fs28.constants.W_OK);
+    fs29.accessSync(checkPath, fs29.constants.R_OK | fs29.constants.W_OK);
   } catch {
     findings.push(`${label}: path is not readable and writable`);
   }
 }
 function walkHookScripts(dir) {
-  if (!fs28.existsSync(dir)) {
+  if (!fs29.existsSync(dir)) {
     return [];
   }
-  return fs28.readdirSync(dir).map((entry) => path25.join(dir, entry)).filter((entryPath) => fs28.statSync(entryPath).isFile());
+  return fs29.readdirSync(dir).map((entry) => path26.join(dir, entry)).filter((entryPath) => fs29.statSync(entryPath).isFile());
 }
 function fixManagedHookScriptModes(scriptRoot, sourceRoot, logger) {
-  if (!fs28.existsSync(scriptRoot)) {
+  if (!fs29.existsSync(scriptRoot)) {
     return;
   }
   if (hasSymlinkAncestor(scriptRoot, resolveTargetPath("~/.agents")) || isInside(realPathOrInput2(scriptRoot), realPathOrInput2(sourceRoot))) {
@@ -24163,49 +24274,49 @@ function fixManagedHookScriptModes(scriptRoot, sourceRoot, logger) {
     return;
   }
   for (const scriptPath of walkHookScripts(scriptRoot)) {
-    fs28.chmodSync(scriptPath, 493);
+    fs29.chmodSync(scriptPath, 493);
   }
 }
 function hasSymlinkAncestor(targetPath, stopAt) {
-  const relative = path25.relative(
-    path25.resolve(stopAt),
-    path25.resolve(targetPath)
+  const relative = path26.relative(
+    path26.resolve(stopAt),
+    path26.resolve(targetPath)
   );
-  if (relative.startsWith("..") || path25.isAbsolute(relative)) {
+  if (relative.startsWith("..") || path26.isAbsolute(relative)) {
     return false;
   }
-  return relative.split(path25.sep).some((_segment, index, segments) => {
-    const candidate = path25.join(
-      path25.resolve(stopAt),
+  return relative.split(path26.sep).some((_segment, index, segments) => {
+    const candidate = path26.join(
+      path26.resolve(stopAt),
       ...segments.slice(0, index + 1)
     );
     try {
-      return fs28.lstatSync(candidate).isSymbolicLink();
+      return fs29.lstatSync(candidate).isSymbolicLink();
     } catch {
       return false;
     }
   });
 }
 function isInside(childPath, parentPath) {
-  const relative = path25.relative(parentPath, childPath);
-  return relative.length === 0 || !relative.startsWith("..") && !path25.isAbsolute(relative);
+  const relative = path26.relative(parentPath, childPath);
+  return relative.length === 0 || !relative.startsWith("..") && !path26.isAbsolute(relative);
 }
 function realPathOrInput2(filePath) {
   try {
-    return fs28.realpathSync(filePath);
+    return fs29.realpathSync(filePath);
   } catch {
     return filePath;
   }
 }
 
 // src/commands/init.ts
-import fs29 from "fs";
-import path26 from "path";
+import fs30 from "fs";
+import path27 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: path26.resolve("projects/tangyr/agent-coding")
+    default: path27.resolve("projects/tangyr/agent-coding")
   });
   const componentCount = [
     "CLAUDE.md",
@@ -24215,7 +24326,7 @@ async function runInitCommand(_options, logger) {
     "rules",
     "hooks"
   ].filter(
-    (relativePath) => fs29.existsSync(path26.join(sourceRoot, relativePath))
+    (relativePath) => fs30.existsSync(path27.join(sourceRoot, relativePath))
   ).length;
   const detectedTargets = detectTargets(logger);
   const enabledTargets = await dist_default4({
@@ -24235,8 +24346,8 @@ async function runInitCommand(_options, logger) {
       value
     }))
   });
-  const configPath = path26.join(sourceRoot, "tangyr.config.yaml");
-  if (fs29.existsSync(configPath)) {
+  const configPath = path27.join(sourceRoot, "tangyr.config.yaml");
+  if (fs30.existsSync(configPath)) {
     const overwrite = await dist_default5({
       message: `${configPath} exists. Overwrite?`,
       default: false
@@ -24246,7 +24357,7 @@ async function runInitCommand(_options, logger) {
       return;
     }
   }
-  fs29.writeFileSync(
+  fs30.writeFileSync(
     configPath,
     (0, import_yaml7.stringify)({
       schema: 1,
@@ -24293,11 +24404,11 @@ import fs39 from "fs";
 import path39 from "path";
 
 // src/core/channel-state.ts
-import fs30 from "fs";
-import path27 from "path";
+import fs31 from "fs";
+import path28 from "path";
 var CHANNEL_STATE_FILENAME = ".tangyr-channels.json";
 function stateFilePath(cacheRoot) {
-  return path27.join(cacheRoot, CHANNEL_STATE_FILENAME);
+  return path28.join(cacheRoot, CHANNEL_STATE_FILENAME);
 }
 function channelKey(kit, channel) {
   return `${kit}/${channel}`;
@@ -24306,7 +24417,7 @@ function readState(cacheRoot) {
   const filePath = stateFilePath(cacheRoot);
   let raw;
   try {
-    raw = fs30.readFileSync(filePath, "utf8");
+    raw = fs31.readFileSync(filePath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { state: {} };
@@ -24353,13 +24464,13 @@ function writeChannelSequence(params) {
     [key]: { sequence, version, seenAt: now.toISOString() }
   };
   const filePath = stateFilePath(cacheRoot);
-  fs30.mkdirSync(path27.dirname(filePath), { recursive: true, mode: 448 });
+  fs31.mkdirSync(path28.dirname(filePath), { recursive: true, mode: 448 });
   const tempPath = `${filePath}.${process.pid}.tmp`;
-  fs30.writeFileSync(tempPath, `${JSON.stringify(state, null, 2)}
+  fs31.writeFileSync(tempPath, `${JSON.stringify(state, null, 2)}
 `, {
     mode: 384
   });
-  fs30.renameSync(tempPath, filePath);
+  fs31.renameSync(tempPath, filePath);
 }
 function assertChannelNotRolledBack(params) {
   const { originUrl, kit, channel, seen, seenVersion, incoming } = params;
@@ -24375,8 +24486,8 @@ var CHANNEL_POINTER_TYPE = "tangyr.channel-pointer.v1";
 var DEFAULT_CHANNEL = "stable";
 
 // src/core/materialize.ts
-import fs31 from "fs";
-import path28 from "path";
+import fs32 from "fs";
+import path29 from "path";
 
 // src/core/integrity.ts
 import crypto3 from "crypto";
@@ -24712,7 +24823,7 @@ function assertFileWithinCeiling(entryPath, byteLength) {
 }
 var WINDOWS_DRIVE_ABSOLUTE = /^[a-zA-Z]:[\\/]/u;
 function sanitizeBundleFilePath(entryPath, stagingDir) {
-  if (path28.isAbsolute(entryPath) || WINDOWS_DRIVE_ABSOLUTE.test(entryPath)) {
+  if (path29.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).`
     );
@@ -24728,13 +24839,13 @@ function sanitizeBundleFilePath(entryPath, stagingDir) {
       `Bundle file path "${entryPath}" contains a ".." segment \u2014 directory traversal is rejected (REQ-INT-004).`
     );
   }
-  const resolved = path28.resolve(stagingDir, entryPath);
+  const resolved = path29.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 + path28.sep)) {
+  if (!resolved.startsWith(stagingDir + path29.sep)) {
     throw new IntegrityError(
       `Bundle file path "${entryPath}" escapes the staging directory \u2014 refusing to write (REQ-INT-004).`
     );
@@ -24786,10 +24897,10 @@ function verifyBundleFileHashes(bundle) {
 function writeStagedFiles(stagingDir, decoded) {
   for (const [rawPath, bytes] of decoded) {
     const target = sanitizeBundleFilePath(rawPath, stagingDir);
-    fs31.mkdirSync(path28.dirname(target), { recursive: true, mode: 448 });
+    fs32.mkdirSync(path29.dirname(target), { recursive: true, mode: 448 });
     let existingStat;
     try {
-      existingStat = fs31.lstatSync(target);
+      existingStat = fs32.lstatSync(target);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -24800,7 +24911,7 @@ function writeStagedFiles(stagingDir, decoded) {
         `Refusing to write "${rawPath}" \u2014 a symbolic link already exists at the target path.`
       );
     }
-    fs31.writeFileSync(target, bytes, { mode: 384, flag: "wx" });
+    fs32.writeFileSync(target, bytes, { mode: 384, flag: "wx" });
   }
 }
 function verifyWarmCacheEntry(entryDir, reference, keys, now) {
@@ -24856,14 +24967,14 @@ async function materializeRemoteKit(params) {
     writeStagedFiles(stagingDir, decoded);
     writeBundleDocument(stagingDir, bundle);
     writeCompletionMarker(stagingDir, reference);
-    if (replace && fs31.existsSync(entryDir)) {
-      fs31.rmSync(entryDir, { recursive: true, force: true });
+    if (replace && fs32.existsSync(entryDir)) {
+      fs32.rmSync(entryDir, { recursive: true, force: true });
     }
     publishCacheEntry(stagingDir, entryDir);
     return entryDir;
   } catch (error) {
     if (stagingDir !== void 0) {
-      fs31.rmSync(stagingDir, { recursive: true, force: true });
+      fs32.rmSync(stagingDir, { recursive: true, force: true });
     }
     throw error;
   }
@@ -25205,7 +25316,7 @@ import path33 from "path";
 // src/compiler/agents.ts
 var TOML = __toESM(require_toml(), 1);
 var import_yaml8 = __toESM(require_dist(), 1);
-import path29 from "path";
+import path30 from "path";
 var writeCapabilityClasses = /* @__PURE__ */ new Set(["filesystem-write", "shell-execution"]);
 var copilotToolAliasesByClass = {
   delegation: "agent",
@@ -25217,7 +25328,7 @@ var copilotToolAliasesByClass = {
 };
 function compileAgent(sourceFile, target, mappings, extensions, lossReport) {
   const { data, body } = parseMarkdownFrontmatter(sourceFile);
-  const relativeSource = `agents/${path29.basename(sourceFile)}`;
+  const relativeSource = `agents/${path30.basename(sourceFile)}`;
   if (target === "opencode") {
     return compileOpenCodeAgent(
       sourceFile,
@@ -25258,7 +25369,7 @@ function compileAgent(sourceFile, target, mappings, extensions, lossReport) {
     mappings,
     lossReport
   );
-  const overlayKey = `agents/${path29.basename(sourceFile, ".md")}.${target}.yaml`;
+  const overlayKey = `agents/${path30.basename(sourceFile, ".md")}.${target}.yaml`;
   const targetFields = {
     ...translated.fields,
     ...extensions[overlayKey] ?? {}
@@ -25292,7 +25403,7 @@ ${TOML.stringify({
 function compileOpenCodeAgent(sourceFile, data, body, relativeSource, lossReport) {
   if (typeof data.description !== "string" || data.description.trim() === "") {
     throw new Error(
-      `${path29.basename(sourceFile)}: OpenCode agent requires a non-empty description field`
+      `${path30.basename(sourceFile)}: OpenCode agent requires a non-empty description field`
     );
   }
   const frontmatter = {
@@ -25346,7 +25457,7 @@ function compileOpenCodeAgent(sourceFile, data, body, relativeSource, lossReport
                 "permission",
                 "permission-coarsening"
               ),
-              detail: `${path29.basename(sourceFile)}: per-tool permission '${tool}' mapped to coarse allow|deny action`
+              detail: `${path30.basename(sourceFile)}: per-tool permission '${tool}' mapped to coarse allow|deny action`
             }
           ]
         });
@@ -25371,7 +25482,7 @@ ${(0, import_yaml8.stringify)(frontmatter).trim()}
 function compileCursorAgent(sourceFile, data, body, relativeSource, lossReport) {
   if (typeof data.description !== "string" || data.description.trim() === "") {
     throw new Error(
-      `${path29.basename(sourceFile)}: Cursor agent requires a non-empty description field`
+      `${path30.basename(sourceFile)}: Cursor agent requires a non-empty description field`
     );
   }
   const frontmatter = {
@@ -25408,7 +25519,7 @@ function compileCursorAgent(sourceFile, data, body, relativeSource, lossReport)
             "permission",
             "permission-coarsening"
           ),
-          detail: `${path29.basename(sourceFile)}: per-agent tool allow set coarsened to readonly=${readonly} boolean (Cursor only exposes readonly control)`
+          detail: `${path30.basename(sourceFile)}: per-agent tool allow set coarsened to readonly=${readonly} boolean (Cursor only exposes readonly control)`
         }
       ]
     });
@@ -25427,7 +25538,7 @@ function compileCursorAgent(sourceFile, data, body, relativeSource, lossReport)
             "provider",
             "provider-not-representable"
           ),
-          detail: `${path29.basename(sourceFile)}: custom provider cannot be expressed in Cursor subagent frontmatter \u2014 configure manually via Cursor settings`
+          detail: `${path30.basename(sourceFile)}: custom provider cannot be expressed in Cursor subagent frontmatter \u2014 configure manually via Cursor settings`
         }
       ]
     });
@@ -25459,7 +25570,7 @@ function compileClineAgent(sourceFile, _data, _body, relativeSource, lossReport)
           "persona",
           "persona-not-representable"
         ),
-        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.`
+        detail: `${path30.basename(sourceFile)}: Cline has no committable per-agent persona file for the VSCode extension target; configure the agent through Cline Settings \u2192 Agent.`
       }
     ]
   });
@@ -25507,7 +25618,7 @@ function applyFieldAction(sourceFile, field, value, action, target, mappings, tr
           field,
           "model-not-representable"
         ),
-        detail: `${path29.basename(sourceFile)}: model tier '${String(value)}' has no stable Copilot model literal; omitted so VS Code uses the selected model.`
+        detail: `${path30.basename(sourceFile)}: model tier '${String(value)}' has no stable Copilot model literal; omitted so VS Code uses the selected model.`
       });
       return;
     }
@@ -25525,9 +25636,9 @@ function applyFieldAction(sourceFile, field, value, action, target, mappings, tr
       lossReport,
       target,
       "agents",
-      `agents/${path29.basename(sourceFile)}`,
+      `agents/${path30.basename(sourceFile)}`,
       "info",
-      `${path29.basename(sourceFile)}: ${field} is delivered through another managed surface.`
+      `${path30.basename(sourceFile)}: ${field} is delivered through another managed surface.`
     );
     return;
   }
@@ -25536,7 +25647,7 @@ function applyFieldAction(sourceFile, field, value, action, target, mappings, tr
     field,
     action: entryType,
     severity: resolveLossSeverity("agent-field", field, entryType),
-    detail: `${path29.basename(sourceFile)}: ${field} has no emitted field for this target.`
+    detail: `${path30.basename(sourceFile)}: ${field} has no emitted field for this target.`
   });
 }
 function mapToolsToCapabilities(value, mappings) {
@@ -25630,8 +25741,8 @@ function compileCursorHooks(sourceHooksJson, mappings, lossReport, sourceLabel)
       sourceEvent
     );
     if (mapping.status === "mapped" && mapping.target_event) {
-      const extracted = extractHookCommand(payload);
-      if (!extracted.command) {
+      const entries = extractHookCommands(payload);
+      if (entries.length === 0) {
         droppedEvents.push(sourceEvent);
         addHookLoss(
           lossReport,
@@ -25644,26 +25755,24 @@ function compileCursorHooks(sourceHooksJson, mappings, lossReport, sourceLabel)
         dropped += 1;
         continue;
       }
-      hooks[mapping.target_event] = { command: extracted.command };
+      const untranslatable = /* @__PURE__ */ new Set();
+      hooks[mapping.target_event] = entries.map((entry) => {
+        const matcher = entry.matcher === void 0 ? void 0 : translateCursorMatcher(entry.matcher, untranslatable);
+        return {
+          type: "command",
+          command: entry.command,
+          ...matcher !== void 0 ? { matcher } : {}
+        };
+      });
       translated += 1;
-      if (extracted.remaining.length > 0) {
-        addHookLoss(
-          lossReport,
-          "cursor",
-          sourceEvent,
-          sourceLabel,
-          "error",
-          `${sourceEvent}: the source registers ${extracted.remaining.length + 1} hooks on this event and Cursor's entry holds one command. Only '${extracted.command}' was written; ${extracted.remaining.map((c) => `'${c}'`).join(", ")} ${extracted.remaining.length === 1 ? "does" : "do"} not run under Cursor. To fix: give this event a single entry point that dispatches to the others, or accept the loss knowingly.`
-        );
-      }
-      if (extracted.matcher) {
+      if (untranslatable.size > 0) {
         addInformational(
           lossReport,
           "cursor",
           "hooks",
           sourceLabel,
           "warning",
-          `${sourceEvent}: the source scopes this hook to '${extracted.matcher}', and Cursor's hook entry carries no matcher. It will run for every tool call on this event, not only the matched ones.`
+          `${sourceEvent}: ${[...untranslatable].map((m) => `'${m}'`).join(", ")} ${untranslatable.size === 1 ? "names a tool" : "name tools"} with no known Cursor equivalent and ${untranslatable.size === 1 ? "was" : "were"} written through unchanged. Cursor matches on its own tool names \u2014 measured: Shell, Read, Write, Grep \u2014 so a hook scoped to a name it does not use will not run. To fix: add the name to CURSOR_TOOL_NAMES in the compiler once its Cursor equivalent has been measured.`
         );
       }
       continue;
@@ -25821,7 +25930,35 @@ function compileCopilotHooks(sourceHooksJson, mappings, lossReport, sourceLabel)
   }
   return { payload: { hooks }, translated, dropped, droppedEvents };
 }
-function extractHookCommand(payload) {
+var CURSOR_TOOL_NAMES = {
+  Bash: "Shell",
+  Edit: "Write",
+  MultiEdit: "Write",
+  // Cursor's own names map to themselves. Without these a kit that already
+  // writes a Cursor matcher — the natural thing to do once this mapping is
+  // documented — would have it reported as untranslatable and warned about,
+  // while it is in fact the only spelling that works.
+  Shell: "Shell",
+  Read: "Read",
+  Write: "Write",
+  Grep: "Grep"
+};
+function translateCursorMatcher(matcher, untranslatable) {
+  const translated = [];
+  for (const token of matcher.split("|")) {
+    const trimmed = token.trim();
+    if (!trimmed) continue;
+    const mapped = CURSOR_TOOL_NAMES[trimmed];
+    if (mapped === void 0) {
+      untranslatable.add(trimmed);
+      if (!translated.includes(trimmed)) translated.push(trimmed);
+      continue;
+    }
+    if (!translated.includes(mapped)) translated.push(mapped);
+  }
+  return translated.join("|");
+}
+function extractHookCommands(payload) {
   const entries = Array.isArray(payload) ? payload : [payload];
   const found = [];
   for (const entry of entries) {
@@ -25838,15 +25975,7 @@ function extractHookCommand(payload) {
       }
     }
   }
-  if (found.length === 0) {
-    return { command: "", remaining: [] };
-  }
-  const [first, ...rest] = found;
-  return {
-    command: first.command,
-    ...first.matcher !== void 0 ? { matcher: first.matcher } : {},
-    remaining: rest.map((r) => r.command)
-  };
+  return found;
 }
 function normalizeHookEventRule(value, target, sourceEvent) {
   if (typeof value === "string") {
@@ -25928,23 +26057,23 @@ function addHookLoss(lossReport, target, eventName, sourceLabel, severity, reaso
 }
 
 // src/core/hook-scripts.ts
-import path30 from "path";
+import path31 from "path";
 function hookScriptsDir(bridge, target) {
   const globalBridge = resolveTargetPath("~/.agents/hooks");
-  if (path30.resolve(bridge) === path30.resolve(globalBridge)) {
+  if (path31.resolve(bridge) === path31.resolve(globalBridge)) {
     return { prefix: GLOBAL_HOOK_SCRIPTS_DIR, machineLocal: false };
   }
-  const relative = path30.relative(process.cwd(), bridge);
-  const insideProject = !relative.startsWith("..") && !path30.isAbsolute(relative) && relative !== "";
+  const relative = path31.relative(process.cwd(), bridge);
+  const insideProject = !relative.startsWith("..") && !path31.isAbsolute(relative) && relative !== "";
   const variable = PROJECT_DIR_VARIABLE[target];
   if (insideProject && variable) {
-    const posix = path30.posix.join(
-      relative.split(path30.sep).join("/"),
+    const posix = path31.posix.join(
+      relative.split(path31.sep).join("/"),
       "scripts"
     );
     return { prefix: `$${variable.slice(1)}/${posix}`, machineLocal: false };
   }
-  return { prefix: path30.join(bridge, "scripts"), machineLocal: true };
+  return { prefix: path31.join(bridge, "scripts"), machineLocal: true };
 }
 var PROJECT_DIR_VARIABLE = {
   "claude-code": "$CLAUDE_PROJECT_DIR"
@@ -25953,52 +26082,6 @@ function machineLocalScriptPathNotice(target, prefix) {
   return `The hook commands compiled for ${target} name '${prefix}', an absolute path. ${target} publishes no project-directory variable a command could use instead \u2014 measured, not assumed \u2014 and a bare relative path would resolve against whatever directory the harness runs the hook from. The compiled file is therefore correct on this machine and not on another: re-run 'tangyr sync' after cloning, and prefer keeping it out of version control.`;
 }
 
-// src/adapters/hook-scripts-bridge.ts
-import fs32 from "fs";
-import path31 from "path";
-function syncHookScriptsBridge(args) {
-  const { source, destination, config, sourceRoot, options, logger } = args;
-  if (!fs32.existsSync(source)) {
-    return {
-      component: "hooks",
-      status: "skipped",
-      path: `${source}: source not configured`
-    };
-  }
-  if (options.dryRun) {
-    logger.info(`[dry-run] hooks: symlink ${source} -> ${destination}`);
-    return { component: "hooks", status: "dry-run", path: destination };
-  }
-  const artifactClass = classifyArtifact(destination, config, sourceRoot);
-  if (artifactClass === "managed-symlink" && isSymlinkTo(destination, source)) {
-    return { component: "hooks", status: "skipped-current", path: destination };
-  }
-  if (artifactClass === "managed-stale" && isOurStaleSymlink(destination, /* @__PURE__ */ new Set([destination]), config)) {
-    fs32.unlinkSync(destination);
-  } else if (artifactClass === "unmanaged-conflict" && !args.onConflict()) {
-    return { component: "hooks", status: "conflict", path: destination };
-  } else if (artifactClass === "managed-symlink") {
-    fs32.unlinkSync(destination);
-  }
-  ensureDir(path31.dirname(destination));
-  createRelativeSymlink(source, destination, "dir");
-  if (args.manifest && args.scopePath) {
-    addArtifactToManifest(args.manifest, {
-      relativePath: path31.relative(args.scopePath, destination),
-      hash: `dir:${source}`,
-      origin: "tangyr-managed"
-    });
-  }
-  return { component: "hooks", status: "success", path: destination };
-}
-function isSymlinkTo(linkPath, source) {
-  try {
-    return fs32.realpathSync(linkPath) === fs32.realpathSync(source);
-  } catch {
-    return false;
-  }
-}
-
 // src/compiler/mcp.ts
 var TOML2 = __toESM(require_toml(), 1);
 import crypto4 from "crypto";
@@ -29781,7 +29864,14 @@ function installCopilotTool(config, kitInfo, manifest, options, mappings, logger
     manifest,
     copilotScopePath
   );
-  recordInstalledArtifacts(manifest, "copilot", result.outcomes, mappings);
+  recordInstalledArtifacts(
+    manifest,
+    "copilot",
+    result.outcomes,
+    mappings,
+    scope,
+    projectRoot
+  );
   return countInstalledArtifacts(result.outcomes);
 }
 function installCodexTool(config, kitInfo, manifest, options, mappings, logger, scope = "global", projectRoot, lossReport) {
@@ -29812,7 +29902,14 @@ function installCodexTool(config, kitInfo, manifest, options, mappings, logger,
     manifest,
     codexScopePath
   );
-  recordInstalledArtifacts(manifest, "codex", result.outcomes, mappings);
+  recordInstalledArtifacts(
+    manifest,
+    "codex",
+    result.outcomes,
+    mappings,
+    scope,
+    projectRoot
+  );
   return countInstalledArtifacts(result.outcomes);
 }
 function installOpenCodeTool(config, kitInfo, manifest, options, mappings, logger, scope = "global", projectRoot, lossReport) {
@@ -29974,16 +30071,16 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
     throwUnrecognizedTarget(tool);
   }
   if (tool === "cline") {
-    const profile = resolveTargetPaths({
+    const profile2 = resolveTargetPaths({
       scope,
       projectRoot,
       mappings: mappings.platformPaths
     }).cline;
-    const instrFile = profile.instructions !== null ? resolveTargetPath(profile.instructions) : null;
-    const rulesRoot2 = resolveTargetPath(profile.rules);
-    const workflowsRoot = resolveTargetPath(profile.workflows);
-    const skillsRoot2 = resolveTargetPath(profile.skills);
-    const mcpFile2 = resolveTargetPath(profile.mcp_file);
+    const instrFile = profile2.instructions !== null ? resolveTargetPath(profile2.instructions) : null;
+    const rulesRoot2 = resolveTargetPath(profile2.rules);
+    const workflowsRoot = resolveTargetPath(profile2.workflows);
+    const skillsRoot2 = resolveTargetPath(profile2.skills);
+    const mcpFile2 = resolveTargetPath(profile2.mcp_file);
     if (instrFile !== null && outcome.path === instrFile) {
       return "cline/AGENTS.md";
     }
@@ -30002,19 +30099,19 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
     return null;
   }
   if (tool === "cursor") {
-    const profile = resolveTargetPaths({
+    const profile2 = resolveTargetPaths({
       scope,
       projectRoot,
       mappings: mappings.platformPaths
     }).cursor;
-    const instrFile = resolveTargetPath(profile.instructions);
-    const agentsRoot2 = resolveTargetPath(profile.agents);
-    const rulesRoot2 = resolveTargetPath(profile.rules);
-    const skillsRoot2 = resolveTargetPath(profile.skills);
-    const skillsSharedRoot = resolveTargetPath(profile.skills_shared);
-    const hooksFile2 = resolveTargetPath(profile.hooks_file);
-    const mcpFile2 = resolveTargetPath(profile.mcp_file);
-    const permissionsFile = resolveTargetPath(profile.permissions_file);
+    const instrFile = resolveTargetPath(profile2.instructions);
+    const agentsRoot2 = resolveTargetPath(profile2.agents);
+    const rulesRoot2 = resolveTargetPath(profile2.rules);
+    const skillsRoot2 = resolveTargetPath(profile2.skills);
+    const skillsSharedRoot = resolveTargetPath(profile2.skills_shared);
+    const hooksFile2 = resolveTargetPath(profile2.hooks_file);
+    const mcpFile2 = resolveTargetPath(profile2.mcp_file);
+    const permissionsFile = resolveTargetPath(profile2.permissions_file);
     if (outcome.path === instrFile) {
       return "cursor/AGENTS.md";
     }
@@ -30046,17 +30143,17 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
     return null;
   }
   if (tool === "opencode") {
-    const profile = resolveTargetPaths({
+    const profile2 = resolveTargetPaths({
       scope,
       projectRoot,
       mappings: mappings.platformPaths
     }).opencode;
-    const instrFile = resolveTargetPath(profile.instructions);
-    const agentsRoot2 = resolveTargetPath(profile.agents);
-    const commandsRoot = resolveTargetPath(profile.commands);
-    const skillsRoot2 = resolveTargetPath(profile.skills);
-    const skillsSharedRoot = resolveTargetPath(profile.skills_shared);
-    const configDocFile = resolveTargetPath(profile.config_doc);
+    const instrFile = resolveTargetPath(profile2.instructions);
+    const agentsRoot2 = resolveTargetPath(profile2.agents);
+    const commandsRoot = resolveTargetPath(profile2.commands);
+    const skillsRoot2 = resolveTargetPath(profile2.skills);
+    const skillsSharedRoot = resolveTargetPath(profile2.skills_shared);
+    const configDocFile = resolveTargetPath(profile2.config_doc);
     if (outcome.path === instrFile) {
       return "opencode/AGENTS.md";
     }
@@ -30077,16 +30174,25 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
     }
     return null;
   }
-  const targetPaths = mappings.platformPaths.targets[tool].global;
+  const profile = resolveTargetPaths({
+    scope,
+    projectRoot,
+    mappings: mappings.platformPaths
+  })[tool];
   if (tool === "copilot") {
-    const agentsRoot2 = resolveTargetPath(targetPaths.agents ?? "");
-    const promptsRoot = resolveTargetPath(targetPaths.prompts ?? "");
-    const skillsRoot2 = resolveTargetPath(targetPaths.skills ?? "");
-    const hooksRoot = resolveTargetPath(targetPaths.hooks ?? "");
-    const mcpFile2 = resolveTargetPath(targetPaths.mcp_shared_file ?? "");
+    const copilot = profile;
+    const agentsRoot2 = resolveTargetPath(copilot.agents);
+    const promptsRoot = resolveTargetPath(copilot.prompts);
+    const skillsRoot2 = resolveTargetPath(copilot.skills);
+    const hooksRoot = resolveTargetPath(copilot.hooks);
+    const mcpFile2 = resolveTargetPath(copilot.mcp_shared_file);
+    const instructionsMirror = copilot.instructions !== null ? resolveTargetPath(copilot.instructions) : null;
     if (outcome.path === skillsRoot2) {
       return "copilot/skills";
     }
+    if (instructionsMirror !== null && outcome.path === instructionsMirror) {
+      return `copilot/${path39.basename(outcome.path)}`;
+    }
     if (outcome.path.startsWith(`${agentsRoot2}${path39.sep}`)) {
       return `copilot/agents/${path39.basename(outcome.path)}`;
     }
@@ -30101,12 +30207,13 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
     }
     return null;
   }
-  const instructionsFile = resolveTargetPath(targetPaths.instructions ?? "");
-  const agentsRoot = resolveTargetPath(targetPaths.agents ?? "");
-  const rulesRoot = resolveTargetPath(targetPaths.rules ?? "");
-  const skillsRoot = resolveTargetPath(targetPaths.skills ?? "");
-  const hooksFile = resolveTargetPath(targetPaths.hooks_shared_file ?? "");
-  const mcpFile = resolveTargetPath(targetPaths.mcp_shared_file ?? "");
+  const codex = profile;
+  const instructionsFile = resolveTargetPath(codex.instructions);
+  const agentsRoot = resolveTargetPath(codex.agents);
+  const rulesRoot = resolveTargetPath(codex.rules);
+  const skillsRoot = resolveTargetPath(codex.skills);
+  const hooksFile = resolveTargetPath(codex.hooks_shared_file);
+  const mcpFile = resolveTargetPath(codex.mcp_shared_file);
   if (outcome.path === instructionsFile) {
     return "codex/AGENTS.md";
   }