@alessandroraffa/tangyr 0.15.0 → 0.16.1

package/dist/index.js

@@ -1372,8 +1372,8 @@ var require_command = __commonJS({
     "use strict";
     var EventEmitter = __require("events").EventEmitter;
     var childProcess = __require("child_process");
-    var path46 = __require("path");
-    var fs45 = __require("fs");
+    var path45 = __require("path");
+    var fs44 = __require("fs");
     var process5 = __require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2367,7 +2367,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs45.existsSync(executableFile)) return;
+        if (fs44.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -2385,11 +2385,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path46.resolve(baseDir, baseName);
-          if (fs45.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path46.extname(baseName))) return void 0;
+          const localBin = path45.resolve(baseDir, baseName);
+          if (fs44.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path45.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs45.existsSync(`${localBin}${ext}`)
+            (ext) => fs44.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2401,21 +2401,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs45.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs44.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path46.resolve(
-            path46.dirname(resolvedScriptPath),
+          executableDir = path45.resolve(
+            path45.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path46.basename(
+            const legacyName = path45.basename(
               this._scriptPath,
-              path46.extname(this._scriptPath)
+              path45.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2426,7 +2426,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path46.extname(executableFile));
+        launchWithNode = sourceExt.includes(path45.extname(executableFile));
         let proc;
         if (process5.platform !== "win32") {
           if (launchWithNode) {
@@ -3341,7 +3341,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path46.basename(filename, path46.extname(filename));
+        this._name = path45.basename(filename, path45.extname(filename));
         return this;
       }
       /**
@@ -3355,9 +3355,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path47) {
-        if (path47 === void 0) return this._executableDir;
-        this._executableDir = path47;
+      executableDir(path46) {
+        if (path46 === void 0) return this._executableDir;
+        this._executableDir = path46;
         return this;
       }
       /**
@@ -3713,17 +3713,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path46) {
-      const ctrl = callVisitor(key, node, visitor, path46);
+    function visit_(key, node, visitor, path45) {
+      const ctrl = callVisitor(key, node, visitor, path45);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path46, ctrl);
-        return visit_(key, ctrl, visitor, path46);
+        replaceNode(key, path45, ctrl);
+        return visit_(key, ctrl, visitor, path45);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path46 = Object.freeze(path46.concat(node));
+          path45 = Object.freeze(path45.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci2 = visit_(i, node.items[i], visitor, path46);
+            const ci2 = visit_(i, node.items[i], visitor, path45);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -3734,13 +3734,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path46 = Object.freeze(path46.concat(node));
-          const ck = visit_("key", node.key, visitor, path46);
+          path45 = Object.freeze(path45.concat(node));
+          const ck = visit_("key", node.key, visitor, path45);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path46);
+          const cv = visit_("value", node.value, visitor, path45);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -3761,17 +3761,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path46) {
-      const ctrl = await callVisitor(key, node, visitor, path46);
+    async function visitAsync_(key, node, visitor, path45) {
+      const ctrl = await callVisitor(key, node, visitor, path45);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path46, ctrl);
-        return visitAsync_(key, ctrl, visitor, path46);
+        replaceNode(key, path45, ctrl);
+        return visitAsync_(key, ctrl, visitor, path45);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path46 = Object.freeze(path46.concat(node));
+          path45 = Object.freeze(path45.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci2 = await visitAsync_(i, node.items[i], visitor, path46);
+            const ci2 = await visitAsync_(i, node.items[i], visitor, path45);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -3782,13 +3782,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path46 = Object.freeze(path46.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path46);
+          path45 = Object.freeze(path45.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path45);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path46);
+          const cv = await visitAsync_("value", node.value, visitor, path45);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -3815,23 +3815,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path46) {
+    function callVisitor(key, node, visitor, path45) {
       if (typeof visitor === "function")
-        return visitor(key, node, path46);
+        return visitor(key, node, path45);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path46);
+        return visitor.Map?.(key, node, path45);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path46);
+        return visitor.Seq?.(key, node, path45);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path46);
+        return visitor.Pair?.(key, node, path45);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path46);
+        return visitor.Scalar?.(key, node, path45);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path46);
+        return visitor.Alias?.(key, node, path45);
       return void 0;
     }
-    function replaceNode(key, path46, node) {
-      const parent = path46[path46.length - 1];
+    function replaceNode(key, path45, node) {
+      const parent = path45[path45.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -4439,10 +4439,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path46, value) {
+    function collectionFromPath(schema, path45, value) {
       let v2 = value;
-      for (let i = path46.length - 1; i >= 0; --i) {
-        const k2 = path46[i];
+      for (let i = path45.length - 1; i >= 0; --i) {
+        const k2 = path45[i];
         if (typeof k2 === "number" && Number.isInteger(k2) && k2 >= 0) {
           const a = [];
           a[k2] = v2;
@@ -4461,7 +4461,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path46) => path46 == null || typeof path46 === "object" && !!path46[Symbol.iterator]().next().done;
+    var isEmptyPath = (path45) => path45 == null || typeof path45 === "object" && !!path45[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -4491,11 +4491,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path46, value) {
-        if (isEmptyPath(path46))
+      addIn(path45, value) {
+        if (isEmptyPath(path45))
           this.add(value);
         else {
-          const [key, ...rest] = path46;
+          const [key, ...rest] = path45;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -4509,8 +4509,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path46) {
-        const [key, ...rest] = path46;
+      deleteIn(path45) {
+        const [key, ...rest] = path45;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -4524,8 +4524,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path46, keepScalar) {
-        const [key, ...rest] = path46;
+      getIn(path45, keepScalar) {
+        const [key, ...rest] = path45;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -4543,8 +4543,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path46) {
-        const [key, ...rest] = path46;
+      hasIn(path45) {
+        const [key, ...rest] = path45;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -4554,8 +4554,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path46, value) {
-        const [key, ...rest] = path46;
+      setIn(path45, value) {
+        const [key, ...rest] = path45;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -7067,9 +7067,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path46, value) {
+      addIn(path45, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path46, value);
+          this.contents.addIn(path45, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -7144,14 +7144,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path46) {
-        if (Collection.isEmptyPath(path46)) {
+      deleteIn(path45) {
+        if (Collection.isEmptyPath(path45)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path46) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path45) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -7166,10 +7166,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path46, keepScalar) {
-        if (Collection.isEmptyPath(path46))
+      getIn(path45, keepScalar) {
+        if (Collection.isEmptyPath(path45))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path46, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path45, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -7180,10 +7180,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path46) {
-        if (Collection.isEmptyPath(path46))
+      hasIn(path45) {
+        if (Collection.isEmptyPath(path45))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path46) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path45) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -7200,13 +7200,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path46, value) {
-        if (Collection.isEmptyPath(path46)) {
+      setIn(path45, value) {
+        if (Collection.isEmptyPath(path45)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path46), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path45), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path46, value);
+          this.contents.setIn(path45, value);
         }
       }
       /**
@@ -9163,9 +9163,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path46) => {
+    visit.itemAtPath = (cst, path45) => {
       let item = cst;
-      for (const [field, index] of path46) {
+      for (const [field, index] of path45) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -9174,23 +9174,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path46) => {
-      const parent = visit.itemAtPath(cst, path46.slice(0, -1));
-      const field = path46[path46.length - 1][0];
+    visit.parentCollection = (cst, path45) => {
+      const parent = visit.itemAtPath(cst, path45.slice(0, -1));
+      const field = path45[path45.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path46, item, visitor) {
-      let ctrl = visitor(item, path46);
+    function _visit(path45, item, visitor) {
+      let ctrl = visitor(item, path45);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci2 = _visit(Object.freeze(path46.concat([[field, i]])), token.items[i], visitor);
+            const ci2 = _visit(Object.freeze(path45.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -9201,10 +9201,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path46);
+            ctrl = ctrl(item, path45);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path46) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path45) : ctrl;
     }
     exports2.visit = visit;
   }
@@ -10489,14 +10489,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs45 = this.flowScalar(this.type);
+              const fs44 = this.flowScalar(this.type);
               if (atNextItem || it2.value) {
-                map.items.push({ start, key: fs45, sep: [] });
+                map.items.push({ start, key: fs44, sep: [] });
                 this.onKeyLine = true;
               } else if (it2.sep) {
-                this.stack.push(fs45);
+                this.stack.push(fs44);
               } else {
-                Object.assign(it2, { key: fs45, sep: [] });
+                Object.assign(it2, { key: fs44, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -10624,13 +10624,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs45 = this.flowScalar(this.type);
+              const fs44 = this.flowScalar(this.type);
               if (!it2 || it2.value)
-                fc.items.push({ start: [], key: fs45, sep: [] });
+                fc.items.push({ start: [], key: fs44, sep: [] });
               else if (it2.sep)
-                this.stack.push(fs45);
+                this.stack.push(fs44);
               else
-                Object.assign(it2, { key: fs45, sep: [] });
+                Object.assign(it2, { key: fs44, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -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)) {
+      if (readDirectory(extensionDirectory).some(matchesExtension)) {
         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))) {
-        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: {
@@ -23142,11 +23985,11 @@ 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;
@@ -23220,7 +24063,6 @@ function assertChannelNotRolledBack(params) {
 }
 
 // src/core/bundle.ts
-var DENY_LIST_TYPE = "tangyr.deny-list.v2";
 var CHANNEL_POINTER_TYPE = "tangyr.channel-pointer.v1";
 var DEFAULT_CHANNEL = "stable";
 
@@ -23344,47 +24186,6 @@ function verifyBundle(bundle, keys, expectedIdentity, now) {
   verifyBundleSignature(bundle, keys, now);
   verifyIdentity(bundle.manifest, expectedIdentity);
 }
-function verifyDenyList(denyList, keys, now) {
-  if (denyList === null || typeof denyList !== "object") {
-    throw new IntegrityError(DENY_LIST_MALFORMED);
-  }
-  const actualKeys = Object.keys(denyList).sort();
-  const expectedKeys = [
-    "entries",
-    "expiresAt",
-    "issuedAt",
-    "keyId",
-    "sequence",
-    "signature",
-    "type"
-  ];
-  if (actualKeys.length !== expectedKeys.length || actualKeys.some((key, index) => key !== expectedKeys[index])) {
-    throw new IntegrityError(
-      `${DENY_LIST_MALFORMED} Expected exactly [${expectedKeys.join(", ")}], got [${actualKeys.join(", ")}].`
-    );
-  }
-  const list = denyList;
-  const shapeOk = list.type === DENY_LIST_TYPE && typeof list.keyId === "string" && typeof list.signature === "string" && list.signature.length > 0 && Number.isSafeInteger(list.sequence) && list.sequence >= 0 && typeof list.issuedAt === "string" && typeof list.expiresAt === "string" && Array.isArray(list.entries) && list.entries.every((entry) => typeof entry === "string");
-  if (!shapeOk) {
-    throw new IntegrityError(DENY_LIST_MALFORMED);
-  }
-  const { signature, ...signed } = list;
-  verifySignedPayload(
-    canonicalJsonBytes(signed),
-    signature,
-    list.keyId,
-    keys,
-    now
-  );
-  assertFreshnessWindow(
-    list.issuedAt,
-    list.expiresAt,
-    now,
-    "An expired revocation deny-list is not evidence that nothing is revoked \u2014 the publisher must re-sign and republish it."
-  );
-  return list;
-}
-var DENY_LIST_MALFORMED = "Revocation deny-list response is malformed, unsigned, or corrupted \u2014 treated as an integrity failure, never as an absent deny-list (REQ-INT-009).";
 function assertFreshnessWindow(issuedAt, expiresAt, now, expiryConsequence) {
   const utcDesignatorPattern = /Z|[+-]\d{2}:\d{2}$/;
   if (!utcDesignatorPattern.test(issuedAt) || !utcDesignatorPattern.test(expiresAt)) {
@@ -23437,101 +24238,32 @@ function verifyChannelPointer(pointer, expectedKit, expectedChannel, keys, now)
       `${CHANNEL_POINTER_MALFORMED} Expected exactly [${expectedKeys.join(", ")}], got [${actualKeys.join(", ")}].`
     );
   }
-  const candidate = pointer;
-  const shapeOk = candidate.type === CHANNEL_POINTER_TYPE && typeof candidate.keyId === "string" && typeof candidate.kit === "string" && candidate.kit.length > 0 && typeof candidate.channel === "string" && candidate.channel.length > 0 && typeof candidate.version === "string" && candidate.version.length > 0 && typeof candidate.signature === "string" && candidate.signature.length > 0 && Number.isSafeInteger(candidate.sequence) && candidate.sequence >= 0 && typeof candidate.issuedAt === "string" && typeof candidate.expiresAt === "string";
-  if (!shapeOk) {
-    throw new IntegrityError(CHANNEL_POINTER_MALFORMED);
-  }
-  const { signature, ...signed } = candidate;
-  verifySignedPayload(
-    canonicalJsonBytes(signed),
-    signature,
-    candidate.keyId,
-    keys,
-    now
-  );
-  if (candidate.kit !== expectedKit || candidate.channel !== expectedChannel) {
-    throw new IntegrityError(
-      `Channel pointer is signed for ${candidate.kit}/${candidate.channel} but was served as ${expectedKit}/${expectedChannel}. A pointer the publisher signed for one channel is being presented as another's \u2014 refusing.`
-    );
-  }
-  assertPathSafeComponent("version", candidate.version);
-  assertFreshnessWindow(
-    candidate.issuedAt,
-    candidate.expiresAt,
-    now,
-    "An expired channel pointer is not evidence that it still names the newest version \u2014 the publisher must re-sign and republish it."
-  );
-  return candidate;
-}
-
-// src/core/revocation-state.ts
-import fs29 from "fs";
-import path27 from "path";
-var REVOCATION_STATE_FILENAME = ".tangyr-revocation.json";
-function stateFilePath2(cacheRoot) {
-  return path27.join(cacheRoot, REVOCATION_STATE_FILENAME);
-}
-function readState2(cacheRoot) {
-  const filePath = stateFilePath2(cacheRoot);
-  let raw;
-  try {
-    raw = fs29.readFileSync(filePath, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      return { state: {} };
-    }
-    return {
-      state: {},
-      warning: `Could not read ${filePath} (${err.message}); the deny-list replay guard starts from nothing for this run.`
-    };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return {
-      state: {},
-      warning: `${filePath} is not valid JSON; the deny-list replay guard starts from nothing for this run.`
-    };
-  }
-  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return {
-      state: {},
-      warning: `${filePath} does not contain an object; the deny-list replay guard starts from nothing for this run.`
-    };
-  }
-  return { state: parsed };
-}
-function readRevocationSequence(cacheRoot, originUrl) {
-  const { state, warning } = readState2(cacheRoot);
-  const record = state[originUrl];
-  const sequence = record !== void 0 && Number.isSafeInteger(record.sequence) ? record.sequence : void 0;
-  return warning === void 0 ? { sequence } : { sequence, warning };
-}
-function writeRevocationSequence(cacheRoot, originUrl, sequence, now) {
-  const { state } = readState2(cacheRoot);
-  const existing = state[originUrl]?.sequence;
-  if (existing !== void 0 && existing >= sequence) {
-    return;
-  }
-  state[originUrl] = { sequence, seenAt: now.toISOString() };
-  const filePath = stateFilePath2(cacheRoot);
-  fs29.mkdirSync(path27.dirname(filePath), { recursive: true, mode: 448 });
-  const tempPath = `${filePath}.${process.pid}.tmp`;
-  fs29.writeFileSync(tempPath, `${JSON.stringify(state, null, 2)}
-`, {
-    mode: 384
-  });
-  fs29.renameSync(tempPath, filePath);
-}
-function assertSequenceNotReplayed(params) {
-  const { originUrl, seen, incoming } = params;
-  if (seen !== void 0 && incoming < seen) {
+  const candidate = pointer;
+  const shapeOk = candidate.type === CHANNEL_POINTER_TYPE && typeof candidate.keyId === "string" && typeof candidate.kit === "string" && candidate.kit.length > 0 && typeof candidate.channel === "string" && candidate.channel.length > 0 && typeof candidate.version === "string" && candidate.version.length > 0 && typeof candidate.signature === "string" && candidate.signature.length > 0 && Number.isSafeInteger(candidate.sequence) && candidate.sequence >= 0 && typeof candidate.issuedAt === "string" && typeof candidate.expiresAt === "string";
+  if (!shapeOk) {
+    throw new IntegrityError(CHANNEL_POINTER_MALFORMED);
+  }
+  const { signature, ...signed } = candidate;
+  verifySignedPayload(
+    canonicalJsonBytes(signed),
+    signature,
+    candidate.keyId,
+    keys,
+    now
+  );
+  if (candidate.kit !== expectedKit || candidate.channel !== expectedChannel) {
     throw new IntegrityError(
-      `Revocation deny-list from ${originUrl} carries sequence ${incoming}, behind the highest already accepted (${seen}). That is a replay of a superseded deny-list, which would silently un-revoke a kit \u2014 refusing (REQ-INT-009).`
+      `Channel pointer is signed for ${candidate.kit}/${candidate.channel} but was served as ${expectedKit}/${expectedChannel}. A pointer the publisher signed for one channel is being presented as another's \u2014 refusing.`
     );
   }
+  assertPathSafeComponent("version", candidate.version);
+  assertFreshnessWindow(
+    candidate.issuedAt,
+    candidate.expiresAt,
+    now,
+    "An expired channel pointer is not evidence that it still names the newest version \u2014 the publisher must re-sign and republish it."
+  );
+  return candidate;
 }
 
 // src/core/materialize.ts
@@ -23579,7 +24311,6 @@ async function withBoundedRetry(operation, sleep2, logger) {
   );
 }
 var BUNDLE_OBJECT_PATH_PREFIX = "/v1/kits";
-var DENY_LIST_OBJECT_PATH = "/v1/deny-list";
 async function fetchVerifiedBundle(params) {
   const { originUrl, reference, transport, keys, now, logger, sleep: sleep2 } = params;
   const credentials = resolveCredentialNonInteractive();
@@ -23633,76 +24364,6 @@ async function fetchVerifiedBundle(params) {
   }
   return parsed;
 }
-async function assertReferenceNotRevoked(params) {
-  const {
-    originUrl,
-    reference,
-    cacheRoot,
-    transport,
-    keys,
-    now,
-    logger,
-    sleep: sleep2
-  } = params;
-  const credentials = resolveCredentialNonInteractive();
-  const denyList = await withBoundedRetry(
-    async () => {
-      const controller = new AbortController();
-      const response = await transport.fetchObjectStream(
-        originUrl,
-        DENY_LIST_OBJECT_PATH,
-        credentials,
-        controller.signal
-      );
-      if (response.status === 401 || response.status === 403) {
-        throw new AuthenticationError(
-          `The origin rejected the credential (HTTP ${response.status}) fetching the revocation deny-list. Set TANGYR_ACCESS_CLIENT_ID and TANGYR_ACCESS_CLIENT_SECRET, or run 'tangyr auth login'.`
-        );
-      }
-      if (response.status !== 200) {
-        throw new Error(
-          `Unexpected HTTP ${response.status} fetching the revocation deny-list from ${originUrl}${DENY_LIST_OBJECT_PATH}.`
-        );
-      }
-      const buffer = await readBoundedStream(
-        response.body,
-        MAX_TOTAL_BUNDLE_BYTES,
-        () => controller.abort()
-      );
-      let parsed;
-      try {
-        parsed = JSON.parse(buffer.toString("utf8"));
-      } catch {
-        throw new IntegrityError(
-          "Revocation deny-list response is not valid JSON \u2014 rejecting (REQ-INT-009)."
-        );
-      }
-      return verifyDenyList(parsed, keys, now);
-    },
-    sleep2,
-    logger
-  );
-  const seen = readRevocationSequence(cacheRoot, originUrl);
-  if (seen.warning) {
-    logger.warn(seen.warning);
-  }
-  assertSequenceNotReplayed({
-    originUrl,
-    seen: seen.sequence,
-    incoming: denyList.sequence
-  });
-  writeRevocationSequence(cacheRoot, originUrl, denyList.sequence, now);
-  const key = `${reference.name}@${reference.version}`;
-  if (denyList.entries.includes(key)) {
-    const entryDir = cacheEntryPath(cacheRoot, reference);
-    if (fs30.existsSync(entryDir)) {
-      fs30.rmSync(entryDir, { recursive: true, force: true });
-    }
-    throw new IntegrityError(
-      `"${key}" is present on the signed revocation deny-list \u2014 refusing to materialize or install; any existing cache entry has been invalidated (REQ-INT-009).`
-    );
-  }
-}
 function parseVersionTriple(version) {
   const leading = version.split("-")[0];
   const parts = leading.split(".");
@@ -23873,16 +24534,6 @@ async function materializeRemoteKit(params) {
     logger,
     sleep: sleep2
   });
-  await assertReferenceNotRevoked({
-    originUrl,
-    reference,
-    cacheRoot,
-    transport,
-    keys,
-    now,
-    logger,
-    sleep: sleep2
-  });
   assertCliVersionCompatible(bundle.manifest.minCliVersion, CLI_VERSION);
   const decoded = verifyBundleFileHashes(bundle);
   if (decoded.has(CACHE_COMPLETION_MARKER) || decoded.has(BUNDLE_DOCUMENT_FILENAME)) {
@@ -24081,7 +24732,7 @@ async function resolveKitSource(params) {
   }
   function degradedWarmReturn() {
     process.stderr.write(
-      `Degraded: proceeding on the warm cache for "${reference.name}@${reference.version}" after a network failure during the authorization-freshness re-check \u2014 revocation and freshness were not re-checked. Run with --refresh once connectivity is restored.
+      `Degraded: proceeding on the warm cache for "${reference.name}@${reference.version}" after a network failure during the authorization-freshness re-check \u2014 freshness was not re-checked. Run with --refresh once connectivity is restored.
 `
     );
     return {
@@ -24123,23 +24774,6 @@ async function resolveKitSource(params) {
       );
     }
     if (probeOutcome.outcome === "success") {
-      try {
-        await assertReferenceNotRevoked({
-          originUrl: config.source.url,
-          reference,
-          cacheRoot,
-          transport,
-          keys,
-          now,
-          logger,
-          sleep: sleep2
-        });
-      } catch (error) {
-        if (!(error instanceof RemoteUnavailableError)) {
-          throw error;
-        }
-        return degradedWarmReturn();
-      }
       writeLastAuthorizedAt(cacheRoot, config.source.url, now);
       const warning = formatAdvanceExpiryWarning(
         probeOutcome.metadata.expiresAt,
@@ -24262,7 +24896,7 @@ import path31 from "path";
 
 // src/compiler/agents.ts
 var TOML = __toESM(require_toml(), 1);
-var import_yaml7 = __toESM(require_dist(), 1);
+var import_yaml8 = __toESM(require_dist(), 1);
 import path29 from "path";
 
 // src/compiler/loss-report.ts
@@ -24388,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}`;
@@ -24474,7 +25108,7 @@ function compileOpenCodeAgent(sourceFile, data, body, relativeSource, lossReport
   );
   return `${marker}
 ---
-${(0, import_yaml7.stringify)(frontmatter).trim()}
+${(0, import_yaml8.stringify)(frontmatter).trim()}
 ---
 `;
 }
@@ -24553,7 +25187,7 @@ ${body.trim()}
 ` : "";
   return `${marker}
 ---
-${(0, import_yaml7.stringify)(frontmatter).trim()}
+${(0, import_yaml8.stringify)(frontmatter).trim()}
 ---
 ${bodySection}`;
 }
@@ -25244,7 +25878,7 @@ function compileOpenCodeMcp(sourceMcpJson, lossReport, sourceLabel) {
 
 // src/compiler/rules.ts
 import path30 from "path";
-var import_yaml8 = __toESM(require_dist(), 1);
+var import_yaml9 = __toESM(require_dist(), 1);
 import fs31 from "fs";
 function compileRules(sourceRulesDir, target, _mappings, lossReport) {
   if (target === "copilot") {
@@ -25323,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,
@@ -25375,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 = {};
         }
@@ -25422,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 = {};
         }
@@ -26024,7 +26658,7 @@ import fs33 from "fs";
 import path33 from "path";
 
 // src/compiler/commands.ts
-var import_yaml9 = __toESM(require_dist(), 1);
+var import_yaml10 = __toESM(require_dist(), 1);
 import path32 from "path";
 function compileCommandPrompt(sourceFile) {
   const { data, body } = parseMarkdownFrontmatter(sourceFile);
@@ -26038,7 +26672,7 @@ function compileCommandPrompt(sourceFile) {
   );
   return `${marker}
 ---
-${(0, import_yaml9.stringify)(fields).trim()}
+${(0, import_yaml10.stringify)(fields).trim()}
 ---
 
 ${body.trimEnd()}
@@ -27614,7 +28248,7 @@ import crypto9 from "crypto";
 import fs36 from "fs";
 import os6 from "os";
 import path36 from "path";
-var import_yaml10 = __toESM(require_dist(), 1);
+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({
@@ -27834,12 +28468,12 @@ 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 = path36.join(sourceRoot, config.source.commands);
@@ -27869,7 +28503,7 @@ 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()}
@@ -28109,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 {
@@ -29797,8 +30431,8 @@ function hashString6(value) {
 }
 
 // src/commands/sync.ts
-import fs42 from "fs";
-import path43 from "path";
+import fs41 from "fs";
+import path42 from "path";
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -30296,8 +30930,8 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // src/adapters/claude-code.ts
-import fs41 from "fs";
-import path42 from "path";
+import fs40 from "fs";
+import path41 from "path";
 
 // src/core/shim.ts
 import crypto11 from "crypto";
@@ -30312,145 +30946,6 @@ function buildAgentsMdShim(shimPath, _agentsMdPath, target) {
 ${SHIM_BODY}`;
 }
 
-// src/compiler/hook-components.ts
-var import_yaml11 = __toESM(require_dist(), 1);
-import fs40 from "fs";
-import path41 from "path";
-function parseHookDeclaration(filePath) {
-  let raw;
-  try {
-    raw = fs40.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 = path41.join(hooksDir, "hooks.json");
-  if (fs40.existsSync(hooksJsonPath)) {
-    const raw = fs40.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 (!fs40.existsSync(hooksDir) || !fs40.statSync(hooksDir).isDirectory()) {
-      return [];
-    }
-    names = fs40.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 = path41.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 [
@@ -30546,7 +31041,7 @@ function syncClaudeCode(config, sourceRoot, options, logger, mappings, manifest,
   }
   if (!shouldSkipComponent6(options, "instructions") && manifest && scopePath) {
     const shimPath = profile.instructions_shim;
-    const agentsMdPath = path42.resolve(sourceRoot, config.source.instructions);
+    const agentsMdPath = path41.resolve(sourceRoot, config.source.instructions);
     if (!options.dryRun) {
       applyClaudeCodeShimUpgrade(
         shimPath,
@@ -30600,13 +31095,13 @@ function syncClaudeCode(config, sourceRoot, options, logger, mappings, manifest,
 }
 function syncProviderLoss2(config, sourceRoot, mappings, lossReport) {
   if (!mappings.modelTiers.custom_provider) return;
-  const agentsDir = path42.join(sourceRoot, config.source.agents);
-  if (!fs41.existsSync(agentsDir)) return;
-  for (const agentFile of ts(path42.join(agentsDir, "*.md")).sort()) {
+  const agentsDir = path41.join(sourceRoot, config.source.agents);
+  if (!fs40.existsSync(agentsDir)) return;
+  for (const agentFile of ts(path41.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 = path42.basename(agentFile);
+      const basename = path41.basename(agentFile);
       addLoss(lossReport, "claude-code", "agents", {
         source: `agents/${basename}`,
         fields: [
@@ -30631,19 +31126,19 @@ function shouldSkipComponent6(options, component) {
 function applyClaudeCodeShimUpgrade(shimPath, agentsMdPath, manifest, scopePath, logger) {
   const expectedBodyHash = shimBodyHash();
   const shimContent = buildAgentsMdShim(shimPath, agentsMdPath, "claude-code");
-  if (!fs41.existsSync(shimPath)) {
+  if (!fs40.existsSync(shimPath)) {
     manifest.artifacts.push({
-      relativePath: path42.relative(scopePath, shimPath),
+      relativePath: path41.relative(scopePath, shimPath),
       hash: expectedBodyHash,
       origin: "tangyr-managed"
     });
     writeManifest(scopePath, manifest);
-    fs41.mkdirSync(path42.dirname(shimPath), { recursive: true });
-    fs41.writeFileSync(shimPath, shimContent);
+    fs40.mkdirSync(path41.dirname(shimPath), { recursive: true });
+    fs40.writeFileSync(shimPath, shimContent);
     logger?.verbose(`instructions-shim: wrote @AGENTS.md shim -> ${shimPath}`);
     return;
   }
-  const existing = fs41.readFileSync(shimPath, "utf8");
+  const existing = fs40.readFileSync(shimPath, "utf8");
   const firstNonEmptyLine = existing.split("\n").find((l) => l.trim().length > 0) ?? "";
   const marker = extractProvenanceMarker(firstNonEmptyLine);
   if (marker !== null && marker.hash === expectedBodyHash) {
@@ -30654,21 +31149,21 @@ function applyClaudeCodeShimUpgrade(shimPath, agentsMdPath, manifest, scopePath,
   }
   backupFile(shimPath, manifest);
   writeManifest(scopePath, manifest);
-  fs41.writeFileSync(shimPath, shimContent);
+  fs40.writeFileSync(shimPath, shimContent);
   manifest.artifacts.push({
-    relativePath: path42.relative(scopePath, shimPath),
+    relativePath: path41.relative(scopePath, shimPath),
     hash: expectedBodyHash,
     origin: "tangyr-managed"
   });
   logger?.verbose(`instructions-shim: backed up and replaced -> ${shimPath}`);
 }
 function syncDirectComponent(config, sourceRoot, options, logger, directComponent, manifest, scopePath) {
-  const source = path42.resolve(
+  const source = path41.resolve(
     sourceRoot,
     config.source[directComponent.sourceKey]
   );
   const destination = directComponent.destination;
-  if (!fs41.existsSync(source)) {
+  if (!fs40.existsSync(source)) {
     return skippedMissingSource6(directComponent.component, source);
   }
   if (options.dryRun) {
@@ -30690,7 +31185,7 @@ function syncDirectComponent(config, sourceRoot, options, logger, directComponen
     };
   }
   if (artifactClass === "managed-stale" && isOurStaleSymlink(destination, /* @__PURE__ */ new Set([destination]), config)) {
-    fs41.unlinkSync(destination);
+    fs40.unlinkSync(destination);
   } else if (artifactClass === "unmanaged-conflict" && !handleConflict6(destination, config, options, logger, manifest, scopePath)) {
     return {
       component: directComponent.component,
@@ -30698,9 +31193,9 @@ function syncDirectComponent(config, sourceRoot, options, logger, directComponen
       path: destination
     };
   } else if (artifactClass === "managed-symlink") {
-    fs41.unlinkSync(destination);
+    fs40.unlinkSync(destination);
   }
-  ensureDir(path42.dirname(destination));
+  ensureDir(path41.dirname(destination));
   createRelativeSymlink(source, destination, directComponent.type, {
     logger,
     provenanceMarker: directComponent.type === "file" ? formatProvenanceMarker(
@@ -30717,8 +31212,8 @@ function syncDirectComponent(config, sourceRoot, options, logger, directComponen
   };
 }
 function syncClaudeCodeSkills(config, sourceRoot, options, logger, destination, manifest, scopePath) {
-  const source = path42.resolve(sourceRoot, config.source.skills);
-  if (!fs41.existsSync(source)) {
+  const source = path41.resolve(sourceRoot, config.source.skills);
+  if (!fs40.existsSync(source)) {
     return [skippedMissingSource6("skills", source)];
   }
   const declaredNames = resolveKitSkillNames(sourceRoot);
@@ -30728,7 +31223,7 @@ function syncClaudeCodeSkills(config, sourceRoot, options, logger, destination,
     if (isLegacyWholesaleSymlink) {
       for (const name of foreignSkillNames(source, declaredNames)) {
         logger.info(
-          `[dry-run] skills: migrate foreign skill ${path42.join(source, name)} -> ${path42.join(destination, name)}`
+          `[dry-run] skills: migrate foreign skill ${path41.join(source, name)} -> ${path41.join(destination, name)}`
         );
       }
       logger.info(
@@ -30736,9 +31231,9 @@ function syncClaudeCodeSkills(config, sourceRoot, options, logger, destination,
       );
     }
     for (const name of declaredNames ?? listSkillDirNames(source)) {
-      const skillDestination = path42.join(destination, name);
+      const skillDestination = path41.join(destination, name);
       logger.info(
-        `[dry-run] skills: symlink ${path42.join(source, name)} -> ${skillDestination}`
+        `[dry-run] skills: symlink ${path41.join(source, name)} -> ${skillDestination}`
       );
       outcomes2.push({
         component: "skills",
@@ -30771,9 +31266,9 @@ function syncClaudeCodeSkills(config, sourceRoot, options, logger, destination,
   return outcomes;
 }
 function syncSingleSkill(config, sourceRoot, options, logger, source, destination, name, manifest, scopePath) {
-  const skillSource = path42.join(source, name);
-  const skillDestination = path42.join(destination, name);
-  if (!fs41.existsSync(skillSource)) {
+  const skillSource = path41.join(source, name);
+  const skillDestination = path41.join(destination, name);
+  if (!fs40.existsSync(skillSource)) {
     return skippedMissingSource6("skills", skillSource);
   }
   const artifactClass = classifyArtifact(skillDestination, config, sourceRoot);
@@ -30785,7 +31280,7 @@ function syncSingleSkill(config, sourceRoot, options, logger, source, destinatio
     };
   }
   if (artifactClass === "managed-stale" && isOurStaleSymlink(skillDestination, /* @__PURE__ */ new Set([skillDestination]), config)) {
-    fs41.unlinkSync(skillDestination);
+    fs40.unlinkSync(skillDestination);
   } else if (artifactClass === "unmanaged-conflict" && !handleConflict6(
     skillDestination,
     config,
@@ -30796,25 +31291,25 @@ function syncSingleSkill(config, sourceRoot, options, logger, source, destinatio
   )) {
     return { component: "skills", status: "conflict", path: skillDestination };
   } else if (artifactClass === "managed-symlink") {
-    fs41.unlinkSync(skillDestination);
+    fs40.unlinkSync(skillDestination);
   }
   createRelativeSymlink(skillSource, skillDestination, "dir");
   return { component: "skills", status: "success", path: skillDestination };
 }
 function migrateWholesaleSkillsSymlink(source, destination, declaredNames, logger) {
   const foreignNames = foreignSkillNames(source, declaredNames);
-  fs41.unlinkSync(destination);
+  fs40.unlinkSync(destination);
   ensureDir(destination);
   for (const name of foreignNames) {
-    const from = path42.join(source, name);
-    const to = path42.join(destination, name);
-    if (fs41.existsSync(to)) {
+    const from = path41.join(source, name);
+    const to = path41.join(destination, name);
+    if (fs40.existsSync(to)) {
       logger.warn(
         `skills migration: ${to} already exists \u2014 skipping move of ${from} to avoid overwrite`
       );
       continue;
     }
-    fs41.renameSync(from, to);
+    fs40.renameSync(from, to);
     logger.info(`skills migration: moved ${from} -> ${to}`);
   }
 }
@@ -30826,21 +31321,21 @@ function foreignSkillNames(source, declaredNames) {
   return listSkillDirNames(source).filter((name) => !declaredSet.has(name));
 }
 function listSkillDirNames(dir) {
-  if (!fs41.existsSync(dir)) {
+  if (!fs40.existsSync(dir)) {
     return [];
   }
-  return fs41.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name);
+  return fs40.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name);
 }
 function isSymlinkPath(filePath) {
   try {
-    return fs41.lstatSync(filePath).isSymbolicLink();
+    return fs40.lstatSync(filePath).isSymbolicLink();
   } catch {
     return false;
   }
 }
 function syncHookScriptsBridge(config, sourceRoot, options, logger, destination, manifest, scopePath) {
-  const source = path42.resolve(sourceRoot, config.source.hooks);
-  if (!fs41.existsSync(source)) {
+  const source = path41.resolve(sourceRoot, config.source.hooks);
+  if (!fs40.existsSync(source)) {
     return skippedMissingSource6("hooks", source);
   }
   if (options.dryRun) {
@@ -30852,13 +31347,13 @@ function syncHookScriptsBridge(config, sourceRoot, options, logger, destination,
     return { component: "hooks", status: "skipped-current", path: destination };
   }
   if (artifactClass === "managed-stale" && isOurStaleSymlink(destination, /* @__PURE__ */ new Set([destination]), config)) {
-    fs41.unlinkSync(destination);
+    fs40.unlinkSync(destination);
   } else if (artifactClass === "unmanaged-conflict" && !handleConflict6(destination, config, options, logger, manifest, scopePath)) {
     return { component: "hooks", status: "conflict", path: destination };
   } else if (artifactClass === "managed-symlink") {
-    fs41.unlinkSync(destination);
+    fs40.unlinkSync(destination);
   }
-  ensureDir(path42.dirname(destination));
+  ensureDir(path41.dirname(destination));
   createRelativeSymlink(source, destination, "dir");
   return { component: "hooks", status: "success", path: destination };
 }
@@ -30881,7 +31376,7 @@ function syncHooks6(config, sourceRoot, options, logger, destination) {
     destination,
     settings,
     stringifyJson3,
-    !fs41.existsSync(destination),
+    !fs40.existsSync(destination),
     logger
   );
   return {
@@ -30891,8 +31386,8 @@ function syncHooks6(config, sourceRoot, options, logger, destination) {
   };
 }
 function syncMcp6(config, sourceRoot, options, logger, destination) {
-  const source = path42.resolve(sourceRoot, config.source.mcp);
-  if (!fs41.existsSync(source)) {
+  const source = path41.resolve(sourceRoot, config.source.mcp);
+  if (!fs40.existsSync(source)) {
     return skippedMissingSource6("mcp", source);
   }
   if (options.dryRun) {
@@ -30917,7 +31412,7 @@ function syncMcp6(config, sourceRoot, options, logger, destination) {
     destination,
     hostConfig,
     stringifyJson3,
-    !fs41.existsSync(destination),
+    !fs40.existsSync(destination),
     logger
   );
   return {
@@ -30927,8 +31422,8 @@ function syncMcp6(config, sourceRoot, options, logger, destination) {
   };
 }
 function syncSettings2(config, sourceRoot, options, logger, destination) {
-  const source = path42.resolve(sourceRoot, config.source.settings);
-  if (!fs41.existsSync(source)) {
+  const source = path41.resolve(sourceRoot, config.source.settings);
+  if (!fs40.existsSync(source)) {
     return skippedMissingSource6("settings", source);
   }
   if (options.dryRun) {
@@ -30946,7 +31441,7 @@ function syncSettings2(config, sourceRoot, options, logger, destination) {
     destination,
     settings,
     stringifyJson3,
-    !fs41.existsSync(destination),
+    !fs40.existsSync(destination),
     logger
   );
   return {
@@ -30971,11 +31466,11 @@ function handleConflict6(destination, config, options, logger, manifest, scopePa
       backupFile(destination, manifest);
       writeManifest(scopePath, manifest);
     } else {
-      fs41.renameSync(destination, `${destination}.bak.${Date.now()}`);
+      fs40.renameSync(destination, `${destination}.bak.${Date.now()}`);
     }
     return true;
   }
-  fs41.rmSync(destination, { recursive: true, force: true });
+  fs40.rmSync(destination, { recursive: true, force: true });
   return true;
 }
 function skippedMissingSource6(component, source) {
@@ -30987,16 +31482,16 @@ function skippedMissingSource6(component, source) {
 }
 function isSymlinkTo6(linkPath, source) {
   try {
-    return fs41.realpathSync(linkPath) === fs41.realpathSync(source);
+    return fs40.realpathSync(linkPath) === fs40.realpathSync(source);
   } catch {
     return false;
   }
 }
 function readJsonObject4(filePath) {
-  if (!fs41.existsSync(filePath)) {
+  if (!fs40.existsSync(filePath)) {
     return {};
   }
-  const parsed = JSON.parse(fs41.readFileSync(filePath, "utf8"));
+  const parsed = JSON.parse(fs40.readFileSync(filePath, "utf8"));
   return isRecord5(parsed) ? parsed : {};
 }
 function markManaged(value) {
@@ -31262,7 +31757,7 @@ function writeLossReport(filePath, report) {
   if (!filePath) {
     return;
   }
-  fs42.writeFileSync(filePath, `${JSON.stringify(report, null, 2)}
+  fs41.writeFileSync(filePath, `${JSON.stringify(report, null, 2)}
 `);
 }
 function prepareKitManifest(scope, projectRoot, kitInfo) {
@@ -31303,8 +31798,8 @@ function updateManifest(kitInfo, kitSync) {
   writeManifest(kitSync.scopePath, kitSync.manifest);
 }
 function resolveKitFilePath(kitPath, relativePath) {
-  const fullPath = path43.join(kitPath, relativePath);
-  return fs42.existsSync(fullPath) ? fullPath : null;
+  const fullPath = path42.join(kitPath, relativePath);
+  return fs41.existsSync(fullPath) ? fullPath : null;
 }
 function cleanupRemovedManagedArtifacts(config, mappings, targets, options, removedSourcePaths, logger) {
   if (removedSourcePaths.length === 0 || !mappings) {
@@ -31365,9 +31860,9 @@ function cleanupRemovedCopilotArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("agents/")) {
     removeManagedCompiledArtifact2(
-      path43.join(
+      path42.join(
         resolveTargetPath(paths.agents ?? ""),
-        `${path43.parse(relativePath).name}.agent.md`
+        `${path42.parse(relativePath).name}.agent.md`
       ),
       "copilot",
       relativePath,
@@ -31377,9 +31872,9 @@ function cleanupRemovedCopilotArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("commands/")) {
     removeManagedCompiledArtifact2(
-      path43.join(
+      path42.join(
         resolveTargetPath(paths.prompts ?? ""),
-        `${path43.parse(relativePath).name}.prompt.md`
+        `${path42.parse(relativePath).name}.prompt.md`
       ),
       "copilot",
       relativePath,
@@ -31389,7 +31884,7 @@ function cleanupRemovedCopilotArtifact(relativePath, paths, logger) {
   }
   if (relativePath.endsWith("hooks.json")) {
     removeManagedCompiledArtifact2(
-      path43.join(resolveTargetPath(paths.hooks ?? ""), "tangyr-managed.json"),
+      path42.join(resolveTargetPath(paths.hooks ?? ""), "tangyr-managed.json"),
       "copilot",
       relativePath,
       logger
@@ -31419,9 +31914,9 @@ function cleanupRemovedCodexArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("agents/")) {
     removeManagedCompiledArtifact2(
-      path43.join(
+      path42.join(
         resolveTargetPath(paths.agents ?? ""),
-        `${path43.parse(relativePath).name}.toml`
+        `${path42.parse(relativePath).name}.toml`
       ),
       "codex",
       relativePath,
@@ -31431,9 +31926,9 @@ function cleanupRemovedCodexArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("rules/")) {
     removeManagedCompiledArtifact2(
-      path43.join(
+      path42.join(
         resolveTargetPath(paths.rules ?? ""),
-        `${path43.parse(relativePath).name}.rules`
+        `${path42.parse(relativePath).name}.rules`
       ),
       "codex",
       relativePath,
@@ -31472,9 +31967,9 @@ function cleanupRemovedOpenCodeArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("agents/")) {
     removeManagedCompiledArtifact2(
-      path43.join(
+      path42.join(
         resolveTargetPath(paths.agents ?? ""),
-        `${path43.parse(relativePath).name}.md`
+        `${path42.parse(relativePath).name}.md`
       ),
       "opencode",
       relativePath,
@@ -31484,9 +31979,9 @@ function cleanupRemovedOpenCodeArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("commands/")) {
     removeManagedCompiledArtifact2(
-      path43.join(
+      path42.join(
         resolveTargetPath(paths.commands ?? ""),
-        `${path43.parse(relativePath).name}.md`
+        `${path42.parse(relativePath).name}.md`
       ),
       "opencode",
       relativePath,
@@ -31518,9 +32013,9 @@ function cleanupRemovedCursorArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("agents/")) {
     removeManagedCompiledArtifact2(
-      path43.join(
+      path42.join(
         resolveTargetPath(paths.agents ?? ""),
-        `${path43.parse(relativePath).name}.md`
+        `${path42.parse(relativePath).name}.md`
       ),
       "cursor",
       relativePath,
@@ -31530,9 +32025,9 @@ function cleanupRemovedCursorArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("rules/")) {
     removeManagedCompiledArtifact2(
-      path43.join(
+      path42.join(
         resolveTargetPath(paths.rules ?? ""),
-        `${path43.parse(relativePath).name}.mdc`
+        `${path42.parse(relativePath).name}.mdc`
       ),
       "cursor",
       relativePath,
@@ -31542,9 +32037,9 @@ function cleanupRemovedCursorArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("commands/")) {
     removeManagedCompiledArtifact2(
-      path43.join(
+      path42.join(
         resolveTargetPath(paths.skills ?? ""),
-        path43.parse(relativePath).name,
+        path42.parse(relativePath).name,
         "SKILL.md"
       ),
       "cursor",
@@ -31588,9 +32083,9 @@ function cleanupRemovedClineArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("rules/")) {
     removeManagedCompiledArtifact2(
-      path43.join(
+      path42.join(
         resolveTargetPath(paths.rules ?? ""),
-        `${path43.parse(relativePath).name}.md`
+        `${path42.parse(relativePath).name}.md`
       ),
       "cline",
       relativePath,
@@ -31600,9 +32095,9 @@ function cleanupRemovedClineArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("commands/")) {
     removeManagedCompiledArtifact2(
-      path43.join(
+      path42.join(
         resolveTargetPath(paths.workflows ?? ""),
-        path43.basename(relativePath)
+        path42.basename(relativePath)
       ),
       "cline",
       relativePath,
@@ -31620,17 +32115,17 @@ function cleanupRemovedClineArtifact(relativePath, paths, logger) {
   }
 }
 function removeManagedCompiledArtifact2(artifactPath, expectedTarget, expectedSource, logger) {
-  if (!fs42.existsSync(artifactPath)) {
+  if (!fs41.existsSync(artifactPath)) {
     return;
   }
-  if (!fs42.statSync(artifactPath).isFile()) {
+  if (!fs41.statSync(artifactPath).isFile()) {
     return;
   }
-  const marker = extractProvenanceMarker(fs42.readFileSync(artifactPath, "utf8"));
+  const marker = extractProvenanceMarker(fs41.readFileSync(artifactPath, "utf8"));
   if (marker?.source !== expectedSource || marker.target !== expectedTarget) {
     return;
   }
-  fs42.rmSync(artifactPath, { force: true });
+  fs41.rmSync(artifactPath, { force: true });
   logger.verbose(`  removed stale target artifact: ${artifactPath}`);
 }
 function removeManagedCopilotMcpArtifact2(artifactPath, expectedSource, logger) {
@@ -31661,10 +32156,10 @@ function removeManagedCodexHooksArtifact2(artifactPath, expectedSource, logger)
   logger.verbose(`  removed stale target artifact: ${artifactPath}`);
 }
 function removeManagedCodexMcpArtifact2(artifactPath, expectedSource, logger) {
-  if (!fs42.existsSync(artifactPath)) {
+  if (!fs41.existsSync(artifactPath)) {
     return;
   }
-  const content = fs42.readFileSync(artifactPath, "utf8");
+  const content = fs41.readFileSync(artifactPath, "utf8");
   const startMarker = "# tangyr: managed mcp start";
   const endMarker = "# tangyr: managed mcp end";
   const startIndex = content.indexOf(startMarker);
@@ -31681,19 +32176,19 @@ function removeManagedCodexMcpArtifact2(artifactPath, expectedSource, logger) {
   const after = content.slice(endIndex + endMarker.length).trimStart();
   const cleaned = [before, after].filter((entry) => entry.length > 0).join("\n\n");
   if (cleaned.length === 0) {
-    fs42.rmSync(artifactPath, { force: true });
+    fs41.rmSync(artifactPath, { force: true });
   } else {
-    fs42.writeFileSync(artifactPath, `${cleaned}
+    fs41.writeFileSync(artifactPath, `${cleaned}
 `);
   }
   logger.verbose(`  removed stale target artifact: ${artifactPath}`);
 }
 function readJsonObject5(filePath) {
-  if (!fs42.existsSync(filePath)) {
+  if (!fs41.existsSync(filePath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(fs42.readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(fs41.readFileSync(filePath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -31707,10 +32202,10 @@ function readJsonMetadata(value) {
 }
 function writeJsonOrRemove2(filePath, parsed) {
   if (isEmptyJsonValue2(parsed)) {
-    fs42.rmSync(filePath, { force: true });
+    fs41.rmSync(filePath, { force: true });
     return;
   }
-  fs42.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
+  fs41.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
 `);
 }
 function isEmptyJsonValue2(value) {
@@ -31770,8 +32265,8 @@ function removeManagedHookEntries(value, expectedSource) {
 }
 
 // src/commands/validate.ts
-import fs43 from "fs";
-import path44 from "path";
+import fs42 from "fs";
+import path43 from "path";
 var SUPPORTED_KIT_FORMATS2 = [1];
 var SUPPORTED_DISCIPLINE_VERSIONS = [
   "0.14.0",
@@ -31855,8 +32350,8 @@ function checkKitFormatSupported(kit) {
 }
 function checkEntrypointExists(kit) {
   const entrypoint = "CLAUDE.md";
-  const entrypointPath = path44.join(kit.path, entrypoint);
-  if (!fs43.existsSync(entrypointPath)) {
+  const entrypointPath = path43.join(kit.path, entrypoint);
+  if (!fs42.existsSync(entrypointPath)) {
     return {
       code: "entrypoint-missing",
       location: entrypoint,
@@ -31913,9 +32408,9 @@ function checkComponentFrontmatter(kit) {
     const missingSet = new Set(kit.components[cat].missing);
     for (const name of kit.components[cat].declared) {
       if (missingSet.has(name)) continue;
-      const filePath = cat === "skills" ? path44.join(kit.path, cat, name, "SKILL.md") : path44.join(kit.path, cat, `${name}.md`);
-      if (!fs43.existsSync(filePath)) continue;
-      const relPath = path44.relative(kit.path, filePath);
+      const filePath = cat === "skills" ? path43.join(kit.path, cat, name, "SKILL.md") : path43.join(kit.path, cat, `${name}.md`);
+      if (!fs42.existsSync(filePath)) continue;
+      const relPath = path43.relative(kit.path, filePath);
       try {
         const { data } = parseMarkdownFrontmatter(filePath);
         for (const field of requiredFields) {
@@ -31940,10 +32435,10 @@ function checkComponentFrontmatter(kit) {
 }
 function checkReservedRootNames(kit) {
   const violations = [];
-  if (!fs43.existsSync(kit.path) || !fs43.statSync(kit.path).isDirectory()) {
+  if (!fs42.existsSync(kit.path) || !fs42.statSync(kit.path).isDirectory()) {
     return violations;
   }
-  const entries = fs43.readdirSync(kit.path, { withFileTypes: true });
+  const entries = fs42.readdirSync(kit.path, { withFileTypes: true });
   for (const entry of entries) {
     if (RESERVED_ROOT_NAMES.includes(entry.name)) {
       violations.push({
@@ -31960,8 +32455,8 @@ function checkHumanOnlyCommandInvocation(kit) {
   const missingSet = new Set(kit.components.commands.missing);
   for (const name of kit.components.commands.declared) {
     if (missingSet.has(name)) continue;
-    const filePath = path44.join(kit.path, "commands", `${name}.md`);
-    if (!fs43.existsSync(filePath)) continue;
+    const filePath = path43.join(kit.path, "commands", `${name}.md`);
+    if (!fs42.existsSync(filePath)) continue;
     let data;
     try {
       ({ data } = parseMarkdownFrontmatter(filePath));
@@ -31974,7 +32469,7 @@ function checkHumanOnlyCommandInvocation(kit) {
     if (!barred) {
       violations.push({
         code: "command-human-only-model-invocable",
-        location: path44.relative(kit.path, filePath),
+        location: path43.relative(kit.path, filePath),
         message: "commands: 'launch: human-only' requires 'disable-model-invocation: true' so the model cannot start the command; only a Human-typed launch may"
       });
     }
@@ -31983,8 +32478,8 @@ function checkHumanOnlyCommandInvocation(kit) {
 }
 
 // src/commands/verify.ts
-import fs44 from "fs";
-import path45 from "path";
+import fs43 from "fs";
+import path44 from "path";
 function runVerifyCommand(options, logger) {
   const { config, configDir, sourceRoot, kitInfo } = resolveRuntime(
     options,
@@ -32075,8 +32570,8 @@ function verifyClaudeCodeGlobalRoots(roots, manifestKeys, mappings) {
       if (!slotPath) {
         continue;
       }
-      const fullPath = subPath ? path45.join(slotPath, subPath) : slotPath;
-      if (!fs44.existsSync(fullPath)) {
+      const fullPath = subPath ? path44.join(slotPath, subPath) : slotPath;
+      if (!fs43.existsSync(fullPath)) {
         failures.push(
           `claude-code/${slot}${subPath ? `/${subPath}` : ""} missing in root ${root}: ${fullPath}`
         );