agentinit 1.8.1 → 1.9.0

package/dist/cli.js

@@ -13587,20 +13587,20 @@ var require_parse_async = __commonJS((exports, module) => {
     const index = 0;
     const blocksize = opts.blocksize || 40960;
     const parser = new TOMLParser;
-    return new Promise((resolve6, reject) => {
-      setImmediate(parseAsyncNext, index, blocksize, resolve6, reject);
+    return new Promise((resolve7, reject) => {
+      setImmediate(parseAsyncNext, index, blocksize, resolve7, reject);
     });
-    function parseAsyncNext(index2, blocksize2, resolve6, reject) {
+    function parseAsyncNext(index2, blocksize2, resolve7, reject) {
       if (index2 >= str2.length) {
         try {
-          return resolve6(parser.finish());
+          return resolve7(parser.finish());
         } catch (err) {
           return reject(prettyError(err, str2));
         }
       }
       try {
         parser.parse(str2.slice(index2, index2 + blocksize2));
-        setImmediate(parseAsyncNext, index2 + blocksize2, blocksize2, resolve6, reject);
+        setImmediate(parseAsyncNext, index2 + blocksize2, blocksize2, resolve7, reject);
       } catch (err) {
         reject(prettyError(err, str2));
       }
@@ -13623,7 +13623,7 @@ var require_parse_stream = __commonJS((exports, module) => {
   var parseReadable = function(stm) {
     const parser = new TOMLParser;
     stm.setEncoding("utf8");
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       let readable;
       let ended = false;
       let errored = false;
@@ -13632,7 +13632,7 @@ var require_parse_stream = __commonJS((exports, module) => {
         if (readable)
           return;
         try {
-          resolve6(parser.finish());
+          resolve7(parser.finish());
         } catch (err) {
           reject(err);
         }
@@ -14840,51 +14840,51 @@ var require_uri_all = __commonJS((exports, module) => {
       }
       return uriTokens.join("");
     }
-    function resolveComponents(base2, relative4) {
+    function resolveComponents(base2, relative5) {
       var options2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
       var skipNormalization = arguments[3];
       var target = {};
       if (!skipNormalization) {
         base2 = parse4(serialize(base2, options2), options2);
-        relative4 = parse4(serialize(relative4, options2), options2);
+        relative5 = parse4(serialize(relative5, options2), options2);
       }
       options2 = options2 || {};
-      if (!options2.tolerant && relative4.scheme) {
-        target.scheme = relative4.scheme;
-        target.userinfo = relative4.userinfo;
-        target.host = relative4.host;
-        target.port = relative4.port;
-        target.path = removeDotSegments(relative4.path || "");
-        target.query = relative4.query;
+      if (!options2.tolerant && relative5.scheme) {
+        target.scheme = relative5.scheme;
+        target.userinfo = relative5.userinfo;
+        target.host = relative5.host;
+        target.port = relative5.port;
+        target.path = removeDotSegments(relative5.path || "");
+        target.query = relative5.query;
       } else {
-        if (relative4.userinfo !== undefined || relative4.host !== undefined || relative4.port !== undefined) {
-          target.userinfo = relative4.userinfo;
-          target.host = relative4.host;
-          target.port = relative4.port;
-          target.path = removeDotSegments(relative4.path || "");
-          target.query = relative4.query;
+        if (relative5.userinfo !== undefined || relative5.host !== undefined || relative5.port !== undefined) {
+          target.userinfo = relative5.userinfo;
+          target.host = relative5.host;
+          target.port = relative5.port;
+          target.path = removeDotSegments(relative5.path || "");
+          target.query = relative5.query;
         } else {
-          if (!relative4.path) {
+          if (!relative5.path) {
             target.path = base2.path;
-            if (relative4.query !== undefined) {
-              target.query = relative4.query;
+            if (relative5.query !== undefined) {
+              target.query = relative5.query;
             } else {
               target.query = base2.query;
             }
           } else {
-            if (relative4.path.charAt(0) === "/") {
-              target.path = removeDotSegments(relative4.path);
+            if (relative5.path.charAt(0) === "/") {
+              target.path = removeDotSegments(relative5.path);
             } else {
               if ((base2.userinfo !== undefined || base2.host !== undefined || base2.port !== undefined) && !base2.path) {
-                target.path = "/" + relative4.path;
+                target.path = "/" + relative5.path;
               } else if (!base2.path) {
-                target.path = relative4.path;
+                target.path = relative5.path;
               } else {
-                target.path = base2.path.slice(0, base2.path.lastIndexOf("/") + 1) + relative4.path;
+                target.path = base2.path.slice(0, base2.path.lastIndexOf("/") + 1) + relative5.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative4.query;
+            target.query = relative5.query;
           }
           target.userinfo = base2.userinfo;
           target.host = base2.host;
@@ -14892,10 +14892,10 @@ var require_uri_all = __commonJS((exports, module) => {
         }
         target.scheme = base2.scheme;
       }
-      target.fragment = relative4.fragment;
+      target.fragment = relative5.fragment;
       return target;
     }
-    function resolve10(baseURI, relativeURI, options2) {
+    function resolve11(baseURI, relativeURI, options2) {
       var schemelessOptions = assign({ scheme: "null" }, options2);
       return serialize(resolveComponents(parse4(baseURI, schemelessOptions), parse4(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
     }
@@ -15163,7 +15163,7 @@ var require_uri_all = __commonJS((exports, module) => {
     exports2.removeDotSegments = removeDotSegments;
     exports2.serialize = serialize;
     exports2.resolveComponents = resolveComponents;
-    exports2.resolve = resolve10;
+    exports2.resolve = resolve11;
     exports2.normalize = normalize;
     exports2.equal = equal;
     exports2.escapeComponent = escapeComponent;
@@ -15526,13 +15526,13 @@ var require_json_schema_traverse = __commonJS((exports, module) => {
 
 // node_modules/ajv/lib/compile/resolve.js
 var require_resolve = __commonJS((exports, module) => {
-  var resolve10 = function(compile, root, ref) {
+  var resolve11 = function(compile, root, ref) {
     var refVal = this._refs[ref];
     if (typeof refVal == "string") {
       if (this._refs[refVal])
         refVal = this._refs[refVal];
       else
-        return resolve10.call(this, compile, root, refVal);
+        return resolve11.call(this, compile, root, refVal);
     }
     refVal = refVal || this._schemas[ref];
     if (refVal instanceof SchemaObject) {
@@ -15737,13 +15737,13 @@ var require_resolve = __commonJS((exports, module) => {
   var util6 = require_util3();
   var SchemaObject = require_schema_obj();
   var traverse = require_json_schema_traverse();
-  module.exports = resolve10;
-  resolve10.normalizeId = normalizeId;
-  resolve10.fullPath = getFullPath;
-  resolve10.url = resolveUrl;
-  resolve10.ids = resolveIds;
-  resolve10.inlineRef = inlineRef;
-  resolve10.schema = resolveSchema;
+  module.exports = resolve11;
+  resolve11.normalizeId = normalizeId;
+  resolve11.fullPath = getFullPath;
+  resolve11.url = resolveUrl;
+  resolve11.ids = resolveIds;
+  resolve11.inlineRef = inlineRef;
+  resolve11.schema = resolveSchema;
   var PREVENT_SCOPE_CHANGE = util6.toHash(["properties", "patternProperties", "enum", "dependencies", "definitions"]);
   var SIMPLE_INLINED = util6.toHash([
     "type",
@@ -15774,15 +15774,15 @@ var require_error_classes = __commonJS((exports, module) => {
   };
   var MissingRefError = function(baseId, ref, message) {
     this.message = message || MissingRefError.message(baseId, ref);
-    this.missingRef = resolve10.url(baseId, ref);
-    this.missingSchema = resolve10.normalizeId(resolve10.fullPath(this.missingRef));
+    this.missingRef = resolve11.url(baseId, ref);
+    this.missingSchema = resolve11.normalizeId(resolve11.fullPath(this.missingRef));
   };
   var errorSubclass = function(Subclass) {
     Subclass.prototype = Object.create(Error.prototype);
     Subclass.prototype.constructor = Subclass;
     return Subclass;
   };
-  var resolve10 = require_resolve();
+  var resolve11 = require_resolve();
   module.exports = {
     Validation: errorSubclass(ValidationError),
     MissingRef: errorSubclass(MissingRefError)
@@ -16376,7 +16376,7 @@ var require_compile = __commonJS((exports, module) => {
         RULES,
         validate: validateGenerator,
         util: util6,
-        resolve: resolve10,
+        resolve: resolve11,
         resolveRef,
         usePattern,
         useDefault,
@@ -16415,7 +16415,7 @@ var require_compile = __commonJS((exports, module) => {
       return validate2;
     }
     function resolveRef(baseId2, ref, isRoot) {
-      ref = resolve10.url(baseId2, ref);
+      ref = resolve11.url(baseId2, ref);
       var refIndex = refs[ref];
       var _refVal, refCode;
       if (refIndex !== undefined) {
@@ -16432,11 +16432,11 @@ var require_compile = __commonJS((exports, module) => {
         }
       }
       refCode = addLocalRef(ref);
-      var v2 = resolve10.call(self, localCompile, root, ref);
+      var v2 = resolve11.call(self, localCompile, root, ref);
       if (v2 === undefined) {
         var localSchema = localRefs && localRefs[ref];
         if (localSchema) {
-          v2 = resolve10.inlineRef(localSchema, opts.inlineRefs) ? localSchema : compile.call(self, localSchema, root, localRefs, baseId2);
+          v2 = resolve11.inlineRef(localSchema, opts.inlineRefs) ? localSchema : compile.call(self, localSchema, root, localRefs, baseId2);
         }
       }
       if (v2 === undefined) {
@@ -16578,7 +16578,7 @@ var require_compile = __commonJS((exports, module) => {
       code += statement(i, arr);
     return code;
   };
-  var resolve10 = require_resolve();
+  var resolve11 = require_resolve();
   var util6 = require_util3();
   var errorClasses = require_error_classes();
   var stableStringify = require_fast_json_stable_stringify();
@@ -19827,7 +19827,7 @@ var require_ajv = __commonJS((exports, module) => {
     var id = this._getId(schema2);
     if (id !== undefined && typeof id != "string")
       throw new Error("schema id must be string");
-    key = resolve10.normalizeId(key || id);
+    key = resolve11.normalizeId(key || id);
     checkUnique(this, key);
     this._schemas[key] = this._addSchema(schema2, _skipValidation, _meta, true);
     return this;
@@ -19873,7 +19873,7 @@ var require_ajv = __commonJS((exports, module) => {
     }
   };
   var _getSchemaFragment = function(self, ref) {
-    var res = resolve10.schema.call(self, { schema: {} }, ref);
+    var res = resolve11.schema.call(self, { schema: {} }, ref);
     if (res) {
       var { schema: schema2, root, baseId } = res;
       var v = compileSchema.call(self, schema2, root, undefined, baseId);
@@ -19889,7 +19889,7 @@ var require_ajv = __commonJS((exports, module) => {
     }
   };
   var _getSchemaObj = function(self, keyRef) {
-    keyRef = resolve10.normalizeId(keyRef);
+    keyRef = resolve11.normalizeId(keyRef);
     return self._schemas[keyRef] || self._refs[keyRef] || self._fragments[keyRef];
   };
   var removeSchema = function(schemaKeyRef) {
@@ -19917,7 +19917,7 @@ var require_ajv = __commonJS((exports, module) => {
         this._cache.del(cacheKey);
         var id = this._getId(schemaKeyRef);
         if (id) {
-          id = resolve10.normalizeId(id);
+          id = resolve11.normalizeId(id);
           delete this._schemas[id];
           delete this._refs[id];
         }
@@ -19942,14 +19942,14 @@ var require_ajv = __commonJS((exports, module) => {
     if (cached)
       return cached;
     shouldAddSchema = shouldAddSchema || this._opts.addUsedSchema !== false;
-    var id = resolve10.normalizeId(this._getId(schema2));
+    var id = resolve11.normalizeId(this._getId(schema2));
     if (id && shouldAddSchema)
       checkUnique(this, id);
     var willValidate = this._opts.validateSchema !== false && !skipValidation;
     var recursiveMeta;
-    if (willValidate && !(recursiveMeta = id && id == resolve10.normalizeId(schema2.$schema)))
+    if (willValidate && !(recursiveMeta = id && id == resolve11.normalizeId(schema2.$schema)))
       this.validateSchema(schema2, true);
-    var localRefs = resolve10.ids.call(this, schema2);
+    var localRefs = resolve11.ids.call(this, schema2);
     var schemaObj = new SchemaObject({
       id,
       schema: schema2,
@@ -20110,7 +20110,7 @@ var require_ajv = __commonJS((exports, module) => {
   var noop = function() {
   };
   var compileSchema = require_compile();
-  var resolve10 = require_resolve();
+  var resolve11 = require_resolve();
   var Cache = require_cache();
   var SchemaObject = require_schema_obj();
   var stableStringify = require_fast_json_stable_stringify();
@@ -20171,27 +20171,27 @@ var require_windows = __commonJS((exports, module) => {
     return checkPathExt(path, options2);
   };
   var isexe = function(path, options2, cb) {
-    fs24.stat(path, function(er, stat) {
+    fs25.stat(path, function(er, stat) {
       cb(er, er ? false : checkStat(stat, path, options2));
     });
   };
   var sync = function(path, options2) {
-    return checkStat(fs24.statSync(path), path, options2);
+    return checkStat(fs25.statSync(path), path, options2);
   };
   module.exports = isexe;
   isexe.sync = sync;
-  var fs24 = __require("fs");
+  var fs25 = __require("fs");
 });
 
 // node_modules/isexe/mode.js
 var require_mode = __commonJS((exports, module) => {
   var isexe = function(path, options2, cb) {
-    fs24.stat(path, function(er, stat) {
+    fs25.stat(path, function(er, stat) {
       cb(er, er ? false : checkStat(stat, options2));
     });
   };
   var sync = function(path, options2) {
-    return checkStat(fs24.statSync(path), options2);
+    return checkStat(fs25.statSync(path), options2);
   };
   var checkStat = function(stat, options2) {
     return stat.isFile() && checkMode(stat, options2);
@@ -20211,7 +20211,7 @@ var require_mode = __commonJS((exports, module) => {
   };
   module.exports = isexe;
   isexe.sync = sync;
-  var fs24 = __require("fs");
+  var fs25 = __require("fs");
 });
 
 // node_modules/isexe/index.js
@@ -20225,12 +20225,12 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve10, reject) {
+      return new Promise(function(resolve11, reject) {
         isexe(path, options2 || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve10(is);
+            resolve11(is);
           }
         });
       });
@@ -20256,7 +20256,7 @@ var require_isexe = __commonJS((exports, module) => {
       }
     }
   };
-  var fs24 = __require("fs");
+  var fs25 = __require("fs");
   var core2;
   if (process.platform === "win32" || global.TESTING_WINDOWS) {
     core2 = require_windows();
@@ -20301,27 +20301,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i) => new Promise((resolve10, reject) => {
+    const step = (i) => new Promise((resolve11, reject) => {
       if (i === pathEnv.length)
-        return opt.all && found.length ? resolve10(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve11(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
       const pCmd = path.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve10(subStep(p, i, 0));
+      resolve11(subStep(p, i, 0));
     });
-    const subStep = (p, i, ii) => new Promise((resolve10, reject) => {
+    const subStep = (p, i, ii) => new Promise((resolve11, reject) => {
       if (ii === pathExt.length)
-        return resolve10(step(i + 1));
+        return resolve11(step(i + 1));
       const ext = pathExt[ii];
       isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
         if (!er && is) {
           if (opt.all)
             found.push(p + ext);
           else
-            return resolve10(p + ext);
+            return resolve11(p + ext);
         }
-        return resolve10(subStep(p, i, ii + 1));
+        return resolve11(subStep(p, i, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -20363,8 +20363,8 @@ var require_which = __commonJS((exports, module) => {
 var require_path_key = __commonJS((exports, module) => {
   var pathKey = (options2 = {}) => {
     const environment = options2.env || process.env;
-    const platform = options2.platform || process.platform;
-    if (platform !== "win32") {
+    const platform2 = options2.platform || process.platform;
+    if (platform2 !== "win32") {
       return "PATH";
     }
     return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
@@ -20463,14 +20463,14 @@ var require_readShebang = __commonJS((exports, module) => {
     const buffer = Buffer.alloc(size);
     let fd;
     try {
-      fd = fs24.openSync(command, "r");
-      fs24.readSync(fd, buffer, 0, size, 0);
-      fs24.closeSync(fd);
+      fd = fs25.openSync(command, "r");
+      fs25.readSync(fd, buffer, 0, size, 0);
+      fs25.closeSync(fd);
     } catch (e) {
     }
     return shebangCommand(buffer.toString());
   };
-  var fs24 = __require("fs");
+  var fs25 = __require("fs");
   var shebangCommand = require_shebang_command();
   module.exports = readShebang;
 });
@@ -21911,13 +21911,13 @@ var init_screen_manager = __esm(() => {
 // node_modules/@inquirer/core/dist/lib/promise-polyfill.js
 class PromisePolyfill extends Promise {
   static withResolver() {
-    let resolve11;
+    let resolve12;
     let reject;
     const promise = new Promise((res, rej) => {
-      resolve11 = res;
+      resolve12 = res;
       reject = rej;
     });
-    return { promise, resolve: resolve11, reject };
+    return { promise, resolve: resolve12, reject };
   }
 }
 var init_promise_polyfill = __esm(() => {
@@ -21940,7 +21940,7 @@ function createPrompt(view) {
       output
     });
     const screen = new ScreenManager(rl);
-    const { promise, resolve: resolve11, reject } = PromisePolyfill.withResolver();
+    const { promise, resolve: resolve12, reject } = PromisePolyfill.withResolver();
     const cancel = () => reject(new CancelPromptError);
     if (signal) {
       const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
@@ -21968,7 +21968,7 @@ function createPrompt(view) {
         cycle(() => {
           try {
             const nextView = view(config, (value) => {
-              setImmediate(() => resolve11(value));
+              setImmediate(() => resolve12(value));
             });
             if (nextView === undefined) {
               const callerFilename = callSites[1]?.getFileName();
@@ -27848,26 +27848,26 @@ var require_lib3 = __commonJS((exports) => {
     return matches;
   };
   exports.analyse = analyse;
-  var detectFile = (filepath, opts = {}) => new Promise((resolve11, reject) => {
+  var detectFile = (filepath, opts = {}) => new Promise((resolve12, reject) => {
     let fd;
-    const fs30 = (0, node_1.default)();
+    const fs31 = (0, node_1.default)();
     const handler = (err, buffer) => {
       if (fd) {
-        fs30.closeSync(fd);
+        fs31.closeSync(fd);
       }
       if (err) {
         reject(err);
       } else if (buffer) {
-        resolve11((0, exports.detect)(buffer));
+        resolve12((0, exports.detect)(buffer));
       } else {
         reject(new Error("No error and no buffer received"));
       }
     };
     const sampleSize = (opts === null || opts === undefined ? undefined : opts.sampleSize) || 0;
     if (sampleSize > 0) {
-      fd = fs30.openSync(filepath, "r");
+      fd = fs31.openSync(filepath, "r");
       let sample = Buffer.allocUnsafe(sampleSize);
-      fs30.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+      fs31.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
         if (err) {
           handler(err, null);
         } else {
@@ -27879,22 +27879,22 @@ var require_lib3 = __commonJS((exports) => {
       });
       return;
     }
-    fs30.readFile(filepath, handler);
+    fs31.readFile(filepath, handler);
   });
   exports.detectFile = detectFile;
   var detectFileSync = (filepath, opts = {}) => {
-    const fs30 = (0, node_1.default)();
+    const fs31 = (0, node_1.default)();
     if (opts && opts.sampleSize) {
-      const fd = fs30.openSync(filepath, "r");
+      const fd = fs31.openSync(filepath, "r");
       let sample = Buffer.allocUnsafe(opts.sampleSize);
-      const bytesRead = fs30.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+      const bytesRead = fs31.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
       if (bytesRead < opts.sampleSize) {
         sample = sample.subarray(0, bytesRead);
       }
-      fs30.closeSync(fd);
+      fs31.closeSync(fd);
       return (0, exports.detect)(sample);
     }
-    return (0, exports.detect)(fs30.readFileSync(filepath));
+    return (0, exports.detect)(fs31.readFileSync(filepath));
   };
   exports.detectFileSync = detectFileSync;
   exports.default = {
@@ -32807,7 +32807,7 @@ var {
 } = import_.default;
 
 // dist/commands/init.js
-import {resolve as resolve3} from "path";
+import {resolve as resolve4} from "path";
 
 // node_modules/ora/index.js
 import process9 from "node:process";
@@ -33983,7 +33983,8 @@ var logger = Logger.getInstance();
 
 // dist/utils/fs.js
 import {promises as fs} from "fs";
-import {join, dirname} from "path";
+import {platform} from "os";
+import {join, dirname, basename, resolve, relative} from "path";
 async function fileExists(path) {
   try {
     await fs.access(path);
@@ -34064,9 +34065,85 @@ async function ensureDirectoryExists(filePath) {
   const dir = dirname(filePath);
   await fs.mkdir(dir, { recursive: true });
 }
+async function readSymlinkTarget(path) {
+  try {
+    return await fs.readlink(path);
+  } catch {
+    return null;
+  }
+}
+async function resolveRealPathOrSelf(path) {
+  const resolvedPath = resolve(path);
+  try {
+    return await fs.realpath(resolvedPath);
+  } catch {
+    return resolvedPath;
+  }
+}
+async function resolveParentSymlinks(path) {
+  const resolvedPath = resolve(path);
+  const parentDir = dirname(resolvedPath);
+  const baseName = basename(resolvedPath);
+  try {
+    const realParent = await fs.realpath(parentDir);
+    return join(realParent, baseName);
+  } catch {
+    return resolvedPath;
+  }
+}
+async function pathsReferToSameLocation(left, right) {
+  const [realLeft, realRight] = await Promise.all([
+    resolveRealPathOrSelf(left),
+    resolveRealPathOrSelf(right)
+  ]);
+  if (realLeft === realRight) {
+    return true;
+  }
+  const [leftWithResolvedParents, rightWithResolvedParents] = await Promise.all([
+    resolveParentSymlinks(left),
+    resolveParentSymlinks(right)
+  ]);
+  return leftWithResolvedParents === rightWithResolvedParents;
+}
+async function createRelativeSymlink(target, linkPath) {
+  try {
+    const resolvedTarget = resolve(target);
+    const resolvedLinkPath = resolve(linkPath);
+    if (await pathsReferToSameLocation(resolvedTarget, resolvedLinkPath)) {
+      return true;
+    }
+    try {
+      const stats = await fs.lstat(resolvedLinkPath);
+      if (stats.isSymbolicLink()) {
+        const existingTarget = await fs.readlink(resolvedLinkPath);
+        const resolvedExistingTarget = resolve(dirname(resolvedLinkPath), existingTarget);
+        if (resolvedExistingTarget === resolvedTarget) {
+          return true;
+        }
+        await fs.rm(resolvedLinkPath, { force: true });
+      } else {
+        await fs.rm(resolvedLinkPath, { recursive: true, force: true });
+      }
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ELOOP") {
+        await fs.rm(resolvedLinkPath, { force: true }).catch(() => {
+        });
+      }
+    }
+    await fs.mkdir(dirname(resolvedLinkPath), { recursive: true });
+    const realLinkDir = await resolveParentSymlinks(dirname(resolvedLinkPath));
+    const realTarget = await resolveRealPathOrSelf(resolvedTarget);
+    const relativeTarget = relative(realLinkDir, realTarget);
+    const symlinkType = platform() === "win32" ? "junction" : undefined;
+    await fs.symlink(relativeTarget, resolvedLinkPath, symlinkType);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // dist/core/agentDetector.js
-import {resolve} from "path";
+import {resolve as resolve2} from "path";
 class AgentDetector {
   agentConfigs = [
     { name: "cursor", files: [".cursorrules", ".cursor/settings.json"] },
@@ -34096,7 +34173,7 @@ class AgentDetector {
   }
   async checkAgentFiles(projectPath, files) {
     for (const file of files) {
-      const fullPath = resolve(projectPath, file);
+      const fullPath = resolve2(projectPath, file);
       if (await fileExists(fullPath)) {
         return { found: true, path: fullPath };
       }
@@ -34121,7 +34198,7 @@ class AgentDetector {
 }
 
 // dist/core/stackDetector.js
-import {resolve as resolve2} from "path";
+import {resolve as resolve3} from "path";
 class StackDetector {
   lockFiles = [
     "package-lock.json",
@@ -34166,7 +34243,7 @@ class StackDetector {
   }
   async detectFromLockFiles(projectPath) {
     for (const lockFile of this.lockFiles) {
-      const lockPath = resolve2(projectPath, lockFile);
+      const lockPath = resolve3(projectPath, lockFile);
       if (await fileExists(lockPath)) {
         return this.inferStackFromLockFile(projectPath, lockFile);
       }
@@ -34198,7 +34275,7 @@ class StackDetector {
   }
   async detectFromManifests(projectPath) {
     for (const manifest of this.manifestFiles) {
-      const manifestPath = resolve2(projectPath, manifest);
+      const manifestPath = resolve3(projectPath, manifest);
       if (await fileExists(manifestPath)) {
         return this.inferStackFromManifest(projectPath, manifest);
       }
@@ -34230,7 +34307,7 @@ class StackDetector {
   }
   async detectFromConfigs(projectPath) {
     for (const config of this.configFiles) {
-      const configPath = resolve2(projectPath, config);
+      const configPath = resolve3(projectPath, config);
       if (await fileExists(configPath)) {
         return this.inferStackFromConfig(projectPath, config);
       }
@@ -34289,7 +34366,7 @@ class StackDetector {
     };
   }
   async analyzeJavaScriptProject(projectPath) {
-    const packageJsonPath = resolve2(projectPath, "package.json");
+    const packageJsonPath = resolve3(projectPath, "package.json");
     const packageJsonContent = await readFileIfExists(packageJsonPath);
     const info = {
       language: "javascript",
@@ -34304,7 +34381,7 @@ class StackDetector {
         ...packageJson.devDependencies
       };
       info.dependencies = Object.keys(allDeps);
-      if (allDeps.typescript || await fileExists(resolve2(projectPath, "tsconfig.json"))) {
+      if (allDeps.typescript || await fileExists(resolve3(projectPath, "tsconfig.json"))) {
         info.language = "typescript";
       }
       if (allDeps.next)
@@ -34321,11 +34398,11 @@ class StackDetector {
         info.framework = "express";
       else if (allDeps.fastify)
         info.framework = "fastify";
-      if (await fileExists(resolve2(projectPath, "yarn.lock")))
+      if (await fileExists(resolve3(projectPath, "yarn.lock")))
         info.packageManager = "yarn";
-      else if (await fileExists(resolve2(projectPath, "pnpm-lock.yaml")))
+      else if (await fileExists(resolve3(projectPath, "pnpm-lock.yaml")))
         info.packageManager = "pnpm";
-      else if (await fileExists(resolve2(projectPath, "bun.lockb")))
+      else if (await fileExists(resolve3(projectPath, "bun.lockb")))
         info.packageManager = "bun";
       else
         info.packageManager = "npm";
@@ -34604,7 +34681,7 @@ This is a {{STACK}} project{{FRAMEWORK_CONTEXT}}. The codebase follows modern de
 // dist/commands/init.js
 async function initCommand(options2) {
   const cwd = process.cwd();
-  const agentsPath = resolve3(cwd, "agents.md");
+  const agentsPath = resolve4(cwd, "agents.md");
   logger.title("\uD83D\uDE80 AgentInit - Initialize Project");
   if (!options2.force && await fileExists(agentsPath)) {
     const response = await import_prompts.default({
@@ -34682,7 +34759,7 @@ async function initCommand(options2) {
 }
 var getProjectName = function(cwd) {
   try {
-    const packageJsonPath = resolve3(cwd, "package.json");
+    const packageJsonPath = resolve4(cwd, "package.json");
     const packageJson = __require(packageJsonPath);
     return packageJson.name || cwd.split("/").pop() || "project";
   } catch {
@@ -34692,18 +34769,18 @@ var getProjectName = function(cwd) {
 
 // dist/core/skillsManager.js
 var import_gray_matter = __toESM(require_gray_matter(), 1);
-import {resolve as resolve6, join as join3, relative} from "path";
+import {resolve as resolve7, join as join3, relative as relative2} from "path";
 import {promises as fs18} from "fs";
-import {tmpdir} from "os";
+import {homedir as homedir3, tmpdir} from "os";
 import {execFile} from "child_process";
 import {promisify} from "util";
 
 // dist/agents/Agent.js
-import {resolve as resolve5} from "path";
+import {resolve as resolve6} from "path";
 import {homedir as homedir2} from "os";
 
 // dist/utils/paths.js
-import {resolve as resolve4, join as join2} from "path";
+import {resolve as resolve5, join as join2} from "path";
 import {homedir} from "os";
 function getHomeDirectory() {
   return homedir();
@@ -34737,8 +34814,8 @@ function resolveGlobalConfigPath(globalConfigPath, globalConfigPaths) {
     return expandTilde(globalConfigPath);
   }
   if (globalConfigPaths) {
-    const platform = getPlatform();
-    const platformPath = globalConfigPaths[platform];
+    const platform2 = getPlatform();
+    const platformPath = globalConfigPaths[platform2];
     if (platformPath) {
       return expandTilde(platformPath);
     }
@@ -34765,7 +34842,7 @@ function getFullGlobalConfigPath(globalConfigPath, globalConfigPaths) {
     return null;
   }
   const resolvedPath = resolveEnvironmentVariables(path);
-  return resolve4(resolvedPath);
+  return resolve5(resolvedPath);
 }
 
 // node_modules/contextcalc/dist/lib/index.js
@@ -35198,7 +35275,7 @@ class Agent {
   }
   async detectPresence(projectPath) {
     for (const configFile of this.configFiles) {
-      const fullPath = resolve5(projectPath, configFile.path);
+      const fullPath = resolve6(projectPath, configFile.path);
       if (await pathExists(fullPath, configFile.type)) {
         return {
           agent: this,
@@ -35209,7 +35286,7 @@ class Agent {
     return null;
   }
   getNativeMcpPath(projectPath) {
-    return resolve5(projectPath, this.nativeConfigPath);
+    return resolve6(projectPath, this.nativeConfigPath);
   }
   getGlobalMcpPath() {
     return getFullGlobalConfigPath(this.definition.globalConfigPath, this.definition.globalConfigPaths);
@@ -35218,7 +35295,7 @@ class Agent {
     if (!this.capabilities.rules || !this.definition.rulesPath) {
       return null;
     }
-    return resolve5(projectPath, this.definition.rulesPath);
+    return resolve6(projectPath, this.definition.rulesPath);
   }
   getGlobalRulesPath() {
     if (!this.capabilities.rules) {
@@ -35278,7 +35355,7 @@ class Agent {
     if (global3) {
       return this.definition.skillPaths.global.replace("~", homedir2());
     }
-    return resolve5(projectPath, this.definition.skillPaths.project);
+    return resolve6(projectPath, this.definition.skillPaths.project);
   }
   getProjectRulesStandard() {
     return this.definition.projectStandards?.rules || null;
@@ -37370,7 +37447,7 @@ class SkillsManager {
     const skills = [];
     const seen = new Set;
     for (const searchDir of SKILL_SEARCH_DIRS) {
-      const fullDir = resolve6(repoPath, searchDir);
+      const fullDir = resolve7(repoPath, searchDir);
       if (!await fileExists(fullDir))
         continue;
       const directSkillMd = join3(fullDir, "SKILL.md");
@@ -37378,7 +37455,7 @@ class SkillsManager {
         const parsed = await this.parseSkillMd(directSkillMd);
         if (parsed && !seen.has(parsed.name)) {
           seen.add(parsed.name);
-          skills.push({ ...parsed, path: resolve6(fullDir) });
+          skills.push({ ...parsed, path: resolve7(fullDir) });
         }
       }
       const directSkillMdLower = join3(fullDir, "skill.md");
@@ -37386,7 +37463,7 @@ class SkillsManager {
         const parsed = await this.parseSkillMd(directSkillMdLower);
         if (parsed && !seen.has(parsed.name)) {
           seen.add(parsed.name);
-          skills.push({ ...parsed, path: resolve6(fullDir) });
+          skills.push({ ...parsed, path: resolve7(fullDir) });
         }
       }
       if (!await isDirectory(fullDir))
@@ -37440,7 +37517,7 @@ class SkillsManager {
   async installSkill(skillPath, skillName, targetDir, copy = false) {
     const normalizedSkillName = this.normalizeSkillName(skillName);
     const destPath = this.resolveInstallPath(targetDir, normalizedSkillName);
-    await fs18.mkdir(resolve6(targetDir), { recursive: true });
+    await fs18.mkdir(resolve7(targetDir), { recursive: true });
     if (await fileExists(destPath)) {
       await fs18.rm(destPath, { recursive: true, force: true });
     }
@@ -37454,7 +37531,7 @@ class SkillsManager {
   async installSkillFromContent(skillName, skillContent, targetDir) {
     const normalizedSkillName = this.normalizeSkillName(skillName);
     const destPath = this.resolveInstallPath(targetDir, normalizedSkillName);
-    await fs18.mkdir(resolve6(targetDir), { recursive: true });
+    await fs18.mkdir(resolve7(targetDir), { recursive: true });
     if (await fileExists(destPath)) {
       await fs18.rm(destPath, { recursive: true, force: true });
     }
@@ -37462,6 +37539,95 @@ class SkillsManager {
     await fs18.writeFile(join3(destPath, "SKILL.md"), skillContent, "utf8");
     return destPath;
   }
+  getCanonicalSkillsDir(projectPath, global3 = false) {
+    return global3 ? resolve7(homedir3(), ".agents/skills") : resolve7(projectPath, ".agents/skills");
+  }
+  async getInstallPlan(skillName, agent, projectPath, options2 = {}) {
+    const normalizedSkillName = this.normalizeSkillName(skillName);
+    const skillsDir = agent.getSkillsDir(projectPath, options2.global);
+    if (!skillsDir) {
+      throw new Error(`No skills directory for ${agent.name}`);
+    }
+    const agentPath = this.resolveInstallPath(skillsDir, normalizedSkillName);
+    if (options2.copy) {
+      return {
+        path: agentPath,
+        mode: "copy"
+      };
+    }
+    const canonicalPath = this.resolveInstallPath(this.getCanonicalSkillsDir(projectPath, options2.global ?? false), normalizedSkillName);
+    if (await pathsReferToSameLocation(canonicalPath, agentPath)) {
+      return {
+        path: canonicalPath,
+        canonicalPath,
+        mode: "symlink"
+      };
+    }
+    return {
+      path: agentPath,
+      canonicalPath,
+      mode: "symlink"
+    };
+  }
+  async installSkillForAgent(skillPath, skillName, agent, projectPath, options2 = {}) {
+    const plan = await this.getInstallPlan(skillName, agent, projectPath, options2);
+    const skillsDir = agent.getSkillsDir(projectPath, options2.global);
+    if (!skillsDir) {
+      throw new Error(`No skills directory for ${agent.name}`);
+    }
+    if (plan.mode === "copy") {
+      await this.installSkill(skillPath, skillName, skillsDir, true);
+      return plan;
+    }
+    const canonicalPath = plan.canonicalPath;
+    if (!canonicalPath) {
+      throw new Error(`Missing canonical path for ${skillName}`);
+    }
+    await this.cleanAndCreateDirectory(canonicalPath);
+    await this.copyDir(skillPath, canonicalPath);
+    if (plan.path === canonicalPath) {
+      return plan;
+    }
+    const symlinkCreated = await createRelativeSymlink(canonicalPath, plan.path);
+    if (!symlinkCreated) {
+      await this.cleanAndCreateDirectory(plan.path);
+      await this.copyDir(skillPath, plan.path);
+      return {
+        ...plan,
+        symlinkFailed: true
+      };
+    }
+    return plan;
+  }
+  async installSkillFromContentForAgent(skillName, skillContent, agent, projectPath, options2 = {}) {
+    const plan = await this.getInstallPlan(skillName, agent, projectPath, options2);
+    const skillsDir = agent.getSkillsDir(projectPath, options2.global);
+    if (!skillsDir) {
+      throw new Error(`No skills directory for ${agent.name}`);
+    }
+    if (plan.mode === "copy") {
+      await this.installSkillFromContent(skillName, skillContent, skillsDir);
+      return plan;
+    }
+    const canonicalPath = plan.canonicalPath;
+    if (!canonicalPath) {
+      throw new Error(`Missing canonical path for ${skillName}`);
+    }
+    await this.cleanAndCreateDirectory(canonicalPath);
+    await fs18.writeFile(join3(canonicalPath, "SKILL.md"), skillContent, "utf8");
+    if (plan.path === canonicalPath) {
+      return plan;
+    }
+    const symlinkCreated = await createRelativeSymlink(canonicalPath, plan.path);
+    if (!symlinkCreated) {
+      await this.installSkillFromContent(skillName, skillContent, skillsDir);
+      return {
+        ...plan,
+        symlinkFailed: true
+      };
+    }
+    return plan;
+  }
   normalizeSkillName(skillName) {
     const normalized = skillName.trim();
     if (!normalized) {
@@ -37473,9 +37639,9 @@ class SkillsManager {
     return normalized;
   }
   resolveInstallPath(targetDir, skillName) {
-    const resolvedTargetDir = resolve6(targetDir);
-    const destPath = resolve6(resolvedTargetDir, skillName);
-    const relativePath = relative(resolvedTargetDir, destPath);
+    const resolvedTargetDir = resolve7(targetDir);
+    const destPath = resolve7(resolvedTargetDir, skillName);
+    const relativePath = relative2(resolvedTargetDir, destPath);
     if (relativePath === "" || relativePath.startsWith("..") || relativePath.includes("/../") || relativePath.includes("\\..\\")) {
       throw new Error(`Refusing to install skill outside target directory: ${skillName}`);
     }
@@ -37484,18 +37650,17 @@ class SkillsManager {
   getInstallPath(skillName, targetDir) {
     return this.resolveInstallPath(targetDir, this.normalizeSkillName(skillName));
   }
+  async cleanAndCreateDirectory(path) {
+    await fs18.rm(path, { recursive: true, force: true }).catch(() => {
+    });
+    await fs18.mkdir(path, { recursive: true });
+  }
+  isWithinPath(basePath, targetPath) {
+    const relativePath = relative2(resolve7(basePath), resolve7(targetPath));
+    return relativePath === "" || !relativePath.startsWith("..") && !relativePath.includes("/../") && !relativePath.includes("\\..\\");
+  }
   async copyDir(src, dest) {
-    await fs18.mkdir(dest, { recursive: true });
-    const entries = await fs18.readdir(src, { withFileTypes: true });
-    for (const entry of entries) {
-      const srcPath = join3(src, entry.name);
-      const destPath = join3(dest, entry.name);
-      if (entry.isDirectory()) {
-        await this.copyDir(srcPath, destPath);
-      } else {
-        await fs18.copyFile(srcPath, destPath);
-      }
-    }
+    await fs18.cp(src, dest, { recursive: true, dereference: true });
   }
   async addFromSource(source, projectPath, options2 = {}) {
     const resolved = this.resolveSource(source);
@@ -37507,7 +37672,7 @@ class SkillsManager {
       tempDir = await this.cloneRepo(resolved.url);
       repoPath = tempDir;
     } else {
-      repoPath = resolve6(resolved.path || source);
+      repoPath = resolve7(resolved.path || source);
       if (!await fileExists(repoPath)) {
         throw new Error(`Local path not found: ${repoPath}`);
       }
@@ -37529,7 +37694,7 @@ class SkillsManager {
         };
       }
       const result = { installed: [], skipped: [] };
-      const dirToAgents = new Map;
+      const installableAgents = [];
       for (const agent of agents) {
         if (!agent.supportsSkills()) {
           for (const skill of skills) {
@@ -37544,18 +37709,17 @@ class SkillsManager {
           }
           continue;
         }
-        const existing = dirToAgents.get(skillsDir) || [];
-        existing.push(agent);
-        dirToAgents.set(skillsDir, existing);
+        installableAgents.push(agent);
       }
       for (const skill of skills) {
-        for (const [skillsDir, dirAgents] of dirToAgents) {
+        for (const agent of installableAgents) {
           try {
-            const shouldCopy = options2.copy || resolved.type === "github";
-            const installedPath = await this.installSkill(skill.path, skill.name, skillsDir, shouldCopy);
-            for (const agent of dirAgents) {
-              result.installed.push({ skill, agent: agent.id, path: installedPath });
-            }
+            const installOptions = {
+              ...options2.global !== undefined ? { global: options2.global } : {},
+              ...options2.copy !== undefined ? { copy: options2.copy } : {}
+            };
+            const installed = await this.installSkillForAgent(skill.path, skill.name, agent, projectPath, installOptions);
+            result.installed.push({ skill, agent: agent.id, ...installed });
           } catch (error) {
             result.skipped.push({ skill, reason: error.message });
           }
@@ -37571,6 +37735,9 @@ class SkillsManager {
   }
   async listInstalled(projectPath, options2 = {}) {
     const agents = await this.getTargetAgents(projectPath, options2);
+    return this.listInstalledForAgents(projectPath, agents, options2);
+  }
+  async listInstalledForAgents(projectPath, agents, options2 = {}) {
     const installed = [];
     for (const agent of agents) {
       if (!agent.supportsSkills())
@@ -37597,9 +37764,17 @@ class SkillsManager {
           if (!parsed)
             continue;
           let isSymlink = false;
+          let canonicalPath;
           try {
             const stat = await fs18.lstat(entryPath);
             isSymlink = stat.isSymbolicLink();
+            const canonicalBase = this.getCanonicalSkillsDir(projectPath, scope === "global");
+            const resolvedEntryPath = await resolveRealPathOrSelf(entryPath);
+            if (this.isWithinPath(canonicalBase, resolvedEntryPath)) {
+              canonicalPath = resolvedEntryPath;
+            } else if (this.isWithinPath(canonicalBase, entryPath)) {
+              canonicalPath = resolve7(entryPath);
+            }
           } catch {
           }
           installed.push({
@@ -37608,7 +37783,9 @@ class SkillsManager {
             path: entryPath,
             agent: agent.id,
             scope,
-            isSymlink
+            isSymlink,
+            mode: canonicalPath ? "symlink" : "copy",
+            ...canonicalPath ? { canonicalPath } : {}
           });
         }
       }
@@ -37617,42 +37794,60 @@ class SkillsManager {
   }
   async remove(skillNames, projectPath, options2 = {}) {
     const agents = await this.getTargetAgents(projectPath, options2);
+    const allAgents = this.agentManager.getAllAgents().filter((agent) => agent.supportsSkills());
     const removed = [];
     const notFound = [];
+    const skipped = [];
     const namesLower = new Set(skillNames.map((n) => n.toLowerCase()));
-    for (const agent of agents) {
-      if (!agent.supportsSkills())
-        continue;
-      const scopes = [];
-      if (!options2.global) {
-        scopes.push({ scope: "project", dir: agent.getSkillsDir(projectPath, false) });
-      }
-      if (options2.global) {
-        scopes.push({ scope: "global", dir: agent.getSkillsDir(projectPath, true) });
+    const targetAgentIds = new Set(agents.map((agent) => agent.id));
+    const installed = await this.listInstalledForAgents(projectPath, allAgents, options2);
+    const scopedInstalled = installed.filter((entry) => options2.global ? entry.scope === "global" : entry.scope === "project");
+    const targetedEntries = scopedInstalled.filter((entry) => targetAgentIds.has(entry.agent) && namesLower.has(entry.name.toLowerCase()));
+    const targetedKeys = new Set(targetedEntries.map((entry) => `${entry.agent}:${entry.scope}:${entry.path}:${entry.name}`));
+    const remainingEntries = installed.filter((entry) => !targetedKeys.has(`${entry.agent}:${entry.scope}:${entry.path}:${entry.name}`));
+    const removedPaths = new Set;
+    const removedCanonicalPaths = new Set;
+    for (const entry of targetedEntries) {
+      const removedEntry = `${entry.agent}:${entry.name}`;
+      if (entry.canonicalPath && entry.path === entry.canonicalPath) {
+        const stillReferenced = remainingEntries.some((other) => other.name.toLowerCase() === entry.name.toLowerCase() && other.canonicalPath === entry.canonicalPath);
+        if (stillReferenced) {
+          skipped.push({
+            name: entry.name,
+            reason: `Shared canonical path still used by another agent: ${entry.canonicalPath}`
+          });
+          continue;
+        }
       }
-      for (const { dir } of scopes) {
-        if (!dir || !await fileExists(dir))
+      if (!removedPaths.has(entry.path)) {
+        try {
+          await fs18.rm(entry.path, { recursive: true, force: true });
+          removedPaths.add(entry.path);
+        } catch {
+          skipped.push({
+            name: entry.name,
+            reason: `Could not remove skill path: ${entry.path}`
+          });
           continue;
-        const entries = await listFiles(dir);
-        for (const entry of entries) {
-          if (!namesLower.has(entry.toLowerCase()))
-            continue;
-          const entryPath = join3(dir, entry);
-          try {
-            await fs18.rm(entryPath, { recursive: true, force: true });
-            removed.push(`${agent.id}:${entry}`);
-          } catch {
-          }
         }
       }
+      if (entry.canonicalPath && entry.canonicalPath !== entry.path && !removedCanonicalPaths.has(entry.canonicalPath)) {
+        const stillReferenced = remainingEntries.some((other) => other.name.toLowerCase() === entry.name.toLowerCase() && other.canonicalPath === entry.canonicalPath);
+        if (!stillReferenced) {
+          await fs18.rm(entry.canonicalPath, { recursive: true, force: true }).catch(() => {
+          });
+          removedCanonicalPaths.add(entry.canonicalPath);
+        }
+      }
+      removed.push(removedEntry);
     }
-    const removedNames = new Set(removed.map((r) => r.split(":")[1]?.toLowerCase()));
+    const foundNames = new Set(targetedEntries.map((entry) => entry.name.toLowerCase()));
     for (const name of skillNames) {
-      if (!removedNames.has(name.toLowerCase())) {
+      if (!foundNames.has(name.toLowerCase())) {
         notFound.push(name);
       }
     }
-    return { removed, notFound };
+    return { removed, notFound, skipped };
   }
 }
 
@@ -37723,11 +37918,12 @@ async function detectCommand(options2) {
 }
 
 // dist/commands/sync.js
-import {relative as relative3} from "path";
+import {relative as relative4} from "path";
 
 // dist/core/propagator.js
 var import_gray_matter2 = __toESM(require_gray_matter(), 1);
-import {resolve as resolve7} from "path";
+import {promises as fs20} from "fs";
+import {resolve as resolve8} from "path";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
 var isNothing = function(subject) {
@@ -40356,6 +40552,9 @@ var parseTargets = function(value) {
   }
   return [];
 };
+var parseRulesAlias = function(value) {
+  return typeof value === "string" && value.trim().toLowerCase() === "agents" ? "agents" : null;
+};
 
 class Propagator {
   agentAdapters = new Map;
@@ -40367,9 +40566,10 @@ class Propagator {
       success: true,
       changes: [],
       errors: [],
+      warnings: [],
       resolvedTargets: []
     };
-    const agentsPath = resolve7(projectPath, "agents.md");
+    const agentsPath = resolve8(projectPath, "agents.md");
     if (!await fileExists(agentsPath)) {
       result.success = false;
       result.errors.push("agents.md not found. Run `agentinit init` first.");
@@ -40384,12 +40584,14 @@ class Propagator {
       }
       const parsed = import_gray_matter2.default(agentsContent);
       const targets = await this.resolveTargets(projectPath, options2.targets, parsed.data.targets);
+      const rulesAlias = parseRulesAlias(parsed.data.rules_alias);
       result.resolvedTargets = targets;
-      const generatedFiles = await this.buildGeneratedFiles(projectPath, parsed.content, targets);
+      const generatedFiles = await this.buildGeneratedFiles(projectPath, parsed.content, targets, rulesAlias);
       for (const generatedFile of generatedFiles) {
         try {
           const syncResult = await this.writeGeneratedFile(projectPath, generatedFile, options2);
           result.changes.push(...syncResult.changes);
+          result.warnings.push(...syncResult.warnings);
           if (!syncResult.success) {
             result.errors.push(...syncResult.errors);
           }
@@ -40421,51 +40623,86 @@ class Propagator {
     }
     return this.getDefaultTargets();
   }
-  async buildGeneratedFiles(projectPath, content, targets) {
+  async buildGeneratedFiles(projectPath, content, targets, rulesAlias) {
     const generatedFiles = new Map;
+    if (rulesAlias === "agents" && targets.includes("claude")) {
+      this.mergeGeneratedFile(projectPath, generatedFiles, {
+        path: "AGENTS.md",
+        kind: "file",
+        content
+      }, "claude");
+      this.mergeGeneratedFile(projectPath, generatedFiles, {
+        path: "CLAUDE.md",
+        kind: "symlink",
+        target: "AGENTS.md",
+        content
+      }, "claude");
+    }
     for (const target of targets) {
+      if (target === "claude" && rulesAlias === "agents") {
+        continue;
+      }
       const adapter = this.agentAdapters.get(target);
       if (!adapter) {
         throw new Error(`No adapter found for agent: ${target}`);
       }
       const outputs = await adapter.buildOutputs(projectPath, content);
       for (const output of outputs) {
-        const outputPath = resolve7(projectPath, output.path);
-        const existing = generatedFiles.get(outputPath);
-        if (existing) {
-          if (existing.content !== output.content) {
-            throw new Error(`Conflicting generated content for ${output.path}`);
-          }
-          existing.agents.push(target);
-          continue;
-        }
-        generatedFiles.set(outputPath, {
-          path: outputPath,
-          content: normalizeContent(output.content),
-          agents: [target],
-          ignorePath: output.ignorePath ?? output.path
-        });
+        this.mergeGeneratedFile(projectPath, generatedFiles, output, target);
       }
     }
     return [...generatedFiles.values()];
   }
+  mergeGeneratedFile(projectPath, generatedFiles, output, agentId) {
+    const outputPath = resolve8(projectPath, output.path);
+    const nextKind = output.kind ?? "file";
+    const nextContent = nextKind === "file" || output.content !== undefined ? normalizeContent(output.content || "") : undefined;
+    const existing = generatedFiles.get(outputPath);
+    if (existing) {
+      if (existing.kind !== nextKind) {
+        throw new Error(`Conflicting generated output type for ${output.path}`);
+      }
+      if (existing.target !== output.target) {
+        throw new Error(`Conflicting generated symlink target for ${output.path}`);
+      }
+      if (existing.content !== nextContent) {
+        throw new Error(`Conflicting generated content for ${output.path}`);
+      }
+      existing.agents.push(agentId);
+      return;
+    }
+    generatedFiles.set(outputPath, {
+      path: outputPath,
+      kind: nextKind,
+      agents: [agentId],
+      ignorePath: output.ignorePath ?? output.path,
+      ...nextContent !== undefined ? { content: nextContent } : {},
+      ...output.target !== undefined ? { target: output.target } : {}
+    });
+  }
   async writeGeneratedFile(projectPath, generatedFile, options2) {
     const result = {
       success: true,
       changes: [],
       errors: [],
+      warnings: [],
       resolvedTargets: []
     };
     const exists = await fileExists(generatedFile.path);
-    const existingContent = exists ? await readFileIfExists(generatedFile.path) : null;
+    const existingStats = exists ? await fs20.lstat(generatedFile.path).catch(() => null) : null;
+    const existingContent = exists && !existingStats?.isSymbolicLink() ? await readFileIfExists(generatedFile.path) : null;
+    const existingTarget = existingStats?.isSymbolicLink() ? await readSymlinkTarget(generatedFile.path) : null;
     if (options2.managedState && !options2.dryRun) {
       await options2.managedState.trackGeneratedPath(generatedFile.path, {
         kind: "file",
         source: "sync",
-        ignorePath: resolve7(projectPath, generatedFile.ignorePath)
+        ignorePath: resolve8(projectPath, generatedFile.ignorePath)
       });
     }
-    if (exists && existingContent === generatedFile.content) {
+    if (generatedFile.kind === "file" && exists && !existingStats?.isSymbolicLink() && existingContent === generatedFile.content) {
+      return result;
+    }
+    if (generatedFile.kind === "symlink" && exists && existingStats?.isSymbolicLink() && existingTarget === generatedFile.target) {
       return result;
     }
     if (options2.backup && exists) {
@@ -40481,7 +40718,19 @@ class Propagator {
       });
     }
     if (!options2.dryRun) {
-      await writeFile(generatedFile.path, generatedFile.content);
+      if (generatedFile.kind === "file") {
+        if (existingStats?.isSymbolicLink()) {
+          await fs20.rm(generatedFile.path, { force: true }).catch(() => {
+          });
+        }
+        await writeFile(generatedFile.path, generatedFile.content || "");
+      } else {
+        const symlinkCreated = await createRelativeSymlink(resolve8(projectPath, generatedFile.target || ""), generatedFile.path);
+        if (!symlinkCreated) {
+          await writeFile(generatedFile.path, generatedFile.content || "");
+          result.warnings.push(`Could not create symlink for ${generatedFile.path}; wrote a copied file instead.`);
+        }
+      }
     }
     result.changes.push({
       agent: generatedFile.agents.join(", "),
@@ -40581,7 +40830,7 @@ class Propagator {
     });
   }
   async buildAiderConfig(projectPath) {
-    const configPath = resolve7(projectPath, ".aider.conf.yml");
+    const configPath = resolve8(projectPath, ".aider.conf.yml");
     const existingContent = await readFileIfExists(configPath);
     let document = {};
     if (existingContent) {
@@ -40647,30 +40896,37 @@ ${content}
 }
 
 // dist/core/managedState.js
-import {promises as fs21} from "fs";
-import {dirname as dirname2, join as join4, relative as relative2, resolve as resolve8} from "path";
+import {promises as fs22} from "fs";
+import {dirname as dirname2, join as join4, relative as relative3, resolve as resolve9} from "path";
 var toPosixPath = function(value) {
   return value.replace(/\\/g, "/");
 };
 async function pathType(targetPath) {
   try {
-    const stat = await fs21.stat(targetPath);
+    const stat = await fs22.lstat(targetPath);
+    if (stat.isSymbolicLink()) {
+      return "symlink";
+    }
     return stat.isDirectory() ? "directory" : "file";
   } catch {
     return null;
   }
 }
 async function copyDirectory(src, dest) {
-  await fs21.mkdir(dest, { recursive: true });
-  const entries = await fs21.readdir(src, { withFileTypes: true });
+  await fs22.mkdir(dest, { recursive: true });
+  const entries = await fs22.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = join4(src, entry.name);
     const destPath = join4(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory(srcPath, destPath);
+    } else if (entry.isSymbolicLink()) {
+      const target = await fs22.readlink(srcPath);
+      await fs22.mkdir(dirname2(destPath), { recursive: true });
+      await fs22.symlink(target, destPath);
     } else {
-      await fs21.mkdir(dirname2(destPath), { recursive: true });
-      await fs21.copyFile(srcPath, destPath);
+      await fs22.mkdir(dirname2(destPath), { recursive: true });
+      await fs22.copyFile(srcPath, destPath);
     }
   }
 }
@@ -40679,11 +40935,14 @@ async function copyPath(src, dest) {
   if (!type2) {
     return;
   }
-  await fs21.mkdir(dirname2(dest), { recursive: true });
-  if (type2 === "directory") {
+  await fs22.mkdir(dirname2(dest), { recursive: true });
+  if (type2 === "symlink") {
+    const target = await fs22.readlink(src);
+    await fs22.symlink(target, dest);
+  } else if (type2 === "directory") {
     await copyDirectory(src, dest);
   } else {
-    await fs21.copyFile(src, dest);
+    await fs22.copyFile(src, dest);
   }
 }
 var MANAGED_STATE_FILE = "managed-state.json";
@@ -40701,7 +40960,7 @@ class ManagedStateStore {
     const statePath = join4(agentInitDir, MANAGED_STATE_FILE);
     const emptyState = { version: 1, entries: [] };
     try {
-      const raw = await fs21.readFile(statePath, "utf8");
+      const raw = await fs22.readFile(statePath, "utf8");
       const parsed = JSON.parse(raw);
       if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.entries)) {
         return new ManagedStateStore(projectPath, emptyState);
@@ -40722,7 +40981,7 @@ class ManagedStateStore {
   }
   normalizeRelativePath(targetPath, preserveTrailingSlash = false) {
     const hasTrailingSlash = preserveTrailingSlash && /[\\/]$/.test(targetPath);
-    const relativePath = relative2(this.projectPath, resolve8(targetPath));
+    const relativePath = relative3(this.projectPath, resolve9(targetPath));
     const normalizedPath = toPosixPath(relativePath);
     if (hasTrailingSlash && normalizedPath) {
       return normalizedPath.endsWith("/") ? normalizedPath : `${normalizedPath}/`;
@@ -40734,15 +40993,24 @@ class ManagedStateStore {
     return this.state.entries.find((entry) => entry.path === relativePath);
   }
   async createBackup(targetPath) {
-    if (!await fileExists(targetPath)) {
-      return;
+    const type2 = await pathType(targetPath);
+    if (!type2) {
+      return {};
+    }
+    if (type2 === "symlink") {
+      try {
+        const backupLinkTarget = await fs22.readlink(targetPath);
+        return { backupLinkTarget };
+      } catch {
+        return {};
+      }
     }
     const relativeTargetPath = this.normalizeRelativePath(targetPath);
     const backupPath = join4(this.backupsDir, relativeTargetPath);
     if (!await fileExists(backupPath)) {
       await copyPath(targetPath, backupPath);
     }
-    return this.normalizeRelativePath(backupPath);
+    return { backupPath: this.normalizeRelativePath(backupPath) };
   }
   async trackGeneratedPath(targetPath, options2) {
     const existing = this.getEntry(targetPath);
@@ -40753,13 +41021,14 @@ class ManagedStateStore {
       return existing;
     }
     const existedBefore = await fileExists(targetPath);
-    const backupPath = existedBefore ? await this.createBackup(targetPath) : undefined;
+    const backup = existedBefore ? await this.createBackup(targetPath) : {};
     const entry = {
       path: this.normalizeRelativePath(targetPath),
       kind: options2.kind,
       source: options2.source,
       existedBefore,
-      ...backupPath ? { backupPath } : {},
+      ...backup.backupPath ? { backupPath: backup.backupPath } : {},
+      ...backup.backupLinkTarget ? { backupLinkTarget: backup.backupLinkTarget } : {},
       ...options2.ignorePath ? { ignorePath: this.normalizeRelativePath(options2.ignorePath, true) } : {}
     };
     this.state.entries.push(entry);
@@ -40784,8 +41053,8 @@ class ManagedStateStore {
     return [...paths2];
   }
   async save() {
-    await fs21.mkdir(this.agentInitDir, { recursive: true });
-    await fs21.writeFile(this.stateFilePath, JSON.stringify(this.state, null, 2), "utf8");
+    await fs22.mkdir(this.agentInitDir, { recursive: true });
+    await fs22.writeFile(this.stateFilePath, JSON.stringify(this.state, null, 2), "utf8");
   }
   async revertAll(options2 = {}) {
     const summary = {
@@ -40795,25 +41064,34 @@ class ManagedStateStore {
     };
     const entries = [...this.state.entries].sort((a, b) => b.path.length - a.path.length);
     for (const entry of entries) {
-      const absolutePath = resolve8(this.projectPath, entry.path);
-      const backupPath = entry.backupPath ? resolve8(this.projectPath, entry.backupPath) : null;
-      if (entry.existedBefore && backupPath && await fileExists(backupPath)) {
+      const absolutePath = resolve9(this.projectPath, entry.path);
+      const backupPath = entry.backupPath ? resolve9(this.projectPath, entry.backupPath) : null;
+      const backupLinkTarget = entry.backupLinkTarget;
+      if (entry.existedBefore && backupLinkTarget !== undefined) {
+        if (!options2.dryRun) {
+          await fs22.rm(absolutePath, { recursive: true, force: true }).catch(() => {
+          });
+          await fs22.mkdir(dirname2(absolutePath), { recursive: true });
+          await fs22.symlink(backupLinkTarget, absolutePath);
+        }
+        summary.restored++;
+      } else if (entry.existedBefore && backupPath && await fileExists(backupPath)) {
         if (!options2.dryRun) {
-          await fs21.rm(absolutePath, { recursive: true, force: true }).catch(() => {
+          await fs22.rm(absolutePath, { recursive: true, force: true }).catch(() => {
           });
           await copyPath(backupPath, absolutePath);
         }
         summary.restored++;
       } else {
         if (!options2.dryRun) {
-          await fs21.rm(absolutePath, { recursive: true, force: true }).catch(() => {
+          await fs22.rm(absolutePath, { recursive: true, force: true }).catch(() => {
           });
         }
         summary.removed++;
       }
       if (!options2.keepBackups && backupPath && await fileExists(backupPath)) {
         if (!options2.dryRun) {
-          await fs21.rm(backupPath, { recursive: true, force: true }).catch(() => {
+          await fs22.rm(backupPath, { recursive: true, force: true }).catch(() => {
           });
         }
         summary.backupsRemoved++;
@@ -40821,16 +41099,16 @@ class ManagedStateStore {
     }
     if (!options2.dryRun) {
       this.state.entries.length = 0;
-      await fs21.rm(this.stateFilePath, { force: true }).catch(() => {
+      await fs22.rm(this.stateFilePath, { force: true }).catch(() => {
       });
       if (!options2.keepBackups) {
-        await fs21.rm(this.backupsDir, { recursive: true, force: true }).catch(() => {
+        await fs22.rm(this.backupsDir, { recursive: true, force: true }).catch(() => {
         });
       }
       try {
-        const remainingEntries = await fs21.readdir(this.agentInitDir);
+        const remainingEntries = await fs22.readdir(this.agentInitDir);
         if (remainingEntries.length === 0) {
-          await fs21.rm(this.agentInitDir, { recursive: true, force: true });
+          await fs22.rm(this.agentInitDir, { recursive: true, force: true });
         }
       } catch {
       }
@@ -40869,6 +41147,9 @@ async function syncCommand(options2) {
     }
     if (result.success) {
       spinner.succeed("Synchronization complete");
+      if (result.warnings.length > 0) {
+        result.warnings.forEach((warning) => logger.warning(warning));
+      }
       if (result.changes.length === 0) {
         logger.info("No changes needed - all configurations are up to date");
       } else {
@@ -40876,7 +41157,7 @@ async function syncCommand(options2) {
         for (const change of result.changes) {
           const action = change.action === "created" ? "\u2795" : change.action === "updated" ? "\uD83D\uDCDD" : "\uD83D\uDCBE";
           const names = change.agents.map((id) => agentManager4.getAgentById(id)?.name || id).join(", ");
-          logger.info(`  ${action} ${relative3(cwd, change.file) || change.file}`);
+          logger.info(`  ${action} ${relative4(cwd, change.file) || change.file}`);
           logger.info(`     Agents: ${names}`);
         }
         if (options2.backup && result.changes.some((c) => c.action === "backed_up")) {
@@ -40888,6 +41169,9 @@ async function syncCommand(options2) {
       for (const error of result.errors) {
         logger.error(error);
       }
+      for (const warning of result.warnings) {
+        logger.warning(warning);
+      }
       if (result.changes.length > 0) {
         logger.warning("Partial sync completed. Some changes were applied:");
         for (const change of result.changes) {
@@ -40902,7 +41186,7 @@ async function syncCommand(options2) {
 }
 
 // dist/commands/apply.js
-import {relative as relative4} from "path";
+import {relative as relative5} from "path";
 
 // dist/types/index.js
 var MCPServerType;
@@ -41203,7 +41487,7 @@ import {readFileSync as readFileSync3} from "fs";
 
 // dist/core/rulesTemplateLoader.js
 var toml = __toESM(require_toml(), 1);
-import {resolve as resolve9, dirname as dirname4} from "path";
+import {resolve as resolve10, dirname as dirname4} from "path";
 import {fileURLToPath as fileURLToPath2} from "url";
 import {readFileSync as readFileSync2, readdirSync, existsSync} from "fs";
 var __filename2 = fileURLToPath2(import.meta.url);
@@ -41213,7 +41497,7 @@ class RulesTemplateLoader {
   templatesPath;
   templates = new Map;
   constructor() {
-    this.templatesPath = resolve9(__dirname2, "../templates/rules");
+    this.templatesPath = resolve10(__dirname2, "../templates/rules");
     this.loadTemplates();
   }
   loadTemplates() {
@@ -41223,7 +41507,7 @@ class RulesTemplateLoader {
     const files = readdirSync(this.templatesPath).filter((file) => file.endsWith(".toml"));
     for (const file of files) {
       try {
-        const filePath = resolve9(this.templatesPath, file);
+        const filePath = resolve10(this.templatesPath, file);
         const content = readFileSync2(filePath, "utf-8");
         const parsed = toml.default.parse(content);
         const template = {
@@ -46883,7 +47167,7 @@ class Protocol {
   }
   request(request, resultSchema, options2) {
     const { relatedRequestId, resumptionToken, onresumptiontoken } = options2 !== null && options2 !== undefined ? options2 : {};
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve11, reject) => {
       var _a, _b, _c, _d, _e, _f;
       if (!this._transport) {
         reject(new Error("Not connected"));
@@ -46934,7 +47218,7 @@ class Protocol {
         }
         try {
           const result = resultSchema.parse(response.result);
-          resolve10(result);
+          resolve11(result);
         } catch (error) {
           reject(error);
         }
@@ -47314,7 +47598,7 @@ class StdioClientTransport {
     if (this._process) {
       throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
     }
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve11, reject) => {
       var _a, _b, _c, _d, _e;
       this._process = import_cross_spawn.default(this._serverParams.command, (_a = this._serverParams.args) !== null && _a !== undefined ? _a : [], {
         env: {
@@ -47337,7 +47621,7 @@ class StdioClientTransport {
         (_b2 = this.onerror) === null || _b2 === undefined || _b2.call(this, error);
       });
       this._process.on("spawn", () => {
-        resolve10();
+        resolve11();
       });
       this._process.on("close", (_code) => {
         var _a2;
@@ -47392,16 +47676,16 @@ class StdioClientTransport {
     this._readBuffer.clear();
   }
   send(message) {
-    return new Promise((resolve10) => {
+    return new Promise((resolve11) => {
       var _a;
       if (!((_a = this._process) === null || _a === undefined ? undefined : _a.stdin)) {
         throw new Error("Not connected");
       }
       const json2 = serializeMessage(message);
       if (this._process.stdin.write(json2)) {
-        resolve10();
+        resolve11();
       } else {
-        this._process.stdin.once("drain", resolve10);
+        this._process.stdin.once("drain", resolve11);
       }
     });
   }
@@ -48823,7 +49107,7 @@ class SSEClientTransport {
   _startOrAuth() {
     var _a, _b, _c;
     const fetchImpl = (_c = (_b = (_a = this === null || this === undefined ? undefined : this._eventSourceInit) === null || _a === undefined ? undefined : _a.fetch) !== null && _b !== undefined ? _b : this._fetch) !== null && _c !== undefined ? _c : fetch;
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve11, reject) => {
       this._eventSource = new EventSource(this._url.href, {
         ...this._eventSourceInit,
         fetch: async (url, init2) => {
@@ -48843,7 +49127,7 @@ class SSEClientTransport {
       this._eventSource.onerror = (event) => {
         var _a2;
         if (event.code === 401 && this._authProvider) {
-          this._authThenStart().then(resolve10, reject);
+          this._authThenStart().then(resolve11, reject);
           return;
         }
         const error = new SseError(event.code, event.message, event);
@@ -48866,7 +49150,7 @@ class SSEClientTransport {
           this.close();
           return;
         }
-        resolve10();
+        resolve11();
       });
       this._eventSource.onmessage = (event) => {
         var _a2, _b2;
@@ -49527,11 +49811,11 @@ class MCPVerifier {
 }
 
 // dist/core/gitignoreManager.js
-import {promises as fs24} from "fs";
+import {promises as fs25} from "fs";
 import {dirname as dirname5, join as join6} from "path";
 var normalizeIgnorePath = function(projectPath, value) {
-  const relative4 = value.startsWith(projectPath) ? value.slice(projectPath.length + 1) : value;
-  const normalized = relative4.replace(/\\/g, "/").replace(/^\/+/, "");
+  const relative5 = value.startsWith(projectPath) ? value.slice(projectPath.length + 1) : value;
+  const normalized = relative5.replace(/\\/g, "/").replace(/^\/+/, "");
   if (!normalized) {
     return normalized;
   }
@@ -49580,7 +49864,7 @@ async function updateManagedIgnoreFile(projectPath, paths2, options2 = {}) {
   if (options2.local) {
     const gitDir = join6(projectPath, ".git");
     try {
-      const stat = await fs24.stat(gitDir);
+      const stat = await fs25.stat(gitDir);
       if (!stat.isDirectory()) {
         throw new Error;
       }
@@ -49591,13 +49875,13 @@ async function updateManagedIgnoreFile(projectPath, paths2, options2 = {}) {
   const normalizedPaths = [...new Set(paths2.map((path) => normalizeIgnorePath(projectPath, path)).filter(Boolean))].sort();
   let existingContent = "";
   try {
-    existingContent = await fs24.readFile(ignoreFilePath, "utf8");
+    existingContent = await fs25.readFile(ignoreFilePath, "utf8");
   } catch {
     existingContent = "";
   }
   const updatedContent = updateManagedBlock(existingContent, normalizedPaths);
-  await fs24.mkdir(dirname5(ignoreFilePath), { recursive: true });
-  await fs24.writeFile(ignoreFilePath, updatedContent, "utf8");
+  await fs25.mkdir(dirname5(ignoreFilePath), { recursive: true });
+  await fs25.writeFile(ignoreFilePath, updatedContent, "utf8");
   return ignoreFilePath;
 }
 async function removeManagedIgnoreBlock(projectPath, options2 = {}) {
@@ -49605,7 +49889,7 @@ async function removeManagedIgnoreBlock(projectPath, options2 = {}) {
   const ignoreFilePath = join6(projectPath, ignoreFile);
   let content;
   try {
-    content = await fs24.readFile(ignoreFilePath, "utf8");
+    content = await fs25.readFile(ignoreFilePath, "utf8");
   } catch {
     return false;
   }
@@ -49621,13 +49905,13 @@ async function removeManagedIgnoreBlock(projectPath, options2 = {}) {
   const afterBlock = content.slice(endIndex + END_MARKER.length).replace(/^\n+/, "");
   let nextContent = `${beforeBlock}${afterBlock}`.replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "");
   if (nextContent.trim() === "") {
-    await fs24.rm(ignoreFilePath, { force: true }).catch(() => {
+    await fs25.rm(ignoreFilePath, { force: true }).catch(() => {
     });
   } else {
     if (!nextContent.endsWith("\n")) {
       nextContent += "\n";
     }
-    await fs24.writeFile(ignoreFilePath, nextContent, "utf8");
+    await fs25.writeFile(ignoreFilePath, nextContent, "utf8");
   }
   return true;
 }
@@ -49635,7 +49919,7 @@ var START_MARKER = "# START AgentInit Generated Files";
 var END_MARKER = "# END AgentInit Generated Files";
 
 // dist/core/projectSkills.js
-import {join as join7} from "path";
+import {dirname as dirname6, join as join7} from "path";
 async function discoverProjectSkills(projectPath, skillsManager3) {
   const sources = [];
   const skills = new Map;
@@ -49681,7 +49965,6 @@ async function applyProjectSkills(projectPath, targetAgentIds, managedState2, op
       skipped: skills.map((skill) => ({ skill, reason: "No target agents found" }))
     };
   }
-  const dirToAgents = new Map;
   for (const agent of targetAgents) {
     if (!agent.supportsSkills()) {
       for (const skill of skills) {
@@ -49696,25 +49979,30 @@ async function applyProjectSkills(projectPath, targetAgentIds, managedState2, op
       }
       continue;
     }
-    const existing = dirToAgents.get(skillsDir) || [];
-    existing.push(agent);
-    dirToAgents.set(skillsDir, existing);
   }
-  for (const [skillsDir, dirAgents] of dirToAgents) {
+  for (const agent of targetAgents) {
+    if (!agent.supportsSkills())
+      continue;
+    if (!agent.getSkillsDir(projectPath, false))
+      continue;
     for (const skill of skills) {
       try {
-        const installPath = skillsManager3.getInstallPath(skill.name, skillsDir);
+        const installOptions = {
+          ...options2.copy !== undefined ? { copy: options2.copy } : {}
+        };
+        const installPlan = await skillsManager3.getInstallPlan(skill.name, agent, projectPath, installOptions);
         if (!options2.dryRun) {
-          await managedState2.trackGeneratedPath(installPath, {
-            kind: "directory",
-            source: "skills",
-            ignorePath: `${skillsDir}/`
-          });
-        }
-        const installedPath = options2.dryRun ? installPath : await skillsManager3.installSkill(skill.path, skill.name, skillsDir, true);
-        for (const agent of dirAgents) {
-          installed.push({ skill, agent: agent.id, path: installedPath });
+          const generatedPaths = new Set([installPlan.path, installPlan.canonicalPath].filter((value) => !!value));
+          for (const generatedPath of generatedPaths) {
+            await managedState2.trackGeneratedPath(generatedPath, {
+              kind: "directory",
+              source: "skills",
+              ignorePath: `${dirname6(generatedPath)}/`
+            });
+          }
         }
+        const installResult = options2.dryRun ? installPlan : await skillsManager3.installSkillForAgent(skill.path, skill.name, agent, projectPath, installOptions);
+        installed.push({ skill, agent: agent.id, ...installResult });
       } catch (error) {
         skipped.push({ skill, reason: error.message });
       }
@@ -49781,10 +50069,14 @@ async function applyProjectCommand(options2) {
       }
       spinner.fail("Apply failed");
       syncResult.errors.forEach((error) => logger.error(error));
+      syncResult.warnings.forEach((warning) => logger.warning(warning));
       return;
     }
     const skillsEnabled = options2.skills !== false;
-    const projectSkills2 = skillsEnabled ? await applyProjectSkills(cwd, syncResult.resolvedTargets, managedState3, options2.dryRun !== undefined ? { dryRun: options2.dryRun } : {}) : {
+    const projectSkills2 = skillsEnabled ? await applyProjectSkills(cwd, syncResult.resolvedTargets, managedState3, {
+      ...options2.dryRun !== undefined ? { dryRun: options2.dryRun } : {},
+      ...options2.copySkills !== undefined ? { copy: options2.copySkills } : {}
+    }) : {
       discovered: 0,
       sources: [],
       installed: [],
@@ -49804,6 +50096,9 @@ async function applyProjectCommand(options2) {
       await managedState3.save();
     }
     spinner.succeed("Apply complete");
+    if (syncResult.warnings.length > 0) {
+      syncResult.warnings.forEach((warning) => logger.warning(warning));
+    }
     if (syncResult.changes.length === 0 && projectSkills2.installed.length === 0) {
       logger.info("No changes needed - generated files are already up to date");
     } else {
@@ -49813,7 +50108,7 @@ async function applyProjectCommand(options2) {
           if (change.action === "backed_up")
             return;
           const names = change.agents.map((id) => agentManager6.getAgentById(id)?.name || id).join(", ");
-          logger.info(`  ${relative4(cwd, change.file) || change.file}`);
+          logger.info(`  ${relative5(cwd, change.file) || change.file}`);
           logger.info(`    Agents: ${names}`);
         });
       }
@@ -49831,7 +50126,7 @@ async function applyProjectCommand(options2) {
           installsByPath.set(item.path, existing);
         }
         for (const [path, details] of installsByPath) {
-          logger.info(`  ${relative4(cwd, path) || path}`);
+          logger.info(`  ${relative5(cwd, path) || path}`);
           logger.info(`    Agents: ${[...details.agents].join(", ")}`);
           logger.info(`    Skills: ${[...details.skills].join(", ")}`);
         }
@@ -50521,7 +50816,7 @@ async function revertCommand(options2) {
 }
 
 // dist/commands/skills.js
-import {relative as relative5} from "path";
+import {relative as relative6} from "path";
 function registerSkillsCommand(program2) {
   const skills = program2.command("skills").description("Manage agent skills");
   skills.command("add <source>").description("Add skills from a GitHub repo or local path").option("-g, --global", "Install skills globally").option("-a, --agent <agents...>", "Target specific agent(s)").option("-s, --skill <names...>", "Install only specific skills by name").option("-l, --list", "List available skills from the source without installing").option("--copy", "Copy skill files instead of symlinking").option("-y, --yes", "Skip confirmation prompts").action(async (source, options2) => {
@@ -50559,8 +50854,8 @@ function registerSkillsCommand(program2) {
           logger.info(`  ${green(name)}  ${skill.description}`);
         }
         if (tempDir) {
-          const { promises: fs27 } = await import("fs");
-          await fs27.rm(tempDir, { recursive: true, force: true }).catch(() => {
+          const { promises: fs28 } = await import("fs");
+          await fs28.rm(tempDir, { recursive: true, force: true }).catch(() => {
           });
         }
       } catch (error) {
@@ -50596,7 +50891,7 @@ function registerSkillsCommand(program2) {
         byPath.set(path, existing);
       }
       for (const [path, details] of byPath) {
-        logger.info(`  ${relative5(process.cwd(), path) || path}`);
+        logger.info(`  ${relative6(process.cwd(), path) || path}`);
         logger.info(`    Agents: ${[...details.agents].join(", ")}`);
         logger.info(`    Skills: ${green(String(details.skills.size))} installed (${[...details.skills].join(", ")})`);
       }
@@ -50625,19 +50920,32 @@ function registerSkillsCommand(program2) {
       logger.info("No skills installed.");
       return;
     }
-    const byAgent = new Map;
+    const bySkill = new Map;
     for (const skill of installed) {
-      const list = byAgent.get(skill.agent) || [];
-      list.push(skill);
-      byAgent.set(skill.agent, list);
-    }
-    for (const [agent, agentSkills] of byAgent) {
-      logger.info(`\n  ${green(agent)}`);
-      for (const skill of agentSkills) {
-        const symlink = skill.isSymlink ? " (symlink)" : "";
-        const scope = skill.scope === "global" ? " [global]" : "";
-        logger.info(`    ${green(skill.name)} - ${skill.description}${scope}${symlink}`);
+      const canonicalPath = skill.canonicalPath || skill.path;
+      const key = `${skill.scope}:${canonicalPath}`;
+      const existing = bySkill.get(key) || {
+        name: skill.name,
+        description: skill.description,
+        path: canonicalPath,
+        scope: skill.scope,
+        mode: skill.mode,
+        isSymlink: skill.isSymlink,
+        agents: new Set
+      };
+      existing.isSymlink = existing.isSymlink || skill.isSymlink;
+      if (skill.mode === "symlink") {
+        existing.mode = "symlink";
       }
+      existing.agents.add(agentManager8.getAgentById(skill.agent)?.name || skill.agent);
+      bySkill.set(key, existing);
+    }
+    for (const skill of bySkill.values()) {
+      const mode = skill.mode === "symlink" ? " (canonical)" : "";
+      const scope = skill.scope === "global" ? " [global]" : "";
+      logger.info(`\n  ${green(skill.name)} - ${skill.description}${scope}${mode}`);
+      logger.info(`    Path: ${relative6(process.cwd(), skill.path) || skill.path}`);
+      logger.info(`    Agents: ${[...skill.agents].join(", ")}`);
     }
   });
   skills.command("remove [names...]").alias("rm").description("Remove installed skills by name").option("-g, --global", "Remove from global scope").option("-a, --agent <agents...>", "Target specific agent(s)").option("-y, --yes", "Skip confirmation prompts").action(async (names, options2) => {
@@ -50665,7 +50973,13 @@ function registerSkillsCommand(program2) {
     if (result.notFound.length > 0) {
       logger.warn(`Not found: ${result.notFound.join(", ")}`);
     }
-    if (result.removed.length === 0 && result.notFound.length === 0) {
+    if (result.skipped.length > 0) {
+      logger.warn(`Skipped: ${result.skipped.length}`);
+      for (const entry of result.skipped) {
+        logger.info(`  ${entry.name}: ${entry.reason}`);
+      }
+    }
+    if (result.removed.length === 0 && result.notFound.length === 0 && result.skipped.length === 0) {
       logger.info("Nothing to remove.");
     }
   });
@@ -51458,15 +51772,15 @@ function registerRulesCommand(program2) {
 
 // dist/core/pluginManager.js
 var import_gray_matter3 = __toESM(require_gray_matter(), 1);
-import {resolve as resolve10, join as join8, basename} from "path";
-import {promises as fs28} from "fs";
-import {homedir as homedir3} from "os";
+import {resolve as resolve11, join as join8, basename as basename2} from "path";
+import {promises as fs29} from "fs";
+import {homedir as homedir4} from "os";
 var getMarketplaceCacheDir = function(registryId) {
-  return join8(homedir3(), ".agentinit", "marketplace-cache", registryId);
+  return join8(homedir4(), ".agentinit", "marketplace-cache", registryId);
 };
 var getRegistryPath = function(projectPath, global3) {
   if (global3) {
-    return join8(homedir3(), ".agentinit", "plugins.json");
+    return join8(homedir4(), ".agentinit", "plugins.json");
   }
   return join8(projectPath, ".agentinit", "plugins.json");
 };
@@ -51551,7 +51865,7 @@ class PluginManager {
     const cacheMetaPath = join8(cacheDir, ".agentinit-cache-meta.json");
     if (await fileExists(cacheMetaPath)) {
       try {
-        const meta = JSON.parse(await fs28.readFile(cacheMetaPath, "utf8"));
+        const meta = JSON.parse(await fs29.readFile(cacheMetaPath, "utf8"));
         const age = Date.now() - (meta.fetchedAt || 0);
         if (age < registry.cacheTtlMs) {
           return cacheDir;
@@ -51566,22 +51880,22 @@ class PluginManager {
       try {
         await exec("git", ["pull", "--ff-only"], { cwd: cacheDir, timeout: 30000 });
       } catch {
-        await fs28.rm(cacheDir, { recursive: true, force: true });
+        await fs29.rm(cacheDir, { recursive: true, force: true });
         await this.cloneMarketplace(registry.repoUrl, cacheDir);
       }
     } else {
       await this.cloneMarketplace(registry.repoUrl, cacheDir);
     }
-    await fs28.mkdir(cacheDir, { recursive: true });
-    await fs28.writeFile(cacheMetaPath, JSON.stringify({ fetchedAt: Date.now() }));
+    await fs29.mkdir(cacheDir, { recursive: true });
+    await fs29.writeFile(cacheMetaPath, JSON.stringify({ fetchedAt: Date.now() }));
     return cacheDir;
   }
   async cloneMarketplace(repoUrl, dest) {
-    await fs28.mkdir(dest, { recursive: true });
+    await fs29.mkdir(dest, { recursive: true });
     const { execFile: execFile2 } = await import("child_process");
     const { promisify: promisify2 } = await import("util");
     const exec = promisify2(execFile2);
-    await fs28.rm(dest, { recursive: true, force: true }).catch(() => {
+    await fs29.rm(dest, { recursive: true, force: true }).catch(() => {
     });
     await exec("git", ["clone", "--depth", "1", repoUrl, dest], { timeout: 60000 });
   }
@@ -51630,7 +51944,7 @@ class PluginManager {
         let version = "0.0.0";
         if (await fileExists(manifestPath)) {
           try {
-            const manifest = JSON.parse(await fs28.readFile(manifestPath, "utf8"));
+            const manifest = JSON.parse(await fs29.readFile(manifestPath, "utf8"));
             name = manifest.name || entry;
             description = manifest.description || "";
             version = manifest.version || "0.0.0";
@@ -51724,7 +52038,7 @@ class PluginManager {
   async parseGenericPlugin(pluginDir, source) {
     const skills = await this.skillsManager.discoverSkills(pluginDir);
     const mcpServers = await this.parseMcpJson(pluginDir);
-    const dirName = basename(pluginDir);
+    const dirName = basename2(pluginDir);
     return {
       name: dirName,
       version: "0.0.0",
@@ -51781,7 +52095,7 @@ class PluginManager {
     if (manifest.commands) {
       const cmds = Array.isArray(manifest.commands) ? manifest.commands : [manifest.commands];
       for (const cmd of cmds) {
-        commandsDirs.push(resolve10(pluginDir, cmd));
+        commandsDirs.push(resolve11(pluginDir, cmd));
       }
     } else {
       commandsDirs.push(join8(pluginDir, "commands"));
@@ -51805,7 +52119,7 @@ class PluginManager {
     const content = await readFileIfExists(cmdPath);
     if (!content)
       return null;
-    const fileName = basename(cmdPath, ".md");
+    const fileName = basename2(cmdPath, ".md");
     let skillName;
     let description;
     let body;
@@ -51846,7 +52160,7 @@ ${body.trim()}
       tempDir = await this.skillsManager.cloneRepo(resolved.url);
       pluginDir = tempDir;
     } else {
-      pluginDir = resolve10(resolved.path || source);
+      pluginDir = resolve11(resolved.path || source);
       if (!await fileExists(pluginDir)) {
         throw new Error(`Local path not found: ${pluginDir}`);
       }
@@ -51897,7 +52211,7 @@ ${body.trim()}
       };
     } finally {
       if (tempDir) {
-        await fs28.rm(tempDir, { recursive: true, force: true }).catch(() => {
+        await fs29.rm(tempDir, { recursive: true, force: true }).catch(() => {
         });
       }
     }
@@ -51907,7 +52221,6 @@ ${body.trim()}
     const skipped = [];
     if (plugin.skills.length === 0)
       return { installed, skipped };
-    const dirToAgents = new Map;
     for (const agent of agents) {
       if (!agent.supportsSkills()) {
         for (const skill of plugin.skills) {
@@ -51915,24 +52228,20 @@ ${body.trim()}
         }
         continue;
       }
-      const skillsDir = agent.getSkillsDir(projectPath, options2.global);
-      if (!skillsDir) {
+      if (!agent.getSkillsDir(projectPath, options2.global)) {
         for (const skill of plugin.skills) {
           skipped.push({ name: skill.name, reason: `No skills directory for ${agent.name}` });
         }
         continue;
       }
-      const existing = dirToAgents.get(skillsDir) || [];
-      existing.push(agent);
-      dirToAgents.set(skillsDir, existing);
-    }
-    for (const [skillsDir, dirAgents] of dirToAgents) {
       for (const skill of plugin.skills) {
         try {
-          const installedPath = skill.generatedContent ? await this.skillsManager.installSkillFromContent(skill.name, skill.generatedContent, skillsDir) : await this.skillsManager.installSkill(skill.path, skill.name, skillsDir, true);
-          for (const agent of dirAgents) {
-            installed.push({ name: skill.name, agent: agent.id, path: installedPath });
-          }
+          const installOptions = {
+            ...options2.global !== undefined ? { global: options2.global } : {},
+            ...options2.copySkills !== undefined ? { copy: options2.copySkills } : {}
+          };
+          const installResult = skill.generatedContent ? await this.skillsManager.installSkillFromContentForAgent(skill.name, skill.generatedContent, agent, projectPath, installOptions) : await this.skillsManager.installSkillForAgent(skill.path, skill.name, agent, projectPath, installOptions);
+          installed.push({ name: skill.name, agent: agent.id, ...installResult });
         } catch (error) {
           skipped.push({ name: skill.name, reason: error.message });
         }
@@ -52057,32 +52366,48 @@ ${body.trim()}
     const agentFilter = options2.agents?.length ? new Set(options2.agents) : null;
     const targetedSkills = agentFilter ? plugin.components.skills.filter((skill) => agentFilter.has(skill.agent)) : plugin.components.skills;
     const retainedSkills = agentFilter ? plugin.components.skills.filter((skill) => !agentFilter.has(skill.agent)) : [];
-    const retainedSkillPaths = new Set(retainedSkills.map((skill) => skill.path));
+    const otherPluginSkills = registry.plugins.filter((entry) => entry.name !== plugin.name).flatMap((entry) => entry.components.skills);
+    const remainingSkillRefs = [
+      ...retainedSkills,
+      ...otherPluginSkills
+    ];
     const removedSkillPaths = new Set;
-    const sharedSkillPaths = new Set;
+    const removedSkillKeys = new Set;
+    const removedCanonicalPaths = new Set;
     for (const skill of targetedSkills) {
-      if (removedSkillPaths.has(skill.path) || sharedSkillPaths.has(skill.path)) {
+      const skillKey = `${skill.agent}:${skill.path}:${skill.name}`;
+      if (removedSkillKeys.has(skillKey)) {
         continue;
       }
-      if (retainedSkillPaths.has(skill.path)) {
-        sharedSkillPaths.add(skill.path);
-        details.push(`Skipped shared skill path: ${skill.path}`);
+      const canonicalRef = skill.canonicalPath || skill.path;
+      const sharedCanonicalPath = remainingSkillRefs.some((other) => (other.canonicalPath || other.path) === canonicalRef);
+      if (skill.canonicalPath && skill.path === skill.canonicalPath && sharedCanonicalPath) {
+        details.push(`Skipped shared canonical skill path: ${skill.path}`);
         continue;
       }
-      try {
-        await fs28.rm(skill.path, { recursive: true, force: true });
-        removedSkillPaths.add(skill.path);
-      } catch {
-        details.push(`Could not remove skill path: ${skill.path}`);
+      if (!removedSkillPaths.has(skill.path)) {
+        try {
+          await fs29.rm(skill.path, { recursive: true, force: true });
+          removedSkillPaths.add(skill.path);
+        } catch {
+          details.push(`Could not remove skill path: ${skill.path}`);
+          continue;
+        }
       }
-    }
-    const removedSkills = targetedSkills.filter((skill) => removedSkillPaths.has(skill.path));
-    for (const skill of removedSkills) {
+      if (skill.canonicalPath && skill.canonicalPath !== skill.path && !removedCanonicalPaths.has(skill.canonicalPath) && !sharedCanonicalPath) {
+        try {
+          await fs29.rm(skill.canonicalPath, { recursive: true, force: true });
+          removedCanonicalPaths.add(skill.canonicalPath);
+        } catch {
+          details.push(`Could not remove canonical skill path: ${skill.canonicalPath}`);
+        }
+      }
+      removedSkillKeys.add(skillKey);
       details.push(`Removed skill: ${skill.name} (${skill.agent})`);
     }
     const remainingSkills = [
       ...retainedSkills,
-      ...targetedSkills.filter((skill) => !removedSkillPaths.has(skill.path))
+      ...targetedSkills.filter((skill) => !removedSkillKeys.has(`${skill.agent}:${skill.path}:${skill.name}`))
     ];
     const targetedMcpServers = agentFilter ? plugin.components.mcpServers.filter((mcp) => agentFilter.has(mcp.agent)) : plugin.components.mcpServers;
     const retainedMcpServers = agentFilter ? plugin.components.mcpServers.filter((mcp) => !agentFilter.has(mcp.agent)) : [];
@@ -52138,7 +52463,7 @@ ${body.trim()}
 function registerPluginsCommand(program2) {
   const marketplaceHelp = new PluginManager().getMarketplaceIds().join(", ");
   const plugins = program2.command("plugins").description("Install agent-agnostic plugins from any marketplace or source");
-  plugins.command("install <source>").description("Install a plugin from <marketplace>/<name>, a GitHub repo, or a local path").option("--from <marketplace>", `Marketplace source override (available: ${marketplaceHelp})`).option("-a, --agent <agents...>", "Target specific agent(s)").option("-g, --global", "Install globally").option("-l, --list", "Preview plugin contents without installing").option("-y, --yes", "Skip confirmation prompts, auto-detect all agents").action(async (source, options2) => {
+  plugins.command("install <source>").description("Install a plugin from <marketplace>/<name>, a GitHub repo, or a local path").option("--from <marketplace>", `Marketplace source override (available: ${marketplaceHelp})`).option("-a, --agent <agents...>", "Target specific agent(s)").option("-g, --global", "Install globally").option("--copy-skills", "Copy plugin skills instead of using canonical symlink installs").option("-l, --list", "Preview plugin contents without installing").option("-y, --yes", "Skip confirmation prompts, auto-detect all agents").action(async (source, options2) => {
     logger.title("\uD83D\uDD0C AgentInit - Plugins");
     const agentManager12 = new AgentManager;
     const pluginManager2 = new PluginManager(agentManager12);
@@ -52201,6 +52526,7 @@ function registerPluginsCommand(program2) {
         from: options2.from,
         agents: agentIds,
         global: options2.global,
+        copySkills: options2.copySkills,
         yes: options2.yes
       });
       const p = result.plugin;
@@ -52395,7 +52721,7 @@ registerPluginsCommand(program2);
 program2.command("init").description("Initialize agents.md configuration for the current project").option("-f, --force", "Overwrite existing configuration").option("-t, --template <template>", "Use specific template (web, cli, library)").action(initCommand);
 program2.command("detect").description("Detect current project stack and existing agent configurations").option("-v, --verbose", "Show detailed detection results").action(detectCommand);
 program2.command("sync").description("Sync agents.md with agent-specific configuration files").option("-a, --agent <agents...>", "Target specific agent(s)").option("-d, --dry-run", "Show what would be changed without making changes").option("-b, --backup", "Create backup before syncing").action(syncCommand);
-program2.command("apply").description("Apply agents.md and project-owned skills to supported agent files").option("-a, --agent <agents...>", "Target specific agent(s)").option("-d, --dry-run", "Preview changes without writing files").option("-b, --backup", "Create sibling .agentinit.backup files before overwriting").option("--no-skills", "Disable project-owned skills propagation").option("--no-gitignore", "Disable managed ignore block updates").option("--gitignore-local", "Write ignore entries to .git/info/exclude instead of .gitignore").allowUnknownOption(true).action(async (options2, command) => {
+program2.command("apply").description("Apply agents.md and project-owned skills to supported agent files").option("-a, --agent <agents...>", "Target specific agent(s)").option("-d, --dry-run", "Preview changes without writing files").option("-b, --backup", "Create sibling .agentinit.backup files before overwriting").option("--no-skills", "Disable project-owned skills propagation").option("--copy-skills", "Copy project-owned skills instead of using canonical symlink installs").option("--no-gitignore", "Disable managed ignore block updates").option("--gitignore-local", "Write ignore entries to .git/info/exclude instead of .gitignore").allowUnknownOption(true).action(async (options2, command) => {
   const rawArgs = command.parent.rawArgs.slice(3);
   if (hasLegacyApplyArgs(rawArgs)) {
     logger.warn("\u26A0 Legacy apply mode detected. Prefer:");