@alessandroraffa/tangyr 4.1.0 → 5.0.0

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 path52 = __require("path");
-    var fs51 = __require("fs");
+    var path53 = __require("path");
+    var fs52 = __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 (fs51.existsSync(executableFile)) return;
+        if (fs52.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 = path52.resolve(baseDir, baseName);
-          if (fs51.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path52.extname(baseName))) return void 0;
+          const localBin = path53.resolve(baseDir, baseName);
+          if (fs52.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path53.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs51.existsSync(`${localBin}${ext}`)
+            (ext) => fs52.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 = fs51.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs52.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path52.resolve(
-            path52.dirname(resolvedScriptPath),
+          executableDir = path53.resolve(
+            path53.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path52.basename(
+            const legacyName = path53.basename(
               this._scriptPath,
-              path52.extname(this._scriptPath)
+              path53.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2426,7 +2426,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path52.extname(executableFile));
+        launchWithNode = sourceExt.includes(path53.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 = path52.basename(filename, path52.extname(filename));
+        this._name = path53.basename(filename, path53.extname(filename));
         return this;
       }
       /**
@@ -3355,9 +3355,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path53) {
-        if (path53 === void 0) return this._executableDir;
-        this._executableDir = path53;
+      executableDir(path54) {
+        if (path54 === void 0) return this._executableDir;
+        this._executableDir = path54;
         return this;
       }
       /**
@@ -3713,17 +3713,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path52) {
-      const ctrl = callVisitor(key, node, visitor, path52);
+    function visit_(key, node, visitor, path53) {
+      const ctrl = callVisitor(key, node, visitor, path53);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path52, ctrl);
-        return visit_(key, ctrl, visitor, path52);
+        replaceNode(key, path53, ctrl);
+        return visit_(key, ctrl, visitor, path53);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path52 = Object.freeze(path52.concat(node));
+          path53 = Object.freeze(path53.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci2 = visit_(i, node.items[i], visitor, path52);
+            const ci2 = visit_(i, node.items[i], visitor, path53);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -3734,13 +3734,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path52 = Object.freeze(path52.concat(node));
-          const ck = visit_("key", node.key, visitor, path52);
+          path53 = Object.freeze(path53.concat(node));
+          const ck = visit_("key", node.key, visitor, path53);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path52);
+          const cv = visit_("value", node.value, visitor, path53);
           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, path52) {
-      const ctrl = await callVisitor(key, node, visitor, path52);
+    async function visitAsync_(key, node, visitor, path53) {
+      const ctrl = await callVisitor(key, node, visitor, path53);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path52, ctrl);
-        return visitAsync_(key, ctrl, visitor, path52);
+        replaceNode(key, path53, ctrl);
+        return visitAsync_(key, ctrl, visitor, path53);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path52 = Object.freeze(path52.concat(node));
+          path53 = Object.freeze(path53.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci2 = await visitAsync_(i, node.items[i], visitor, path52);
+            const ci2 = await visitAsync_(i, node.items[i], visitor, path53);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -3782,13 +3782,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path52 = Object.freeze(path52.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path52);
+          path53 = Object.freeze(path53.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path53);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path52);
+          const cv = await visitAsync_("value", node.value, visitor, path53);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -3815,23 +3815,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path52) {
+    function callVisitor(key, node, visitor, path53) {
       if (typeof visitor === "function")
-        return visitor(key, node, path52);
+        return visitor(key, node, path53);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path52);
+        return visitor.Map?.(key, node, path53);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path52);
+        return visitor.Seq?.(key, node, path53);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path52);
+        return visitor.Pair?.(key, node, path53);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path52);
+        return visitor.Scalar?.(key, node, path53);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path52);
+        return visitor.Alias?.(key, node, path53);
       return void 0;
     }
-    function replaceNode(key, path52, node) {
-      const parent = path52[path52.length - 1];
+    function replaceNode(key, path53, node) {
+      const parent = path53[path53.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, path52, value) {
+    function collectionFromPath(schema, path53, value) {
       let v2 = value;
-      for (let i = path52.length - 1; i >= 0; --i) {
-        const k2 = path52[i];
+      for (let i = path53.length - 1; i >= 0; --i) {
+        const k2 = path53[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 = (path52) => path52 == null || typeof path52 === "object" && !!path52[Symbol.iterator]().next().done;
+    var isEmptyPath = (path53) => path53 == null || typeof path53 === "object" && !!path53[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(path52, value) {
-        if (isEmptyPath(path52))
+      addIn(path53, value) {
+        if (isEmptyPath(path53))
           this.add(value);
         else {
-          const [key, ...rest] = path52;
+          const [key, ...rest] = path53;
           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(path52) {
-        const [key, ...rest] = path52;
+      deleteIn(path53) {
+        const [key, ...rest] = path53;
         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(path52, keepScalar) {
-        const [key, ...rest] = path52;
+      getIn(path53, keepScalar) {
+        const [key, ...rest] = path53;
         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(path52) {
-        const [key, ...rest] = path52;
+      hasIn(path53) {
+        const [key, ...rest] = path53;
         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(path52, value) {
-        const [key, ...rest] = path52;
+      setIn(path53, value) {
+        const [key, ...rest] = path53;
         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(path52, value) {
+      addIn(path53, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path52, value);
+          this.contents.addIn(path53, 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(path52) {
-        if (Collection.isEmptyPath(path52)) {
+      deleteIn(path53) {
+        if (Collection.isEmptyPath(path53)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path52) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path53) : 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(path52, keepScalar) {
-        if (Collection.isEmptyPath(path52))
+      getIn(path53, keepScalar) {
+        if (Collection.isEmptyPath(path53))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path52, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path53, 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(path52) {
-        if (Collection.isEmptyPath(path52))
+      hasIn(path53) {
+        if (Collection.isEmptyPath(path53))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path52) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path53) : 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(path52, value) {
-        if (Collection.isEmptyPath(path52)) {
+      setIn(path53, value) {
+        if (Collection.isEmptyPath(path53)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path52), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path53), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path52, value);
+          this.contents.setIn(path53, value);
         }
       }
       /**
@@ -9163,9 +9163,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path52) => {
+    visit.itemAtPath = (cst, path53) => {
       let item = cst;
-      for (const [field, index] of path52) {
+      for (const [field, index] of path53) {
         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, path52) => {
-      const parent = visit.itemAtPath(cst, path52.slice(0, -1));
-      const field = path52[path52.length - 1][0];
+    visit.parentCollection = (cst, path53) => {
+      const parent = visit.itemAtPath(cst, path53.slice(0, -1));
+      const field = path53[path53.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path52, item, visitor) {
-      let ctrl = visitor(item, path52);
+    function _visit(path53, item, visitor) {
+      let ctrl = visitor(item, path53);
       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(path52.concat([[field, i]])), token.items[i], visitor);
+            const ci2 = _visit(Object.freeze(path53.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, path52);
+            ctrl = ctrl(item, path53);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path52) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path53) : ctrl;
     }
     exports2.visit = visit;
   }
@@ -10489,14 +10489,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs51 = this.flowScalar(this.type);
+              const fs52 = this.flowScalar(this.type);
               if (atNextItem || it2.value) {
-                map.items.push({ start, key: fs51, sep: [] });
+                map.items.push({ start, key: fs52, sep: [] });
                 this.onKeyLine = true;
               } else if (it2.sep) {
-                this.stack.push(fs51);
+                this.stack.push(fs52);
               } else {
-                Object.assign(it2, { key: fs51, sep: [] });
+                Object.assign(it2, { key: fs52, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -10624,13 +10624,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs51 = this.flowScalar(this.type);
+              const fs52 = this.flowScalar(this.type);
               if (!it2 || it2.value)
-                fc.items.push({ start: [], key: fs51, sep: [] });
+                fc.items.push({ start: [], key: fs52, sep: [] });
               else if (it2.sep)
-                this.stack.push(fs51);
+                this.stack.push(fs52);
               else
-                Object.assign(it2, { key: fs51, sep: [] });
+                Object.assign(it2, { key: fs52, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -21625,6 +21625,19 @@ var lossSeverityByEntryType = {
   "rule-as-instruction": "info",
   "rule-mode-downgrade": "warning",
   "rule-path-scoping": "warning",
+  // The rule is not there. Measured on the files each target reads, after every
+  // target has written, so this says what arrived rather than what a compiler
+  // intended — the two have disagreed, most often where several targets write
+  // one instructions file and only the last writer's content survives.
+  //
+  // Error by the severity ladder's own definition: `warning` is "a real
+  // reduction in fidelity that still produces a working artifact", and an
+  // absent rule is not reduced, it is absent. `error` is "an intent that could
+  // not be emitted at all and requires a manual step or a kit change", which is
+  // exactly the remedy the run prints: give the target an instructions path of
+  // its own, or disable it. `acceptedLoss` is how a project that has decided to
+  // live with it says so.
+  "rule-not-delivered": "error",
   "hook-event-drop": "warning",
   // A declaration the parser refuses installs nothing, anywhere, and used to
   // do so silently. Error severity is what makes install and sync exit 3.
@@ -21991,7 +22004,7 @@ function reportHooksSourceConflict(report, targets, hooksDir, hookNames) {
 
 // src/adapters/hook-scripts-bridge.ts
 import fs25 from "fs";
-import path22 from "path";
+import path23 from "path";
 
 // src/utils/fs.ts
 import fs23 from "fs";
@@ -22121,8 +22134,62 @@ function compareArtifactState(recorded, artifactPath) {
   return current === recorded ? "current" : "modified";
 }
 
+// src/core/shared-artifacts.ts
+import path22 from "path";
+var SHARED_NAMESPACE = "shared";
+var SHARED_INSTRUCTIONS_KEY = `${SHARED_NAMESPACE}/AGENTS.md`;
+var SHARED_INSTRUCTIONS_FILE = "AGENTS.md";
+var SHARED_HOOK_SCRIPTS_KEY = `${SHARED_NAMESPACE}/hook_scripts`;
+function sharedArtifactKey(destination, scope, projectRoot) {
+  if (scope !== "project") {
+    return null;
+  }
+  const root = projectRoot ?? process.cwd();
+  const shared = path22.resolve(root, SHARED_INSTRUCTIONS_FILE);
+  return path22.resolve(destination) === shared ? SHARED_INSTRUCTIONS_KEY : null;
+}
+function resolveSharedArtifactKey(key, scope, projectRoot) {
+  if (key !== SHARED_INSTRUCTIONS_KEY || scope !== "project") {
+    return null;
+  }
+  return path22.join(projectRoot ?? process.cwd(), SHARED_INSTRUCTIONS_FILE);
+}
+var SHARED_SKILLS_PREFIX = `${SHARED_NAMESPACE}/skills`;
+function sharedKeyForDestination(destination, scope, projectRoot, platformPaths) {
+  const instructions = sharedArtifactKey(destination, scope, projectRoot);
+  if (instructions) {
+    return instructions;
+  }
+  const resolved = path22.resolve(destination);
+  let profiles;
+  try {
+    profiles = resolveTargetPaths({
+      scope,
+      projectRoot,
+      mappings: platformPaths
+    });
+  } catch {
+    return null;
+  }
+  if (resolved === path22.resolve(profiles.codex.hook_scripts)) {
+    return SHARED_HOOK_SCRIPTS_KEY;
+  }
+  const skillsRoot = path22.resolve(profiles.opencode.skills_shared);
+  if (resolved.startsWith(`${skillsRoot}${path22.sep}`)) {
+    const inside = path22.relative(skillsRoot, resolved).split(path22.sep).join("/");
+    return `${SHARED_SKILLS_PREFIX}/${inside}`;
+  }
+  return null;
+}
+function resolveSharedSkillsKey(key, sharedSkillsRoot) {
+  if (!key.startsWith(`${SHARED_SKILLS_PREFIX}/`) || !sharedSkillsRoot) {
+    return null;
+  }
+  const inside = key.slice(SHARED_SKILLS_PREFIX.length + 1);
+  return path22.join(sharedSkillsRoot, ...inside.split("/"));
+}
+
 // src/adapters/hook-scripts-bridge.ts
-var SHARED_HOOK_SCRIPTS_KEY = "shared/hook_scripts";
 function syncHookScriptsBridge(args) {
   const { source, destination, config, sourceRoot, options, logger } = args;
   if (!fs25.existsSync(source)) {
@@ -22147,7 +22214,7 @@ function syncHookScriptsBridge(args) {
   } else if (artifactClass === "managed-symlink") {
     fs25.unlinkSync(destination);
   }
-  ensureDir(path22.dirname(destination));
+  ensureDir(path23.dirname(destination));
   createRelativeSymlink(source, destination, "dir");
   if (args.manifest) {
     const state = describeArtifactState(destination);
@@ -22176,26 +22243,6 @@ function isSymlinkTo(linkPath, source) {
   }
 }
 
-// src/core/shared-artifacts.ts
-import path23 from "path";
-var SHARED_NAMESPACE = "shared";
-var SHARED_INSTRUCTIONS_KEY = `${SHARED_NAMESPACE}/AGENTS.md`;
-var SHARED_INSTRUCTIONS_FILE = "AGENTS.md";
-function sharedArtifactKey(destination, scope, projectRoot) {
-  if (scope !== "project") {
-    return null;
-  }
-  const root = projectRoot ?? process.cwd();
-  const shared = path23.resolve(root, SHARED_INSTRUCTIONS_FILE);
-  return path23.resolve(destination) === shared ? SHARED_INSTRUCTIONS_KEY : null;
-}
-function resolveSharedArtifactKey(key, scope, projectRoot) {
-  if (key !== SHARED_INSTRUCTIONS_KEY || scope !== "project") {
-    return null;
-  }
-  return path23.join(projectRoot ?? process.cwd(), SHARED_INSTRUCTIONS_FILE);
-}
-
 // src/core/remove.ts
 import fs26 from "fs";
 function removeManagedPath(managedPath) {
@@ -22316,6 +22363,7 @@ async function runUninstallCommand(options, logger) {
   const claudeRoots = scope === "global" && selectedTools.has("claude-code") ? resolveClaudeRootsForUninstall(manifest, runtime) : [];
   let removedCount = 0;
   const removedParentDirs = /* @__PURE__ */ new Set();
+  const keptSurfaces = [];
   for (const file of useManifestPathRemoval ? manifestArtifacts : []) {
     if (isMergeSurfaceKey(file.relativePath)) {
       const surfacePath = file.path ?? resolveManifestKeyToPath(
@@ -22327,6 +22375,9 @@ async function runUninstallCommand(options, logger) {
       if (surfacePath && stripTangyrFromMergeSurface(surfacePath, logger)) {
         removedParentDirs.add(path24.dirname(surfacePath));
         removedCount++;
+        if (fs27.existsSync(surfacePath)) {
+          keptSurfaces.push(surfacePath);
+        }
       } else {
         logger.verbose(
           `  left in place (merge surface, nothing of ours in it): ${surfacePath ?? file.relativePath}`
@@ -22429,10 +22480,6 @@ ${String(kept.length)} later backup(s) were NOT restored: the earliest copy of e
       logger.verbose(`  removed manifest: ${manifestPath}`);
     }
     pruneEmptyDirs(path24.join(scopePath, "backups"), logger);
-    const pruneBoundary = path24.dirname(scopePath);
-    for (const dir of removedParentDirs) {
-      pruneEmptyAncestors(dir, pruneBoundary, logger);
-    }
     try {
       const remaining = fs27.readdirSync(scopePath);
       if (remaining.length === 0) {
@@ -22455,6 +22502,22 @@ ${String(kept.length)} later backup(s) were NOT restored: the earliest copy of e
   } else {
     logger.verbose("  no manifest to update after partial residue cleanup");
   }
+  const pruneBoundary = path24.dirname(scopePath);
+  for (const dir of removedParentDirs) {
+    pruneEmptyAncestors(dir, pruneBoundary, logger);
+  }
+  if (keptSurfaces.length > 0) {
+    logger.warn(
+      `
+${String(keptSurfaces.length)} shared file(s) kept, with Tangyr's own block removed from each:`
+    );
+    for (const surface of keptSurfaces) {
+      logger.warn(`  ${surface}`);
+    }
+    logger.warn(
+      "  What remains in them was not written with a marker of ours, so it is left rather than guessed at. Delete what you no longer want."
+    );
+  }
   logger.info(`
 Uninstallation complete: ${removedCount} file(s) removed.`);
 }
@@ -22470,6 +22533,13 @@ function resolveManifestKeyToPath(key, scope, runtime, projectRootOverride) {
     if (component === "hook_scripts") {
       return resolveSharedHookScriptsPath(runtime, scope, projectRoot);
     }
+    const sharedSkill = resolveSharedSkillsKey(
+      key,
+      resolveSharedSkillsPath(runtime, scope, projectRoot)
+    );
+    if (sharedSkill) {
+      return sharedSkill;
+    }
     return resolveSharedArtifactKey(key, scope, projectRoot);
   }
   if (tool === "claude-code") {
@@ -23867,6 +23937,27 @@ function resolveSharedHookScriptsPath(runtime, scope, projectRoot) {
   }
   return resolveTargetPath("~/.agents/hooks");
 }
+function resolveSharedSkillsPath(runtime, scope, projectRoot) {
+  if (runtime) {
+    try {
+      const mappings = loadMappings(
+        runtime.sourceRoot,
+        runtime.config,
+        runtime.configDir
+      );
+      return resolveTargetPaths({
+        scope,
+        projectRoot,
+        mappings: mappings.platformPaths
+      }).opencode.skills_shared;
+    } catch {
+    }
+  }
+  if (scope === "project") {
+    return path24.join(projectRoot ?? process.cwd(), ".agents", "skills");
+  }
+  return resolveTargetPath("~/.agents/skills");
+}
 function resolveOpenCodePaths(runtime, scope = "global", projectRoot) {
   if (runtime) {
     try {
@@ -25223,8 +25314,8 @@ function toConflictPolicy2(value) {
 }
 
 // src/commands/install.ts
-import fs45 from "fs";
-import path45 from "path";
+import fs46 from "fs";
+import path46 from "path";
 
 // src/core/channel-state.ts
 import fs32 from "fs";
@@ -26171,12 +26262,15 @@ function findContestedInstructions(instructionsByTarget) {
   }
   return contested;
 }
-function reportContestedInstructions(instructionsByTarget, kitDeclaresRules, logger) {
+function reportContestedInstructions(instructionsByTarget, kitDeclaresRules, logger, missingByTarget) {
   if (!kitDeclaresRules) {
     return;
   }
   for (const contested of findContestedInstructions(instructionsByTarget)) {
-    if (contested.losers.length === 0) {
+    const losers = missingByTarget ? contested.losers.filter(
+      (target) => (missingByTarget.get(target)?.length ?? 0) > 0
+    ) : contested.losers;
+    if (losers.length === 0) {
       continue;
     }
     logger.warn(
@@ -26186,7 +26280,7 @@ ${contested.destination} is the instructions file for ${contested.claimants.join
     if (contested.survivor) {
       logger.warn(`  The content on disk is ${contested.survivor}'s.`);
     }
-    for (const target of contested.losers) {
+    for (const target of losers) {
       logger.warn(
         `  ${target} does NOT get its rules: ${FOLDS_RULES_INTO_INSTRUCTIONS[target]}, and that content is overwritten here.`
       );
@@ -26209,12 +26303,161 @@ function instructionsByActiveTarget(tools, scope, projectRoot, mappings) {
       byTarget.set(tool, instructions);
     }
   }
+  if (scope === "project" && projectRoot && tools.includes("copilot")) {
+    byTarget.set("copilot", path31.join(projectRoot, "AGENTS.md"));
+  }
   return byTarget;
 }
 
+// src/core/rules-coverage.ts
+import fs35 from "fs";
+import path32 from "path";
+function readingSurfaces(profile) {
+  const record = profile;
+  return {
+    slot: typeof record?.rules === "string" ? record.rules : null,
+    instructions: typeof record?.instructions === "string" ? record.instructions : null
+  };
+}
+function inRulesSlot(slot, rule) {
+  let entries;
+  try {
+    entries = fs35.readdirSync(slot);
+  } catch {
+    return false;
+  }
+  return entries.some(
+    (entry) => entry === rule || entry.startsWith(`${rule}.`)
+  );
+}
+function inInstructions(instructions, rule) {
+  let content;
+  try {
+    content = fs35.readFileSync(instructions, "utf8");
+  } catch {
+    return false;
+  }
+  return content.split("\n").some((line) => line.trim() === `## ${rule}`);
+}
+function recordedRulesLoss(lossReport, target) {
+  const entries = lossReport.targets[target]?.rules ?? [];
+  for (const artifact of entries) {
+    for (const field of artifact.fields) {
+      if (field.detail.length > 0) {
+        return field.detail;
+      }
+    }
+  }
+  return null;
+}
+function measureRulesCoverage(tools, declaredRules, scope, projectRoot, mappings, lossReport, instructionsByTarget) {
+  const resolved = resolveTargetPaths({
+    scope,
+    projectRoot,
+    mappings: mappings.platformPaths
+  });
+  const contestedByPath = new Map(
+    findContestedInstructions(instructionsByTarget).map((contested) => [
+      contested.destination,
+      contested
+    ])
+  );
+  return tools.map((target) => {
+    const surfaces = readingSurfaces(resolved[target]);
+    const missing = declaredRules.filter((rule) => {
+      if (surfaces.slot && inRulesSlot(surfaces.slot, rule)) {
+        return false;
+      }
+      return !(surfaces.instructions && inInstructions(surfaces.instructions, rule));
+    });
+    return {
+      target,
+      missing,
+      declared: declaredRules.length,
+      reason: missing.length === 0 ? null : explain(target, surfaces, contestedByPath, lossReport, projectRoot)
+    };
+  });
+}
+function explain(target, surfaces, contestedByPath, lossReport, projectRoot) {
+  if (surfaces.instructions) {
+    const contested = contestedByPath.get(path32.resolve(surfaces.instructions));
+    if (contested && contested.survivor !== null && contested.survivor !== target) {
+      return `its rules are folded into ${display(surfaces.instructions, projectRoot)}, which ${contested.survivor} wrote last`;
+    }
+  }
+  const recorded = recordedRulesLoss(lossReport, target);
+  if (recorded) {
+    return recorded;
+  }
+  if (!surfaces.slot) {
+    return "it has no rules surface in this scope";
+  }
+  return `not in ${display(surfaces.slot, projectRoot)}, nor folded into the instructions file`;
+}
+function display(target, projectRoot) {
+  if (!projectRoot) {
+    return target;
+  }
+  const relative = path32.relative(projectRoot, target);
+  return relative.startsWith("..") ? target : relative;
+}
+function reportRulesCoverage(coverage, logger) {
+  if (coverage.length === 0 || coverage[0].declared === 0) {
+    return;
+  }
+  const complete = coverage.every((entry) => entry.missing.length === 0);
+  const say = complete ? (line) => {
+    logger.verbose(line);
+  } : (line) => {
+    logger.warn(line);
+  };
+  const declared = coverage[0].declared;
+  const width = Math.max(...coverage.map((entry) => entry.target.length));
+  say(
+    `
+Rules reaching each target (${String(declared)} declared, measured on disk):`
+  );
+  for (const entry of coverage) {
+    const delivered = declared - entry.missing.length;
+    const counts = `${String(delivered)}/${String(declared)}`;
+    const head = `  ${entry.target.padEnd(width)}  ${counts}`;
+    if (entry.missing.length === 0) {
+      say(head);
+      continue;
+    }
+    say(`${head}  missing: ${entry.missing.join(", ")}`);
+    if (entry.reason) {
+      say(`  ${" ".repeat(width)}  ${entry.reason}`);
+    }
+  }
+}
+function missingRulesByTarget(coverage) {
+  return new Map(coverage.map((entry) => [entry.target, entry.missing]));
+}
+function recordRulesCoverageLoss(coverage, lossReport) {
+  for (const entry of coverage) {
+    if (entry.missing.length === 0) {
+      continue;
+    }
+    addLoss(lossReport, entry.target, "rules", {
+      source: "rules",
+      fields: entry.missing.map((rule) => ({
+        field: rule,
+        action: "rule-not-delivered",
+        severity: resolveLossSeverity(
+          "agent-field",
+          rule,
+          "rule-not-delivered"
+        ),
+        detail: `${rule}: not readable by ${entry.target}${entry.reason ? ` \u2014 ${entry.reason}` : ""}`
+      }))
+    });
+  }
+}
+
 // src/adapters/claude-code.ts
-import fs37 from "fs";
-import path35 from "path";
+import fs38 from "fs";
+import path36 from "path";
 
 // src/core/shim.ts
 import crypto4 from "crypto";
@@ -26236,8 +26479,8 @@ ${SHIM_BODY}`;
 }
 
 // src/core/skills-slot.ts
-import fs35 from "fs";
-import path32 from "path";
+import fs36 from "fs";
+import path33 from "path";
 function isForeignSkillsSlotSymlink(destination, config, sourceRoot, source) {
   if (!isSymlinkPath(destination)) {
     return false;
@@ -26250,7 +26493,7 @@ function isForeignSkillsSlotSymlink(destination, config, sourceRoot, source) {
 }
 function syncSkillsSlot(sync) {
   const { source, destination, logger } = sync;
-  if (!fs35.existsSync(source)) {
+  if (!fs36.existsSync(source)) {
     return [
       {
         component: "skills",
@@ -26278,7 +26521,7 @@ function syncSkillsSlot(sync) {
     if (isLegacyWholesaleSymlink) {
       for (const name of foreignSkillNames(source, declaredNames)) {
         logger.info(
-          `[dry-run] skills: migrate foreign skill ${path32.join(source, name)} -> ${path32.join(destination, name)}`
+          `[dry-run] skills: migrate foreign skill ${path33.join(source, name)} -> ${path33.join(destination, name)}`
         );
       }
       logger.info(
@@ -26286,9 +26529,9 @@ function syncSkillsSlot(sync) {
       );
     }
     for (const name of declaredNames ?? listSkillDirNames(source)) {
-      const skillDestination = path32.join(destination, name);
+      const skillDestination = path33.join(destination, name);
       logger.info(
-        `[dry-run] skills: symlink ${path32.join(source, name)} -> ${skillDestination}`
+        `[dry-run] skills: symlink ${path33.join(source, name)} -> ${skillDestination}`
       );
       outcomes2.push({
         component: "skills",
@@ -26315,9 +26558,9 @@ function syncSkillsSlot(sync) {
 }
 function syncSingleSkill(sync, name) {
   const { config, sourceRoot, source, destination } = sync;
-  const skillSource = path32.join(source, name);
-  const skillDestination = path32.join(destination, name);
-  if (!fs35.existsSync(skillSource)) {
+  const skillSource = path33.join(source, name);
+  const skillDestination = path33.join(destination, name);
+  if (!fs36.existsSync(skillSource)) {
     return {
       component: "skills",
       status: "skipped",
@@ -26333,29 +26576,29 @@ function syncSingleSkill(sync, name) {
     };
   }
   if (artifactClass === "managed-stale" && isOurStaleSymlink(skillDestination, /* @__PURE__ */ new Set([skillDestination]), config)) {
-    fs35.unlinkSync(skillDestination);
+    fs36.unlinkSync(skillDestination);
   } else if (artifactClass === "unmanaged-conflict" && !sync.onUnmanagedConflict(skillDestination)) {
     return { component: "skills", status: "conflict", path: skillDestination };
   } else if (artifactClass === "managed-symlink") {
-    fs35.unlinkSync(skillDestination);
+    fs36.unlinkSync(skillDestination);
   }
   createRelativeSymlink(skillSource, skillDestination, "dir");
   return { component: "skills", status: "success", path: skillDestination };
 }
 function migrateWholesaleSkillsSymlink(source, destination, declaredNames, logger) {
   const foreignNames = foreignSkillNames(source, declaredNames);
-  fs35.unlinkSync(destination);
+  fs36.unlinkSync(destination);
   ensureDir(destination);
   for (const name of foreignNames) {
-    const from = path32.join(source, name);
-    const to = path32.join(destination, name);
-    if (fs35.existsSync(to)) {
+    const from = path33.join(source, name);
+    const to = path33.join(destination, name);
+    if (fs36.existsSync(to)) {
       logger.warn(
         `skills migration: ${to} already exists \u2014 skipping ${from} to avoid overwrite. Nothing in the kit was changed.`
       );
       continue;
     }
-    fs35.cpSync(from, to, { recursive: true, verbatimSymlinks: true });
+    fs36.cpSync(from, to, { recursive: true, verbatimSymlinks: true });
     logger.warn(
       `skills migration: '${name}' is present under the kit's skills/ but is not declared in its manifest. Copied ${from} -> ${to} so the harness can read it. The original is left in the kit deliberately: this command does not modify a kit. Remove ${from} yourself if it does not belong there, or declare it in tangyr-kit.yaml if it does.`
     );
@@ -26369,44 +26612,44 @@ function foreignSkillNames(source, declaredNames) {
   return listSkillDirNames(source).filter((name) => !declaredSet.has(name));
 }
 function listSkillDirNames(dir) {
-  if (!fs35.existsSync(dir)) {
+  if (!fs36.existsSync(dir)) {
     return [];
   }
-  return fs35.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name);
+  return fs36.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name);
 }
 function isSymlinkPath(filePath) {
   try {
-    return fs35.lstatSync(filePath).isSymbolicLink();
+    return fs36.lstatSync(filePath).isSymbolicLink();
   } catch {
     return false;
   }
 }
 function isSymlinkTo2(linkPath, source) {
   try {
-    return fs35.realpathSync(linkPath) === fs35.realpathSync(source);
+    return fs36.realpathSync(linkPath) === fs36.realpathSync(source);
   } catch {
     return false;
   }
 }
 
 // src/core/hook-scripts.ts
-import path33 from "path";
+import path34 from "path";
 function hookScriptsDir(bridge, target, projectRoot) {
   const globalBridge = resolveTargetPath("~/.agents/hooks");
-  if (path33.resolve(bridge) === path33.resolve(globalBridge)) {
+  if (path34.resolve(bridge) === path34.resolve(globalBridge)) {
     return { prefix: GLOBAL_HOOK_SCRIPTS_DIR, machineLocal: false };
   }
-  const relative = path33.relative(projectRoot ?? process.cwd(), bridge);
-  const insideProject = !relative.startsWith("..") && !path33.isAbsolute(relative) && relative !== "";
+  const relative = path34.relative(projectRoot ?? process.cwd(), bridge);
+  const insideProject = !relative.startsWith("..") && !path34.isAbsolute(relative) && relative !== "";
   const variable = PROJECT_DIR_VARIABLE[target];
   if (insideProject && variable) {
-    const posix = path33.posix.join(
-      relative.split(path33.sep).join("/"),
+    const posix = path34.posix.join(
+      relative.split(path34.sep).join("/"),
       "scripts"
     );
     return { prefix: `$${variable.slice(1)}/${posix}`, machineLocal: false };
   }
-  return { prefix: path33.join(bridge, "scripts"), machineLocal: true };
+  return { prefix: path34.join(bridge, "scripts"), machineLocal: true };
 }
 var PROJECT_DIR_VARIABLE = {
   "claude-code": "$CLAUDE_PROJECT_DIR"
@@ -26416,19 +26659,19 @@ function machineLocalScriptPathNotice(target, prefix) {
 }
 
 // src/core/instructions-source.ts
-import fs36 from "fs";
-import path34 from "path";
+import fs37 from "fs";
+import path35 from "path";
 var PORTABLE_INSTRUCTIONS_NAME = "AGENTS.md";
 var InstructionsSourceMissingError = class extends Error {
   constructor(kitRoot, expected, declaredBy) {
     super(
-      `${path34.join(kitRoot, expected)}: instructions source not found (declared by ${declaredBy}). To fix: create that file, or point '${declaredBy}' at the file this kit actually carries. With neither declaration, the kit's ${DEFAULT_ENTRYPOINT} or ${PORTABLE_INSTRUCTIONS_NAME} is used.`
+      `${path35.join(kitRoot, expected)}: instructions source not found (declared by ${declaredBy}). To fix: create that file, or point '${declaredBy}' at the file this kit actually carries. With neither declaration, the kit's ${DEFAULT_ENTRYPOINT} or ${PORTABLE_INSTRUCTIONS_NAME} is used.`
     );
     this.name = "InstructionsSourceMissingError";
   }
 };
 function normalizeLabel(kitRoot, file) {
-  return path34.relative(kitRoot, file).split(path34.sep).join("/");
+  return path35.relative(kitRoot, file).split(path35.sep).join("/");
 }
 function isExplicitOverride(configured) {
   const normalize = (value) => value.replace(/\\/gu, "/").replace(/^\.\//u, "");
@@ -26437,8 +26680,8 @@ function isExplicitOverride(configured) {
 function resolveInstructionsSource(kitRoot, config) {
   const configured = config.source.instructions;
   if (isExplicitOverride(configured)) {
-    const file = path34.resolve(kitRoot, configured);
-    if (!fs36.existsSync(file)) {
+    const file = path35.resolve(kitRoot, configured);
+    if (!fs37.existsSync(file)) {
       throw new InstructionsSourceMissingError(
         kitRoot,
         configured,
@@ -26453,8 +26696,8 @@ function resolveInstructionsSource(kitRoot, config) {
   }
   const declared = resolveKitEntrypointName(kitRoot);
   if (declared !== void 0) {
-    const file = path34.resolve(kitRoot, declared);
-    if (!fs36.existsSync(file)) {
+    const file = path35.resolve(kitRoot, declared);
+    if (!fs37.existsSync(file)) {
       throw new InstructionsSourceMissingError(
         kitRoot,
         declared,
@@ -26468,13 +26711,13 @@ function resolveInstructionsSource(kitRoot, config) {
     };
   }
   for (const name of [DEFAULT_ENTRYPOINT, PORTABLE_INSTRUCTIONS_NAME]) {
-    const file = path34.resolve(kitRoot, name);
-    if (fs36.existsSync(file)) {
+    const file = path35.resolve(kitRoot, name);
+    if (fs37.existsSync(file)) {
       return { file, label: name, origin: "convention" };
     }
   }
-  const legacy = path34.resolve(kitRoot, LEGACY_ENTRYPOINT);
-  if (fs36.existsSync(legacy)) {
+  const legacy = path35.resolve(kitRoot, LEGACY_ENTRYPOINT);
+  if (fs37.existsSync(legacy)) {
     return {
       file: legacy,
       label: LEGACY_ENTRYPOINT,
@@ -26486,7 +26729,7 @@ function resolveInstructionsSource(kitRoot, config) {
 }
 function instructionsSourcePath(kitRoot, config) {
   const resolved = resolveInstructionsSource(kitRoot, config);
-  return resolved ? resolved.file : path34.resolve(kitRoot, config.source.instructions);
+  return resolved ? resolved.file : path35.resolve(kitRoot, config.source.instructions);
 }
 function instructionsSourceLabel(kitRoot, config) {
   const resolved = resolveInstructionsSource(kitRoot, config);
@@ -26607,7 +26850,7 @@ function syncClaudeCode(config, sourceRoot, options, logger, mappings, manifest,
   if (!shouldSkipComponent(options, "hooks")) {
     outcomes.push(
       syncHookScriptsBridge({
-        source: path35.resolve(sourceRoot, config.source.hooks),
+        source: path36.resolve(sourceRoot, config.source.hooks),
         destination: profile.hook_scripts,
         config,
         sourceRoot,
@@ -26659,13 +26902,13 @@ function syncClaudeCode(config, sourceRoot, options, logger, mappings, manifest,
 }
 function syncProviderLoss(config, sourceRoot, mappings, lossReport) {
   if (!mappings.modelTiers.custom_provider) return;
-  const agentsDir = path35.join(sourceRoot, config.source.agents);
-  if (!fs37.existsSync(agentsDir)) return;
-  for (const agentFile of ts(path35.join(agentsDir, "*.md")).sort()) {
+  const agentsDir = path36.join(sourceRoot, config.source.agents);
+  if (!fs38.existsSync(agentsDir)) return;
+  for (const agentFile of ts(path36.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 = path35.basename(agentFile);
+      const basename = path36.basename(agentFile);
       addLoss(lossReport, "claude-code", "agents", {
         source: `agents/${basename}`,
         fields: [
@@ -26690,7 +26933,7 @@ function shouldSkipComponent(options, component) {
 var SHIM_MANIFEST_KEY = "claude-code/instructions_shim";
 function lstatOrNull(p) {
   try {
-    return fs37.lstatSync(p);
+    return fs38.lstatSync(p);
   } catch {
     return null;
   }
@@ -26702,12 +26945,12 @@ function applyClaudeCodeShimUpgrade(shimPath, agentsMdPath, manifest, scopePath,
   if (shimLink?.isSymbolicLink()) {
     backupFile(shimPath, manifest, scopePath);
     writeManifest(scopePath, manifest);
-    fs37.unlinkSync(shimPath);
+    fs38.unlinkSync(shimPath);
     logger?.verbose(
       `instructions-shim: replaced an unmanaged symlink at ${shimPath}`
     );
   }
-  if (!fs37.existsSync(shimPath)) {
+  if (!fs38.existsSync(shimPath)) {
     addArtifactToManifest(manifest, {
       relativePath: SHIM_MANIFEST_KEY,
       path: shimPath,
@@ -26715,12 +26958,12 @@ function applyClaudeCodeShimUpgrade(shimPath, agentsMdPath, manifest, scopePath,
       origin: "tangyr-managed"
     });
     writeManifest(scopePath, manifest);
-    fs37.mkdirSync(path35.dirname(shimPath), { recursive: true });
-    fs37.writeFileSync(shimPath, shimContent);
+    fs38.mkdirSync(path36.dirname(shimPath), { recursive: true });
+    fs38.writeFileSync(shimPath, shimContent);
     logger?.verbose(`instructions-shim: wrote @AGENTS.md shim -> ${shimPath}`);
     return;
   }
-  const existing = fs37.readFileSync(shimPath, "utf8");
+  const existing = fs38.readFileSync(shimPath, "utf8");
   const firstNonEmptyLine = existing.split("\n").find((l) => l.trim().length > 0) ?? "";
   const marker = extractProvenanceMarker(firstNonEmptyLine);
   if (marker !== null && marker.hash === expectedBodyHash) {
@@ -26737,7 +26980,7 @@ function applyClaudeCodeShimUpgrade(shimPath, agentsMdPath, manifest, scopePath,
   }
   backupFile(shimPath, manifest, scopePath);
   writeManifest(scopePath, manifest);
-  fs37.writeFileSync(shimPath, shimContent);
+  fs38.writeFileSync(shimPath, shimContent);
   addArtifactToManifest(manifest, {
     relativePath: SHIM_MANIFEST_KEY,
     path: shimPath,
@@ -26747,10 +26990,10 @@ function applyClaudeCodeShimUpgrade(shimPath, agentsMdPath, manifest, scopePath,
   logger?.verbose(`instructions-shim: backed up and replaced -> ${shimPath}`);
 }
 function syncDirectComponent(config, sourceRoot, options, logger, directComponent, manifest, scopePath) {
-  const source = directComponent.sourceKey === "instructions" ? instructionsSourcePath(sourceRoot, config) : path35.resolve(sourceRoot, config.source[directComponent.sourceKey]);
+  const source = directComponent.sourceKey === "instructions" ? instructionsSourcePath(sourceRoot, config) : path36.resolve(sourceRoot, config.source[directComponent.sourceKey]);
   const sourceLabel = directComponent.sourceKey === "instructions" ? instructionsSourceLabel(sourceRoot, config) : config.source[directComponent.sourceKey];
   const destination = directComponent.destination;
-  if (!fs37.existsSync(source)) {
+  if (!fs38.existsSync(source)) {
     return skippedMissingSource(directComponent.component, source);
   }
   if (options.dryRun) {
@@ -26772,7 +27015,7 @@ function syncDirectComponent(config, sourceRoot, options, logger, directComponen
     };
   }
   if (artifactClass === "managed-stale" && isOurStaleSymlink(destination, /* @__PURE__ */ new Set([destination]), config)) {
-    fs37.unlinkSync(destination);
+    fs38.unlinkSync(destination);
   } else if (artifactClass === "unmanaged-conflict" && !handleConflict(destination, config, options, logger, manifest, scopePath)) {
     return {
       component: directComponent.component,
@@ -26780,11 +27023,11 @@ function syncDirectComponent(config, sourceRoot, options, logger, directComponen
       path: destination
     };
   } else if (artifactClass === "managed-symlink") {
-    fs37.unlinkSync(destination);
+    fs38.unlinkSync(destination);
   } else if (artifactClass === "managed-compiled") {
-    fs37.unlinkSync(destination);
+    fs38.unlinkSync(destination);
   }
-  ensureDir(path35.dirname(destination));
+  ensureDir(path36.dirname(destination));
   createRelativeSymlink(source, destination, directComponent.type, {
     logger,
     provenanceMarker: directComponent.type === "file" ? formatProvenanceMarker(
@@ -26804,7 +27047,7 @@ function syncClaudeCodeSkills(config, sourceRoot, options, logger, destination,
   return syncSkillsSlot({
     config,
     sourceRoot,
-    source: path35.resolve(sourceRoot, config.source.skills),
+    source: path36.resolve(sourceRoot, config.source.skills),
     destination,
     dryRun: options.dryRun,
     logger,
@@ -26838,7 +27081,7 @@ function syncHooks(config, sourceRoot, options, logger, destination, scriptsBrid
     destination,
     settings,
     stringifyJson2,
-    !fs37.existsSync(destination),
+    !fs38.existsSync(destination),
     logger
   );
   return {
@@ -26848,8 +27091,8 @@ function syncHooks(config, sourceRoot, options, logger, destination, scriptsBrid
   };
 }
 function syncMcp(config, sourceRoot, options, logger, destination) {
-  const source = path35.resolve(sourceRoot, config.source.mcp);
-  if (!fs37.existsSync(source)) {
+  const source = path36.resolve(sourceRoot, config.source.mcp);
+  if (!fs38.existsSync(source)) {
     return skippedMissingSource("mcp", source);
   }
   if (options.dryRun) {
@@ -26874,7 +27117,7 @@ function syncMcp(config, sourceRoot, options, logger, destination) {
     destination,
     hostConfig,
     stringifyJson2,
-    !fs37.existsSync(destination),
+    !fs38.existsSync(destination),
     logger
   );
   return {
@@ -26884,8 +27127,8 @@ function syncMcp(config, sourceRoot, options, logger, destination) {
   };
 }
 function syncSettings(config, sourceRoot, options, logger, destination) {
-  const source = path35.resolve(sourceRoot, config.source.settings);
-  if (!fs37.existsSync(source)) {
+  const source = path36.resolve(sourceRoot, config.source.settings);
+  if (!fs38.existsSync(source)) {
     return skippedMissingSource("settings", source);
   }
   if (options.dryRun) {
@@ -26903,7 +27146,7 @@ function syncSettings(config, sourceRoot, options, logger, destination) {
     destination,
     settings,
     stringifyJson2,
-    !fs37.existsSync(destination),
+    !fs38.existsSync(destination),
     logger
   );
   return {
@@ -26927,7 +27170,7 @@ function handleConflict(destination, config, options, logger, manifest, scopePat
     if (manifest && scopePath) {
       backupFile(destination, manifest, scopePath);
       writeManifest(scopePath, manifest);
-      fs37.rmSync(destination, { recursive: true, force: true });
+      fs38.rmSync(destination, { recursive: true, force: true });
     } else {
       const parked = parkConflictingPath(
         destination,
@@ -26942,7 +27185,7 @@ function handleConflict(destination, config, options, logger, manifest, scopePat
     }
     return true;
   }
-  fs37.rmSync(destination, { recursive: true, force: true });
+  fs38.rmSync(destination, { recursive: true, force: true });
   return true;
 }
 function skippedMissingSource(component, source) {
@@ -26954,16 +27197,16 @@ function skippedMissingSource(component, source) {
 }
 function isSymlinkTo3(linkPath, source) {
   try {
-    return fs37.realpathSync(linkPath) === fs37.realpathSync(source);
+    return fs38.realpathSync(linkPath) === fs38.realpathSync(source);
   } catch {
     return false;
   }
 }
 function readJsonObject3(filePath) {
-  if (!fs37.existsSync(filePath)) {
+  if (!fs38.existsSync(filePath)) {
     return {};
   }
-  const parsed = JSON.parse(fs37.readFileSync(filePath, "utf8"));
+  const parsed = JSON.parse(fs38.readFileSync(filePath, "utf8"));
   return isRecord3(parsed) ? parsed : {};
 }
 function markManaged(value) {
@@ -26990,13 +27233,13 @@ function isRecord3(value) {
 // src/adapters/codex.ts
 var TOML3 = __toESM(require_toml(), 1);
 import crypto6 from "crypto";
-import fs40 from "fs";
-import path39 from "path";
+import fs41 from "fs";
+import path40 from "path";
 
 // src/compiler/agents.ts
 var TOML = __toESM(require_toml(), 1);
 var import_yaml8 = __toESM(require_dist(), 1);
-import path36 from "path";
+import path37 from "path";
 var writeCapabilityClasses = /* @__PURE__ */ new Set(["filesystem-write", "shell-execution"]);
 var copilotToolAliasesByClass = {
   delegation: "agent",
@@ -27008,7 +27251,7 @@ var copilotToolAliasesByClass = {
 };
 function compileAgent(sourceFile, target, mappings, extensions, lossReport) {
   const { data, body } = parseMarkdownFrontmatter(sourceFile);
-  const relativeSource = `agents/${path36.basename(sourceFile)}`;
+  const relativeSource = `agents/${path37.basename(sourceFile)}`;
   if (target === "opencode") {
     return compileOpenCodeAgent(
       sourceFile,
@@ -27049,7 +27292,7 @@ function compileAgent(sourceFile, target, mappings, extensions, lossReport) {
     mappings,
     lossReport
   );
-  const overlayKey = `agents/${path36.basename(sourceFile, ".md")}.${target}.yaml`;
+  const overlayKey = `agents/${path37.basename(sourceFile, ".md")}.${target}.yaml`;
   const targetFields = {
     ...translated.fields,
     ...extensions[overlayKey] ?? {}
@@ -27083,7 +27326,7 @@ ${TOML.stringify({
 function compileOpenCodeAgent(sourceFile, data, body, relativeSource, lossReport) {
   if (typeof data.description !== "string" || data.description.trim() === "") {
     throw new Error(
-      `${path36.basename(sourceFile)}: OpenCode agent requires a non-empty description field`
+      `${path37.basename(sourceFile)}: OpenCode agent requires a non-empty description field`
     );
   }
   const frontmatter = {
@@ -27137,7 +27380,7 @@ function compileOpenCodeAgent(sourceFile, data, body, relativeSource, lossReport
                 "permission",
                 "permission-coarsening"
               ),
-              detail: `${path36.basename(sourceFile)}: per-tool permission '${tool}' mapped to coarse allow|deny action`
+              detail: `${path37.basename(sourceFile)}: per-tool permission '${tool}' mapped to coarse allow|deny action`
             }
           ]
         });
@@ -27162,7 +27405,7 @@ ${(0, import_yaml8.stringify)(frontmatter).trim()}
 function compileCursorAgent(sourceFile, data, body, relativeSource, lossReport) {
   if (typeof data.description !== "string" || data.description.trim() === "") {
     throw new Error(
-      `${path36.basename(sourceFile)}: Cursor agent requires a non-empty description field`
+      `${path37.basename(sourceFile)}: Cursor agent requires a non-empty description field`
     );
   }
   const frontmatter = {
@@ -27199,7 +27442,7 @@ function compileCursorAgent(sourceFile, data, body, relativeSource, lossReport)
             "permission",
             "permission-coarsening"
           ),
-          detail: `${path36.basename(sourceFile)}: per-agent tool allow set coarsened to readonly=${readonly} boolean (Cursor only exposes readonly control)`
+          detail: `${path37.basename(sourceFile)}: per-agent tool allow set coarsened to readonly=${readonly} boolean (Cursor only exposes readonly control)`
         }
       ]
     });
@@ -27218,7 +27461,7 @@ function compileCursorAgent(sourceFile, data, body, relativeSource, lossReport)
             "provider",
             "provider-not-representable"
           ),
-          detail: `${path36.basename(sourceFile)}: custom provider cannot be expressed in Cursor subagent frontmatter \u2014 configure manually via Cursor settings`
+          detail: `${path37.basename(sourceFile)}: custom provider cannot be expressed in Cursor subagent frontmatter \u2014 configure manually via Cursor settings`
         }
       ]
     });
@@ -27250,7 +27493,7 @@ function compileClineAgent(sourceFile, _data, _body, relativeSource, lossReport)
           "persona",
           "persona-not-representable"
         ),
-        detail: `${path36.basename(sourceFile)}: Cline has no committable per-agent persona file for the VSCode extension target; configure the agent through Cline Settings \u2192 Agent.`
+        detail: `${path37.basename(sourceFile)}: Cline has no committable per-agent persona file for the VSCode extension target; configure the agent through Cline Settings \u2192 Agent.`
       }
     ]
   });
@@ -27298,7 +27541,7 @@ function applyFieldAction(sourceFile, field, value, action, target, mappings, tr
           field,
           "model-not-representable"
         ),
-        detail: `${path36.basename(sourceFile)}: model tier '${String(value)}' has no stable Copilot model literal; omitted so VS Code uses the selected model.`
+        detail: `${path37.basename(sourceFile)}: model tier '${String(value)}' has no stable Copilot model literal; omitted so VS Code uses the selected model.`
       });
       return;
     }
@@ -27316,9 +27559,9 @@ function applyFieldAction(sourceFile, field, value, action, target, mappings, tr
       lossReport,
       target,
       "agents",
-      `agents/${path36.basename(sourceFile)}`,
+      `agents/${path37.basename(sourceFile)}`,
       "info",
-      `${path36.basename(sourceFile)}: ${field} is delivered through another managed surface.`
+      `${path37.basename(sourceFile)}: ${field} is delivered through another managed surface.`
     );
     return;
   }
@@ -27327,7 +27570,7 @@ function applyFieldAction(sourceFile, field, value, action, target, mappings, tr
     field,
     action: entryType,
     severity: resolveLossSeverity("agent-field", field, entryType),
-    detail: `${path36.basename(sourceFile)}: ${field} has no emitted field for this target.`
+    detail: `${path37.basename(sourceFile)}: ${field} has no emitted field for this target.`
   });
 }
 function mapToolsToCapabilities(value, mappings) {
@@ -27515,23 +27758,6 @@ function compileOpenCodeHooks(sourceHooksJson, lossReport, sourceLabel) {
       ]
     });
   }
-  if (Object.keys(sourceHooks).length === 0) {
-    addLoss(lossReport, "opencode", "hooks", {
-      source: sourceLabel,
-      fields: [
-        {
-          field: "hooks",
-          action: "hook-as-plugin",
-          severity: resolveLossSeverity(
-            "agent-field",
-            "hooks",
-            "hook-as-plugin"
-          ),
-          detail: "OpenCode exposes hooks only as plugin code \u2014 no declarative hook file emitted"
-        }
-      ]
-    });
-  }
   return { payload: {}, translated: 0, dropped: 0, droppedEvents: [] };
 }
 function compileClineHooks(sourceHooksJson, lossReport, sourceLabel) {
@@ -27553,23 +27779,6 @@ function compileClineHooks(sourceHooksJson, lossReport, sourceLabel) {
       ]
     });
   }
-  if (Object.keys(sourceHooks).length === 0) {
-    addLoss(lossReport, "cline", "hooks", {
-      source: sourceLabel,
-      fields: [
-        {
-          field: "hooks",
-          action: "hook-as-plugin",
-          severity: resolveLossSeverity(
-            "agent-field",
-            "hooks",
-            "hook-as-plugin"
-          ),
-          detail: "Cline exposes hooks only as @cline/sdk AgentPlugin TypeScript/JS code \u2014 no declarative hook file emitted"
-        }
-      ]
-    });
-  }
   return { payload: {}, translated: 0, dropped: 0, droppedEvents: [] };
 }
 function compileCopilotHooks(sourceHooksJson, mappings, lossReport, sourceLabel) {
@@ -27791,13 +28000,13 @@ function addHookLoss(lossReport, target, eventName, sourceLabel, severity, reaso
 
 // src/compiler/command-as-skill.ts
 var import_yaml9 = __toESM(require_dist(), 1);
-import fs38 from "fs";
-import path37 from "path";
+import fs39 from "fs";
+import path38 from "path";
 var CARRIED_OVER = ["argument-hint", "agent", "launch"];
 function compileCommandAsSkill(commandFile, target) {
-  const name = path37.basename(commandFile, ".md");
+  const name = path38.basename(commandFile, ".md");
   const { data, body } = parseMarkdownFrontmatter(commandFile);
-  const relativeSource = `commands/${path37.basename(commandFile)}`;
+  const relativeSource = `commands/${path38.basename(commandFile)}`;
   const description = typeof data.description === "string" && data.description.trim().length > 0 ? data.description.trim() : `The ${name} command.`;
   const frontmatter = { name, description };
   for (const key of CARRIED_OVER) {
@@ -27820,11 +28029,11 @@ ${body.trim()}
   return { name, content, relativeSource };
 }
 function compileCommandsAsSkills(commandsRoot, target) {
-  if (!fs38.existsSync(commandsRoot)) {
+  if (!fs39.existsSync(commandsRoot)) {
     return [];
   }
-  return fs38.readdirSync(commandsRoot).filter((entry) => entry.endsWith(".md")).sort().map(
-    (entry) => compileCommandAsSkill(path37.join(commandsRoot, entry), target)
+  return fs39.readdirSync(commandsRoot).filter((entry) => entry.endsWith(".md")).sort().map(
+    (entry) => compileCommandAsSkill(path38.join(commandsRoot, entry), target)
   );
 }
 
@@ -28107,9 +28316,9 @@ function compileOpenCodeMcp(sourceMcpJson, lossReport, sourceLabel) {
 }
 
 // src/compiler/rules.ts
-import path38 from "path";
+import path39 from "path";
 var import_yaml10 = __toESM(require_dist(), 1);
-import fs39 from "fs";
+import fs40 from "fs";
 function compileRules(sourceRulesDir, target, _mappings, lossReport) {
   if (target === "copilot") {
     addLoss(lossReport, "copilot", "rules", {
@@ -28146,13 +28355,13 @@ function compileRules(sourceRulesDir, target, _mappings, lossReport) {
   }
   const appendixParts = [];
   const dotRulesFiles = [];
-  for (const ruleFile of ts(path38.join(sourceRulesDir, "*.md")).sort()) {
+  for (const ruleFile of ts(path39.join(sourceRulesDir, "*.md")).sort()) {
     const parsed = parseRule(ruleFile);
-    const name = path38.basename(ruleFile, ".md");
+    const name = path39.basename(ruleFile, ".md");
     if (parsed.mode === "exec-policy") {
       dotRulesFiles.push({
         name: `${name}.rules`,
-        content: `${formatProvenanceMarker("toml", `rules/${path38.basename(ruleFile)}`, computeSourceHash(ruleFile), "codex")}
+        content: `${formatProvenanceMarker("toml", `rules/${path39.basename(ruleFile)}`, computeSourceHash(ruleFile), "codex")}
 ${parsed.body}`
       });
       continue;
@@ -28161,7 +28370,7 @@ ${parsed.body}`
 
 ${parsed.body.trim()}`);
     addLoss(lossReport, "codex", "rules", {
-      source: `rules/${path38.basename(ruleFile)}`,
+      source: `rules/${path39.basename(ruleFile)}`,
       fields: [
         {
           field: "mode",
@@ -28171,7 +28380,7 @@ ${parsed.body.trim()}`);
             "mode",
             "rule-as-instruction"
           ),
-          detail: `${path38.basename(ruleFile)} is appended to the managed Codex instructions file as guidance.`
+          detail: `${path39.basename(ruleFile)} is appended to the managed Codex instructions file as guidance.`
         }
       ]
     });
@@ -28179,7 +28388,7 @@ ${parsed.body.trim()}`);
   return { agentsAppendix: appendixParts.join("\n\n"), dotRulesFiles };
 }
 function parseRule(ruleFile) {
-  const content = fs39.readFileSync(ruleFile, "utf8");
+  const content = fs40.readFileSync(ruleFile, "utf8");
   if (!content.startsWith("---\n")) {
     return { mode: "guidance", body: content };
   }
@@ -28203,14 +28412,14 @@ function isRuleMode(value) {
 }
 function compileOpenCodeRules(sourceRulesDir, lossReport) {
   const appendixParts = [];
-  for (const ruleFile of ts(path38.join(sourceRulesDir, "*.md")).sort()) {
+  for (const ruleFile of ts(path39.join(sourceRulesDir, "*.md")).sort()) {
     const parsed = parseRule(ruleFile);
-    const name = path38.basename(ruleFile, ".md");
+    const name = path39.basename(ruleFile, ".md");
     appendixParts.push(`## ${name}
 
 ${parsed.body.trim()}`);
     addLoss(lossReport, "opencode", "rules", {
-      source: `rules/${path38.basename(ruleFile)}`,
+      source: `rules/${path39.basename(ruleFile)}`,
       fields: [
         {
           field: "rule",
@@ -28220,7 +28429,7 @@ ${parsed.body.trim()}`);
             "rule",
             "rule-path-scoping"
           ),
-          detail: `${path38.basename(ruleFile)}: OpenCode has no per-agent rule scoping \u2014 rule appended to AGENTS.md instructions`
+          detail: `${path39.basename(ruleFile)}: OpenCode has no per-agent rule scoping \u2014 rule appended to AGENTS.md instructions`
         }
       ]
     });
@@ -28229,9 +28438,9 @@ ${parsed.body.trim()}`);
 }
 function compileCursorRules(sourceRulesDir, _lossReport) {
   const dotRulesFiles = [];
-  for (const ruleFile of ts(path38.join(sourceRulesDir, "*.md")).sort()) {
-    const content = fs39.readFileSync(ruleFile, "utf8");
-    const name = path38.basename(ruleFile, ".md");
+  for (const ruleFile of ts(path39.join(sourceRulesDir, "*.md")).sort()) {
+    const content = fs40.readFileSync(ruleFile, "utf8");
+    const name = path39.basename(ruleFile, ".md");
     let frontmatterData = {};
     let body = content;
     if (content.startsWith("---\n")) {
@@ -28260,7 +28469,7 @@ function compileCursorRules(sourceRulesDir, _lossReport) {
     }
     const marker = formatProvenanceMarker(
       "markdown",
-      `rules/${path38.basename(ruleFile)}`,
+      `rules/${path39.basename(ruleFile)}`,
       computeSourceHash(ruleFile),
       "cursor"
     );
@@ -28276,9 +28485,9 @@ ${body}`;
 }
 function compileClineRules(sourceRulesDir, lossReport) {
   const dotRulesFiles = [];
-  for (const ruleFile of ts(path38.join(sourceRulesDir, "*.md")).sort()) {
-    const content = fs39.readFileSync(ruleFile, "utf8");
-    const name = path38.basename(ruleFile, ".md");
+  for (const ruleFile of ts(path39.join(sourceRulesDir, "*.md")).sort()) {
+    const content = fs40.readFileSync(ruleFile, "utf8");
+    const name = path39.basename(ruleFile, ".md");
     let frontmatterData = {};
     let body = content;
     if (content.startsWith("---\n")) {
@@ -28295,13 +28504,13 @@ function compileClineRules(sourceRulesDir, lossReport) {
     }
     const marker = formatProvenanceMarker(
       "markdown",
-      `rules/${path38.basename(ruleFile)}`,
+      `rules/${path39.basename(ruleFile)}`,
       computeSourceHash(ruleFile),
       "cline"
     );
     if (frontmatterData.mode === "exec-policy") {
       addLoss(lossReport, "cline", "rules", {
-        source: `rules/${path38.basename(ruleFile)}`,
+        source: `rules/${path39.basename(ruleFile)}`,
         fields: [
           {
             field: "mode",
@@ -28311,7 +28520,7 @@ function compileClineRules(sourceRulesDir, lossReport) {
               "mode",
               "rule-mode-downgrade"
             ),
-            detail: `${path38.basename(ruleFile)}: Cline rules have no exec-policy mode; rule emitted as guidance.`
+            detail: `${path39.basename(ruleFile)}: Cline rules have no exec-policy mode; rule emitted as guidance.`
           }
         ]
       });
@@ -28331,12 +28540,12 @@ ${frontmatterYaml}${body}`;
   return { agentsAppendix: "", dotRulesFiles };
 }
 function compileCopilotRules(sourceRulesDir) {
-  if (!fs39.existsSync(sourceRulesDir)) {
+  if (!fs40.existsSync(sourceRulesDir)) {
     return [];
   }
   const files = [];
-  for (const ruleFile of ts(path38.join(sourceRulesDir, "*.md")).sort()) {
-    const name = path38.basename(ruleFile, ".md");
+  for (const ruleFile of ts(path39.join(sourceRulesDir, "*.md")).sort()) {
+    const name = path39.basename(ruleFile, ".md");
     const { data } = parseMarkdownFrontmatter(ruleFile);
     const { body } = parseRule(ruleFile);
     const declared = data.paths;
@@ -28345,7 +28554,7 @@ function compileCopilotRules(sourceRulesDir) {
       "---",
       `applyTo: ${JSON.stringify(applyTo)}`,
       "x-tangyr:",
-      `  source: rules/${path38.basename(ruleFile)}`,
+      `  source: rules/${path39.basename(ruleFile)}`,
       `  hash: ${computeSourceHash(ruleFile)}`,
       "  target: copilot",
       "---"
@@ -28382,7 +28591,7 @@ function syncCodex(config, sourceRoot, mappings, extensions, options, lossReport
     rules: profile.rules
   };
   const rules = compileRules(
-    path39.join(sourceRoot, config.source.rules),
+    path40.join(sourceRoot, config.source.rules),
     "codex",
     mappings,
     lossReport
@@ -28462,7 +28671,7 @@ function syncCodex(config, sourceRoot, mappings, extensions, options, lossReport
   if (!shouldSkipComponent2(options, "hooks")) {
     outcomes.push(
       syncHookScriptsBridge({
-        source: path39.resolve(sourceRoot, config.source.hooks),
+        source: path40.resolve(sourceRoot, config.source.hooks),
         destination: resolveTargetPath(paths.hook_scripts),
         config,
         sourceRoot,
@@ -28561,9 +28770,9 @@ function syncCodex(config, sourceRoot, mappings, extensions, options, lossReport
 function buildProviderTomlSection(config, sourceRoot, mappings, scope, lossReport) {
   const cp = mappings.modelTiers.custom_provider;
   if (!cp) return "";
-  const agentsDir = path39.join(sourceRoot, config.source.agents);
-  if (!fs40.existsSync(agentsDir)) return "";
-  const agentFiles = ts(path39.join(agentsDir, "*.md")).sort();
+  const agentsDir = path40.join(sourceRoot, config.source.agents);
+  if (!fs41.existsSync(agentsDir)) return "";
+  const agentFiles = ts(path40.join(agentsDir, "*.md")).sort();
   const hasProviderAgent = agentFiles.some((agentFile) => {
     const { data } = parseMarkdownFrontmatter(agentFile);
     return typeof data.provider === "string" || typeof data.provider === "object" && data.provider !== null && Object.keys(data.provider).length > 0;
@@ -28628,7 +28837,7 @@ function syncRules(config, sourceRoot, paths, rules, options, logger, manifest,
     }
   ];
   for (const ruleFile of rules.dotRulesFiles) {
-    const destination = path39.join(rulesRoot, ruleFile.name);
+    const destination = path40.join(rulesRoot, ruleFile.name);
     if (options.dryRun) {
       logger.info(`[dry-run] rules: write ${destination}`);
       outcomes.push({
@@ -28658,16 +28867,16 @@ function syncRules(config, sourceRoot, paths, rules, options, logger, manifest,
 function syncInstructions(config, sourceRoot, paths, agentsAppendix, options, logger, manifest, scopePath) {
   const source = instructionsSourcePath(sourceRoot, config);
   const destination = resolveTargetPath(paths.instructions);
-  if (!fs40.existsSync(source)) {
+  if (!fs41.existsSync(source)) {
     return skippedMissingSource2("instructions", source);
   }
-  const composed = `${fs40.readFileSync(source, "utf8").trim()}
+  const composed = `${fs41.readFileSync(source, "utf8").trim()}
 
 --- tangyr managed rules ---
 ${agentsAppendix}`.trim();
   const marker = formatProvenanceMarker(
     "markdown",
-    path39.basename(instructionsSourceLabel(sourceRoot, config)),
+    path40.basename(instructionsSourceLabel(sourceRoot, config)),
     hashString(composed),
     "codex"
   );
@@ -28697,7 +28906,7 @@ function syncSkills(config, sourceRoot, paths, options, logger, manifest, scopeP
   return syncSkillsSlot({
     config,
     sourceRoot,
-    source: path39.resolve(sourceRoot, config.source.skills),
+    source: path40.resolve(sourceRoot, config.source.skills),
     destination: resolveTargetPath(paths.skills),
     dryRun: options.dryRun,
     logger,
@@ -28712,13 +28921,13 @@ function syncSkills(config, sourceRoot, paths, options, logger, manifest, scopeP
   });
 }
 function syncCommandsAsSkills(config, sourceRoot, paths, options, _lossReport, logger, manifest, scopePath) {
-  const commandsRoot = path39.resolve(sourceRoot, config.source.commands);
-  if (!fs40.existsSync(commandsRoot)) {
+  const commandsRoot = path40.resolve(sourceRoot, config.source.commands);
+  if (!fs41.existsSync(commandsRoot)) {
     return [skippedMissingSource2("commands", commandsRoot)];
   }
   const skillsRoot = resolveTargetPath(paths.skills);
   return compileCommandsAsSkills(commandsRoot, "codex").map((skill) => {
-    const destination = path39.join(skillsRoot, skill.name, "SKILL.md");
+    const destination = path40.join(skillsRoot, skill.name, "SKILL.md");
     if (options.dryRun) {
       logger.info(
         `[dry-run] commands: compile ${skill.relativeSource} -> ${destination}`
@@ -28744,16 +28953,16 @@ function syncCommandsAsSkills(config, sourceRoot, paths, options, _lossReport, l
   });
 }
 function syncAgents(config, sourceRoot, paths, mappings, extensions, options, lossReport, logger, manifest, scopePath) {
-  const sourceAgentsRoot = path39.join(sourceRoot, config.source.agents);
-  if (!fs40.existsSync(sourceAgentsRoot)) {
+  const sourceAgentsRoot = path40.join(sourceRoot, config.source.agents);
+  if (!fs41.existsSync(sourceAgentsRoot)) {
     return [skippedMissingSource2("agents", sourceAgentsRoot)];
   }
-  const sourceAgents = ts(path39.join(sourceAgentsRoot, "*.md")).sort();
+  const sourceAgents = ts(path40.join(sourceAgentsRoot, "*.md")).sort();
   const agentsRoot = resolveTargetPath(paths.agents);
   return sourceAgents.map((agentFile) => {
-    const destination = path39.join(
+    const destination = path40.join(
       agentsRoot,
-      `${path39.basename(agentFile, ".md")}.toml`
+      `${path40.basename(agentFile, ".md")}.toml`
     );
     const compiled = compileAgent(
       agentFile,
@@ -28831,7 +29040,7 @@ function syncHooks2(config, sourceRoot, paths, mappings, options, lossReport, lo
     destination,
     hostHooks,
     stringifyJson3,
-    !fs40.existsSync(destination),
+    !fs41.existsSync(destination),
     logger
   );
   return {
@@ -28844,7 +29053,7 @@ function syncMcp2(config, sourceRoot, paths, options, lossReport, logger, provid
   const source = resolveMcpSourceFile(sourceRoot, config);
   const sourceLabel = mcpSourceLabel(config);
   const destination = resolveTargetPath(paths.mcp_shared_file);
-  if (!fs40.existsSync(source)) {
+  if (!fs41.existsSync(source)) {
     if (providerToml && !options.dryRun) {
       const changed2 = writeTomlManagedSection(
         destination,
@@ -28859,7 +29068,7 @@ function syncMcp2(config, sourceRoot, paths, options, lossReport, logger, provid
     }
     return skippedMissingSource2("mcp", source);
   }
-  const sourceMcpJson = JSON.parse(fs40.readFileSync(source, "utf8"));
+  const sourceMcpJson = JSON.parse(fs41.readFileSync(source, "utf8"));
   const compiled = compileMcp(sourceMcpJson, "codex", lossReport, sourceLabel);
   const managedContent = providerToml ? `${compiled.trimEnd()}${providerToml}` : compiled;
   if (options.dryRun) {
@@ -28884,18 +29093,18 @@ function writeCompiledArtifact(component, destination, content, expectedHash, co
   if (artifactClass === "unmanaged-conflict" && !handleConflict2(destination, config, options, logger, manifest, scopePath)) {
     return { component, status: "conflict", path: destination };
   }
-  ensureDir(path39.dirname(destination));
+  ensureDir(path40.dirname(destination));
   const clearedLink = clearSymlinkAtDestination(destination);
   if (clearedLink !== null) {
     logger.verbose(
       `  ${destination}: replaced a symlink to ${clearedLink} with generated content`
     );
   }
-  fs40.writeFileSync(destination, content);
+  fs41.writeFileSync(destination, content);
   return { component, status: "success", path: destination };
 }
 function writeTomlManagedSection(destination, managedContent, logger) {
-  const current = fs40.existsSync(destination) ? fs40.readFileSync(destination, "utf8") : "";
+  const current = fs41.existsSync(destination) ? fs41.readFileSync(destination, "utf8") : "";
   const isFirstWrite = current.length > 0 && !current.includes(managedMcpStart);
   if (isFirstWrite) {
     logger.warn(
@@ -28911,8 +29120,8 @@ ${managedMcpEnd}
   if (current === next.trimStart()) {
     return false;
   }
-  ensureDir(path39.dirname(destination));
-  fs40.writeFileSync(destination, next.trimStart());
+  ensureDir(path40.dirname(destination));
+  fs41.writeFileSync(destination, next.trimStart());
   return true;
 }
 function removeManagedTomlSection(content) {
@@ -28938,7 +29147,7 @@ function handleConflict2(destination, config, options, logger, manifest, scopePa
     if (manifest && scopePath) {
       backupFile(destination, manifest, scopePath);
       writeManifest(scopePath, manifest);
-      fs40.rmSync(destination, { recursive: true, force: true });
+      fs41.rmSync(destination, { recursive: true, force: true });
     } else {
       const parked = parkConflictingPath(
         destination,
@@ -28953,12 +29162,12 @@ function handleConflict2(destination, config, options, logger, manifest, scopePa
     }
     return true;
   }
-  fs40.rmSync(destination, { recursive: true, force: true });
+  fs41.rmSync(destination, { recursive: true, force: true });
   return true;
 }
 function isCompiledCurrent(destination, expectedContent, _expectedHash) {
   try {
-    return fs40.readFileSync(destination, "utf8") === expectedContent;
+    return fs41.readFileSync(destination, "utf8") === expectedContent;
   } catch {
     return false;
   }
@@ -28974,10 +29183,10 @@ function shouldSkipComponent2(options, component) {
   return Boolean(options.component && options.component !== component);
 }
 function readJsonObject4(filePath) {
-  if (!fs40.existsSync(filePath)) {
+  if (!fs41.existsSync(filePath)) {
     return {};
   }
-  const parsed = JSON.parse(fs40.readFileSync(filePath, "utf8"));
+  const parsed = JSON.parse(fs41.readFileSync(filePath, "utf8"));
   return isRecord5(parsed) ? parsed : {};
 }
 function stringifyJson3(value) {
@@ -28993,16 +29202,16 @@ function hashString(value) {
 
 // src/adapters/copilot.ts
 import crypto7 from "crypto";
-import fs41 from "fs";
-import path41 from "path";
+import fs42 from "fs";
+import path42 from "path";
 
 // src/compiler/commands.ts
 var import_yaml11 = __toESM(require_dist(), 1);
-import path40 from "path";
+import path41 from "path";
 function compileCommandPrompt(sourceFile) {
   const { data, body } = parseMarkdownFrontmatter(sourceFile);
-  const relativeSource = `commands/${path40.basename(sourceFile)}`;
-  const fields = promptFrontmatter(data, path40.basename(sourceFile, ".md"));
+  const relativeSource = `commands/${path41.basename(sourceFile)}`;
+  const fields = promptFrontmatter(data, path41.basename(sourceFile, ".md"));
   const marker = formatProvenanceMarker(
     "markdown",
     relativeSource,
@@ -29143,7 +29352,7 @@ function syncCopilot(config, sourceRoot, mappings, extensions, options, lossRepo
   if (!shouldSkipComponent3(options, "hooks")) {
     outcomes.push(
       syncHookScriptsBridge({
-        source: path41.resolve(sourceRoot, config.source.hooks),
+        source: path42.resolve(sourceRoot, config.source.hooks),
         destination: resolveTargetPath(paths.hook_scripts),
         config,
         sourceRoot,
@@ -29224,13 +29433,13 @@ function syncCopilot(config, sourceRoot, mappings, extensions, options, lossRepo
 }
 function syncProviderLoss2(config, sourceRoot, mappings, lossReport) {
   if (!mappings.modelTiers.custom_provider) return;
-  const agentsDir = path41.join(sourceRoot, config.source.agents);
-  if (!fs41.existsSync(agentsDir)) return;
-  for (const agentFile of ts(path41.join(agentsDir, "*.md")).sort()) {
+  const agentsDir = path42.join(sourceRoot, config.source.agents);
+  if (!fs42.existsSync(agentsDir)) return;
+  for (const agentFile of ts(path42.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 = path41.basename(agentFile);
+      const basename = path42.basename(agentFile);
       addLoss(lossReport, "copilot", "agents", {
         source: `agents/${basename}`,
         fields: [
@@ -29256,22 +29465,22 @@ function syncCopilotInstructions(config, sourceRoot, options, lossReport, logger
     return [{ component: "instructions", status: "skipped", path: message }];
   }
   const source = instructionsSourcePath(sourceRoot, config);
-  if (!fs41.existsSync(source)) {
+  if (!fs42.existsSync(source)) {
     return [skippedMissingSource3("instructions", source)];
   }
-  const rawContent = fs41.readFileSync(source, "utf8");
+  const rawContent = fs42.readFileSync(source, "utf8");
   const contentHash = hashString2(rawContent);
   const marker = formatProvenanceMarker(
     "markdown",
-    path41.basename(instructionsSourceLabel(sourceRoot, config)),
+    path42.basename(instructionsSourceLabel(sourceRoot, config)),
     contentHash,
     "copilot"
   );
   const composedContent = `${marker}
 ${rawContent}`;
   const projectRoot = options.projectRoot ?? process.cwd();
-  const agentsMdDest = path41.resolve(projectRoot, "AGENTS.md");
-  const mirrorDest = path41.resolve(
+  const agentsMdDest = path42.resolve(projectRoot, "AGENTS.md");
+  const mirrorDest = path42.resolve(
     projectRoot,
     ".github",
     "copilot-instructions.md"
@@ -29325,14 +29534,14 @@ function writeInstructionsFile(component, destination, content, contentHash, con
   if (artifactClass === "unmanaged-conflict" && !handleConflict3(destination, config, options, logger, manifest, scopePath)) {
     return { component, status: "conflict", path: destination };
   }
-  ensureDir(path41.dirname(destination));
+  ensureDir(path42.dirname(destination));
   const clearedLink = clearSymlinkAtDestination(destination);
   if (clearedLink !== null) {
     logger.verbose(
       `  ${destination}: replaced a symlink to ${clearedLink} with generated content`
     );
   }
-  fs41.writeFileSync(destination, content);
+  fs42.writeFileSync(destination, content);
   return { component, status: "success", path: destination };
 }
 function hashString2(value) {
@@ -29342,7 +29551,7 @@ function syncSkills2(config, sourceRoot, paths, options, logger, manifest, scope
   return syncSkillsSlot({
     config,
     sourceRoot,
-    source: path41.resolve(sourceRoot, config.source.skills),
+    source: path42.resolve(sourceRoot, config.source.skills),
     destination: resolveTargetPath(paths.skills),
     dryRun: options.dryRun,
     logger,
@@ -29357,16 +29566,16 @@ function syncSkills2(config, sourceRoot, paths, options, logger, manifest, scope
   });
 }
 function syncAgents2(config, sourceRoot, paths, mappings, extensions, options, lossReport, logger, manifest, scopePath) {
-  const sourceAgentsRoot = path41.join(sourceRoot, config.source.agents);
-  if (!fs41.existsSync(sourceAgentsRoot)) {
+  const sourceAgentsRoot = path42.join(sourceRoot, config.source.agents);
+  if (!fs42.existsSync(sourceAgentsRoot)) {
     return [skippedMissingSource3("agents", sourceAgentsRoot)];
   }
-  const sourceAgents = ts(path41.join(sourceAgentsRoot, "*.md")).sort();
+  const sourceAgents = ts(path42.join(sourceAgentsRoot, "*.md")).sort();
   const agentsRoot = resolveTargetPath(paths.agents);
   return sourceAgents.map((agentFile) => {
-    const destination = path41.join(
+    const destination = path42.join(
       agentsRoot,
-      `${path41.basename(agentFile, ".md")}.agent.md`
+      `${path42.basename(agentFile, ".md")}.agent.md`
     );
     const compiled = compileAgent(
       agentFile,
@@ -29394,16 +29603,16 @@ function syncAgents2(config, sourceRoot, paths, mappings, extensions, options, l
   });
 }
 function syncCommands(config, sourceRoot, paths, options, logger, manifest, scopePath) {
-  const sourceCommandsRoot = path41.join(sourceRoot, config.source.commands);
-  if (!fs41.existsSync(sourceCommandsRoot)) {
+  const sourceCommandsRoot = path42.join(sourceRoot, config.source.commands);
+  if (!fs42.existsSync(sourceCommandsRoot)) {
     return [skippedMissingSource3("commands", sourceCommandsRoot)];
   }
-  const sourceCommands = ts(path41.join(sourceCommandsRoot, "*.md")).sort();
+  const sourceCommands = ts(path42.join(sourceCommandsRoot, "*.md")).sort();
   const promptsRoot = resolveTargetPath(paths.prompts);
   return sourceCommands.map((commandFile) => {
-    const destination = path41.join(
+    const destination = path42.join(
       promptsRoot,
-      `${path41.basename(commandFile, ".md")}.prompt.md`
+      `${path42.basename(commandFile, ".md")}.prompt.md`
     );
     const compiled = compileCommandPrompt(commandFile);
     if (options.dryRun) {
@@ -29427,7 +29636,7 @@ function syncCommands(config, sourceRoot, paths, options, logger, manifest, scop
   });
 }
 function syncHooks3(config, sourceRoot, paths, mappings, options, lossReport, logger) {
-  const destination = path41.join(
+  const destination = path42.join(
     resolveTargetPath(paths.hooks),
     "tangyr-managed.json"
   );
@@ -29490,10 +29699,10 @@ function syncMcp3(config, sourceRoot, paths, options, lossReport, logger) {
   const source = resolveMcpSourceFile(sourceRoot, config);
   const sourceLabel = mcpSourceLabel(config);
   const destination = resolveTargetPath(paths.mcp_shared_file);
-  if (!fs41.existsSync(source)) {
+  if (!fs42.existsSync(source)) {
     return skippedMissingSource3("mcp", source);
   }
-  const sourceMcpJson = JSON.parse(fs41.readFileSync(source, "utf8"));
+  const sourceMcpJson = JSON.parse(fs42.readFileSync(source, "utf8"));
   const compiled = compileMcp(
     sourceMcpJson,
     "copilot",
@@ -29516,13 +29725,13 @@ function syncMcp3(config, sourceRoot, paths, options, lossReport, logger) {
   );
 }
 function syncRules2(config, sourceRoot, rulesSlot, options, logger, manifest, scopePath) {
-  const sourceRulesDir = path41.resolve(sourceRoot, config.source.rules);
-  if (!fs41.existsSync(sourceRulesDir)) {
+  const sourceRulesDir = path42.resolve(sourceRoot, config.source.rules);
+  if (!fs42.existsSync(sourceRulesDir)) {
     return [skippedMissingSource3("rules", sourceRulesDir)];
   }
   const destinationRoot = resolveTargetPath(rulesSlot);
   return compileCopilotRules(sourceRulesDir).map((file) => {
-    const destination = path41.join(destinationRoot, file.name);
+    const destination = path42.join(destinationRoot, file.name);
     if (options.dryRun) {
       logger.info(`[dry-run] rules: compile -> ${destination}`);
       return {
@@ -29556,19 +29765,19 @@ function writeCompiledArtifact2(component, destination, content, expectedHash, c
   if (artifactClass === "unmanaged-conflict" && !handleConflict3(destination, config, options, logger, manifest, scopePath)) {
     return { component, status: "conflict", path: destination };
   }
-  ensureDir(path41.dirname(destination));
+  ensureDir(path42.dirname(destination));
   const clearedLink = clearSymlinkAtDestination(destination);
   if (clearedLink !== null) {
     logger.verbose(
       `  ${destination}: replaced a symlink to ${clearedLink} with generated content`
     );
   }
-  fs41.writeFileSync(destination, content);
+  fs42.writeFileSync(destination, content);
   return { component, status: "success", path: destination };
 }
 function isCompiledCurrent2(destination, expectedContent, _expectedHash) {
   try {
-    return fs41.readFileSync(destination, "utf8") === expectedContent;
+    return fs42.readFileSync(destination, "utf8") === expectedContent;
   } catch {
     return false;
   }
@@ -29588,7 +29797,7 @@ function handleConflict3(destination, config, options, logger, manifest, scopePa
     if (manifest && scopePath) {
       backupFile(destination, manifest, scopePath);
       writeManifest(scopePath, manifest);
-      fs41.rmSync(destination, { recursive: true, force: true });
+      fs42.rmSync(destination, { recursive: true, force: true });
     } else {
       const parked = parkConflictingPath(
         destination,
@@ -29603,7 +29812,7 @@ function handleConflict3(destination, config, options, logger, manifest, scopePa
     }
     return true;
   }
-  fs41.rmSync(destination, { recursive: true, force: true });
+  fs42.rmSync(destination, { recursive: true, force: true });
   return true;
 }
 function shouldSkipComponent3(options, component) {
@@ -29612,12 +29821,12 @@ function shouldSkipComponent3(options, component) {
 function cleanupLegacyAgents(paths, options, logger) {
   const currentAgentsRoot = resolveTargetPath(paths.agents);
   const legacyAgentsRoot = resolveTargetPath(legacyCopilotAgentsPath);
-  if (path41.resolve(currentAgentsRoot) === path41.resolve(legacyAgentsRoot)) {
+  if (path42.resolve(currentAgentsRoot) === path42.resolve(legacyAgentsRoot)) {
     return [];
   }
   const outcomes = [];
   for (const filePath of ts(
-    path41.join(legacyAgentsRoot, "*.agent.md")
+    path42.join(legacyAgentsRoot, "*.agent.md")
   ).sort()) {
     if (!isCopilotManagedCompiledFile(filePath)) {
       continue;
@@ -29627,14 +29836,14 @@ function cleanupLegacyAgents(paths, options, logger) {
       outcomes.push({ component: "agents", status: "dry-run", path: filePath });
       continue;
     }
-    fs41.rmSync(filePath, { force: true });
+    fs42.rmSync(filePath, { force: true });
     outcomes.push({ component: "agents", status: "success", path: filePath });
   }
   return outcomes;
 }
 function isCopilotManagedCompiledFile(filePath) {
   try {
-    return extractProvenanceMarker(fs41.readFileSync(filePath, "utf8"))?.target === "copilot";
+    return extractProvenanceMarker(fs42.readFileSync(filePath, "utf8"))?.target === "copilot";
   } catch {
     return false;
   }
@@ -29649,8 +29858,8 @@ function skippedMissingSource3(component, source) {
 
 // src/adapters/cursor.ts
 import crypto8 from "crypto";
-import fs42 from "fs";
-import path42 from "path";
+import fs43 from "fs";
+import path43 from "path";
 function syncCursor(config, sourceRoot, mappings, extensions, options, lossReport, logger, manifest, scopePath) {
   const scope = options.scope ?? "global";
   const profile = resolveTargetPaths({
@@ -29762,7 +29971,7 @@ function syncCursor(config, sourceRoot, mappings, extensions, options, lossRepor
   if (!shouldSkipComponent4(options, "hooks")) {
     outcomes.push(
       syncHookScriptsBridge({
-        source: path42.resolve(sourceRoot, config.source.hooks),
+        source: path43.resolve(sourceRoot, config.source.hooks),
         destination: resolveTargetPath(paths.hook_scripts),
         config,
         sourceRoot,
@@ -29827,7 +30036,7 @@ function syncInstructions2(config, sourceRoot, paths, options, lossReport, logge
   const composed = composeCursorInstructions(config, sourceRoot, lossReport);
   const marker = formatProvenanceMarker(
     "markdown",
-    path42.basename(instructionsSourceLabel(sourceRoot, config)),
+    path43.basename(instructionsSourceLabel(sourceRoot, config)),
     hashString3(composed),
     "cursor"
   );
@@ -29853,7 +30062,7 @@ ${composed}
 }
 function composeCursorInstructions(config, sourceRoot, lossReport) {
   const source = instructionsSourcePath(sourceRoot, config);
-  const baseContent = fs42.existsSync(source) ? fs42.readFileSync(source, "utf8").trim() : "";
+  const baseContent = fs43.existsSync(source) ? fs43.readFileSync(source, "utf8").trim() : "";
   const personaContent = extractPrimaryPersonaContent(
     config,
     sourceRoot,
@@ -29866,11 +30075,11 @@ function composeCursorInstructions(config, sourceRoot, lossReport) {
 ${personaContent}`.trim() : baseContent;
 }
 function extractPrimaryPersonaContent(config, sourceRoot, lossReport) {
-  const agentsDir = path42.join(sourceRoot, config.source.agents);
-  if (!fs42.existsSync(agentsDir)) {
+  const agentsDir = path43.join(sourceRoot, config.source.agents);
+  if (!fs43.existsSync(agentsDir)) {
     return null;
   }
-  const agentFiles = ts(path42.join(agentsDir, "*.md")).sort();
+  const agentFiles = ts(path43.join(agentsDir, "*.md")).sort();
   if (agentFiles.length === 0) {
     return null;
   }
@@ -29893,7 +30102,7 @@ function extractPrimaryPersonaContent(config, sourceRoot, lossReport) {
     return null;
   }
   addLoss(lossReport, "cursor", "instructions", {
-    source: `agents/${path42.basename(primaryFile)}`,
+    source: `agents/${path43.basename(primaryFile)}`,
     fields: [
       {
         field: "persona",
@@ -29903,23 +30112,23 @@ function extractPrimaryPersonaContent(config, sourceRoot, lossReport) {
           "persona",
           "instructions-shim"
         ),
-        detail: `Primary persona from ${path42.basename(primaryFile)} folded into AGENTS.md (Cursor has no custom modes surface)`
+        detail: `Primary persona from ${path43.basename(primaryFile)} folded into AGENTS.md (Cursor has no custom modes surface)`
       }
     ]
   });
   return body.trim();
 }
 function syncAgents3(config, sourceRoot, paths, mappings, extensions, options, lossReport, logger, manifest, scopePath) {
-  const sourceAgentsRoot = path42.join(sourceRoot, config.source.agents);
-  if (!fs42.existsSync(sourceAgentsRoot)) {
+  const sourceAgentsRoot = path43.join(sourceRoot, config.source.agents);
+  if (!fs43.existsSync(sourceAgentsRoot)) {
     return [skippedMissingSource4("agents", sourceAgentsRoot)];
   }
-  const sourceAgents = ts(path42.join(sourceAgentsRoot, "*.md")).sort();
+  const sourceAgents = ts(path43.join(sourceAgentsRoot, "*.md")).sort();
   const agentsRoot = resolveTargetPath(paths.agents);
   return sourceAgents.map((agentFile) => {
-    const destination = path42.join(
+    const destination = path43.join(
       agentsRoot,
-      `${path42.basename(agentFile, ".md")}.md`
+      `${path43.basename(agentFile, ".md")}.md`
     );
     let compiled;
     try {
@@ -29960,14 +30169,14 @@ function syncAgents3(config, sourceRoot, paths, mappings, extensions, options, l
   });
 }
 function syncRules3(config, sourceRoot, paths, mappings, options, lossReport, logger, manifest, scopePath) {
-  const sourceRulesDir = path42.join(sourceRoot, config.source.rules);
-  if (!fs42.existsSync(sourceRulesDir)) {
+  const sourceRulesDir = path43.join(sourceRoot, config.source.rules);
+  if (!fs43.existsSync(sourceRulesDir)) {
     return [skippedMissingSource4("rules", sourceRulesDir)];
   }
   const compiled = compileRules(sourceRulesDir, "cursor", mappings, lossReport);
   const rulesDir = resolveTargetPath(paths.rules);
   return compiled.dotRulesFiles.map(({ name, content }) => {
-    const destination = path42.join(rulesDir, name);
+    const destination = path43.join(rulesDir, name);
     if (options.dryRun) {
       logger.info(`[dry-run] rules: write ${destination}`);
       return {
@@ -29991,15 +30200,15 @@ function syncRules3(config, sourceRoot, paths, mappings, options, lossReport, lo
   });
 }
 function syncCommands2(config, sourceRoot, paths, options, logger, manifest, scopePath) {
-  const sourceCommandsRoot = path42.join(sourceRoot, config.source.commands);
-  if (!fs42.existsSync(sourceCommandsRoot)) {
+  const sourceCommandsRoot = path43.join(sourceRoot, config.source.commands);
+  if (!fs43.existsSync(sourceCommandsRoot)) {
     return [skippedMissingSource4("commands", sourceCommandsRoot)];
   }
-  const sourceCommands = ts(path42.join(sourceCommandsRoot, "*.md")).sort();
+  const sourceCommands = ts(path43.join(sourceCommandsRoot, "*.md")).sort();
   const skillsRoot = resolveTargetPath(paths.skills);
   return sourceCommands.map((commandFile) => {
-    const baseName = path42.basename(commandFile, ".md");
-    const destination = path42.join(skillsRoot, baseName, "SKILL.md");
+    const baseName = path43.basename(commandFile, ".md");
+    const destination = path43.join(skillsRoot, baseName, "SKILL.md");
     const { content } = compileCommandAsSkill(commandFile, "cursor");
     if (options.dryRun) {
       logger.info(
@@ -30029,7 +30238,7 @@ function syncSkills3(config, sourceRoot, options, logger, manifest, scopePath, _
   return syncSkillsSlot({
     config,
     sourceRoot,
-    source: path42.resolve(sourceRoot, config.source.skills),
+    source: path43.resolve(sourceRoot, config.source.skills),
     destination,
     dryRun: options.dryRun,
     logger,
@@ -30077,18 +30286,18 @@ function syncHooks4(config, sourceRoot, paths, mappings, options, lossReport, lo
   }
   const hooksFileContent = `${JSON.stringify({ version: 1, hooks: compiled.payload }, null, 2)}
 `;
-  ensureDir(path42.dirname(destination));
-  fs42.writeFileSync(destination, hooksFileContent);
+  ensureDir(path43.dirname(destination));
+  fs43.writeFileSync(destination, hooksFileContent);
   return { component: "hooks", status: "success", path: destination };
 }
 function syncMcp4(config, sourceRoot, paths, options, lossReport, logger, manifest, scopePath) {
   const source = resolveMcpSourceFile(sourceRoot, config);
   const sourceLabel = mcpSourceLabel(config);
   const destination = resolveTargetPath(paths.mcp_file);
-  if (!fs42.existsSync(source)) {
+  if (!fs43.existsSync(source)) {
     return skippedMissingSource4("mcp", source);
   }
-  const sourceMcpJson = JSON.parse(fs42.readFileSync(source, "utf8"));
+  const sourceMcpJson = JSON.parse(fs43.readFileSync(source, "utf8"));
   const mcpJson = compileMcp(sourceMcpJson, "cursor", lossReport, sourceLabel);
   if (options.dryRun) {
     logger.info(`[dry-run] mcp: compile ${source} -> ${destination}`);
@@ -30141,13 +30350,13 @@ function syncPermissions(config, paths, options, _lossReport, logger, manifest,
   );
 }
 function syncProviderPin(config, sourceRoot, lossReport) {
-  const agentsDir = path42.join(sourceRoot, config.source.agents);
-  if (!fs42.existsSync(agentsDir)) return;
-  for (const agentFile of ts(path42.join(agentsDir, "*.md")).sort()) {
+  const agentsDir = path43.join(sourceRoot, config.source.agents);
+  if (!fs43.existsSync(agentsDir)) return;
+  for (const agentFile of ts(path43.join(agentsDir, "*.md")).sort()) {
     const { data } = parseMarkdownFrontmatter(agentFile);
     const hasCustomProvider = typeof data.provider === "string" || typeof data.provider === "object" && data.provider !== null && Object.keys(data.provider).length > 0;
     if (hasCustomProvider) {
-      const relativeSource = `agents/${path42.basename(agentFile)}`;
+      const relativeSource = `agents/${path43.basename(agentFile)}`;
       addLoss(lossReport, "cursor", "agents", {
         source: relativeSource,
         fields: [
@@ -30159,7 +30368,7 @@ function syncProviderPin(config, sourceRoot, lossReport) {
               "provider",
               "provider-not-representable"
             ),
-            detail: `${path42.basename(agentFile)}: custom provider cannot be expressed in Cursor subagent frontmatter \u2014 configure manually via Cursor settings`
+            detail: `${path43.basename(agentFile)}: custom provider cannot be expressed in Cursor subagent frontmatter \u2014 configure manually via Cursor settings`
           }
         ]
       });
@@ -30177,14 +30386,14 @@ function writeCompiledArtifact3(component, destination, content, expectedHash, c
   if (artifactClass === "unmanaged-conflict" && !handleConflict4(destination, config, options, logger, manifest, scopePath)) {
     return { component, status: "conflict", path: destination };
   }
-  ensureDir(path42.dirname(destination));
+  ensureDir(path43.dirname(destination));
   const clearedLink = clearSymlinkAtDestination(destination);
   if (clearedLink !== null) {
     logger.verbose(
       `  ${destination}: replaced a symlink to ${clearedLink} with generated content`
     );
   }
-  fs42.writeFileSync(destination, content);
+  fs43.writeFileSync(destination, content);
   return { component, status: "success", path: destination };
 }
 function handleConflict4(destination, config, options, logger, manifest, scopePath) {
@@ -30202,7 +30411,7 @@ function handleConflict4(destination, config, options, logger, manifest, scopePa
     if (manifest && scopePath) {
       backupFile(destination, manifest, scopePath);
       writeManifest(scopePath, manifest);
-      fs42.rmSync(destination, { recursive: true, force: true });
+      fs43.rmSync(destination, { recursive: true, force: true });
     } else {
       const parked = parkConflictingPath(
         destination,
@@ -30217,12 +30426,12 @@ function handleConflict4(destination, config, options, logger, manifest, scopePa
     }
     return true;
   }
-  fs42.rmSync(destination, { recursive: true, force: true });
+  fs43.rmSync(destination, { recursive: true, force: true });
   return true;
 }
 function isCompiledCurrent3(destination, expectedContent, _expectedHash) {
   try {
-    return fs42.readFileSync(destination, "utf8") === expectedContent;
+    return fs43.readFileSync(destination, "utf8") === expectedContent;
   } catch {
     return false;
   }
@@ -30243,8 +30452,8 @@ function hashString3(value) {
 
 // src/adapters/cline.ts
 import crypto9 from "crypto";
-import fs43 from "fs";
-import path43 from "path";
+import fs44 from "fs";
+import path44 from "path";
 function syncCline(config, sourceRoot, mappings, extensions, options, lossReport, logger, manifest, scopePath) {
   const scope = options.scope ?? "global";
   const profile = resolveTargetPaths({
@@ -30357,7 +30566,7 @@ function syncCline(config, sourceRoot, mappings, extensions, options, lossReport
 function syncInstructions3(config, sourceRoot, paths, scope, options, lossReport, logger, manifest, scopePath) {
   if (scope === "global" || paths.instructions === null) {
     addLoss(lossReport, "cline", "instructions", {
-      source: path43.basename(instructionsSourceLabel(sourceRoot, config)),
+      source: path44.basename(instructionsSourceLabel(sourceRoot, config)),
       fields: [
         {
           field: "instructions",
@@ -30379,10 +30588,10 @@ function syncInstructions3(config, sourceRoot, paths, scope, options, lossReport
   }
   const source = instructionsSourcePath(sourceRoot, config);
   const destination = resolveTargetPath(paths.instructions);
-  const baseContent = fs43.existsSync(source) ? fs43.readFileSync(source, "utf8").trim() : "";
+  const baseContent = fs44.existsSync(source) ? fs44.readFileSync(source, "utf8").trim() : "";
   const marker = formatProvenanceMarker(
     "markdown",
-    path43.basename(instructionsSourceLabel(sourceRoot, config)),
+    path44.basename(instructionsSourceLabel(sourceRoot, config)),
     hashString4(baseContent),
     "cline"
   );
@@ -30407,11 +30616,11 @@ ${baseContent}
   );
 }
 function syncAgents4(config, sourceRoot, mappings, extensions, options, lossReport, logger) {
-  const sourceAgentsRoot = path43.join(sourceRoot, config.source.agents);
-  if (!fs43.existsSync(sourceAgentsRoot)) {
+  const sourceAgentsRoot = path44.join(sourceRoot, config.source.agents);
+  if (!fs44.existsSync(sourceAgentsRoot)) {
     return [skippedMissingSource5("agents", sourceAgentsRoot)];
   }
-  const sourceAgents = ts(path43.join(sourceAgentsRoot, "*.md")).sort();
+  const sourceAgents = ts(path44.join(sourceAgentsRoot, "*.md")).sort();
   return sourceAgents.map((agentFile) => {
     compileAgent(agentFile, "cline", mappings, extensions, lossReport);
     if (options.dryRun) {
@@ -30427,14 +30636,14 @@ function syncAgents4(config, sourceRoot, mappings, extensions, options, lossRepo
   });
 }
 function syncRules4(config, sourceRoot, paths, mappings, options, lossReport, logger, manifest, scopePath) {
-  const sourceRulesDir = path43.join(sourceRoot, config.source.rules);
-  if (!fs43.existsSync(sourceRulesDir)) {
+  const sourceRulesDir = path44.join(sourceRoot, config.source.rules);
+  if (!fs44.existsSync(sourceRulesDir)) {
     return [skippedMissingSource5("rules", sourceRulesDir)];
   }
   const compiled = compileRules(sourceRulesDir, "cline", mappings, lossReport);
   const rulesDir = resolveTargetPath(paths.rules);
   return compiled.dotRulesFiles.map(({ name, content }) => {
-    const destination = path43.join(rulesDir, name);
+    const destination = path44.join(rulesDir, name);
     if (options.dryRun) {
       logger.info(`[dry-run] rules: write ${destination}`);
       return {
@@ -30458,17 +30667,17 @@ function syncRules4(config, sourceRoot, paths, mappings, options, lossReport, lo
   });
 }
 function syncCommands3(config, sourceRoot, paths, options, logger, manifest, scopePath) {
-  const sourceCommandsRoot = path43.join(sourceRoot, config.source.commands);
-  if (!fs43.existsSync(sourceCommandsRoot)) {
+  const sourceCommandsRoot = path44.join(sourceRoot, config.source.commands);
+  if (!fs44.existsSync(sourceCommandsRoot)) {
     return [skippedMissingSource5("commands", sourceCommandsRoot)];
   }
-  const sourceCommands = ts(path43.join(sourceCommandsRoot, "*.md")).sort();
+  const sourceCommands = ts(path44.join(sourceCommandsRoot, "*.md")).sort();
   const workflowsRoot = resolveTargetPath(paths.workflows);
   return sourceCommands.map((commandFile) => {
-    const baseName = path43.basename(commandFile);
-    const destination = path43.join(workflowsRoot, baseName);
-    const commandContent = fs43.readFileSync(commandFile, "utf8");
-    const relativeSource = `commands/${path43.basename(commandFile)}`;
+    const baseName = path44.basename(commandFile);
+    const destination = path44.join(workflowsRoot, baseName);
+    const commandContent = fs44.readFileSync(commandFile, "utf8");
+    const relativeSource = `commands/${path44.basename(commandFile)}`;
     const marker = formatProvenanceMarker(
       "markdown",
       relativeSource,
@@ -30506,7 +30715,7 @@ function syncSkills4(config, sourceRoot, paths, options, logger, manifest, scope
   return syncSkillsSlot({
     config,
     sourceRoot,
-    source: path43.resolve(sourceRoot, config.source.skills),
+    source: path44.resolve(sourceRoot, config.source.skills),
     destination: resolveTargetPath(paths.skills),
     dryRun: options.dryRun,
     logger,
@@ -30539,10 +30748,10 @@ function syncMcp5(config, sourceRoot, paths, options, lossReport, logger, manife
   const source = resolveMcpSourceFile(sourceRoot, config);
   const sourceLabel = mcpSourceLabel(config);
   const destination = resolveTargetPath(paths.mcp_file);
-  if (!fs43.existsSync(source)) {
+  if (!fs44.existsSync(source)) {
     return skippedMissingSource5("mcp", source);
   }
-  const sourceMcpJson = JSON.parse(fs43.readFileSync(source, "utf8"));
+  const sourceMcpJson = JSON.parse(fs44.readFileSync(source, "utf8"));
   const mcpJson = compileMcp(sourceMcpJson, "cline", lossReport, sourceLabel);
   if (options.dryRun) {
     logger.info(`[dry-run] mcp: compile ${source} -> ${destination}`);
@@ -30585,11 +30794,11 @@ function syncSettings2(lossReport) {
   };
 }
 function syncProviderAndModel(config, sourceRoot, lossReport) {
-  const agentsDir = path43.join(sourceRoot, config.source.agents);
-  if (!fs43.existsSync(agentsDir)) return;
-  for (const agentFile of ts(path43.join(agentsDir, "*.md")).sort()) {
+  const agentsDir = path44.join(sourceRoot, config.source.agents);
+  if (!fs44.existsSync(agentsDir)) return;
+  for (const agentFile of ts(path44.join(agentsDir, "*.md")).sort()) {
     const { data } = parseMarkdownFrontmatter(agentFile);
-    const relativeSource = `agents/${path43.basename(agentFile)}`;
+    const relativeSource = `agents/${path44.basename(agentFile)}`;
     const hasCustomProvider = typeof data.provider === "string" || typeof data.provider === "object" && data.provider !== null && Object.keys(data.provider).length > 0;
     if (hasCustomProvider) {
       addLoss(lossReport, "cline", "agents", {
@@ -30603,7 +30812,7 @@ function syncProviderAndModel(config, sourceRoot, lossReport) {
               "provider",
               "provider-not-representable"
             ),
-            detail: `${path43.basename(agentFile)}: Cline provider is interface-only (Settings \u2192 API Provider); configure manually.`
+            detail: `${path44.basename(agentFile)}: Cline provider is interface-only (Settings \u2192 API Provider); configure manually.`
           }
         ]
       });
@@ -30621,7 +30830,7 @@ function syncProviderAndModel(config, sourceRoot, lossReport) {
               "model",
               "model-not-representable"
             ),
-            detail: `${path43.basename(agentFile)}: Cline model pin is interface-only (Settings \u2192 Model); configure manually.`
+            detail: `${path44.basename(agentFile)}: Cline model pin is interface-only (Settings \u2192 Model); configure manually.`
           }
         ]
       });
@@ -30639,14 +30848,14 @@ function writeCompiledArtifact4(component, destination, content, expectedHash, c
   if (artifactClass === "unmanaged-conflict" && !handleConflict5(destination, config, options, logger, manifest, scopePath)) {
     return { component, status: "conflict", path: destination };
   }
-  ensureDir(path43.dirname(destination));
+  ensureDir(path44.dirname(destination));
   const clearedLink = clearSymlinkAtDestination(destination);
   if (clearedLink !== null) {
     logger.verbose(
       `  ${destination}: replaced a symlink to ${clearedLink} with generated content`
     );
   }
-  fs43.writeFileSync(destination, content);
+  fs44.writeFileSync(destination, content);
   return { component, status: "success", path: destination };
 }
 function handleConflict5(destination, config, options, logger, manifest, scopePath) {
@@ -30664,7 +30873,7 @@ function handleConflict5(destination, config, options, logger, manifest, scopePa
     if (manifest && scopePath) {
       backupFile(destination, manifest, scopePath);
       writeManifest(scopePath, manifest);
-      fs43.rmSync(destination, { recursive: true, force: true });
+      fs44.rmSync(destination, { recursive: true, force: true });
     } else {
       const parked = parkConflictingPath(
         destination,
@@ -30679,12 +30888,12 @@ function handleConflict5(destination, config, options, logger, manifest, scopePa
     }
     return true;
   }
-  fs43.rmSync(destination, { recursive: true, force: true });
+  fs44.rmSync(destination, { recursive: true, force: true });
   return true;
 }
 function isCompiledCurrent4(destination, expectedContent, _expectedHash) {
   try {
-    return fs43.readFileSync(destination, "utf8") === expectedContent;
+    return fs44.readFileSync(destination, "utf8") === expectedContent;
   } catch {
     return false;
   }
@@ -30705,9 +30914,9 @@ function hashString4(value) {
 
 // src/adapters/opencode.ts
 import crypto10 from "crypto";
-import fs44 from "fs";
+import fs45 from "fs";
 import os6 from "os";
-import path44 from "path";
+import path45 from "path";
 var import_yaml12 = __toESM(require_dist(), 1);
 function syncOpenCode(config, sourceRoot, mappings, extensions, options, lossReport, logger, manifest, scopePath) {
   const scope = options.scope ?? "global";
@@ -30725,7 +30934,7 @@ function syncOpenCode(config, sourceRoot, mappings, extensions, options, lossRep
     config_doc: profile.config_doc
   };
   const rules = compileRules(
-    path44.join(sourceRoot, config.source.rules),
+    path45.join(sourceRoot, config.source.rules),
     "opencode",
     mappings,
     lossReport
@@ -30733,7 +30942,7 @@ function syncOpenCode(config, sourceRoot, mappings, extensions, options, lossRep
   const outcomes = [];
   if (!shouldSkipComponent6(options, "instructions")) {
     outcomes.push(
-      syncInstructions4(
+      ...syncInstructions4(
         config,
         sourceRoot,
         paths,
@@ -30829,14 +31038,14 @@ function syncOpenCode(config, sourceRoot, mappings, extensions, options, lossRep
 function syncInstructions4(config, sourceRoot, paths, agentsAppendix, options, logger, manifest, scopePath) {
   const source = instructionsSourcePath(sourceRoot, config);
   const destination = resolveTargetPath(paths.instructions);
-  const baseContent = fs44.existsSync(source) ? fs44.readFileSync(source, "utf8").trim() : "";
+  const baseContent = fs45.existsSync(source) ? fs45.readFileSync(source, "utf8").trim() : "";
   const composed = agentsAppendix ? `${baseContent}
 
 --- tangyr managed rules ---
 ${agentsAppendix}`.trim() : baseContent;
   const marker = formatProvenanceMarker(
     "markdown",
-    path44.basename(instructionsSourceLabel(sourceRoot, config)),
+    path45.basename(instructionsSourceLabel(sourceRoot, config)),
     hashString5(composed),
     "opencode"
   );
@@ -30847,9 +31056,11 @@ ${composed}
     logger.info(
       `[dry-run] instructions: generate ${source} + rules appendix -> ${destination}`
     );
-    return { component: "instructions", status: "dry-run", path: destination };
+    return [
+      { component: "instructions", status: "dry-run", path: destination }
+    ];
   }
-  return writeCompiledArtifact5(
+  const written = writeCompiledArtifact5(
     "instructions",
     destination,
     content,
@@ -30861,18 +31072,60 @@ ${composed}
     manifest,
     scopePath
   );
+  const declared = declareInstructions(paths);
+  return declared === null ? [written] : [
+    written,
+    { component: "instructions", status: "success", path: declared }
+  ];
+}
+function declaredInstructionsPath(paths) {
+  const configDir = path45.dirname(resolveTargetPath(paths.config_doc));
+  const instructions = resolveTargetPath(paths.instructions);
+  const relative = path45.relative(configDir, instructions);
+  if (relative === "AGENTS.md" || relative.startsWith("..")) {
+    return null;
+  }
+  return relative.split(path45.sep).join("/");
+}
+function withDeclaredInstructions(existing, reference) {
+  const listed = Array.isArray(existing) ? existing.filter((entry) => typeof entry === "string") : [];
+  return listed.includes(reference) ? listed : [...listed, reference];
+}
+function declareInstructions(paths) {
+  const reference = declaredInstructionsPath(paths);
+  if (reference === null) {
+    return null;
+  }
+  const destination = resolveTargetPath(paths.config_doc);
+  let existing = {};
+  if (fs45.existsSync(destination)) {
+    try {
+      existing = JSON.parse(fs45.readFileSync(destination, "utf8"));
+    } catch {
+      existing = {};
+    }
+  }
+  const config = {
+    $schema: "https://opencode.ai/config.json",
+    ...existing,
+    instructions: withDeclaredInstructions(existing.instructions, reference)
+  };
+  ensureDir(path45.dirname(destination));
+  fs45.writeFileSync(destination, `${JSON.stringify(config, null, 2)}
+`);
+  return destination;
 }
 function syncAgents5(config, sourceRoot, paths, mappings, extensions, options, lossReport, logger, manifest, scopePath) {
-  const sourceAgentsRoot = path44.join(sourceRoot, config.source.agents);
-  if (!fs44.existsSync(sourceAgentsRoot)) {
+  const sourceAgentsRoot = path45.join(sourceRoot, config.source.agents);
+  if (!fs45.existsSync(sourceAgentsRoot)) {
     return [skippedMissingSource6("agents", sourceAgentsRoot)];
   }
-  const sourceAgents = ts(path44.join(sourceAgentsRoot, "*.md")).sort();
+  const sourceAgents = ts(path45.join(sourceAgentsRoot, "*.md")).sort();
   const agentsRoot = resolveTargetPath(paths.agents);
   return sourceAgents.map((agentFile) => {
-    const destination = path44.join(
+    const destination = path45.join(
       agentsRoot,
-      `${path44.basename(agentFile, ".md")}.md`
+      `${path45.basename(agentFile, ".md")}.md`
     );
     let compiled;
     try {
@@ -30936,11 +31189,11 @@ function applyProviderModelBinding(compiled, mappings) {
   return `${before}${(0, import_yaml12.stringify)(fields).trim()}${after}`;
 }
 function syncCommands4(config, sourceRoot, paths, options, logger, manifest, scopePath) {
-  const sourceCommandsRoot = path44.join(sourceRoot, config.source.commands);
-  if (!fs44.existsSync(sourceCommandsRoot)) {
+  const sourceCommandsRoot = path45.join(sourceRoot, config.source.commands);
+  if (!fs45.existsSync(sourceCommandsRoot)) {
     return [skippedMissingSource6("commands", sourceCommandsRoot)];
   }
-  const sourceCommands = ts(path44.join(sourceCommandsRoot, "*.md")).sort();
+  const sourceCommands = ts(path45.join(sourceCommandsRoot, "*.md")).sort();
   const commandsRoot = resolveTargetPath(paths.commands);
   return sourceCommands.map((commandFile) => {
     const { data, body } = parseCommandFile(commandFile);
@@ -30954,7 +31207,7 @@ function syncCommands4(config, sourceRoot, paths, options, logger, manifest, sco
     if (typeof data.model === "string") {
       frontmatter.model = data.model;
     }
-    const relativeSource = `commands/${path44.basename(commandFile)}`;
+    const relativeSource = `commands/${path45.basename(commandFile)}`;
     const marker = formatProvenanceMarker(
       "markdown",
       relativeSource,
@@ -30970,9 +31223,9 @@ ${body.trimEnd()}
 ` : `${marker}
 ${body.trimEnd()}
 `;
-    const destination = path44.join(
+    const destination = path45.join(
       commandsRoot,
-      `${path44.basename(commandFile, ".md")}.md`
+      `${path45.basename(commandFile, ".md")}.md`
     );
     if (options.dryRun) {
       logger.info(
@@ -31002,7 +31255,7 @@ function syncSkills5(config, sourceRoot, _paths, options, logger, manifest, scop
   return syncSkillsSlot({
     config,
     sourceRoot,
-    source: path44.resolve(sourceRoot, config.source.skills),
+    source: path45.resolve(sourceRoot, config.source.skills),
     destination,
     dryRun: options.dryRun,
     logger,
@@ -31020,13 +31273,13 @@ function syncMcp6(config, sourceRoot, paths, mappings, options, lossReport, logg
   const source = resolveMcpSourceFile(sourceRoot, config);
   const sourceLabel = mcpSourceLabel(config);
   const destination = resolveTargetPath(paths.config_doc);
-  if (!fs44.existsSync(source)) {
+  if (!fs45.existsSync(source)) {
     if (!options.dryRun) {
       syncConfigDoc(paths, {}, lossReport, {}, mappings);
     }
     return skippedMissingSource6("mcp", source);
   }
-  const sourceMcpJson = JSON.parse(fs44.readFileSync(source, "utf8"));
+  const sourceMcpJson = JSON.parse(fs45.readFileSync(source, "utf8"));
   const mcpJson = compileMcp(
     sourceMcpJson,
     "opencode",
@@ -31092,9 +31345,9 @@ function syncProviderBlock(mappings) {
 function syncConfigDoc(paths, mcpEntries, _lossReport, permissionMap, mappings) {
   const destination = resolveTargetPath(paths.config_doc);
   let existing = {};
-  if (fs44.existsSync(destination)) {
+  if (fs45.existsSync(destination)) {
     try {
-      existing = JSON.parse(fs44.readFileSync(destination, "utf8"));
+      existing = JSON.parse(fs45.readFileSync(destination, "utf8"));
     } catch {
       existing = {};
     }
@@ -31107,6 +31360,13 @@ function syncConfigDoc(paths, mcpEntries, _lossReport, permissionMap, mappings)
       ...mcpEntries
     }
   };
+  const instructionsRef = declaredInstructionsPath(paths);
+  if (instructionsRef !== null) {
+    config.instructions = withDeclaredInstructions(
+      existing.instructions,
+      instructionsRef
+    );
+  }
   if (Object.keys(permissionMap).length > 0) {
     config.permission = permissionMap;
   }
@@ -31119,8 +31379,8 @@ function syncConfigDoc(paths, mcpEntries, _lossReport, permissionMap, mappings)
       };
     }
   }
-  ensureDir(path44.dirname(destination));
-  fs44.writeFileSync(destination, `${JSON.stringify(config, null, 2)}
+  ensureDir(path45.dirname(destination));
+  fs45.writeFileSync(destination, `${JSON.stringify(config, null, 2)}
 `);
 }
 function writeCompiledArtifact5(component, destination, content, expectedHash, config, sourceRoot, options, logger, manifest, scopePath) {
@@ -31134,14 +31394,14 @@ function writeCompiledArtifact5(component, destination, content, expectedHash, c
   if (artifactClass === "unmanaged-conflict" && !handleConflict6(destination, config, options, logger, manifest, scopePath)) {
     return { component, status: "conflict", path: destination };
   }
-  ensureDir(path44.dirname(destination));
+  ensureDir(path45.dirname(destination));
   const clearedLink = clearSymlinkAtDestination(destination);
   if (clearedLink !== null) {
     logger.verbose(
       `  ${destination}: replaced a symlink to ${clearedLink} with generated content`
     );
   }
-  fs44.writeFileSync(destination, content);
+  fs45.writeFileSync(destination, content);
   return { component, status: "success", path: destination };
 }
 function handleConflict6(destination, config, options, logger, manifest, scopePath) {
@@ -31159,7 +31419,7 @@ function handleConflict6(destination, config, options, logger, manifest, scopePa
     if (manifest && scopePath) {
       backupFile(destination, manifest, scopePath);
       writeManifest(scopePath, manifest);
-      fs44.rmSync(destination, { recursive: true, force: true });
+      fs45.rmSync(destination, { recursive: true, force: true });
     } else {
       const parked = parkConflictingPath(
         destination,
@@ -31174,12 +31434,12 @@ function handleConflict6(destination, config, options, logger, manifest, scopePa
     }
     return true;
   }
-  fs44.rmSync(destination, { recursive: true, force: true });
+  fs45.rmSync(destination, { recursive: true, force: true });
   return true;
 }
 function isCompiledCurrent5(destination, expectedContent, _expectedHash) {
   try {
-    return fs44.readFileSync(destination, "utf8") === expectedContent;
+    return fs45.readFileSync(destination, "utf8") === expectedContent;
   } catch {
     return false;
   }
@@ -31198,7 +31458,7 @@ function hashString5(value) {
   return `sha256:${crypto10.createHash("sha256").update(value).digest("hex")}`;
 }
 function parseCommandFile(commandFile) {
-  const content = fs44.readFileSync(commandFile, "utf8");
+  const content = fs45.readFileSync(commandFile, "utf8");
   if (!content.startsWith("---\n")) {
     return { data: {}, body: content };
   }
@@ -31218,7 +31478,7 @@ function parseCommandFile(commandFile) {
 // src/commands/install.ts
 function isBackupablePath(targetPath) {
   try {
-    const lstat = fs45.lstatSync(targetPath);
+    const lstat = fs46.lstatSync(targetPath);
     return lstat.isSymbolicLink() || lstat.isFile() || lstat.isDirectory();
   } catch {
     return false;
@@ -31255,7 +31515,7 @@ async function runInstallCommand(options, logger) {
     );
   }
   const kitName = resolvedKitName ?? config.kit;
-  const kitPath = kitPathOverride ?? (options.kitPath ? path45.resolve(options.kitPath) : config.kitPath);
+  const kitPath = kitPathOverride ?? (options.kitPath ? path46.resolve(options.kitPath) : config.kitPath);
   if (!kitName && !kitPath) {
     logger.error(
       "No kit specified. Use --kit <name>, --kit-path <path>, or set 'kit'/'kitPath' in tangyr.config.yaml."
@@ -31360,8 +31620,8 @@ async function runInstallCommand(options, logger) {
     config: options.config,
     scope
   });
-  const skillsSource = path45.resolve(kitInfo.path, config.source.skills);
-  const isPerSkillSkillsSlot = (f) => (f.tool === "claude-code" || f.tool === "copilot") && path45.basename(f.path) === "skills";
+  const skillsSource = path46.resolve(kitInfo.path, config.source.skills);
+  const isPerSkillSkillsSlot = (f) => (f.tool === "claude-code" || f.tool === "copilot") && path46.basename(f.path) === "skills";
   const foreignSkillsSlots = new Set(
     assessResult.findings.filter(
       (f) => isPerSkillSkillsSlot(f) && isForeignSkillsSlotSymlink(
@@ -31399,7 +31659,7 @@ async function runInstallCommand(options, logger) {
     let instructionsLabel;
     try {
       const resolved = resolveInstructionsSource(kitInfo.path, config);
-      instructionsLabel = resolved ? path45.relative(kitInfo.path, resolved.file) : "(none \u2014 no instructions file resolves in this kit)";
+      instructionsLabel = resolved ? path46.relative(kitInfo.path, resolved.file) : "(none \u2014 no instructions file resolves in this kit)";
     } catch (err) {
       logger.error(
         `[dry-run] ${err instanceof Error ? err.message : String(err)}`
@@ -31427,7 +31687,7 @@ async function runInstallCommand(options, logger) {
       }
     }
     logger.info(
-      `[dry-run] Total: ${plannedTotal} destination(s); manifest at ${path45.join(scopePath, "manifest.json")}`
+      `[dry-run] Total: ${plannedTotal} destination(s); manifest at ${path46.join(scopePath, "manifest.json")}`
     );
     return;
   }
@@ -31486,7 +31746,7 @@ ACCEPTED CONFLICTS (posture: ${posture}; ${replaceable.length} target(s)):`
           logger.info(`  - ${finding.path}`);
           logger.info(`    source: ${sources}`);
           logger.info(
-            `    action: backup-and-replace${fs45.lstatSync(finding.path).isDirectory() ? " (directory)" : ""}`
+            `    action: backup-and-replace${fs46.lstatSync(finding.path).isDirectory() ? " (directory)" : ""}`
           );
           logger.info(`    backup: ${backupLocation}`);
           continue;
@@ -31594,11 +31854,29 @@ SKIPPED CONFLICTS (${skippedTargetPaths.size} target(s) left unchanged):`
       installLossReport
     );
   }
+  const instructionsByTarget = instructionsByActiveTarget(
+    tools,
+    scope,
+    projectRoot,
+    mappings
+  );
+  const rulesCoverage = measureRulesCoverage(
+    tools,
+    kitInfo.components.rules?.declared ?? [],
+    scope,
+    projectRoot,
+    mappings,
+    installLossReport,
+    instructionsByTarget
+  );
   reportContestedInstructions(
-    instructionsByActiveTarget(tools, scope, projectRoot, mappings),
+    instructionsByTarget,
     (kitInfo.components.rules?.declared.length ?? 0) > 0,
-    logger
+    logger,
+    missingRulesByTarget(rulesCoverage)
   );
+  reportRulesCoverage(rulesCoverage, logger);
+  recordRulesCoverageLoss(rulesCoverage, installLossReport);
   for (const [relativePath, sourcePath] of collectAllFiles(kitInfo, config)) {
     addFileToManifest(manifest, {
       relativePath,
@@ -31610,20 +31888,20 @@ SKIPPED CONFLICTS (${skippedTargetPaths.size} target(s) left unchanged):`
   writeManifest(scopePath, manifest);
   logger.info(`
 Installation complete: ${installedCount} files installed.`);
-  logger.info(`Manifest written to ${path45.join(scopePath, "manifest.json")}`);
+  logger.info(`Manifest written to ${path46.join(scopePath, "manifest.json")}`);
   logger.info(`Kit: ${kitInfo.name} (archetype: ${kitInfo.archetype})`);
   logger.info(`Scope: ${scope}`);
   logger.info(`Tools: ${tools.join(", ")}`);
   reportHookRejections(
     installLossReport,
     tools,
-    path45.resolve(kitInfo.path, "hooks"),
+    path46.resolve(kitInfo.path, "hooks"),
     kitInfo.components.hooks.declared
   );
   const hooksConflict = reportHooksSourceConflict(
     installLossReport,
     tools,
-    path45.resolve(kitInfo.path, "hooks"),
+    path46.resolve(kitInfo.path, "hooks"),
     kitInfo.components.hooks.declared
   );
   if (hooksConflict) {
@@ -31929,7 +32207,8 @@ function installClaudeCodeAdapterSlots(args) {
         profile,
         outcome,
         scope,
-        projectRoot
+        projectRoot,
+        mappings
       );
       if (!key) {
         continue;
@@ -31954,8 +32233,13 @@ function installClaudeCodeAdapterSlots(args) {
   }
   return count;
 }
-function claudeCodeOutcomeToManifestKey(profile, outcome, scope, projectRoot) {
-  const shared = sharedArtifactKey(outcome.path, scope, projectRoot);
+function claudeCodeOutcomeToManifestKey(profile, outcome, scope, projectRoot, mappings) {
+  const shared = sharedKeyForDestination(
+    outcome.path,
+    scope,
+    projectRoot,
+    mappings.platformPaths
+  );
   if (shared) {
     return shared;
   }
@@ -31982,7 +32266,7 @@ function installClaudeCodeSkills(config, kitInfo, manifest, options, logger, sco
     return 0;
   }
   try {
-    const stat = fs45.lstatSync(destination);
+    const stat = fs46.lstatSync(destination);
     if (stat.isFile() && !stat.isSymbolicLink()) {
       logger.warn(
         `${destination}: a regular file occupies the skills slot \u2014 skipping skills. Move or remove it, then re-run install.`
@@ -32010,17 +32294,17 @@ function installClaudeCodeSkills(config, kitInfo, manifest, options, logger, sco
     manifest,
     scopePath
   );
-  const skillsSource = path45.resolve(kitInfo.path, config.source.skills);
+  const skillsSource = path46.resolve(kitInfo.path, config.source.skills);
   let count = 0;
   for (const outcome of outcomes) {
     if (outcome.status !== "success" && outcome.status !== "skipped-current") {
       continue;
     }
-    const skillName = path45.basename(outcome.path);
+    const skillName = path46.basename(outcome.path);
     addArtifactToManifest(manifest, {
       relativePath: `claude-code/skills/${skillName}`,
       path: outcome.path,
-      hash: describeArtifactState(outcome.path) ?? `dir:${path45.join(skillsSource, skillName)}`,
+      hash: describeArtifactState(outcome.path) ?? `dir:${path46.join(skillsSource, skillName)}`,
       origin: "tangyr-managed"
     });
     count++;
@@ -32034,10 +32318,10 @@ function applyClaudeCodePlacements(placements, manifest, skippedTargetPaths, log
       logger.verbose(`  skipped (operator choice): ${placement.destination}`);
       continue;
     }
-    const destDir = path45.dirname(placement.destination);
-    fs45.mkdirSync(destDir, { recursive: true });
+    const destDir = path46.dirname(placement.destination);
+    fs46.mkdirSync(destDir, { recursive: true });
     if (placement.type === "symlink") {
-      if (fs45.existsSync(placement.destination) || isSymlink2(placement.destination)) {
+      if (fs46.existsSync(placement.destination) || isSymlink2(placement.destination)) {
         removeManagedPath(placement.destination);
       }
       createRelativeSymlink(
@@ -32054,7 +32338,7 @@ function applyClaudeCodePlacements(placements, manifest, skippedTargetPaths, log
         `  symlink: ${placement.source} \u2192 ${placement.destination}`
       );
     } else {
-      fs45.copyFileSync(placement.source, placement.destination);
+      fs46.copyFileSync(placement.source, placement.destination);
       logger.verbose(`  copy: ${placement.source} \u2192 ${placement.destination}`);
     }
     addArtifactToManifest(manifest, {
@@ -32304,7 +32588,12 @@ function countInstalledArtifacts(outcomes) {
   ).length;
 }
 function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", projectRoot) {
-  const shared = sharedArtifactKey(outcome.path, scope, projectRoot);
+  const shared = sharedKeyForDestination(
+    outcome.path,
+    scope,
+    projectRoot,
+    mappings.platformPaths
+  );
   if (shared) {
     return shared;
   }
@@ -32346,11 +32635,11 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
     if (outcome.path === mcpFile2) {
       return "cline/mcp.json";
     }
-    if (outcome.path.startsWith(`${workflowsRoot}${path45.sep}`)) {
-      return `cline/workflows/${path45.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${workflowsRoot}${path46.sep}`)) {
+      return `cline/workflows/${path46.basename(outcome.path)}`;
     }
-    if (outcome.path.startsWith(`${rulesRoot2}${path45.sep}`)) {
-      return `cline/rules/${path45.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${rulesRoot2}${path46.sep}`)) {
+      return `cline/rules/${path46.basename(outcome.path)}`;
     }
     return null;
   }
@@ -32386,14 +32675,14 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
     if (outcome.path === permissionsFile) {
       return "cursor/permissions.json";
     }
-    if (outcome.path.startsWith(`${agentsRoot2}${path45.sep}`)) {
-      return `cursor/agents/${path45.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${agentsRoot2}${path46.sep}`)) {
+      return `cursor/agents/${path46.basename(outcome.path)}`;
     }
-    if (outcome.path.startsWith(`${rulesRoot2}${path45.sep}`)) {
-      return `cursor/rules/${path45.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${rulesRoot2}${path46.sep}`)) {
+      return `cursor/rules/${path46.basename(outcome.path)}`;
     }
-    if (outcome.path.startsWith(`${skillsRoot2}${path45.sep}`)) {
-      const rel = path45.relative(skillsRoot2, outcome.path);
+    if (outcome.path.startsWith(`${skillsRoot2}${path46.sep}`)) {
+      const rel = path46.relative(skillsRoot2, outcome.path);
       return `cursor/skills/${rel}`;
     }
     return null;
@@ -32419,14 +32708,14 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
     if (outcome.path === skillsSharedRoot) {
       return "opencode/skills_shared";
     }
-    if (outcome.path.startsWith(`${agentsRoot2}${path45.sep}`)) {
-      return `opencode/agents/${path45.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${agentsRoot2}${path46.sep}`)) {
+      return `opencode/agents/${path46.basename(outcome.path)}`;
     }
-    if (outcome.path.startsWith(`${commandsRoot}${path45.sep}`)) {
-      return `opencode/commands/${path45.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${commandsRoot}${path46.sep}`)) {
+      return `opencode/commands/${path46.basename(outcome.path)}`;
     }
     if (outcome.path === configDocFile) {
-      return `opencode/${path45.basename(outcome.path)}`;
+      return `opencode/${path46.basename(outcome.path)}`;
     }
     return null;
   }
@@ -32443,29 +32732,29 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
     const hooksRoot = resolveTargetPath(copilot.hooks);
     const mcpFile2 = resolveTargetPath(copilot.mcp_shared_file);
     const instructionsMirror = copilot.instructions !== null ? resolveTargetPath(copilot.instructions) : null;
-    if (copilot.rules !== null && outcome.path.startsWith(`${resolveTargetPath(copilot.rules)}${path45.sep}`)) {
-      return `copilot/rules/${path45.relative(resolveTargetPath(copilot.rules), outcome.path)}`;
+    if (copilot.rules !== null && outcome.path.startsWith(`${resolveTargetPath(copilot.rules)}${path46.sep}`)) {
+      return `copilot/rules/${path46.relative(resolveTargetPath(copilot.rules), outcome.path)}`;
     }
-    if (outcome.path.startsWith(`${skillsRoot2}${path45.sep}`)) {
-      return `copilot/skills/${path45.relative(skillsRoot2, outcome.path)}`;
+    if (outcome.path.startsWith(`${skillsRoot2}${path46.sep}`)) {
+      return `copilot/skills/${path46.relative(skillsRoot2, outcome.path)}`;
     }
     if (outcome.path === skillsRoot2) {
       return "copilot/skills";
     }
     if (instructionsMirror !== null && outcome.path === instructionsMirror) {
-      return `copilot/${path45.basename(outcome.path)}`;
+      return `copilot/${path46.basename(outcome.path)}`;
     }
-    if (outcome.path.startsWith(`${agentsRoot2}${path45.sep}`)) {
-      return `copilot/agents/${path45.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${agentsRoot2}${path46.sep}`)) {
+      return `copilot/agents/${path46.basename(outcome.path)}`;
     }
-    if (outcome.path.startsWith(`${promptsRoot}${path45.sep}`)) {
-      return `copilot/prompts/${path45.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${promptsRoot}${path46.sep}`)) {
+      return `copilot/prompts/${path46.basename(outcome.path)}`;
     }
-    if (outcome.path.startsWith(`${hooksRoot}${path45.sep}`)) {
-      return `copilot/hooks/${path45.basename(outcome.path)}`;
+    if (outcome.path.startsWith(`${hooksRoot}${path46.sep}`)) {
+      return `copilot/hooks/${path46.basename(outcome.path)}`;
     }
     if (outcome.path === mcpFile2) {
-      return `copilot/${path45.basename(outcome.path)}`;
+      return `copilot/${path46.basename(outcome.path)}`;
     }
     return null;
   }
@@ -32482,17 +32771,17 @@ function syncOutcomeToManifestKey(tool, outcome, mappings, scope = "global", pro
   if (outcome.path === skillsRoot) {
     return "codex/skills";
   }
-  if (outcome.path.startsWith(`${agentsRoot}${path45.sep}`)) {
-    return `codex/agents/${path45.basename(outcome.path)}`;
+  if (outcome.path.startsWith(`${agentsRoot}${path46.sep}`)) {
+    return `codex/agents/${path46.basename(outcome.path)}`;
   }
-  if (outcome.path.startsWith(`${rulesRoot}${path45.sep}`)) {
-    return `codex/rules/${path45.basename(outcome.path)}`;
+  if (outcome.path.startsWith(`${rulesRoot}${path46.sep}`)) {
+    return `codex/rules/${path46.basename(outcome.path)}`;
   }
   if (outcome.path === hooksFile) {
-    return `codex/${path45.basename(outcome.path)}`;
+    return `codex/${path46.basename(outcome.path)}`;
   }
   if (outcome.path === mcpFile) {
-    return `codex/${path45.basename(outcome.path)}`;
+    return `codex/${path46.basename(outcome.path)}`;
   }
   return null;
 }
@@ -32561,8 +32850,8 @@ function getClaudeCodePlacements(kitInfo, config, scope = "global", projectRoot,
     rules: resolvedPaths.rules
   };
   for (const [component, targetPath] of Object.entries(componentDirMap)) {
-    const componentDir = path45.join(kitInfo.path, component);
-    if (fs45.existsSync(componentDir) && fs45.statSync(componentDir).isDirectory()) {
+    const componentDir = path46.join(kitInfo.path, component);
+    if (fs46.existsSync(componentDir) && fs46.statSync(componentDir).isDirectory()) {
       placements.push({
         source: componentDir,
         destination: targetPath,
@@ -32592,8 +32881,8 @@ function getClaudeCodePlacementsFromProfile(kitInfo, profile, config) {
     rules: profile.rules
   };
   for (const [component, targetPath] of Object.entries(componentDirMap)) {
-    const componentDir = path45.join(kitInfo.path, component);
-    if (fs45.existsSync(componentDir) && fs45.statSync(componentDir).isDirectory()) {
+    const componentDir = path46.join(kitInfo.path, component);
+    if (fs46.existsSync(componentDir) && fs46.statSync(componentDir).isDirectory()) {
       placements.push({
         source: componentDir,
         destination: targetPath,
@@ -32609,7 +32898,7 @@ function collectAllFiles(kitInfo, config) {
   const files = /* @__PURE__ */ new Map();
   const entrypoint = resolveInstructionsSource(kitInfo.path, config);
   if (entrypoint) {
-    files.set(path45.basename(entrypoint.file), entrypoint.file);
+    files.set(path46.basename(entrypoint.file), entrypoint.file);
   }
   for (const [component, reconciliation] of Object.entries(
     kitInfo.components
@@ -32618,22 +32907,22 @@ function collectAllFiles(kitInfo, config) {
     const missingSet = new Set(reconciliation.missing);
     for (const entry of reconciliation.declared) {
       if (missingSet.has(entry)) continue;
-      const relPath = isSkills ? path45.join(component, entry) : path45.join(component, `${entry}.md`);
-      files.set(relPath, path45.join(kitInfo.path, relPath));
+      const relPath = isSkills ? path46.join(component, entry) : path46.join(component, `${entry}.md`);
+      files.set(relPath, path46.join(kitInfo.path, relPath));
     }
   }
   return files;
 }
 function readLinkTarget(p) {
   try {
-    return fs45.readlinkSync(p);
+    return fs46.readlinkSync(p);
   } catch {
     return null;
   }
 }
 function isSymlink2(p) {
   try {
-    return fs45.lstatSync(p).isSymbolicLink();
+    return fs46.lstatSync(p).isSymbolicLink();
   } catch {
     return false;
   }
@@ -32652,10 +32941,10 @@ function skillsSubPathKey(tool, outcomePath, mappings, scope, projectRoot) {
       continue;
     }
     const root = resolveTargetPath(slot);
-    if (!outcomePath.startsWith(`${root}${path45.sep}`)) {
+    if (!outcomePath.startsWith(`${root}${path46.sep}`)) {
       continue;
     }
-    const inside = path45.relative(root, outcomePath).split(path45.sep).join("/");
+    const inside = path46.relative(root, outcomePath).split(path46.sep).join("/");
     return `${tool}/skills/${inside}`;
   }
   return null;
@@ -32700,14 +32989,14 @@ async function runKitUpdateCommand(options, logger) {
 }
 
 // src/commands/list.ts
-import path46 from "path";
+import path47 from "path";
 function runListCommand(options, logger) {
   let searchPaths = [];
-  let directKitPath = options.kitPath ? path46.resolve(options.kitPath) : void 0;
+  let directKitPath = options.kitPath ? path47.resolve(options.kitPath) : void 0;
   try {
     const { config, configDir } = resolveConfig(options.config);
     searchPaths = config.kitSearchPaths ?? [
-      path46.join(configDir, "operating-kits")
+      path47.join(configDir, "operating-kits")
     ];
     directKitPath = directKitPath ?? config.kitPath;
   } catch (err) {
@@ -32782,7 +33071,7 @@ function withDirectKit(kits, directKitPath) {
     return kits;
   }
   const directKit = loadKit(directKitPath);
-  if (kits.some((kit) => path46.resolve(kit.path) === directKit.path)) {
+  if (kits.some((kit) => path47.resolve(kit.path) === directKit.path)) {
     return kits;
   }
   return [...kits, directKit];
@@ -32790,8 +33079,8 @@ function withDirectKit(kits, directKitPath) {
 
 // src/commands/probe.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import fs46 from "fs";
-import path47 from "path";
+import fs47 from "fs";
+import path48 from "path";
 function runProbeCommand(options, logger) {
   const { config, configDir, configSource, sourceRoot } = resolveRuntime(
     options,
@@ -32819,7 +33108,7 @@ function runProbeCommand(options, logger) {
         toProbeRow(
           target,
           key,
-          scope === "project" ? path47.resolve(projectRoot ?? process.cwd(), rawPath) : rawPath
+          scope === "project" ? path48.resolve(projectRoot ?? process.cwd(), rawPath) : rawPath
         )
       );
     }
@@ -32841,7 +33130,7 @@ function toProbeRow(target, key, rawPath) {
   const resolved = resolveTargetPath(rawPath);
   let accessible = false;
   try {
-    fs46.accessSync(resolved);
+    fs47.accessSync(resolved);
     accessible = true;
   } catch {
     accessible = false;
@@ -32850,7 +33139,7 @@ function toProbeRow(target, key, rawPath) {
     target,
     key,
     path: resolved,
-    exists: fs46.existsSync(resolved),
+    exists: fs47.existsSync(resolved),
     accessible
   };
 }
@@ -32868,7 +33157,7 @@ function codexRuntimeProbeRows() {
     ["binary_snap", "/snap/bin/codex"],
     ["binary_flatpak", "/var/lib/flatpak/exports/bin/codex"]
   ]) {
-    if (fs46.existsSync(candidatePath)) {
+    if (fs47.existsSync(candidatePath)) {
       rows.push(toProbeRow("codex", key, candidatePath));
     }
   }
@@ -32884,8 +33173,8 @@ function commandProbeRows(target, key, command, args) {
 
 // src/commands/status.ts
 import crypto11 from "crypto";
-import fs47 from "fs";
-import path48 from "path";
+import fs48 from "fs";
+import path49 from "path";
 function runStatusCommand(options, logger) {
   const { config, configDir, configSource, sourceRoot } = resolveRuntime(
     options,
@@ -32991,11 +33280,11 @@ function classifyTargetRows(target, config, sourceRoot, configDir, scope, projec
   }
 }
 function sourceMarkdownFiles(sourceRoot, componentPath) {
-  const root = path48.join(sourceRoot, componentPath);
-  if (!fs47.existsSync(root)) {
+  const root = path49.join(sourceRoot, componentPath);
+  if (!fs48.existsSync(root)) {
     return [];
   }
-  return ts(path48.join(root, "*.md")).sort();
+  return ts(path49.join(root, "*.md")).sort();
 }
 function notRepresentableRow(component, detail) {
   return {
@@ -33006,11 +33295,11 @@ function notRepresentableRow(component, detail) {
   };
 }
 function readTargetJson(filePath) {
-  if (!fs47.existsSync(filePath)) {
+  if (!fs48.existsSync(filePath)) {
     return { kind: "missing" };
   }
   try {
-    const parsed = JSON.parse(fs47.readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(fs48.readFileSync(filePath, "utf8"));
     return { kind: "object", value: isRecord(parsed) ? parsed : {} };
   } catch (err) {
     return {
@@ -33099,7 +33388,7 @@ function classifyInstructions(filePath, target, expectedHash, config, sourceRoot
 }
 function compiledMcpDocument(config, sourceRoot, target) {
   const source = resolveMcpSourceFile(sourceRoot, config);
-  if (!fs47.existsSync(source)) {
+  if (!fs48.existsSync(source)) {
     return {};
   }
   const compiled = compileMcp(
@@ -33112,7 +33401,7 @@ function compiledMcpDocument(config, sourceRoot, target) {
   return isRecord(parsed) ? parsed : {};
 }
 function classifyMcpDocument(config, sourceRoot, target, filePath) {
-  if (!fs47.existsSync(resolveMcpSourceFile(sourceRoot, config))) {
+  if (!fs48.existsSync(resolveMcpSourceFile(sourceRoot, config))) {
     return notConfiguredRow("mcp", filePath);
   }
   return classifyJsonDocument(
@@ -33142,12 +33431,12 @@ function classifyOpenCodeFiles(config, sourceRoot, configDir, scope, projectRoot
   const rows = [];
   const instructionsSource = instructionsSourcePath(sourceRoot, config);
   const rules = compileRules(
-    path48.join(sourceRoot, config.source.rules),
+    path49.join(sourceRoot, config.source.rules),
     "opencode",
     mappings,
     createLossReport()
   );
-  const baseInstructions = fs47.existsSync(instructionsSource) ? fs47.readFileSync(instructionsSource, "utf8").trim() : "";
+  const baseInstructions = fs48.existsSync(instructionsSource) ? fs48.readFileSync(instructionsSource, "utf8").trim() : "";
   const composedInstructions = rules.agentsAppendix ? `${baseInstructions}
 
 --- tangyr managed rules ---
@@ -33169,10 +33458,10 @@ ${rules.agentsAppendix}`.trim() : baseInstructions;
   )) {
     rows.push(
       classifyCompiledFile(
-        `agents/${path48.basename(agentFile, ".md")}`,
-        path48.join(
+        `agents/${path49.basename(agentFile, ".md")}`,
+        path49.join(
           resolveTargetPath(paths.agents),
-          `${path48.basename(agentFile, ".md")}.md`
+          `${path49.basename(agentFile, ".md")}.md`
         ),
         "opencode",
         computeSourceHash(agentFile),
@@ -33187,10 +33476,10 @@ ${rules.agentsAppendix}`.trim() : baseInstructions;
   )) {
     rows.push(
       classifyCompiledFile(
-        `commands/${path48.basename(commandFile, ".md")}`,
-        path48.join(
+        `commands/${path49.basename(commandFile, ".md")}`,
+        path49.join(
           resolveTargetPath(paths.commands),
-          `${path48.basename(commandFile, ".md")}.md`
+          `${path49.basename(commandFile, ".md")}.md`
         ),
         "opencode",
         computeSourceHash(commandFile),
@@ -33272,10 +33561,10 @@ function classifyCursorFiles(config, sourceRoot, configDir, scope, projectRoot)
   )) {
     rows.push(
       classifyCompiledFile(
-        `agents/${path48.basename(agentFile, ".md")}`,
-        path48.join(
+        `agents/${path49.basename(agentFile, ".md")}`,
+        path49.join(
           resolveTargetPath(paths.agents),
-          `${path48.basename(agentFile, ".md")}.md`
+          `${path49.basename(agentFile, ".md")}.md`
         ),
         "cursor",
         computeSourceHash(agentFile),
@@ -33292,7 +33581,7 @@ function classifyCursorFiles(config, sourceRoot, configDir, scope, projectRoot)
       rows.push(
         classifyCompiledFile(
           `rules/${ruleFile.name}`,
-          path48.join(resolveTargetPath(paths.rules), ruleFile.name),
+          path49.join(resolveTargetPath(paths.rules), ruleFile.name),
           "cursor",
           void 0,
           config,
@@ -33306,11 +33595,11 @@ function classifyCursorFiles(config, sourceRoot, configDir, scope, projectRoot)
     sourceRoot,
     config.source.commands
   )) {
-    const baseName = path48.basename(commandFile, ".md");
+    const baseName = path49.basename(commandFile, ".md");
     rows.push(
       classifyCompiledFile(
         `commands/${baseName}`,
-        path48.join(resolveTargetPath(paths.skills), baseName, "SKILL.md"),
+        path49.join(resolveTargetPath(paths.skills), baseName, "SKILL.md"),
         "cursor",
         computeSourceHash(commandFile),
         config,
@@ -33393,7 +33682,7 @@ function classifyClineFiles(config, sourceRoot, configDir, scope, projectRoot) {
       rows.push(
         classifyCompiledFile(
           `rules/${ruleFile.name}`,
-          path48.join(resolveTargetPath(paths.rules), ruleFile.name),
+          path49.join(resolveTargetPath(paths.rules), ruleFile.name),
           "cline",
           void 0,
           config,
@@ -33409,10 +33698,10 @@ function classifyClineFiles(config, sourceRoot, configDir, scope, projectRoot) {
   )) {
     rows.push(
       classifyCompiledFile(
-        `commands/${path48.basename(commandFile, ".md")}`,
-        path48.join(
+        `commands/${path49.basename(commandFile, ".md")}`,
+        path49.join(
           resolveTargetPath(paths.workflows),
-          path48.basename(commandFile)
+          path49.basename(commandFile)
         ),
         "cline",
         computeSourceHash(commandFile),
@@ -33453,14 +33742,14 @@ function classifyClineFiles(config, sourceRoot, configDir, scope, projectRoot) {
   return rows;
 }
 function compileRulesFiles(config, sourceRoot, target, mappings) {
-  const rulesSource = path48.join(sourceRoot, config.source.rules);
-  if (!fs47.existsSync(rulesSource)) {
+  const rulesSource = path49.join(sourceRoot, config.source.rules);
+  if (!fs48.existsSync(rulesSource)) {
     return [];
   }
   return compileRules(rulesSource, target, mappings, createLossReport()).dotRulesFiles;
 }
 function classifyDirectoryPresence(component, dirPath) {
-  const present = fs47.existsSync(dirPath) && fs47.statSync(dirPath).isDirectory();
+  const present = fs48.existsSync(dirPath) && fs48.statSync(dirPath).isDirectory();
   return {
     component,
     className: present ? "current" : "missing",
@@ -33479,7 +33768,7 @@ function slotsForScope2(scopeMap, scope, projectRoot) {
   const root = projectRoot ?? process.cwd();
   const resolved = {};
   for (const [slot, value] of Object.entries(projectSlots)) {
-    resolved[slot] = typeof value === "string" ? path48.resolve(root, value) : value;
+    resolved[slot] = typeof value === "string" ? path49.resolve(root, value) : value;
   }
   return resolved;
 }
@@ -33499,21 +33788,21 @@ function classifyCodexFiles(config, sourceRoot, configDir, scope, projectRoot) {
     rules: paths.rules
   };
   const rules = compileRules(
-    path48.join(sourceRoot, config.source.rules),
+    path49.join(sourceRoot, config.source.rules),
     "codex",
     mappings,
     createLossReport()
   );
-  const instructionsSource = fs47.readFileSync(instructionsSourcePath(sourceRoot, config), "utf8").trim();
+  const instructionsSource = fs48.readFileSync(instructionsSourcePath(sourceRoot, config), "utf8").trim();
   const composedInstructions = `${instructionsSource}
 
 --- tangyr managed rules ---
 ${rules.agentsAppendix}`.trim();
   const agentFiles = ts(
-    path48.join(sourceRoot, config.source.agents, "*.md")
+    path49.join(sourceRoot, config.source.agents, "*.md")
   ).sort();
   const hooksPresent = hooksSourceExists(sourceRoot, config);
-  const mcpSource = path48.join(sourceRoot, config.source.mcp);
+  const mcpSource = path49.join(sourceRoot, config.source.mcp);
   const ruleRows = rules.dotRulesFiles.length === 0 ? [
     {
       component: "rules",
@@ -33524,7 +33813,7 @@ ${rules.agentsAppendix}`.trim();
   ] : rules.dotRulesFiles.map(
     (ruleFile) => classifyCompiledFile(
       `rules/${ruleFile.name}`,
-      path48.join(resolveTargetPath(codexPaths.rules), ruleFile.name),
+      path49.join(resolveTargetPath(codexPaths.rules), ruleFile.name),
       "codex",
       void 0,
       config,
@@ -33542,10 +33831,10 @@ ${rules.agentsAppendix}`.trim();
     ),
     ...agentFiles.map(
       (agentFile) => classifyCompiledFile(
-        `agents/${path48.basename(agentFile, ".md")}`,
-        path48.join(
+        `agents/${path49.basename(agentFile, ".md")}`,
+        path49.join(
           resolveTargetPath(codexPaths.agents),
-          `${path48.basename(agentFile, ".md")}.toml`
+          `${path49.basename(agentFile, ".md")}.toml`
         ),
         "codex",
         computeSourceHash(agentFile),
@@ -33573,7 +33862,7 @@ ${rules.agentsAppendix}`.trim();
       "hooks",
       resolveTargetPath(codexPaths.hooksSharedFile)
     ),
-    fs47.existsSync(mcpSource) ? classifyCompiledFile(
+    fs48.existsSync(mcpSource) ? classifyCompiledFile(
       "mcp",
       resolveTargetPath(codexPaths.mcpSharedFile),
       "codex",
@@ -33639,20 +33928,20 @@ function classifyCopilotFiles(config, sourceRoot, configDir, scope, projectRoot)
     mcpSharedFile: paths.mcp_shared_file
   };
   const agentFiles = ts(
-    path48.join(sourceRoot, config.source.agents, "*.md")
+    path49.join(sourceRoot, config.source.agents, "*.md")
   ).sort();
   const commandFiles = ts(
-    path48.join(sourceRoot, config.source.commands, "*.md")
+    path49.join(sourceRoot, config.source.commands, "*.md")
   ).sort();
   const hooksPresent = hooksSourceExists(sourceRoot, config);
-  const mcpSource = path48.join(sourceRoot, config.source.mcp);
+  const mcpSource = path49.join(sourceRoot, config.source.mcp);
   return [
     ...agentFiles.map(
       (agentFile) => classifyCompiledFile(
-        `agents/${path48.basename(agentFile, ".md")}`,
-        path48.join(
+        `agents/${path49.basename(agentFile, ".md")}`,
+        path49.join(
           resolveTargetPath(copilotPaths.agents),
-          `${path48.basename(agentFile, ".md")}.agent.md`
+          `${path49.basename(agentFile, ".md")}.agent.md`
         ),
         "copilot",
         computeSourceHash(agentFile),
@@ -33669,10 +33958,10 @@ function classifyCopilotFiles(config, sourceRoot, configDir, scope, projectRoot)
     ),
     ...commandFiles.map(
       (commandFile) => classifyCompiledFile(
-        `commands/${path48.basename(commandFile, ".md")}`,
-        path48.join(
+        `commands/${path49.basename(commandFile, ".md")}`,
+        path49.join(
           resolveTargetPath(copilotPaths.prompts),
-          `${path48.basename(commandFile, ".md")}.prompt.md`
+          `${path49.basename(commandFile, ".md")}.prompt.md`
         ),
         "copilot",
         computeSourceHash(commandFile),
@@ -33691,19 +33980,19 @@ function classifyCopilotFiles(config, sourceRoot, configDir, scope, projectRoot)
       sourceRoot
     ),
     hooksPresent ? classifyCompiledHooksByProvenance(
-      path48.join(
+      path49.join(
         resolveTargetPath(copilotPaths.hooks),
         "tangyr-managed.json"
       ),
       "copilot"
     ) : notConfiguredRow(
       "hooks",
-      path48.join(
+      path49.join(
         resolveTargetPath(copilotPaths.hooks),
         "tangyr-managed.json"
       )
     ),
-    fs47.existsSync(mcpSource) ? classifyCompiledFile(
+    fs48.existsSync(mcpSource) ? classifyCompiledFile(
       "mcp",
       resolveTargetPath(copilotPaths.mcpSharedFile),
       "copilot",
@@ -33723,7 +34012,7 @@ function notConfiguredRow(component, filePath) {
 }
 function classifyDirectArtifact(artifact, config, sourceRoot) {
   const artifactClass = classifyArtifact(artifact.path, config, sourceRoot);
-  const sourcePath = artifact.sourceKey === "instructions" ? instructionsSourcePath(sourceRoot, config) : artifact.sourceKey ? path48.resolve(sourceRoot, config.source[artifact.sourceKey]) : void 0;
+  const sourcePath = artifact.sourceKey === "instructions" ? instructionsSourcePath(sourceRoot, config) : artifact.sourceKey ? path49.resolve(sourceRoot, config.source[artifact.sourceKey]) : void 0;
   if (artifact.sourceKey === "skills" && artifactClass === "unmanaged-conflict") {
     const perSkill = classifyPerSkillSlot(artifact.path, sourceRoot);
     if (perSkill) {
@@ -33819,11 +34108,11 @@ function classifyClaudeCodeRows(sourceRoot, config, configDir, scope, projectRoo
 function classifyPerSkillSlot(slotPath, sourceRoot) {
   let entries;
   try {
-    const stat = fs47.lstatSync(slotPath);
+    const stat = fs48.lstatSync(slotPath);
     if (!stat.isDirectory() || stat.isSymbolicLink()) {
       return null;
     }
-    entries = fs47.readdirSync(slotPath, { withFileTypes: true });
+    entries = fs48.readdirSync(slotPath, { withFileTypes: true });
   } catch {
     return null;
   }
@@ -33835,7 +34124,7 @@ function classifyPerSkillSlot(slotPath, sourceRoot) {
     return null;
   }
   const ours = links.filter(
-    (entry) => isOurSymlink(path48.join(slotPath, entry.name), sourceRoot)
+    (entry) => isOurSymlink(path49.join(slotPath, entry.name), sourceRoot)
   );
   if (ours.length === 0) {
     return null;
@@ -33847,9 +34136,9 @@ function classifyClaudeSharedFiles(config, sourceRoot, settingsPath, claudeJsonP
     classifyHooks(settingsPath),
     classifySettings(
       settingsPath,
-      path48.resolve(sourceRoot, config.source.settings)
+      path49.resolve(sourceRoot, config.source.settings)
     ),
-    classifyMcp(claudeJsonPath, path48.resolve(sourceRoot, config.source.mcp))
+    classifyMcp(claudeJsonPath, path49.resolve(sourceRoot, config.source.mcp))
   ];
 }
 function claudeSharedFileRows(config, sourceRoot, configDir, scope, projectRoot) {
@@ -33946,14 +34235,14 @@ function classifyMcp(filePath, sourcePath) {
 }
 function isSymlinkCurrent(linkPath, sourcePath) {
   try {
-    return fs47.realpathSync(linkPath) === fs47.realpathSync(sourcePath);
+    return fs48.realpathSync(linkPath) === fs48.realpathSync(sourcePath);
   } catch {
     return false;
   }
 }
 function isCompiledCurrent6(filePath, sourcePath) {
   try {
-    const marker = extractProvenanceMarker(fs47.readFileSync(filePath, "utf8"));
+    const marker = extractProvenanceMarker(fs48.readFileSync(filePath, "utf8"));
     return marker?.hash === computeSourceHash(sourcePath) && marker.target === "claude-code";
   } catch {
     return false;
@@ -33983,7 +34272,7 @@ function classifyCompiledFile(component, filePath, target, expectedHash, config,
 }
 function readCompiledContent(filePath) {
   try {
-    return fs47.readFileSync(filePath, "utf8");
+    return fs48.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -34014,8 +34303,8 @@ function hashString6(value) {
 }
 
 // src/commands/sync.ts
-import fs48 from "fs";
-import path49 from "path";
+import fs49 from "fs";
+import path50 from "path";
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -34685,29 +34974,42 @@ async function runSyncCommand(options, logger) {
     reportHookRejections(
       lossReport,
       targets,
-      path49.resolve(kitInfo.path, "hooks"),
+      path50.resolve(kitInfo.path, "hooks"),
       kitInfo.components.hooks.declared
     );
     const hooksConflict = reportHooksSourceConflict(
       lossReport,
       targets,
-      path49.resolve(kitInfo.path, "hooks"),
+      path50.resolve(kitInfo.path, "hooks"),
       kitInfo.components.hooks.declared
     );
     if (hooksConflict) {
       logger.warn(hooksConflict);
     }
     if (allMappings) {
+      const instructionsByTarget = instructionsByActiveTarget(
+        targets,
+        syncOptions.scope,
+        syncOptions.projectRoot,
+        allMappings
+      );
+      const rulesCoverage = measureRulesCoverage(
+        targets,
+        kitInfo.components.rules.declared,
+        syncOptions.scope,
+        syncOptions.projectRoot,
+        allMappings,
+        lossReport,
+        instructionsByTarget
+      );
       reportContestedInstructions(
-        instructionsByActiveTarget(
-          targets,
-          syncOptions.scope,
-          syncOptions.projectRoot,
-          allMappings
-        ),
+        instructionsByTarget,
         kitInfo.components.rules.declared.length > 0,
-        logger
+        logger,
+        missingRulesByTarget(rulesCoverage)
       );
+      reportRulesCoverage(rulesCoverage, logger);
+      recordRulesCoverageLoss(rulesCoverage, lossReport);
     }
   }
   writeLossReport(options.lossReport, lossReport);
@@ -34894,8 +35196,8 @@ function reconcileSyncedArtifacts(manifest, results, mappings, scope, projectRoo
   }
 }
 function resolveKitFilePath(kitPath, relativePath) {
-  const fullPath = path49.join(kitPath, relativePath);
-  return fs48.existsSync(fullPath) ? fullPath : null;
+  const fullPath = path50.join(kitPath, relativePath);
+  return fs49.existsSync(fullPath) ? fullPath : null;
 }
 function cleanupRemovedManagedArtifacts(config, mappings, targets, options, removedSourcePaths, logger) {
   if (removedSourcePaths.length === 0 || !mappings) {
@@ -34958,9 +35260,9 @@ function cleanupRemovedCopilotArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("agents/")) {
     removeManagedCompiledArtifact2(
-      path49.join(
+      path50.join(
         resolveTargetPath(paths.agents ?? ""),
-        `${path49.parse(relativePath).name}.agent.md`
+        `${path50.parse(relativePath).name}.agent.md`
       ),
       "copilot",
       relativePath,
@@ -34970,9 +35272,9 @@ function cleanupRemovedCopilotArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("commands/")) {
     removeManagedCompiledArtifact2(
-      path49.join(
+      path50.join(
         resolveTargetPath(paths.prompts ?? ""),
-        `${path49.parse(relativePath).name}.prompt.md`
+        `${path50.parse(relativePath).name}.prompt.md`
       ),
       "copilot",
       relativePath,
@@ -34982,7 +35284,7 @@ function cleanupRemovedCopilotArtifact(relativePath, paths, logger) {
   }
   if (relativePath.endsWith("hooks.json")) {
     removeManagedCompiledArtifact2(
-      path49.join(resolveTargetPath(paths.hooks ?? ""), "tangyr-managed.json"),
+      path50.join(resolveTargetPath(paths.hooks ?? ""), "tangyr-managed.json"),
       "copilot",
       relativePath,
       logger
@@ -35012,9 +35314,9 @@ function cleanupRemovedCodexArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("agents/")) {
     removeManagedCompiledArtifact2(
-      path49.join(
+      path50.join(
         resolveTargetPath(paths.agents ?? ""),
-        `${path49.parse(relativePath).name}.toml`
+        `${path50.parse(relativePath).name}.toml`
       ),
       "codex",
       relativePath,
@@ -35024,9 +35326,9 @@ function cleanupRemovedCodexArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("rules/")) {
     removeManagedCompiledArtifact2(
-      path49.join(
+      path50.join(
         resolveTargetPath(paths.rules ?? ""),
-        `${path49.parse(relativePath).name}.rules`
+        `${path50.parse(relativePath).name}.rules`
       ),
       "codex",
       relativePath,
@@ -35065,9 +35367,9 @@ function cleanupRemovedOpenCodeArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("agents/")) {
     removeManagedCompiledArtifact2(
-      path49.join(
+      path50.join(
         resolveTargetPath(paths.agents ?? ""),
-        `${path49.parse(relativePath).name}.md`
+        `${path50.parse(relativePath).name}.md`
       ),
       "opencode",
       relativePath,
@@ -35077,9 +35379,9 @@ function cleanupRemovedOpenCodeArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("commands/")) {
     removeManagedCompiledArtifact2(
-      path49.join(
+      path50.join(
         resolveTargetPath(paths.commands ?? ""),
-        `${path49.parse(relativePath).name}.md`
+        `${path50.parse(relativePath).name}.md`
       ),
       "opencode",
       relativePath,
@@ -35111,9 +35413,9 @@ function cleanupRemovedCursorArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("agents/")) {
     removeManagedCompiledArtifact2(
-      path49.join(
+      path50.join(
         resolveTargetPath(paths.agents ?? ""),
-        `${path49.parse(relativePath).name}.md`
+        `${path50.parse(relativePath).name}.md`
       ),
       "cursor",
       relativePath,
@@ -35123,9 +35425,9 @@ function cleanupRemovedCursorArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("rules/")) {
     removeManagedCompiledArtifact2(
-      path49.join(
+      path50.join(
         resolveTargetPath(paths.rules ?? ""),
-        `${path49.parse(relativePath).name}.mdc`
+        `${path50.parse(relativePath).name}.mdc`
       ),
       "cursor",
       relativePath,
@@ -35135,9 +35437,9 @@ function cleanupRemovedCursorArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("commands/")) {
     removeManagedCompiledArtifact2(
-      path49.join(
+      path50.join(
         resolveTargetPath(paths.skills ?? ""),
-        path49.parse(relativePath).name,
+        path50.parse(relativePath).name,
         "SKILL.md"
       ),
       "cursor",
@@ -35181,9 +35483,9 @@ function cleanupRemovedClineArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("rules/")) {
     removeManagedCompiledArtifact2(
-      path49.join(
+      path50.join(
         resolveTargetPath(paths.rules ?? ""),
-        `${path49.parse(relativePath).name}.md`
+        `${path50.parse(relativePath).name}.md`
       ),
       "cline",
       relativePath,
@@ -35193,9 +35495,9 @@ function cleanupRemovedClineArtifact(relativePath, paths, logger) {
   }
   if (relativePath.startsWith("commands/")) {
     removeManagedCompiledArtifact2(
-      path49.join(
+      path50.join(
         resolveTargetPath(paths.workflows ?? ""),
-        path49.basename(relativePath)
+        path50.basename(relativePath)
       ),
       "cline",
       relativePath,
@@ -35213,17 +35515,17 @@ function cleanupRemovedClineArtifact(relativePath, paths, logger) {
   }
 }
 function removeManagedCompiledArtifact2(artifactPath, expectedTarget, expectedSource, logger) {
-  if (!fs48.existsSync(artifactPath)) {
+  if (!fs49.existsSync(artifactPath)) {
     return;
   }
-  if (!fs48.statSync(artifactPath).isFile()) {
+  if (!fs49.statSync(artifactPath).isFile()) {
     return;
   }
-  const marker = extractProvenanceMarker(fs48.readFileSync(artifactPath, "utf8"));
+  const marker = extractProvenanceMarker(fs49.readFileSync(artifactPath, "utf8"));
   if (marker?.source !== expectedSource || marker.target !== expectedTarget) {
     return;
   }
-  fs48.rmSync(artifactPath, { force: true });
+  fs49.rmSync(artifactPath, { force: true });
   logger.verbose(`  removed stale target artifact: ${artifactPath}`);
 }
 function removeManagedCopilotMcpArtifact2(artifactPath, expectedSource, logger) {
@@ -35254,10 +35556,10 @@ function removeManagedCodexHooksArtifact2(artifactPath, expectedSource, logger)
   logger.verbose(`  removed stale target artifact: ${artifactPath}`);
 }
 function removeManagedCodexMcpArtifact2(artifactPath, expectedSource, logger) {
-  if (!fs48.existsSync(artifactPath)) {
+  if (!fs49.existsSync(artifactPath)) {
     return;
   }
-  const content = fs48.readFileSync(artifactPath, "utf8");
+  const content = fs49.readFileSync(artifactPath, "utf8");
   const startMarker = "# tangyr: managed mcp start";
   const endMarker = "# tangyr: managed mcp end";
   const startIndex = content.indexOf(startMarker);
@@ -35274,19 +35576,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) {
-    fs48.rmSync(artifactPath, { force: true });
+    fs49.rmSync(artifactPath, { force: true });
   } else {
-    fs48.writeFileSync(artifactPath, `${cleaned}
+    fs49.writeFileSync(artifactPath, `${cleaned}
 `);
   }
   logger.verbose(`  removed stale target artifact: ${artifactPath}`);
 }
 function readJsonObject5(filePath) {
-  if (!fs48.existsSync(filePath)) {
+  if (!fs49.existsSync(filePath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(fs48.readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(fs49.readFileSync(filePath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -35300,10 +35602,10 @@ function readJsonMetadata(value) {
 }
 function writeJsonOrRemove2(filePath, parsed) {
   if (isEmptyJsonValue2(parsed)) {
-    fs48.rmSync(filePath, { force: true });
+    fs49.rmSync(filePath, { force: true });
     return;
   }
-  fs48.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
+  fs49.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
 `);
 }
 function isEmptyJsonValue2(value) {
@@ -35363,8 +35665,8 @@ function removeManagedHookEntries(value, expectedSource) {
 }
 
 // src/commands/validate.ts
-import fs49 from "fs";
-import path50 from "path";
+import fs50 from "fs";
+import path51 from "path";
 var SUPPORTED_KIT_FORMATS2 = [1];
 var SUPPORTED_DISCIPLINE_VERSIONS = [
   "0.14.0",
@@ -35479,12 +35781,12 @@ function checkArchetype(kit) {
 }
 function checkHookScriptsExist(kit) {
   const violations = [];
-  const hooksDir = path50.join(kit.path, "hooks");
+  const hooksDir = path51.join(kit.path, "hooks");
   const missingSet = new Set(kit.components.hooks.missing);
   for (const name of kit.components.hooks.declared) {
     if (missingSet.has(name)) continue;
-    const declarationPath = path50.join(hooksDir, `${name}.md`);
-    if (!fs49.existsSync(declarationPath)) continue;
+    const declarationPath = path51.join(hooksDir, `${name}.md`);
+    if (!fs50.existsSync(declarationPath)) continue;
     let data;
     try {
       ({ data } = parseMarkdownFrontmatter(declarationPath));
@@ -35494,8 +35796,8 @@ function checkHookScriptsExist(kit) {
     if (typeof data.command === "string" && data.command.trim().length > 0) {
       continue;
     }
-    const scriptPath = path50.join(hooksDir, "scripts", `${name}.ts`);
-    if (!fs49.existsSync(scriptPath)) {
+    const scriptPath = path51.join(hooksDir, "scripts", `${name}.ts`);
+    if (!fs50.existsSync(scriptPath)) {
       violations.push({
         code: "hook-script-missing",
         location: `hooks/scripts/${name}.ts`,
@@ -35508,10 +35810,10 @@ function checkHookScriptsExist(kit) {
 function checkOptionalSourceDocuments(kit) {
   const violations = [];
   for (const name of [".mcp.json", "settings.json", ".lsp.json"]) {
-    const filePath = path50.join(kit.path, name);
-    if (!fs49.existsSync(filePath)) continue;
+    const filePath = path51.join(kit.path, name);
+    if (!fs50.existsSync(filePath)) continue;
     try {
-      const parsed = JSON.parse(fs49.readFileSync(filePath, "utf8"));
+      const parsed = JSON.parse(fs50.readFileSync(filePath, "utf8"));
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
         violations.push({
           code: "optional-source-malformed",
@@ -35533,10 +35835,10 @@ function checkSkillSubfolderNames(kit) {
   const notices = [];
   const canonical = new Set(CANONICAL_SKILL_SUBFOLDERS);
   for (const name of kit.components.skills.declared) {
-    const skillDir = path50.join(kit.path, "skills", name);
+    const skillDir = path51.join(kit.path, "skills", name);
     let entries;
     try {
-      entries = fs49.readdirSync(skillDir, { withFileTypes: true });
+      entries = fs50.readdirSync(skillDir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -35554,7 +35856,7 @@ function checkSkillSubfolderNames(kit) {
   return notices;
 }
 function checkHooksSourceForm(kit) {
-  const hooksDir = path50.join(kit.path, "hooks");
+  const hooksDir = path51.join(kit.path, "hooks");
   const message = describeHooksSourceConflict(
     hooksDir,
     kit.components.hooks.declared
@@ -35566,12 +35868,12 @@ function checkHooksSourceForm(kit) {
   } : null;
 }
 function checkHookDeclarations(kit) {
-  const hooksDir = path50.join(kit.path, "hooks");
+  const hooksDir = path51.join(kit.path, "hooks");
   return collectHookRejections(hooksDir, kit.components.hooks.declared).map(
     (r) => ({
       code: "hook-declaration-invalid",
-      location: `hooks/${path50.basename(r.file)}`,
-      message: `hooks: '${path50.basename(r.file, ".md")}' was rejected at '${r.field}' \u2014 ${r.reason}. Until this is fixed the hook is not installed on any target; install and sync report it as an error-severity loss and exit 3. To fix: correct the field named above in this file.`
+      location: `hooks/${path51.basename(r.file)}`,
+      message: `hooks: '${path51.basename(r.file, ".md")}' was rejected at '${r.field}' \u2014 ${r.reason}. Until this is fixed the hook is not installed on any target; install and sync report it as an error-severity loss and exit 3. To fix: correct the field named above in this file.`
     })
   );
 }
@@ -35591,11 +35893,11 @@ function checkKitFormatSupported(kit) {
 function checkEntrypointExists(kit) {
   const declared = kit.entrypoint;
   const entrypoint = declared ?? DEFAULT_ENTRYPOINT;
-  const entrypointPath = path50.join(kit.path, entrypoint);
-  if (fs49.existsSync(entrypointPath)) {
+  const entrypointPath = path51.join(kit.path, entrypoint);
+  if (fs50.existsSync(entrypointPath)) {
     return null;
   }
-  const legacyPresent = declared === void 0 && fs49.existsSync(path50.join(kit.path, LEGACY_ENTRYPOINT));
+  const legacyPresent = declared === void 0 && fs50.existsSync(path51.join(kit.path, LEGACY_ENTRYPOINT));
   const remedy = legacyPresent ? `This kit has '${LEGACY_ENTRYPOINT}' but not '${DEFAULT_ENTRYPOINT}'. Until now validate looked for '${LEGACY_ENTRYPOINT}' unconditionally; it now reads the manifest's 'entrypoint', defaulting to '${DEFAULT_ENTRYPOINT}' \u2014 the contract's canonical orientation document, of which '${LEGACY_ENTRYPOINT}' is a target translation. To fix: either add "entrypoint: ${LEGACY_ENTRYPOINT}" to tangyr-kit.yaml to keep the current filename, or rename '${LEGACY_ENTRYPOINT}' to '${DEFAULT_ENTRYPOINT}'.` : declared === void 0 ? `No 'entrypoint' is declared in tangyr-kit.yaml, so '${DEFAULT_ENTRYPOINT}' is expected at the kit root. To fix: create it, or declare the file you use with "entrypoint: <filename>".` : `tangyr-kit.yaml declares "entrypoint: ${declared}", and no such file exists at the kit root. To fix: create it, or correct the declaration.`;
   return {
     code: "entrypoint-missing",
@@ -35654,9 +35956,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" ? path50.join(kit.path, cat, name, "SKILL.md") : path50.join(kit.path, cat, `${name}.md`);
-      if (!fs49.existsSync(filePath)) continue;
-      const relPath = path50.relative(kit.path, filePath);
+      const filePath = cat === "skills" ? path51.join(kit.path, cat, name, "SKILL.md") : path51.join(kit.path, cat, `${name}.md`);
+      if (!fs50.existsSync(filePath)) continue;
+      const relPath = path51.relative(kit.path, filePath);
       try {
         const { data } = parseMarkdownFrontmatter(filePath);
         for (const field of requiredFields) {
@@ -35681,10 +35983,10 @@ function checkComponentFrontmatter(kit) {
 }
 function checkReservedRootNames(kit) {
   const violations = [];
-  if (!fs49.existsSync(kit.path) || !fs49.statSync(kit.path).isDirectory()) {
+  if (!fs50.existsSync(kit.path) || !fs50.statSync(kit.path).isDirectory()) {
     return violations;
   }
-  const entries = fs49.readdirSync(kit.path, { withFileTypes: true });
+  const entries = fs50.readdirSync(kit.path, { withFileTypes: true });
   for (const entry of entries) {
     if (RESERVED_ROOT_NAMES.includes(entry.name)) {
       violations.push({
@@ -35701,8 +36003,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 = path50.join(kit.path, "commands", `${name}.md`);
-    if (!fs49.existsSync(filePath)) continue;
+    const filePath = path51.join(kit.path, "commands", `${name}.md`);
+    if (!fs50.existsSync(filePath)) continue;
     let data;
     try {
       ({ data } = parseMarkdownFrontmatter(filePath));
@@ -35715,7 +36017,7 @@ function checkHumanOnlyCommandInvocation(kit) {
     if (!barred) {
       violations.push({
         code: "command-human-only-model-invocable",
-        location: path50.relative(kit.path, filePath),
+        location: path51.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"
       });
     }
@@ -35724,8 +36026,8 @@ function checkHumanOnlyCommandInvocation(kit) {
 }
 
 // src/commands/verify.ts
-import fs50 from "fs";
-import path51 from "path";
+import fs51 from "fs";
+import path52 from "path";
 function runVerifyCommand(options, logger) {
   if (options.target && !isKnownTarget(options.target)) {
     throwUnrecognizedTarget(options.target);
@@ -35906,8 +36208,8 @@ function verifyClaudeCodeGlobalRoots(roots, manifestKeys, mappings) {
       if (!slotPath) {
         continue;
       }
-      const fullPath = subPath ? path51.join(slotPath, subPath) : slotPath;
-      if (!fs50.existsSync(fullPath)) {
+      const fullPath = subPath ? path52.join(slotPath, subPath) : slotPath;
+      if (!fs51.existsSync(fullPath)) {
         failures.push(
           `claude-code/${slot}${subPath ? `/${subPath}` : ""} missing in root ${root}: ${fullPath}`
         );