@swmansion/argent 0.18.1-next.8 → 0.19.0

package/dist/installer.mjs

@@ -167,6 +167,325 @@ var require_picocolors = __commonJS({
   }
 });
 
+// ../../node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "../../node_modules/dotenv/lib/main.js"(exports, module) {
+    var fs17 = __require("fs");
+    var path21 = __require("path");
+    var os3 = __require("os");
+    var crypto3 = __require("crypto");
+    var TIPS = [
+      "\u25C8 encrypted .env [www.dotenvx.com]",
+      "\u25C8 secrets for agents [www.dotenvx.com]",
+      "\u2301 auth for agents [www.vestauth.com]",
+      "\u2318 custom filepath { path: '/custom/path/.env' }",
+      "\u2318 enable debugging { debug: true }",
+      "\u2318 override existing { override: true }",
+      "\u2318 suppress logs { quiet: true }",
+      "\u2318 multiple files { path: ['.env.local', '.env'] }"
+    ];
+    function _getRandomTip() {
+      return TIPS[Math.floor(Math.random() * TIPS.length)];
+    }
+    function parseBoolean(value) {
+      if (typeof value === "string") {
+        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+      }
+      return Boolean(value);
+    }
+    function supportsAnsi() {
+      return process.stdout.isTTY;
+    }
+    function dim(text2) {
+      return supportsAnsi() ? `\x1B[2m${text2}\x1B[0m` : text2;
+    }
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse4(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      options = options || {};
+      const vaultPath = _vaultPath(options);
+      options.path = vaultPath;
+      const result = DotenvModule.configDotenv(options);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i2 = 0; i2 < length; i2++) {
+        try {
+          const key = keys[i2].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i2 + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.error(`\u26A0 ${message}`);
+    }
+    function _debug(message) {
+      console.log(`\u2506 ${message}`);
+    }
+    function _log(message) {
+      console.log(`\u25C7 ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs17.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path21.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs17.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path21.join(os3.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (debug || !quiet) {
+        _log("loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path21.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("no encoding is specified (UTF-8 is used by default)");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path22 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs17.readFileSync(path22, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`failed to load ${path22} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      const populated = DotenvModule.populate(processEnv, parsedAll, options);
+      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(populated).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative5 = path21.relative(process.cwd(), filePath);
+            shortPaths.push(relative5);
+          } catch (e) {
+            if (debug) {
+              _debug(`failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injected env (${keysCount}) from ${shortPaths.join(",")} ${dim(`// tip: ${_getRandomTip()}`)}`);
+      }
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`you set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto3.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      const populated = {};
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+            populated[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+      }
+      return populated;
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config,
+      decrypt,
+      parse: parse4,
+      populate
+    };
+    module.exports.configDotenv = DotenvModule.configDotenv;
+    module.exports._configVault = DotenvModule._configVault;
+    module.exports._parseVault = DotenvModule._parseVault;
+    module.exports.config = DotenvModule.config;
+    module.exports.decrypt = DotenvModule.decrypt;
+    module.exports.parse = DotenvModule.parse;
+    module.exports.populate = DotenvModule.populate;
+    module.exports = DotenvModule;
+  }
+});
+
 // ../../node_modules/semver/internal/constants.js
 var require_constants = __commonJS({
   "../../node_modules/semver/internal/constants.js"(exports, module) {
@@ -2238,17 +2557,17 @@ var require_visit = __commonJS({
     visit2.BREAK = BREAK;
     visit2.SKIP = SKIP;
     visit2.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path20) {
-      const ctrl = callVisitor(key, node, visitor, path20);
+    function visit_(key, node, visitor, path21) {
+      const ctrl = callVisitor(key, node, visitor, path21);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path20, ctrl);
-        return visit_(key, ctrl, visitor, path20);
+        replaceNode(key, path21, ctrl);
+        return visit_(key, ctrl, visitor, path21);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path20 = Object.freeze(path20.concat(node));
+          path21 = Object.freeze(path21.concat(node));
           for (let i2 = 0; i2 < node.items.length; ++i2) {
-            const ci = visit_(i2, node.items[i2], visitor, path20);
+            const ci = visit_(i2, node.items[i2], visitor, path21);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -2259,13 +2578,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path20 = Object.freeze(path20.concat(node));
-          const ck = visit_("key", node.key, visitor, path20);
+          path21 = Object.freeze(path21.concat(node));
+          const ck = visit_("key", node.key, visitor, path21);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path20);
+          const cv = visit_("value", node.value, visitor, path21);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -2286,17 +2605,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path20) {
-      const ctrl = await callVisitor(key, node, visitor, path20);
+    async function visitAsync_(key, node, visitor, path21) {
+      const ctrl = await callVisitor(key, node, visitor, path21);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path20, ctrl);
-        return visitAsync_(key, ctrl, visitor, path20);
+        replaceNode(key, path21, ctrl);
+        return visitAsync_(key, ctrl, visitor, path21);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path20 = Object.freeze(path20.concat(node));
+          path21 = Object.freeze(path21.concat(node));
           for (let i2 = 0; i2 < node.items.length; ++i2) {
-            const ci = await visitAsync_(i2, node.items[i2], visitor, path20);
+            const ci = await visitAsync_(i2, node.items[i2], visitor, path21);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -2307,13 +2626,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path20 = Object.freeze(path20.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path20);
+          path21 = Object.freeze(path21.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path21);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path20);
+          const cv = await visitAsync_("value", node.value, visitor, path21);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -2340,23 +2659,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path20) {
+    function callVisitor(key, node, visitor, path21) {
       if (typeof visitor === "function")
-        return visitor(key, node, path20);
+        return visitor(key, node, path21);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path20);
+        return visitor.Map?.(key, node, path21);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path20);
+        return visitor.Seq?.(key, node, path21);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path20);
+        return visitor.Pair?.(key, node, path21);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path20);
+        return visitor.Scalar?.(key, node, path21);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path20);
+        return visitor.Alias?.(key, node, path21);
       return void 0;
     }
-    function replaceNode(key, path20, node) {
-      const parent = path20[path20.length - 1];
+    function replaceNode(key, path21, node) {
+      const parent = path21[path21.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -2966,10 +3285,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path20, value) {
+    function collectionFromPath(schema, path21, value) {
       let v = value;
-      for (let i2 = path20.length - 1; i2 >= 0; --i2) {
-        const k = path20[i2];
+      for (let i2 = path21.length - 1; i2 >= 0; --i2) {
+        const k = path21[i2];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a3 = [];
           a3[k] = v;
@@ -2988,7 +3307,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path20) => path20 == null || typeof path20 === "object" && !!path20[Symbol.iterator]().next().done;
+    var isEmptyPath = (path21) => path21 == null || typeof path21 === "object" && !!path21[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -3018,11 +3337,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path20, value) {
-        if (isEmptyPath(path20))
+      addIn(path21, value) {
+        if (isEmptyPath(path21))
           this.add(value);
         else {
-          const [key, ...rest] = path20;
+          const [key, ...rest] = path21;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -3036,8 +3355,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path20) {
-        const [key, ...rest] = path20;
+      deleteIn(path21) {
+        const [key, ...rest] = path21;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -3051,8 +3370,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path20, keepScalar) {
-        const [key, ...rest] = path20;
+      getIn(path21, keepScalar) {
+        const [key, ...rest] = path21;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -3070,8 +3389,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path20) {
-        const [key, ...rest] = path20;
+      hasIn(path21) {
+        const [key, ...rest] = path21;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -3081,8 +3400,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path20, value) {
-        const [key, ...rest] = path20;
+      setIn(path21, value) {
+        const [key, ...rest] = path21;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -5597,9 +5916,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path20, value) {
+      addIn(path21, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path20, value);
+          this.contents.addIn(path21, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -5674,14 +5993,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path20) {
-        if (Collection.isEmptyPath(path20)) {
+      deleteIn(path21) {
+        if (Collection.isEmptyPath(path21)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path20) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path21) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -5696,10 +6015,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path20, keepScalar) {
-        if (Collection.isEmptyPath(path20))
+      getIn(path21, keepScalar) {
+        if (Collection.isEmptyPath(path21))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path20, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path21, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -5710,10 +6029,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path20) {
-        if (Collection.isEmptyPath(path20))
+      hasIn(path21) {
+        if (Collection.isEmptyPath(path21))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path20) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path21) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -5730,13 +6049,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path20, value) {
-        if (Collection.isEmptyPath(path20)) {
+      setIn(path21, value) {
+        if (Collection.isEmptyPath(path21)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path20), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path21), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path20, value);
+          this.contents.setIn(path21, value);
         }
       }
       /**
@@ -7696,9 +8015,9 @@ var require_cst_visit = __commonJS({
     visit2.BREAK = BREAK;
     visit2.SKIP = SKIP;
     visit2.REMOVE = REMOVE;
-    visit2.itemAtPath = (cst, path20) => {
+    visit2.itemAtPath = (cst, path21) => {
       let item = cst;
-      for (const [field, index] of path20) {
+      for (const [field, index] of path21) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -7707,23 +8026,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit2.parentCollection = (cst, path20) => {
-      const parent = visit2.itemAtPath(cst, path20.slice(0, -1));
-      const field = path20[path20.length - 1][0];
+    visit2.parentCollection = (cst, path21) => {
+      const parent = visit2.itemAtPath(cst, path21.slice(0, -1));
+      const field = path21[path21.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path20, item, visitor) {
-      let ctrl = visitor(item, path20);
+    function _visit(path21, item, visitor) {
+      let ctrl = visitor(item, path21);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i2 = 0; i2 < token.items.length; ++i2) {
-            const ci = _visit(Object.freeze(path20.concat([[field, i2]])), token.items[i2], visitor);
+            const ci = _visit(Object.freeze(path21.concat([[field, i2]])), token.items[i2], visitor);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -7734,10 +8053,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path20);
+            ctrl = ctrl(item, path21);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path20) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path21) : ctrl;
     }
     exports.visit = visit2;
   }
@@ -9039,14 +9358,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs16 = this.flowScalar(this.type);
+              const fs17 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs16, sep: [] });
+                map.items.push({ start, key: fs17, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs16);
+                this.stack.push(fs17);
               } else {
-                Object.assign(it, { key: fs16, sep: [] });
+                Object.assign(it, { key: fs17, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -9174,13 +9493,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs16 = this.flowScalar(this.type);
+              const fs17 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs16, sep: [] });
+                fc.items.push({ start: [], key: fs17, sep: [] });
               else if (it.sep)
-                this.stack.push(fs16);
+                this.stack.push(fs17);
               else
-                Object.assign(it, { key: fs16, sep: [] });
+                Object.assign(it, { key: fs17, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -9593,13 +9912,13 @@ var require_min_release_age = __commonJS({
       return Number.isFinite(days) && days > 0 ? days * config_parse_1.DAY_MS : 0;
     }
     function probe(p) {
-      return new Promise((resolve12) => {
+      return new Promise((resolve13) => {
         (0, node_child_process_1.exec)(p.command, { timeout: PROBE_TIMEOUT_MS2, windowsHide: true }, (err, stdout2) => {
           if (err) {
-            resolve12(0);
+            resolve13(0);
             return;
           }
-          resolve12(p.parse(stdout2));
+          resolve13(p.parse(stdout2));
         });
       });
     }
@@ -9632,12 +9951,12 @@ var require_registry = __commonJS({
     var node_https_1 = __importDefault(__require("node:https"));
     var REQUEST_TIMEOUT_MS = 1e4;
     function fetchRegistryInfo2(url) {
-      return new Promise((resolve12) => {
+      return new Promise((resolve13) => {
         let resolved = false;
         const safeResolve = (value) => {
           if (!resolved) {
             resolved = true;
-            resolve12(value);
+            resolve13(value);
           }
         };
         const req = node_https_1.default.get(url, { timeout: REQUEST_TIMEOUT_MS }, (res) => {
@@ -11148,8 +11467,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? dirname2(proce
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path20) {
-  return path20.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path21) {
+  return path21.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 
 // ../../node_modules/@posthog/core/dist/featureFlagUtils.mjs
@@ -13701,15 +14020,15 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path20, ranges, output) {
-  return new Promise((resolve12) => {
-    const stream = createReadStream(path20);
+function getContextLinesFromFile(path21, ranges, output) {
+  return new Promise((resolve13) => {
+    const stream = createReadStream(path21);
     const lineReaded = createInterface2({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve12();
+      resolve13();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -13718,7 +14037,7 @@ function getContextLinesFromFile(path20, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path20, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path21, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -13779,8 +14098,8 @@ function clearLineContext(frame) {
   delete frame.context_line;
   delete frame.post_context;
 }
-function shouldSkipContextLinesForFile(path20) {
-  return path20.startsWith("node:") || path20.endsWith(".min.js") || path20.endsWith(".min.cjs") || path20.endsWith(".min.mjs") || path20.startsWith("data:");
+function shouldSkipContextLinesForFile(path21) {
+  return path21.startsWith("node:") || path21.endsWith(".min.js") || path21.endsWith(".min.cjs") || path21.endsWith(".min.mjs") || path21.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame) {
   if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
@@ -15006,9 +15325,9 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     if (!waitUntil) return;
     if (this.disabled || this.optedOut) return;
     if (!this._waitUntilCycle) {
-      let resolve12;
+      let resolve13;
       const promise = new Promise((r2) => {
-        resolve12 = r2;
+        resolve13 = r2;
       });
       try {
         waitUntil(promise);
@@ -15016,7 +15335,7 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
         return;
       }
       this._waitUntilCycle = {
-        resolve: resolve12,
+        resolve: resolve13,
         startedAt: Date.now(),
         timer: void 0
       };
@@ -15040,12 +15359,12 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     return cycle?.resolve;
   }
   async resolveWaitUntilFlush() {
-    const resolve12 = this._consumeWaitUntilCycle();
+    const resolve13 = this._consumeWaitUntilCycle();
     try {
       await super.flush();
     } catch {
     } finally {
-      resolve12?.();
+      resolve13?.();
     }
   }
   getPersistedProperty(key) {
@@ -15166,15 +15485,15 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
   async waitForLocalEvaluationReady(timeoutMs = THIRTY_SECONDS) {
     if (this.isLocalEvaluationReady()) return true;
     if (void 0 === this.featureFlagsPoller) return false;
-    return new Promise((resolve12) => {
+    return new Promise((resolve13) => {
       const timeout = setTimeout(() => {
         cleanup();
-        resolve12(false);
+        resolve13(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count) => {
         clearTimeout(timeout);
         cleanup();
-        resolve12(count > 0);
+        resolve13(count > 0);
       });
     });
   }
@@ -15629,14 +15948,14 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     this.context?.enter(data, options);
   }
   async _shutdown(shutdownTimeoutMs) {
-    const resolve12 = this._consumeWaitUntilCycle();
+    const resolve13 = this._consumeWaitUntilCycle();
     await this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
     this.errorTracking.shutdown();
     try {
       return await super._shutdown(shutdownTimeoutMs);
     } finally {
       this.distinctIdHasSentFlagCalls = {};
-      resolve12?.();
+      resolve13?.();
     }
   }
   async _requestRemoteConfigPayload(flagKey) {
@@ -16017,6 +16336,11 @@ import { stat } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { basename, extname } from "node:path";
 
+// ../registry/src/file-inputs.ts
+var FLOW_NAME_CHARSET = "[A-Za-z0-9_-]+";
+var FLOW_NAME_PATTERN = new RegExp(`^${FLOW_NAME_CHARSET}$`);
+var FLOW_FILE_NAME_PATTERN = new RegExp(`^${FLOW_NAME_CHARSET}\\.yaml$`);
+
 // ../registry/src/failure-codes.ts
 var FAILURE_CODES = {
   ARGENT_UNCLASSIFIED_FAILURE: "ARGENT_UNCLASSIFIED_FAILURE",
@@ -16034,6 +16358,7 @@ var FAILURE_CODES = {
   CLI_RUN_FLAG_PARSE_FAILED: "CLI_RUN_FLAG_PARSE_FAILED",
   CLI_RUN_ARGS_NOT_OBJECT: "CLI_RUN_ARGS_NOT_OBJECT",
   CLI_RUN_ARGS_JSON_INVALID: "CLI_RUN_ARGS_JSON_INVALID",
+  CLI_RUN_INPUT_VALIDATION_FAILED: "CLI_RUN_INPUT_VALIDATION_FAILED",
   CLI_RUN_TOOL_CALL_FAILED: "CLI_RUN_TOOL_CALL_FAILED",
   CLI_RUN_SAVE_IMAGE_FAILED: "CLI_RUN_SAVE_IMAGE_FAILED",
   TOOL_CAPABILITY_UNSUPPORTED_OPERATION: "TOOL_CAPABILITY_UNSUPPORTED_OPERATION",
@@ -16622,9 +16947,9 @@ function isReplitAgent(env) {
 }
 var DEVIN_MARKER_PATH = "/opt/.devin";
 var JULES_MARKER_PATH = "/opt/environment_summary.sh";
-function safeExists(fileExists, path20) {
+function safeExists(fileExists, path21) {
   try {
-    return fileExists(path20);
+    return fileExists(path21);
   } catch {
     return false;
   }
@@ -17045,7 +17370,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID = randomUUID3();
 function readCliVersion() {
   if (true) {
-    return "0.18.1";
+    return "0.19.0";
   }
   return "0.0.0";
 }
@@ -17079,11 +17404,11 @@ function getBaseProps(runtime) {
 
 // ../telemetry/src/identity.ts
 import * as crypto2 from "node:crypto";
-import * as fs3 from "node:fs";
-import * as path6 from "node:path";
+import * as fs4 from "node:fs";
+import * as path7 from "node:path";
 
 // ../telemetry/src/paths.ts
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 
 // ../configuration-core/src/flags.ts
 import * as fs from "node:fs";
@@ -17218,15 +17543,20 @@ function updateConfig(mutate, scope = "global", options = {}) {
   }
 }
 
-// ../configuration-core/src/config-access.ts
+// ../configuration-core/src/secrets.ts
+var import_dotenv = __toESM(require_main(), 1);
+import * as fs3 from "node:fs";
 import * as path4 from "node:path";
 
+// ../configuration-core/src/config-access.ts
+import * as path5 from "node:path";
+
 // ../telemetry/src/paths.ts
 function identityFilePath() {
-  return path5.join(argentHomeDir(), "telemetry-id");
+  return path6.join(argentHomeDir(), "telemetry-id");
 }
 function debugLogPath() {
-  return path5.join(argentHomeDir(), "telemetry-debug.log");
+  return path6.join(argentHomeDir(), "telemetry-debug.log");
 }
 
 // ../telemetry/src/identity.ts
@@ -17336,66 +17666,66 @@ function resolveFingerprintOnce(resolveFingerprint) {
 function isCorruptIdFile(filePath) {
   let isRegularFile;
   try {
-    isRegularFile = fs3.lstatSync(filePath).isFile();
+    isRegularFile = fs4.lstatSync(filePath).isFile();
   } catch {
     return false;
   }
   return isRegularFile && tryReadId(filePath) === null;
 }
 function writeIdFileAtomic(finalPath, id) {
-  fs3.mkdirSync(argentHomeDir(), { recursive: true });
+  fs4.mkdirSync(argentHomeDir(), { recursive: true });
   let occupant;
   try {
-    occupant = fs3.lstatSync(finalPath);
+    occupant = fs4.lstatSync(finalPath);
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
   if (occupant && !occupant.isFile()) {
     throw new Error("telemetry: refusing to replace a non-regular file at the identity path");
   }
-  const tmpPath = path6.join(
+  const tmpPath = path7.join(
     argentHomeDir(),
     `.telemetry-id.tmp.${process.pid}.${crypto2.randomUUID()}`
   );
-  const fd = fs3.openSync(tmpPath, "wx", 384);
+  const fd = fs4.openSync(tmpPath, "wx", 384);
   try {
     try {
-      fs3.writeSync(fd, id);
-      fs3.fsyncSync(fd);
+      fs4.writeSync(fd, id);
+      fs4.fsyncSync(fd);
     } finally {
-      fs3.closeSync(fd);
+      fs4.closeSync(fd);
     }
-    fs3.renameSync(tmpPath, finalPath);
+    fs4.renameSync(tmpPath, finalPath);
   } finally {
     try {
-      fs3.unlinkSync(tmpPath);
+      fs4.unlinkSync(tmpPath);
     } catch {
     }
   }
 }
 function mintRandomId(finalPath) {
-  fs3.mkdirSync(argentHomeDir(), { recursive: true });
+  fs4.mkdirSync(argentHomeDir(), { recursive: true });
   let value = crypto2.randomUUID();
   for (let attempt = 0; attempt < 3; attempt++) {
-    const tmpPath = path6.join(
+    const tmpPath = path7.join(
       argentHomeDir(),
       `.telemetry-id.tmp.${process.pid}.${crypto2.randomUUID()}`
     );
     let fd;
     try {
-      fd = fs3.openSync(tmpPath, "wx", 384);
+      fd = fs4.openSync(tmpPath, "wx", 384);
     } catch (err) {
       if (err.code === "EEXIST") continue;
       throw err;
     }
     try {
       try {
-        fs3.writeSync(fd, value);
-        fs3.fsyncSync(fd);
+        fs4.writeSync(fd, value);
+        fs4.fsyncSync(fd);
       } finally {
-        fs3.closeSync(fd);
+        fs4.closeSync(fd);
       }
-      fs3.linkSync(tmpPath, finalPath);
+      fs4.linkSync(tmpPath, finalPath);
       cached = { path: finalPath, id: value };
       return value;
     } catch (err) {
@@ -17414,7 +17744,7 @@ function mintRandomId(finalPath) {
       throw err;
     } finally {
       try {
-        fs3.unlinkSync(tmpPath);
+        fs4.unlinkSync(tmpPath);
       } catch {
       }
     }
@@ -17422,12 +17752,12 @@ function mintRandomId(finalPath) {
   throw new Error("telemetry: failed to create identity after retries");
 }
 function claimCorruptOccupant(finalPath) {
-  const claimed = path6.join(
+  const claimed = path7.join(
     argentHomeDir(),
     `.telemetry-id.corrupt.${process.pid}.${crypto2.randomUUID()}`
   );
   try {
-    fs3.renameSync(finalPath, claimed);
+    fs4.renameSync(finalPath, claimed);
   } catch {
     return null;
   }
@@ -17436,7 +17766,7 @@ function claimCorruptOccupant(finalPath) {
     grabbed = tryReadId(claimed);
   } finally {
     try {
-      fs3.unlinkSync(claimed);
+      fs4.unlinkSync(claimed);
     } catch {
     }
   }
@@ -17445,7 +17775,7 @@ function claimCorruptOccupant(finalPath) {
 function deleteAnonId() {
   cached = null;
   try {
-    fs3.unlinkSync(identityFilePath());
+    fs4.unlinkSync(identityFilePath());
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -17453,9 +17783,9 @@ function deleteAnonId() {
 function tryReadId(filePath) {
   let raw;
   try {
-    const stats = fs3.lstatSync(filePath);
+    const stats = fs4.lstatSync(filePath);
     if (!stats.isFile()) return null;
-    raw = fs3.readFileSync(filePath, "utf8");
+    raw = fs4.readFileSync(filePath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     return null;
@@ -17469,12 +17799,12 @@ function tryReadId(filePath) {
 import { execFileSync, spawn } from "node:child_process";
 
 // ../native-devtools-ios/src/index.ts
-import * as path7 from "node:path";
-import * as fs4 from "node:fs";
-var DYLIB_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_DIR ?? path7.join(__dirname, "..", "dylibs");
-var BIN_DIR = process.env.ARGENT_SIMULATOR_SERVER_DIR ?? path7.join(__dirname, "..", "bin");
-var DYLIB_TCP_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_TCP_DIR ?? path7.join(DYLIB_DIR, "tcp");
-var DYLIB_TVOS_DIR = path7.join(DYLIB_DIR, "tvos");
+import * as path8 from "node:path";
+import * as fs5 from "node:fs";
+var DYLIB_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_DIR ?? path8.join(__dirname, "..", "dylibs");
+var BIN_DIR = process.env.ARGENT_SIMULATOR_SERVER_DIR ?? path8.join(__dirname, "..", "bin");
+var DYLIB_TCP_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_TCP_DIR ?? path8.join(DYLIB_DIR, "tcp");
+var DYLIB_TVOS_DIR = path8.join(DYLIB_DIR, "tvos");
 function hostPlatformKey() {
   if (process.platform === "linux" && process.arch === "arm64") {
     return "linux-arm64";
@@ -17485,14 +17815,14 @@ function simulatorServerBinaryName() {
   return process.platform === "win32" ? "simulator-server.exe" : "simulator-server";
 }
 function platformBinDir() {
-  return path7.join(BIN_DIR, hostPlatformKey());
+  return path8.join(BIN_DIR, hostPlatformKey());
 }
 function simulatorServerBinaryPath() {
   const binaryName = simulatorServerBinaryName();
-  const p = path7.join(platformBinDir(), binaryName);
-  if (!fs4.existsSync(p)) {
-    const flat = path7.join(BIN_DIR, binaryName);
-    const migrationHint = fs4.existsSync(flat) ? ` Found a binary at the old flat path ${flat}; move it to ${p} or update ARGENT_SIMULATOR_SERVER_DIR to point at the parent of the platform subdirectory.` : "";
+  const p = path8.join(platformBinDir(), binaryName);
+  if (!fs5.existsSync(p)) {
+    const flat = path8.join(BIN_DIR, binaryName);
+    const migrationHint = fs5.existsSync(flat) ? ` Found a binary at the old flat path ${flat}; move it to ${p} or update ARGENT_SIMULATOR_SERVER_DIR to point at the parent of the platform subdirectory.` : "";
     throw new Error(
       `simulator-server binary not found for platform "${hostPlatformKey()}" at ${p}. Supported hosts today: darwin, linux (x86_64 and arm64), win32.${migrationHint}`
     );
@@ -17525,12 +17855,12 @@ function resolveHostFingerprint() {
   }
 }
 function resolveHostFingerprintAsync() {
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     let binary;
     try {
       binary = simulatorServerBinaryPath();
     } catch {
-      resolve12(null);
+      resolve13(null);
       return;
     }
     let settled = false;
@@ -17543,7 +17873,7 @@ function resolveHostFingerprintAsync() {
         child?.kill("SIGKILL");
       } catch {
       }
-      resolve12(value);
+      resolve13(value);
     };
     const watchdog = setTimeout(() => finish(null), FINGERPRINT_TIMEOUT_MS);
     watchdog.unref?.();
@@ -17576,13 +17906,13 @@ function resolveHostFingerprintAsync() {
 }
 
 // ../telemetry/src/consent.ts
-import * as fs5 from "node:fs";
+import * as fs6 from "node:fs";
 var cache = { current: null };
 var sessionOverride = null;
 function readConfigOverride() {
   let stats;
   try {
-    stats = fs5.lstatSync(configFilePath());
+    stats = fs6.lstatSync(configFilePath());
   } catch (err) {
     if (err.code === "ENOENT") {
       cache.current = { mtimeMs: null, fingerprint: null, enabledOverride: null };
@@ -17602,7 +17932,7 @@ function readConfigOverride() {
   }
   let parsedEnabled = null;
   try {
-    const raw = fs5.readFileSync(configFilePath(), "utf8");
+    const raw = fs6.readFileSync(configFilePath(), "utf8");
     const json = JSON.parse(raw);
     if (json && typeof json === "object") {
       const t2 = json.telemetry;
@@ -17666,7 +17996,7 @@ function setSessionConsentOverride(enabled) {
 }
 
 // ../telemetry/src/debug.ts
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 function isDebugEnabled(env = process.env) {
   const v = env.ARGENT_TELEMETRY_DEBUG;
   if (!v) return false;
@@ -17693,8 +18023,8 @@ function emitDebugPayload(payload) {
   } catch {
   }
   try {
-    fs6.mkdirSync(argentHomeDir(), { recursive: true });
-    fs6.appendFileSync(debugLogPath(), line + "\n");
+    fs7.mkdirSync(argentHomeDir(), { recursive: true });
+    fs7.appendFileSync(debugLogPath(), line + "\n");
   } catch {
   }
 }
@@ -17841,7 +18171,7 @@ async function shutdown(timeoutMs = SHORT_FLUSH_TIMEOUT_MS) {
   try {
     await Promise.race([
       client2.shutdown(timeoutMs),
-      new Promise((resolve12) => setTimeout(resolve12, timeoutMs + 250).unref())
+      new Promise((resolve13) => setTimeout(resolve13, timeoutMs + 250).unref())
     ]);
   } catch (err) {
     emitDebugError("shutdown failed", err);
@@ -17852,8 +18182,8 @@ async function shutdown(timeoutMs = SHORT_FLUSH_TIMEOUT_MS) {
 }
 
 // ../argent-installer/src/mcp-configs.ts
-import * as fs13 from "node:fs";
-import * as path14 from "node:path";
+import * as fs14 from "node:fs";
+import * as path15 from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { homedir as homedir4 } from "node:os";
 
@@ -17867,8 +18197,8 @@ var CURSOR_ALLOWLIST_PATTERN = "argent:*";
 
 // ../argent-installer/src/utils.ts
 var import_semver2 = __toESM(require_semver2(), 1);
-import * as fs12 from "node:fs";
-import * as path13 from "node:path";
+import * as fs13 from "node:fs";
+import * as path14 from "node:path";
 import * as dns from "node:dns";
 import * as os2 from "node:os";
 import { execSync as execSync2 } from "node:child_process";
@@ -19493,12 +19823,12 @@ function parseTree(text2, errors = [], options = ParseOptions.DEFAULT) {
   }
   return result;
 }
-function findNodeAtLocation(root, path20) {
+function findNodeAtLocation(root, path21) {
   if (!root) {
     return void 0;
   }
   let node = root;
-  for (let segment of path20) {
+  for (let segment of path21) {
     if (typeof segment === "string") {
       if (node.type !== "object" || !Array.isArray(node.children)) {
         return void 0;
@@ -19852,14 +20182,14 @@ function getNodeType(value) {
 
 // ../../node_modules/jsonc-parser/lib/esm/impl/edit.js
 function setProperty(text2, originalPath, value, options) {
-  const path20 = originalPath.slice();
+  const path21 = originalPath.slice();
   const errors = [];
   const root = parseTree(text2, errors);
   let parent = void 0;
   let lastSegment = void 0;
-  while (path20.length > 0) {
-    lastSegment = path20.pop();
-    parent = findNodeAtLocation(root, path20);
+  while (path21.length > 0) {
+    lastSegment = path21.pop();
+    parent = findNodeAtLocation(root, path21);
     if (parent === void 0 && value !== void 0) {
       if (typeof lastSegment === "string") {
         value = { [lastSegment]: value };
@@ -20045,8 +20375,8 @@ var ParseErrorCode;
   ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
   ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
 })(ParseErrorCode || (ParseErrorCode = {}));
-function modify(text2, path20, value, options) {
-  return setProperty(text2, path20, value, options);
+function modify(text2, path21, value, options) {
+  return setProperty(text2, path21, value, options);
 }
 function applyEdits(text2, edits) {
   let sortedEdits = edits.slice(0).sort((a3, b) => {
@@ -20070,21 +20400,21 @@ function applyEdits(text2, edits) {
 }
 
 // ../argent-installer/src/package-root.ts
-import * as fs7 from "node:fs";
-import * as path8 from "node:path";
+import * as fs8 from "node:fs";
+import * as path9 from "node:path";
 function resolvePackageRoot(dirname15) {
-  let current = path8.resolve(dirname15);
+  let current = path9.resolve(dirname15);
   while (true) {
-    if (fs7.existsSync(path8.join(current, "package.json"))) return current;
-    const parent = path8.dirname(current);
-    if (parent === current) return path8.resolve(dirname15);
+    if (fs8.existsSync(path9.join(current, "package.json"))) return current;
+    const parent = path9.dirname(current);
+    if (parent === current) return path9.resolve(dirname15);
     current = parent;
   }
 }
 
 // ../argent-installer/src/package-manager.ts
-import * as fs8 from "node:fs";
-import * as path9 from "node:path";
+import * as fs9 from "node:fs";
+import * as path10 from "node:path";
 function formatShellCommand(cmd) {
   const parts = [cmd.bin, ...cmd.args.map((a3) => a3.includes(" ") ? `"${a3}"` : a3)];
   return parts.join(" ");
@@ -20101,7 +20431,7 @@ function asKnownPm(name) {
 }
 function pmFromPackageManagerField(dir) {
   try {
-    const pkg = JSON.parse(fs8.readFileSync(path9.join(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs9.readFileSync(path10.join(dir, "package.json"), "utf8"));
     if (typeof pkg.packageManager === "string") {
       return asKnownPm(pkg.packageManager.split("@")[0]);
     }
@@ -20112,7 +20442,7 @@ function pmFromPackageManagerField(dir) {
 }
 function pmFromDevEngines(dir) {
   try {
-    const pkg = JSON.parse(fs8.readFileSync(path9.join(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs9.readFileSync(path10.join(dir, "package.json"), "utf8"));
     const devEnginesPm = pkg.devEngines?.packageManager;
     const names = /* @__PURE__ */ new Set();
     for (const entry of Array.isArray(devEnginesPm) ? devEnginesPm : [devEnginesPm]) {
@@ -20125,7 +20455,7 @@ function pmFromDevEngines(dir) {
   }
 }
 function pmFromLockfile(dir) {
-  const has = (file) => fs8.existsSync(path9.join(dir, file));
+  const has = (file) => fs9.existsSync(path10.join(dir, file));
   if (has("pnpm-lock.yaml")) return "pnpm";
   if (has("yarn.lock")) return "yarn";
   if (has("bun.lock") || has("bun.lockb")) return "bun";
@@ -20133,15 +20463,15 @@ function pmFromLockfile(dir) {
   return null;
 }
 function pmFromWorkspaceMarker(dir) {
-  return fs8.existsSync(path9.join(dir, "pnpm-workspace.yaml")) ? "pnpm" : null;
+  return fs9.existsSync(path10.join(dir, "pnpm-workspace.yaml")) ? "pnpm" : null;
 }
 function detectProjectPackageManager(projectRoot) {
-  let dir = path9.resolve(projectRoot);
+  let dir = path10.resolve(projectRoot);
   for (; ; ) {
     const pm = pmFromPackageManagerField(dir) ?? pmFromLockfile(dir) ?? pmFromDevEngines(dir) ?? pmFromWorkspaceMarker(dir);
     if (pm) return pm;
-    if (fs8.existsSync(path9.join(dir, ".git"))) break;
-    const parent = path9.dirname(dir);
+    if (fs9.existsSync(path10.join(dir, ".git"))) break;
+    const parent = path10.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -20209,19 +20539,19 @@ function localUninstallCommand(pm, pkg) {
 }
 
 // ../argent-installer/src/preflight.ts
-import * as fs9 from "node:fs";
-import * as path10 from "node:path";
+import * as fs10 from "node:fs";
+import * as path11 from "node:path";
 function hasProjectPackageJson(projectRoot) {
-  return fs9.existsSync(path10.join(projectRoot, "package.json"));
+  return fs10.existsSync(path11.join(projectRoot, "package.json"));
 }
 function isYarnPnp(projectRoot) {
-  return fs9.existsSync(path10.join(projectRoot, ".pnp.cjs")) || fs9.existsSync(path10.join(projectRoot, ".pnp.loader.mjs"));
+  return fs10.existsSync(path11.join(projectRoot, ".pnp.cjs")) || fs10.existsSync(path11.join(projectRoot, ".pnp.loader.mjs"));
 }
 
 // ../argent-installer/src/topology.ts
 var import_semver = __toESM(require_semver2(), 1);
-import * as fs10 from "node:fs";
-import * as path11 from "node:path";
+import * as fs11 from "node:fs";
+import * as path12 from "node:path";
 import { createRequire } from "node:module";
 import { execSync } from "node:child_process";
 var TEMP_RUNNER_MARKERS = [
@@ -20253,9 +20583,9 @@ function getGloballyInstalledPackageRoot() {
   const binaryPath = getGlobalBinaryPath();
   if (!binaryPath) return null;
   try {
-    const realPath = fs10.realpathSync(binaryPath);
-    const root = resolvePackageRoot(path11.dirname(realPath));
-    const pkg = JSON.parse(fs10.readFileSync(path11.join(root, "package.json"), "utf8"));
+    const realPath = fs11.realpathSync(binaryPath);
+    const root = resolvePackageRoot(path12.dirname(realPath));
+    const pkg = JSON.parse(fs11.readFileSync(path12.join(root, "package.json"), "utf8"));
     return pkg.name === PACKAGE_NAME ? root : null;
   } catch {
     return null;
@@ -20265,7 +20595,7 @@ function getGloballyInstalledVersion() {
   const pkgRoot = getGloballyInstalledPackageRoot();
   if (!pkgRoot) return null;
   try {
-    const pkg = JSON.parse(fs10.readFileSync(path11.join(pkgRoot, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs11.readFileSync(path12.join(pkgRoot, "package.json"), "utf8"));
     return pkg.version ?? null;
   } catch {
     return null;
@@ -20274,7 +20604,7 @@ function getGloballyInstalledVersion() {
 function readManifestDeclaration(projectRoot) {
   try {
     const pkg = JSON.parse(
-      fs10.readFileSync(path11.join(projectRoot, "package.json"), "utf8")
+      fs11.readFileSync(path12.join(projectRoot, "package.json"), "utf8")
     );
     const spec = pkg.devDependencies?.[PACKAGE_NAME] ?? pkg.dependencies?.[PACKAGE_NAME] ?? pkg.optionalDependencies?.[PACKAGE_NAME];
     return typeof spec === "string" ? spec : null;
@@ -20287,11 +20617,11 @@ function isDeclaredLocally(projectRoot) {
 }
 function resolveLocalArgentDir(projectRoot) {
   try {
-    const req = createRequire(path11.join(projectRoot, "package.json"));
-    return path11.dirname(req.resolve(`${PACKAGE_NAME}/package.json`));
+    const req = createRequire(path12.join(projectRoot, "package.json"));
+    return path12.dirname(req.resolve(`${PACKAGE_NAME}/package.json`));
   } catch {
-    const plain = path11.join(projectRoot, "node_modules", PACKAGE_NAME);
-    return fs10.existsSync(path11.join(plain, "package.json")) ? plain : null;
+    const plain = path12.join(projectRoot, "node_modules", PACKAGE_NAME);
+    return fs11.existsSync(path12.join(plain, "package.json")) ? plain : null;
   }
 }
 function probeLocalInstall(projectRoot) {
@@ -20299,7 +20629,7 @@ function probeLocalInstall(projectRoot) {
   if (packageDir) {
     let version2;
     try {
-      const pkg = JSON.parse(fs10.readFileSync(path11.join(packageDir, "package.json"), "utf8"));
+      const pkg = JSON.parse(fs11.readFileSync(path12.join(packageDir, "package.json"), "utf8"));
       version2 = pkg.version ?? null;
     } catch {
       version2 = null;
@@ -20322,8 +20652,8 @@ function getLocallyInstalledVersion(projectRoot) {
 }
 function readLocalPackageVersionUncached(projectRoot) {
   try {
-    const pkgPath = path11.join(projectRoot, "node_modules", PACKAGE_NAME, "package.json");
-    const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf8"));
+    const pkgPath = path12.join(projectRoot, "node_modules", PACKAGE_NAME, "package.json");
+    const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf8"));
     return pkg.version ?? null;
   } catch {
     return null;
@@ -20334,7 +20664,7 @@ function getLocalArgentBinRelPath(projectRoot) {
   if (!pkgDir) return null;
   let binSub;
   try {
-    const pkg = JSON.parse(fs10.readFileSync(path11.join(pkgDir, "package.json"), "utf8"));
+    const pkg = JSON.parse(fs11.readFileSync(path12.join(pkgDir, "package.json"), "utf8"));
     if (typeof pkg.bin === "string") binSub = pkg.bin;
     else if (pkg.bin && typeof pkg.bin === "object")
       binSub = pkg.bin[MCP_BINARY_NAME] ?? Object.values(pkg.bin)[0];
@@ -20344,28 +20674,28 @@ function getLocalArgentBinRelPath(projectRoot) {
   if (!binSub) return null;
   let root = projectRoot;
   try {
-    root = fs10.realpathSync(projectRoot);
+    root = fs11.realpathSync(projectRoot);
   } catch {
   }
-  const stableRel = path11.join("node_modules", PACKAGE_NAME, binSub);
-  if (fs10.existsSync(path11.join(root, stableRel))) {
-    return stableRel.split(path11.sep).join("/");
+  const stableRel = path12.join("node_modules", PACKAGE_NAME, binSub);
+  if (fs11.existsSync(path12.join(root, stableRel))) {
+    return stableRel.split(path12.sep).join("/");
   }
-  const abs = path11.join(pkgDir, binSub);
-  if (!fs10.existsSync(abs)) return null;
-  return path11.relative(root, abs).split(path11.sep).join("/");
+  const abs = path12.join(pkgDir, binSub);
+  if (!fs11.existsSync(abs)) return null;
+  return path12.relative(root, abs).split(path12.sep).join("/");
 }
 
 // ../argent-installer/src/install-record.ts
-import * as fs11 from "node:fs";
-import * as path12 from "node:path";
+import * as fs12 from "node:fs";
+import * as path13 from "node:path";
 function getInstallRecordPath(projectRoot) {
-  return path12.join(projectRoot, ".argent", "install.json");
+  return path13.join(projectRoot, ".argent", "install.json");
 }
 function readInstallRecord(projectRoot) {
   try {
     const parsed = JSON.parse(
-      fs11.readFileSync(getInstallRecordPath(projectRoot), "utf8")
+      fs12.readFileSync(getInstallRecordPath(projectRoot), "utf8")
     );
     if (parsed && (parsed.mode === "local" || parsed.mode === "global")) return parsed;
     return null;
@@ -20375,17 +20705,17 @@ function readInstallRecord(projectRoot) {
 }
 function writeInstallRecord(projectRoot, record) {
   const recordPath = getInstallRecordPath(projectRoot);
-  fs11.mkdirSync(path12.dirname(recordPath), { recursive: true });
-  fs11.writeFileSync(recordPath, JSON.stringify(record, null, 2) + "\n");
+  fs12.mkdirSync(path13.dirname(recordPath), { recursive: true });
+  fs12.writeFileSync(recordPath, JSON.stringify(record, null, 2) + "\n");
 }
 function removeInstallRecord(projectRoot) {
   const recordPath = getInstallRecordPath(projectRoot);
   try {
-    if (!fs11.existsSync(recordPath)) return false;
-    fs11.rmSync(recordPath, { force: true });
-    const dir = path12.dirname(recordPath);
+    if (!fs12.existsSync(recordPath)) return false;
+    fs12.rmSync(recordPath, { force: true });
+    const dir = path13.dirname(recordPath);
     try {
-      if (fs11.existsSync(dir) && fs11.readdirSync(dir).length === 0) fs11.rmdirSync(dir);
+      if (fs12.existsSync(dir) && fs12.readdirSync(dir).length === 0) fs12.rmdirSync(dir);
     } catch {
     }
     return true;
@@ -20459,9 +20789,9 @@ async function promptInstallTargets(verb) {
 // ../argent-installer/src/utils.ts
 var PACKAGE_ROOT = resolvePackageRoot(import.meta.dirname);
 function resolveBundledDir(dirName) {
-  const packagedDir = path13.join(PACKAGE_ROOT, dirName);
-  if (fs12.existsSync(packagedDir)) return packagedDir;
-  return path13.resolve(PACKAGE_ROOT, "..", "skills", dirName);
+  const packagedDir = path14.join(PACKAGE_ROOT, dirName);
+  if (fs13.existsSync(packagedDir)) return packagedDir;
+  return path14.resolve(PACKAGE_ROOT, "..", "skills", dirName);
 }
 var SKILLS_DIR = resolveBundledDir("skills");
 var RULES_DIR = resolveBundledDir("rules");
@@ -20473,23 +20803,23 @@ function buildArgentSkillsSource(version2) {
 }
 function listBundledSkills(skillsDir = SKILLS_DIR) {
   try {
-    return fs12.readdirSync(skillsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => fs12.existsSync(path13.join(skillsDir, name, "SKILL.md"))).sort();
+    return fs13.readdirSync(skillsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => fs13.existsSync(path14.join(skillsDir, name, "SKILL.md"))).sort();
   } catch {
     return [];
   }
 }
 function getProjectSkillLockPath(cwd = process.cwd()) {
-  return path13.join(cwd, "skills-lock.json");
+  return path14.join(cwd, "skills-lock.json");
 }
 function getGlobalSkillLockPath() {
   const xdgStateHome = process.env.XDG_STATE_HOME;
-  if (xdgStateHome) return path13.join(xdgStateHome, "skills", ".skill-lock.json");
-  return path13.join(os2.homedir(), ".agents", ".skill-lock.json");
+  if (xdgStateHome) return path14.join(xdgStateHome, "skills", ".skill-lock.json");
+  return path14.join(os2.homedir(), ".agents", ".skill-lock.json");
 }
 var ARGENT_SKILL_PREFIX = "argent-";
 function listArgentSkillsInLock(lockPath) {
   try {
-    const raw = fs12.readFileSync(lockPath, "utf8");
+    const raw = fs13.readFileSync(lockPath, "utf8");
     const lock = JSON.parse(raw);
     const tracked = lock.skills ?? {};
     return Object.keys(tracked).filter((name) => name.startsWith(ARGENT_SKILL_PREFIX)).sort();
@@ -20513,16 +20843,16 @@ var PROJECT_ROOT_MARKERS = [
   "skills-lock.json"
 ];
 function resolveProjectRoot2(startDir) {
-  const initialDir = path13.resolve(startDir);
+  const initialDir = path14.resolve(startDir);
   let currentDir = initialDir;
   while (true) {
-    if (PROJECT_ROOT_MARKERS.some((marker) => fs12.existsSync(path13.join(currentDir, marker)))) {
+    if (PROJECT_ROOT_MARKERS.some((marker) => fs13.existsSync(path14.join(currentDir, marker)))) {
       return currentDir;
     }
-    if (fs12.existsSync(path13.join(currentDir, ".git"))) {
+    if (fs13.existsSync(path14.join(currentDir, ".git"))) {
       return currentDir;
     }
-    const parentDir = path13.dirname(currentDir);
+    const parentDir = path14.dirname(currentDir);
     if (parentDir === currentDir) {
       return initialDir;
     }
@@ -20530,20 +20860,20 @@ function resolveProjectRoot2(startDir) {
   }
 }
 function readToml(filePath) {
-  if (!fs12.existsSync(filePath)) return {};
+  if (!fs13.existsSync(filePath)) return {};
   try {
-    return parse(fs12.readFileSync(filePath, "utf8"));
+    return parse(fs13.readFileSync(filePath, "utf8"));
   } catch {
     return {};
   }
 }
 function writeToml(filePath, data) {
-  fs12.mkdirSync(path13.dirname(filePath), { recursive: true });
-  fs12.writeFileSync(filePath, stringify(data) + "\n");
+  fs13.mkdirSync(path14.dirname(filePath), { recursive: true });
+  fs13.writeFileSync(filePath, stringify(data) + "\n");
 }
 function readYaml(filePath) {
-  if (!fs12.existsSync(filePath)) return new import_yaml.Document({});
-  const text2 = fs12.readFileSync(filePath, "utf8");
+  if (!fs13.existsSync(filePath)) return new import_yaml.Document({});
+  const text2 = fs13.readFileSync(filePath, "utf8");
   const doc = (0, import_yaml.parseDocument)(text2);
   if (doc.errors.length > 0) {
     const messages = doc.errors.map((e) => e.message).join("; ");
@@ -20552,20 +20882,20 @@ function readYaml(filePath) {
   return doc;
 }
 function writeYaml(filePath, doc) {
-  fs12.mkdirSync(path13.dirname(filePath), { recursive: true });
-  fs12.writeFileSync(filePath, doc.toString({ lineWidth: 0 }));
+  fs13.mkdirSync(path14.dirname(filePath), { recursive: true });
+  fs13.writeFileSync(filePath, doc.toString({ lineWidth: 0 }));
 }
 function readJson(filePath) {
-  if (!fs12.existsSync(filePath)) return {};
+  if (!fs13.existsSync(filePath)) return {};
   try {
-    return JSON.parse(fs12.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs13.readFileSync(filePath, "utf8"));
   } catch {
     return {};
   }
 }
 function writeJson(filePath, data) {
-  fs12.mkdirSync(path13.dirname(filePath), { recursive: true });
-  fs12.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  fs13.mkdirSync(path14.dirname(filePath), { recursive: true });
+  fs13.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 }
 var JSONC_FORMATTING = { tabSize: 2, insertSpaces: true };
 function setJsoncIn(text2, jsonPath, value) {
@@ -20573,8 +20903,8 @@ function setJsoncIn(text2, jsonPath, value) {
   return applyEdits(text2, edits);
 }
 function readJsoncFileRaw(filePath) {
-  if (!fs12.existsSync(filePath)) return { text: "{}", hadBom: false, wasEmpty: true };
-  let text2 = fs12.readFileSync(filePath, "utf8");
+  if (!fs13.existsSync(filePath)) return { text: "{}", hadBom: false, wasEmpty: true };
+  let text2 = fs13.readFileSync(filePath, "utf8");
   const hadBom = text2.charCodeAt(0) === 65279;
   if (hadBom) text2 = text2.slice(1);
   const wasEmpty = text2.trim() === "";
@@ -20594,16 +20924,16 @@ function isEmptyPlainObject(value) {
 }
 function rmEmptyDir(dirPath) {
   try {
-    if (!fs12.existsSync(dirPath)) return;
-    if (!fs12.statSync(dirPath).isDirectory()) return;
-    if (fs12.readdirSync(dirPath).length > 0) return;
-    fs12.rmdirSync(dirPath);
+    if (!fs13.existsSync(dirPath)) return;
+    if (!fs13.statSync(dirPath).isDirectory()) return;
+    if (fs13.readdirSync(dirPath).length > 0) return;
+    fs13.rmdirSync(dirPath);
   } catch {
   }
 }
 function readJsonc(filePath) {
-  if (!fs12.existsSync(filePath)) return {};
-  let raw = fs12.readFileSync(filePath, "utf8");
+  if (!fs13.existsSync(filePath)) return {};
+  let raw = fs13.readFileSync(filePath, "utf8");
   if (raw.charCodeAt(0) === 65279) raw = raw.slice(1);
   if (raw.trim() === "") return {};
   const parsed = parse3(raw, [], { allowTrailingComma: true });
@@ -20622,25 +20952,67 @@ function editJsoncFile(filePath, jsonPath, value) {
   }
   const parsed = parse3(text2, [], { allowTrailingComma: true });
   if (isEmptyPlainObject(parsed)) {
-    fs12.rmSync(filePath, { force: true });
-    rmEmptyDir(path13.dirname(filePath));
+    fs13.rmSync(filePath, { force: true });
+    rmEmptyDir(path14.dirname(filePath));
     return;
   }
-  fs12.mkdirSync(path13.dirname(filePath), { recursive: true });
+  fs13.mkdirSync(path14.dirname(filePath), { recursive: true });
   const out = wasEmpty && !text2.endsWith("\n") ? text2 + "\n" : text2;
-  fs12.writeFileSync(filePath, (hadBom ? "\uFEFF" : "") + out);
+  fs13.writeFileSync(filePath, (hadBom ? "\uFEFF" : "") + out);
+}
+var MAX_SYMLINK_HOPS = 40;
+function realpathOrSelf(p) {
+  try {
+    return fs13.realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function resolveLinkedDestination(dest) {
+  let current = dest;
+  for (let hop = 0; hop < MAX_SYMLINK_HOPS; hop++) {
+    let entry;
+    try {
+      entry = fs13.lstatSync(current);
+    } catch {
+      return current === dest || dirExists(path14.dirname(current)) ? current : dest;
+    }
+    if (!entry.isSymbolicLink()) return current;
+    try {
+      current = path14.resolve(realpathOrSelf(path14.dirname(current)), fs13.readlinkSync(current));
+    } catch {
+      return dest;
+    }
+  }
+  return dest;
+}
+function copyDir(src, dest) {
+  if (!fs13.existsSync(src)) return null;
+  const target = resolveLinkedDestination(dest);
+  copyTree(src, target);
+  return target;
+}
+function copyTree(src, dest) {
+  const entries = fs13.readdirSync(src, { withFileTypes: true });
+  fs13.mkdirSync(dest, { recursive: true });
+  for (const entry of entries) {
+    const from = path14.join(src, entry.name);
+    const to = resolveLinkedDestination(path14.join(dest, entry.name));
+    if (entry.isDirectory()) copyTree(from, to);
+    else fs13.copyFileSync(from, to);
+  }
 }
 function dirExists(p) {
   try {
-    return fs12.statSync(p).isDirectory();
+    return fs13.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function getInstalledVersion() {
   try {
-    const pkgPath = path13.join(PACKAGE_ROOT, "package.json");
-    const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf8"));
+    const pkgPath = path14.join(PACKAGE_ROOT, "package.json");
+    const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf8"));
     return pkg.version ?? null;
   } catch {
     return null;
@@ -20679,12 +21051,12 @@ async function isOnline(timeoutMs = PROBE_TIMEOUT_MS) {
   } catch {
     return false;
   }
-  return new Promise((resolve12) => {
-    const timer = setTimeout(() => resolve12(false), timeoutMs);
+  return new Promise((resolve13) => {
+    const timer = setTimeout(() => resolve13(false), timeoutMs);
     timer.unref();
     dns.lookup(host, (err) => {
       clearTimeout(timer);
-      resolve12(!err);
+      resolve13(!err);
     });
   });
 }
@@ -20701,7 +21073,7 @@ function escapeStringRegexp(string) {
 }
 
 // ../argent-installer/src/mcp-configs.ts
-var TOOL_SERVER_BUNDLE = path14.join(import.meta.dirname, "tool-server.cjs");
+var TOOL_SERVER_BUNDLE = path15.join(import.meta.dirname, "tool-server.cjs");
 function getAvailableToolIds() {
   const out = execFileSync2("node", [TOOL_SERVER_BUNDLE, "-t"], { encoding: "utf8" });
   const tools = JSON.parse(out);
@@ -20740,10 +21112,10 @@ function hasCustomizingEnv(entry) {
 }
 function removeDirIfEmpty(dirPath) {
   try {
-    if (!fs13.existsSync(dirPath)) return;
-    if (!fs13.statSync(dirPath).isDirectory()) return;
-    if (fs13.readdirSync(dirPath).length > 0) return;
-    fs13.rmdirSync(dirPath);
+    if (!fs14.existsSync(dirPath)) return;
+    if (!fs14.statSync(dirPath).isDirectory()) return;
+    if (fs14.readdirSync(dirPath).length > 0) return;
+    fs14.rmdirSync(dirPath);
   } catch {
   }
 }
@@ -20780,7 +21152,7 @@ function isArgentManagedEntry(entry) {
       return args.length === 1 && args[0] === "mcp";
     case "node": {
       if (args.length !== 2 || args[1] !== "mcp" || !args[0]) return false;
-      if (path14.isAbsolute(args[0])) return false;
+      if (path15.isAbsolute(args[0])) return false;
       const normalized = args[0].split("\\").join("/");
       return normalized.includes(`node_modules/${PACKAGE_NAME}/`);
     }
@@ -20794,8 +21166,8 @@ function isArgentManagedEntry(entry) {
 }
 function writeTomlOrRemove(filePath, data) {
   if (Object.keys(data).length === 0) {
-    fs13.rmSync(filePath, { force: true });
-    removeDirIfEmpty(path14.dirname(filePath));
+    fs14.rmSync(filePath, { force: true });
+    removeDirIfEmpty(path15.dirname(filePath));
     return;
   }
   writeToml(filePath, data);
@@ -20804,12 +21176,12 @@ function dirHasEditorEvidence(dir, looksArgentOnly) {
   return dirExists(dir) && !looksArgentOnly(dir);
 }
 function fileHasEditorEvidence(filePath, looksArgentOnly) {
-  return fs13.existsSync(filePath) && !looksArgentOnly(filePath);
+  return fs14.existsSync(filePath) && !looksArgentOnly(filePath);
 }
 function parseJsoncStrict(filePath) {
   let raw;
   try {
-    raw = fs13.readFileSync(filePath, "utf8");
+    raw = fs14.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -20822,14 +21194,14 @@ function parseJsoncStrict(filePath) {
 }
 function parseTomlStrict(filePath) {
   try {
-    return parse(fs13.readFileSync(filePath, "utf8"));
+    return parse(fs14.readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
 }
 function parseYamlStrict(filePath) {
   try {
-    const parsed = (0, import_yaml2.parse)(fs13.readFileSync(filePath, "utf8"));
+    const parsed = (0, import_yaml2.parse)(fs14.readFileSync(filePath, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
@@ -20852,7 +21224,7 @@ function bundledManagedNames(kind) {
   if (cached2) return cached2;
   let names;
   try {
-    names = new Set(fs13.readdirSync(kind === "rules" ? RULES_DIR : AGENTS_DIR));
+    names = new Set(fs14.readdirSync(kind === "rules" ? RULES_DIR : AGENTS_DIR));
   } catch {
     names = /* @__PURE__ */ new Set();
   }
@@ -20862,7 +21234,7 @@ function bundledManagedNames(kind) {
 function managedDirLooksArgentOnly(dir, kind) {
   let entries;
   try {
-    entries = fs13.readdirSync(dir);
+    entries = fs14.readdirSync(dir);
   } catch {
     return false;
   }
@@ -20874,13 +21246,13 @@ function managedDirLooksArgentOnly(dir, kind) {
 function cursorDirLooksArgentOnly(dir) {
   let entries;
   try {
-    entries = fs13.readdirSync(dir);
+    entries = fs14.readdirSync(dir);
   } catch {
     return false;
   }
   if (entries.length === 0) return false;
   return entries.every((entry) => {
-    const full = path14.join(dir, entry);
+    const full = path15.join(dir, entry);
     if (entry === "mcp.json") {
       return jsonLooksArgentServerOnly(full, "mcpServers");
     }
@@ -20913,13 +21285,13 @@ function claudeSettingsLooksArgentOnly(filePath) {
 function claudeDirLooksArgentOnly(dir) {
   let entries;
   try {
-    entries = fs13.readdirSync(dir);
+    entries = fs14.readdirSync(dir);
   } catch {
     return false;
   }
   if (entries.length === 0) return false;
   return entries.every((entry) => {
-    const full = path14.join(dir, entry);
+    const full = path15.join(dir, entry);
     if (entry === "settings.json") return claudeSettingsLooksArgentOnly(full);
     if (entry === "rules" || entry === "agents" || entry === "skills") {
       return managedDirLooksArgentOnly(full, entry);
@@ -20930,25 +21302,25 @@ function claudeDirLooksArgentOnly(dir) {
 function vscodeDirLooksArgentOnly(dir) {
   let entries;
   try {
-    entries = fs13.readdirSync(dir);
+    entries = fs14.readdirSync(dir);
   } catch {
     return false;
   }
   if (entries.length === 0) return false;
   return entries.every(
-    (entry) => entry === "mcp.json" && jsonLooksArgentServerOnly(path14.join(dir, entry), "servers")
+    (entry) => entry === "mcp.json" && jsonLooksArgentServerOnly(path15.join(dir, entry), "servers")
   );
 }
 function windsurfDirLooksArgentOnly(dir) {
   let entries;
   try {
-    entries = fs13.readdirSync(dir);
+    entries = fs14.readdirSync(dir);
   } catch {
     return false;
   }
   if (entries.length === 0) return false;
   return entries.every(
-    (entry) => entry === "mcp_config.json" && jsonLooksArgentServerOnly(path14.join(dir, entry), "mcpServers")
+    (entry) => entry === "mcp_config.json" && jsonLooksArgentServerOnly(path15.join(dir, entry), "mcpServers")
   );
 }
 function zedSettingsLooksArgentOnly(filePath) {
@@ -20979,25 +21351,25 @@ function zedSettingsLooksArgentOnly(filePath) {
 function zedDirLooksArgentOnly(dir) {
   let entries;
   try {
-    entries = fs13.readdirSync(dir);
+    entries = fs14.readdirSync(dir);
   } catch {
     return false;
   }
   if (entries.length === 0) return false;
   return entries.every(
-    (entry) => entry === "settings.json" && zedSettingsLooksArgentOnly(path14.join(dir, entry))
+    (entry) => entry === "settings.json" && zedSettingsLooksArgentOnly(path15.join(dir, entry))
   );
 }
 function geminiDirLooksArgentOnly(dir) {
   let entries;
   try {
-    entries = fs13.readdirSync(dir);
+    entries = fs14.readdirSync(dir);
   } catch {
     return false;
   }
   if (entries.length === 0) return false;
   return entries.every((entry) => {
-    const full = path14.join(dir, entry);
+    const full = path15.join(dir, entry);
     if (entry === "settings.json") return jsonLooksArgentServerOnly(full, "mcpServers");
     if (entry === "rules" || entry === "agents") return managedDirLooksArgentOnly(full, entry);
     return false;
@@ -21016,48 +21388,48 @@ function hermesConfigLooksArgentOnly(filePath) {
 function hermesDirLooksArgentOnly(dir) {
   let entries;
   try {
-    entries = fs13.readdirSync(dir);
+    entries = fs14.readdirSync(dir);
   } catch {
     return false;
   }
   if (entries.length === 0) return false;
   return entries.every(
-    (entry) => entry === "config.yaml" && hermesConfigLooksArgentOnly(path14.join(dir, entry))
+    (entry) => entry === "config.yaml" && hermesConfigLooksArgentOnly(path15.join(dir, entry))
   );
 }
 function kiroDirLooksArgentOnly(dir) {
   let entries;
   try {
-    entries = fs13.readdirSync(dir);
+    entries = fs14.readdirSync(dir);
   } catch {
     return false;
   }
   if (entries.length === 0) return false;
   return entries.every((entry) => {
     if (entry !== "settings") return false;
-    const settingsDir = path14.join(dir, entry);
+    const settingsDir = path15.join(dir, entry);
     let settingsEntries;
     try {
-      settingsEntries = fs13.readdirSync(settingsDir);
+      settingsEntries = fs14.readdirSync(settingsDir);
     } catch {
       return false;
     }
     if (settingsEntries.length === 0) return false;
     return settingsEntries.every(
-      (name) => name === "mcp.json" && jsonLooksArgentServerOnly(path14.join(settingsDir, name), "mcpServers")
+      (name) => name === "mcp.json" && jsonLooksArgentServerOnly(path15.join(settingsDir, name), "mcpServers")
     );
   });
 }
 function codexDirLooksArgentOnly(dir) {
   let entries;
   try {
-    entries = fs13.readdirSync(dir);
+    entries = fs14.readdirSync(dir);
   } catch {
     return false;
   }
   if (entries.length === 0) return false;
   return entries.every((entry) => {
-    const full = path14.join(dir, entry);
+    const full = path15.join(dir, entry);
     if (entry === "config.toml") {
       const config = parseTomlStrict(full);
       if (config === null) return false;
@@ -21084,13 +21456,13 @@ function codexDirLooksArgentOnly(dir) {
 var cursorAdapter = {
   name: "Cursor",
   detect() {
-    return dirHasEditorEvidence(path14.join(homedir4(), ".cursor"), cursorDirLooksArgentOnly) || dirHasEditorEvidence(path14.join(process.cwd(), ".cursor"), cursorDirLooksArgentOnly);
+    return dirHasEditorEvidence(path15.join(homedir4(), ".cursor"), cursorDirLooksArgentOnly) || dirHasEditorEvidence(path15.join(process.cwd(), ".cursor"), cursorDirLooksArgentOnly);
   },
   projectPath(root) {
-    return path14.join(root, ".cursor", "mcp.json");
+    return path15.join(root, ".cursor", "mcp.json");
   },
   globalPath() {
-    return path14.join(homedir4(), ".cursor", "mcp.json");
+    return path15.join(homedir4(), ".cursor", "mcp.json");
   },
   // Cursor is a VS Code fork: .cursor/mcp.json is JSONC (line/block comments,
   // trailing commas). Routing write/remove/hasArgentEntry through readJsonc /
@@ -21106,7 +21478,7 @@ var cursorAdapter = {
     });
   },
   remove(configPath) {
-    if (!fs13.existsSync(configPath)) return false;
+    if (!fs14.existsSync(configPath)) return false;
     const config = readJsonc(configPath);
     const servers = config.mcpServers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -21114,7 +21486,7 @@ var cursorAdapter = {
     return true;
   },
   getArgentEntry(configPath) {
-    if (!fs13.existsSync(configPath)) return null;
+    if (!fs14.existsSync(configPath)) return null;
     const config = readJsonc(configPath);
     const servers = config.mcpServers;
     return normalizeServerEntry(servers?.[MCP_SERVER_KEY]);
@@ -21131,7 +21503,7 @@ var cursorAdapter = {
   // because `hasArgentEntry` now reads mcp.json with readJsonc, so `update`
   // detects a commented config as configured and calls this.
   addAllowlist() {
-    const permPath = path14.join(homedir4(), ".cursor", "permissions.json");
+    const permPath = path15.join(homedir4(), ".cursor", "permissions.json");
     const config = readJsonc(permPath);
     const list = Array.isArray(config.mcpAllowlist) ? config.mcpAllowlist : [];
     if (list.includes(CURSOR_ALLOWLIST_PATTERN)) return;
@@ -21139,8 +21511,8 @@ var cursorAdapter = {
   },
   removeAllowlist(_root, scope) {
     if (scope !== "global") return;
-    const permPath = path14.join(homedir4(), ".cursor", "permissions.json");
-    if (!fs13.existsSync(permPath)) return;
+    const permPath = path15.join(homedir4(), ".cursor", "permissions.json");
+    if (!fs14.existsSync(permPath)) return;
     const config = readJsonc(permPath);
     const list = Array.isArray(config.mcpAllowlist) ? config.mcpAllowlist : void 0;
     if (!list || !list.includes(CURSOR_ALLOWLIST_PATTERN)) return;
@@ -21151,16 +21523,16 @@ var cursorAdapter = {
 function claudeProjectKeysForRoot(projects, root) {
   const canonical = (value) => {
     try {
-      return fs13.realpathSync.native(value);
+      return fs14.realpathSync.native(value);
     } catch {
-      return path14.resolve(value);
+      return path15.resolve(value);
     }
   };
   const target = canonical(root);
   return Object.keys(projects).filter((key) => key === root || canonical(key) === target);
 }
 function claudeDisabledListFinding(settingsPath, label, projectConfined) {
-  if (!fs13.existsSync(settingsPath)) return null;
+  if (!fs14.existsSync(settingsPath)) return null;
   const disabled = readJson(settingsPath).disabledMcpjsonServers;
   if (!Array.isArray(disabled) || !disabled.includes(MCP_SERVER_KEY)) return null;
   return {
@@ -21189,13 +21561,13 @@ var claudeAdapter = {
   name: "Claude Code",
   detect() {
     const mcpJsonArgentOnly = (p) => jsonLooksArgentServerOnly(p, "mcpServers");
-    return fileHasEditorEvidence(path14.join(process.cwd(), ".mcp.json"), mcpJsonArgentOnly) || fileHasEditorEvidence(path14.join(homedir4(), ".claude.json"), mcpJsonArgentOnly) || dirHasEditorEvidence(path14.join(process.cwd(), ".claude"), claudeDirLooksArgentOnly) || dirHasEditorEvidence(path14.join(homedir4(), ".claude"), claudeDirLooksArgentOnly);
+    return fileHasEditorEvidence(path15.join(process.cwd(), ".mcp.json"), mcpJsonArgentOnly) || fileHasEditorEvidence(path15.join(homedir4(), ".claude.json"), mcpJsonArgentOnly) || dirHasEditorEvidence(path15.join(process.cwd(), ".claude"), claudeDirLooksArgentOnly) || dirHasEditorEvidence(path15.join(homedir4(), ".claude"), claudeDirLooksArgentOnly);
   },
   projectPath(root) {
-    return path14.join(root, ".mcp.json");
+    return path15.join(root, ".mcp.json");
   },
   globalPath() {
-    return path14.join(homedir4(), ".claude.json");
+    return path15.join(homedir4(), ".claude.json");
   },
   // JSONC is a superset of JSON, so routing through readJsonc / editJsoncFile is
   // safe for this strict-JSON config and keeps every MCP-entry write on the one
@@ -21209,7 +21581,7 @@ var claudeAdapter = {
     });
   },
   remove(configPath) {
-    if (!fs13.existsSync(configPath)) return false;
+    if (!fs14.existsSync(configPath)) return false;
     const config = readJsonc(configPath);
     const servers = config.mcpServers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -21223,7 +21595,7 @@ var claudeAdapter = {
     return true;
   },
   getArgentEntry(configPath) {
-    if (!fs13.existsSync(configPath)) return null;
+    if (!fs14.existsSync(configPath)) return null;
     const config = readJsonc(configPath);
     const servers = config.mcpServers;
     return normalizeServerEntry(servers?.[MCP_SERVER_KEY]);
@@ -21239,7 +21611,7 @@ var claudeAdapter = {
   // reports recorded .mcp.json rejections (see claudeDisabledListFinding).
   findShadowingConfigs(root, writtenScope) {
     const findings = [];
-    const claudeJsonPath = path14.join(homedir4(), ".claude.json");
+    const claudeJsonPath = path15.join(homedir4(), ".claude.json");
     const projects = readJson(claudeJsonPath).projects;
     if (isRecord(projects)) {
       for (const key of claudeProjectKeysForRoot(projects, root)) {
@@ -21276,9 +21648,9 @@ var claudeAdapter = {
     }
     if (writtenScope === "local") {
       const candidates = [
-        [path14.join(root, ".claude", "settings.json"), ".claude/settings.json", true],
-        [path14.join(root, ".claude", "settings.local.json"), ".claude/settings.local.json", true],
-        [path14.join(homedir4(), ".claude", "settings.json"), "~/.claude/settings.json", false]
+        [path15.join(root, ".claude", "settings.json"), ".claude/settings.json", true],
+        [path15.join(root, ".claude", "settings.local.json"), ".claude/settings.local.json", true],
+        [path15.join(homedir4(), ".claude", "settings.json"), "~/.claude/settings.json", false]
       ];
       for (const [settingsPath, label, projectConfined] of candidates) {
         const finding = claudeDisabledListFinding(settingsPath, label, projectConfined);
@@ -21297,10 +21669,10 @@ var claudeAdapter = {
 var vscodeAdapter = {
   name: "VS Code",
   detect() {
-    return dirHasEditorEvidence(path14.join(process.cwd(), ".vscode"), vscodeDirLooksArgentOnly) || dirExists(path14.join(homedir4(), ".vscode"));
+    return dirHasEditorEvidence(path15.join(process.cwd(), ".vscode"), vscodeDirLooksArgentOnly) || dirExists(path15.join(homedir4(), ".vscode"));
   },
   projectPath(root) {
-    return path14.join(root, ".vscode", "mcp.json");
+    return path15.join(root, ".vscode", "mcp.json");
   },
   globalPath() {
     return null;
@@ -21321,7 +21693,7 @@ var vscodeAdapter = {
     });
   },
   remove(configPath) {
-    if (!fs13.existsSync(configPath)) return false;
+    if (!fs14.existsSync(configPath)) return false;
     const config = readJsonc(configPath);
     const servers = config.servers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -21329,7 +21701,7 @@ var vscodeAdapter = {
     return true;
   },
   getArgentEntry(configPath) {
-    if (!fs13.existsSync(configPath)) return null;
+    if (!fs14.existsSync(configPath)) return null;
     const config = readJsonc(configPath);
     const servers = config.servers;
     return normalizeServerEntry(servers?.[MCP_SERVER_KEY]);
@@ -21345,7 +21717,7 @@ var vscodeAdapter = {
   findShadowingConfigs(_root, _writtenScope) {
     const findings = [];
     for (const userDir of vscodeUserDirs()) {
-      const configPath = path14.join(userDir, "mcp.json");
+      const configPath = path15.join(userDir, "mcp.json");
       const entry = this.getArgentEntry(configPath);
       if (!entry) continue;
       findings.push({
@@ -21362,16 +21734,16 @@ var vscodeAdapter = {
 function vscodeUserDirs() {
   const bases = [];
   if (process.platform === "darwin") {
-    bases.push(path14.join(homedir4(), "Library", "Application Support"));
+    bases.push(path15.join(homedir4(), "Library", "Application Support"));
   } else if (process.platform === "win32") {
     if (process.env.APPDATA) bases.push(process.env.APPDATA);
   } else {
-    bases.push(path14.join(homedir4(), ".config"));
+    bases.push(path15.join(homedir4(), ".config"));
   }
   const dirs = [];
   for (const base of bases) {
     for (const product of ["Code", "Code - Insiders"]) {
-      const dir = path14.join(base, product, "User");
+      const dir = path15.join(base, product, "User");
       if (dirExists(dir)) dirs.push(dir);
     }
   }
@@ -21381,7 +21753,7 @@ var windsurfAdapter = {
   name: "Windsurf",
   detect() {
     return dirHasEditorEvidence(
-      path14.join(homedir4(), ".codeium", "windsurf"),
+      path15.join(homedir4(), ".codeium", "windsurf"),
       windsurfDirLooksArgentOnly
     );
   },
@@ -21389,7 +21761,7 @@ var windsurfAdapter = {
     return null;
   },
   globalPath() {
-    return path14.join(homedir4(), ".codeium", "windsurf", "mcp_config.json");
+    return path15.join(homedir4(), ".codeium", "windsurf", "mcp_config.json");
   },
   // JSONC-safe MCP-entry writes (see the Cursor adapter): editJsoncFile
   // preserves comments and pre-existing foreign servers on this JSON config.
@@ -21401,7 +21773,7 @@ var windsurfAdapter = {
     });
   },
   remove(configPath) {
-    if (!fs13.existsSync(configPath)) return false;
+    if (!fs14.existsSync(configPath)) return false;
     const config = readJsonc(configPath);
     const servers = config.mcpServers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -21409,7 +21781,7 @@ var windsurfAdapter = {
     return true;
   },
   getArgentEntry(configPath) {
-    if (!fs13.existsSync(configPath)) return null;
+    if (!fs14.existsSync(configPath)) return null;
     const config = readJsonc(configPath);
     const servers = config.mcpServers;
     return normalizeServerEntry(servers?.[MCP_SERVER_KEY]);
@@ -21423,7 +21795,7 @@ var windsurfAdapter = {
   // silently skipped the toggle; editJsoncFile targets just the argent entry's
   // alwaysAllow key so comments and foreign servers survive.
   addAllowlist() {
-    const configPath = path14.join(homedir4(), ".codeium", "windsurf", "mcp_config.json");
+    const configPath = path15.join(homedir4(), ".codeium", "windsurf", "mcp_config.json");
     const config = readJsonc(configPath);
     const servers = config.mcpServers;
     if (!servers?.[MCP_SERVER_KEY]) return;
@@ -21431,8 +21803,8 @@ var windsurfAdapter = {
   },
   removeAllowlist(_root, scope) {
     if (scope !== "global") return;
-    const configPath = path14.join(homedir4(), ".codeium", "windsurf", "mcp_config.json");
-    if (!fs13.existsSync(configPath)) return;
+    const configPath = path15.join(homedir4(), ".codeium", "windsurf", "mcp_config.json");
+    if (!fs14.existsSync(configPath)) return;
     const config = readJsonc(configPath);
     const servers = config.mcpServers;
     const entry = servers?.[MCP_SERVER_KEY];
@@ -21443,13 +21815,13 @@ var windsurfAdapter = {
 var zedAdapter = {
   name: "Zed",
   detect() {
-    return dirHasEditorEvidence(path14.join(homedir4(), ".config", "zed"), zedDirLooksArgentOnly);
+    return dirHasEditorEvidence(path15.join(homedir4(), ".config", "zed"), zedDirLooksArgentOnly);
   },
   projectPath(root) {
-    return path14.join(root, ".zed", "settings.json");
+    return path15.join(root, ".zed", "settings.json");
   },
   globalPath() {
-    return path14.join(homedir4(), ".config", "zed", "settings.json");
+    return path15.join(homedir4(), ".config", "zed", "settings.json");
   },
   // Zed's settings.json is JSONC (line + block comments, trailing commas).
   // The previous JSON.parse → mutate → JSON.stringify path silently stripped
@@ -21465,7 +21837,7 @@ var zedAdapter = {
     });
   },
   remove(configPath) {
-    if (!fs13.existsSync(configPath)) return false;
+    if (!fs14.existsSync(configPath)) return false;
     const config = readJsonc(configPath);
     const servers = config.context_servers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -21473,7 +21845,7 @@ var zedAdapter = {
     return true;
   },
   getArgentEntry(configPath) {
-    if (!fs13.existsSync(configPath)) return null;
+    if (!fs14.existsSync(configPath)) return null;
     const config = readJsonc(configPath);
     const servers = config.context_servers;
     return normalizeServerEntry(servers?.[MCP_SERVER_KEY]);
@@ -21486,12 +21858,12 @@ var zedAdapter = {
   // documented opt-in; built-in security rules still protect against
   // destructive operations.
   addAllowlist(root, scope) {
-    const settingsPath = scope === "global" ? path14.join(homedir4(), ".config", "zed", "settings.json") : path14.join(root, ".zed", "settings.json");
+    const settingsPath = scope === "global" ? path15.join(homedir4(), ".config", "zed", "settings.json") : path15.join(root, ".zed", "settings.json");
     editJsoncFile(settingsPath, ["agent", "tool_permissions", "default"], "allow");
   },
   removeAllowlist(root, scope) {
-    const settingsPath = scope === "global" ? path14.join(homedir4(), ".config", "zed", "settings.json") : path14.join(root, ".zed", "settings.json");
-    if (!fs13.existsSync(settingsPath)) return;
+    const settingsPath = scope === "global" ? path15.join(homedir4(), ".config", "zed", "settings.json") : path15.join(root, ".zed", "settings.json");
+    if (!fs14.existsSync(settingsPath)) return;
     const config = readJsonc(settingsPath);
     const perms = config.agent?.tool_permissions;
     if (!perms || perms.default !== "allow") return;
@@ -21501,13 +21873,13 @@ var zedAdapter = {
 var geminiAdapter = {
   name: "Gemini",
   detect() {
-    return dirHasEditorEvidence(path14.join(homedir4(), ".gemini"), geminiDirLooksArgentOnly) || dirHasEditorEvidence(path14.join(process.cwd(), ".gemini"), geminiDirLooksArgentOnly);
+    return dirHasEditorEvidence(path15.join(homedir4(), ".gemini"), geminiDirLooksArgentOnly) || dirHasEditorEvidence(path15.join(process.cwd(), ".gemini"), geminiDirLooksArgentOnly);
   },
   projectPath(root) {
-    return path14.join(root, ".gemini", "settings.json");
+    return path15.join(root, ".gemini", "settings.json");
   },
   globalPath() {
-    return path14.join(homedir4(), ".gemini", "settings.json");
+    return path15.join(homedir4(), ".gemini", "settings.json");
   },
   // JSONC-safe MCP-entry writes (see the Cursor adapter): editJsoncFile
   // preserves comments and pre-existing foreign servers on this JSON config.
@@ -21519,7 +21891,7 @@ var geminiAdapter = {
     });
   },
   remove(configPath) {
-    if (!fs13.existsSync(configPath)) return false;
+    if (!fs14.existsSync(configPath)) return false;
     const config = readJsonc(configPath);
     const servers = config.mcpServers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -21527,7 +21899,7 @@ var geminiAdapter = {
     return true;
   },
   getArgentEntry(configPath) {
-    if (!fs13.existsSync(configPath)) return null;
+    if (!fs14.existsSync(configPath)) return null;
     const config = readJsonc(configPath);
     const servers = config.mcpServers;
     return normalizeServerEntry(servers?.[MCP_SERVER_KEY]);
@@ -21552,7 +21924,7 @@ var geminiAdapter = {
   },
   removeAllowlist(root, scope) {
     const configPath = scope === "global" ? this.globalPath() : this.projectPath(root);
-    if (!configPath || !fs13.existsSync(configPath)) {
+    if (!configPath || !fs14.existsSync(configPath)) {
       return;
     }
     const config = readJsonc(configPath);
@@ -21566,13 +21938,13 @@ var CODEX_FILENAME = ".codex";
 var codexAdapter = {
   name: "Codex",
   detect() {
-    return dirHasEditorEvidence(path14.join(homedir4(), CODEX_FILENAME), codexDirLooksArgentOnly) || dirHasEditorEvidence(path14.join(process.cwd(), CODEX_FILENAME), codexDirLooksArgentOnly);
+    return dirHasEditorEvidence(path15.join(homedir4(), CODEX_FILENAME), codexDirLooksArgentOnly) || dirHasEditorEvidence(path15.join(process.cwd(), CODEX_FILENAME), codexDirLooksArgentOnly);
   },
   projectPath(root) {
-    return path14.join(root, CODEX_FILENAME, "config.toml");
+    return path15.join(root, CODEX_FILENAME, "config.toml");
   },
   globalPath() {
-    return path14.join(homedir4(), CODEX_FILENAME, "config.toml");
+    return path15.join(homedir4(), CODEX_FILENAME, "config.toml");
   },
   write(configPath, entry) {
     const config = readToml(configPath);
@@ -21586,7 +21958,7 @@ var codexAdapter = {
     writeToml(configPath, config);
   },
   remove(configPath) {
-    if (!fs13.existsSync(configPath)) return false;
+    if (!fs14.existsSync(configPath)) return false;
     const config = readToml(configPath);
     const servers = config.mcp_servers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -21596,7 +21968,7 @@ var codexAdapter = {
     return true;
   },
   getArgentEntry(configPath) {
-    if (!fs13.existsSync(configPath)) return null;
+    if (!fs14.existsSync(configPath)) return null;
     const config = readToml(configPath);
     const servers = config.mcp_servers;
     return normalizeServerEntry(servers?.[MCP_SERVER_KEY]);
@@ -21644,13 +22016,13 @@ var codexAdapter = {
 var hermesAdapter = {
   name: "Hermes",
   detect() {
-    return dirHasEditorEvidence(path14.join(homedir4(), ".hermes"), hermesDirLooksArgentOnly);
+    return dirHasEditorEvidence(path15.join(homedir4(), ".hermes"), hermesDirLooksArgentOnly);
   },
   projectPath() {
     return null;
   },
   globalPath() {
-    return path14.join(homedir4(), ".hermes", "config.yaml");
+    return path15.join(homedir4(), ".hermes", "config.yaml");
   },
   write(configPath, entry) {
     const doc = readYaml(configPath);
@@ -21669,7 +22041,7 @@ var hermesAdapter = {
     writeYaml(configPath, doc);
   },
   remove(configPath) {
-    if (!fs13.existsSync(configPath)) return false;
+    if (!fs14.existsSync(configPath)) return false;
     const doc = readYaml(configPath);
     const servers = doc.get("mcp_servers");
     if (!(0, import_yaml2.isMap)(servers)) return false;
@@ -21682,7 +22054,7 @@ var hermesAdapter = {
     return true;
   },
   getArgentEntry(configPath) {
-    if (!fs13.existsSync(configPath)) return null;
+    if (!fs14.existsSync(configPath)) return null;
     const doc = readYaml(configPath);
     const servers = doc.get("mcp_servers");
     if (!(0, import_yaml2.isMap)(servers)) return null;
@@ -21709,10 +22081,10 @@ function hasOpenCodeBinary() {
 }
 function pickOpencodeConfig(dir, candidates) {
   for (const name of candidates) {
-    const candidate = path14.join(dir, name);
-    if (fs13.existsSync(candidate)) return candidate;
+    const candidate = path15.join(dir, name);
+    if (fs14.existsSync(candidate)) return candidate;
   }
-  return path14.join(dir, "opencode.json");
+  return path15.join(dir, "opencode.json");
 }
 var openCodeAdapter = {
   name: "opencode",
@@ -21723,7 +22095,7 @@ var openCodeAdapter = {
     return pickOpencodeConfig(root, OPENCODE_PROJECT_FILES);
   },
   globalPath() {
-    return pickOpencodeConfig(path14.join(homedir4(), ".config", "opencode"), OPENCODE_GLOBAL_FILES);
+    return pickOpencodeConfig(path15.join(homedir4(), ".config", "opencode"), OPENCODE_GLOBAL_FILES);
   },
   write(configPath, entry) {
     editJsoncFile(configPath, ["mcp", MCP_SERVER_KEY], {
@@ -21734,7 +22106,7 @@ var openCodeAdapter = {
     });
   },
   remove(configPath) {
-    if (!fs13.existsSync(configPath)) return false;
+    if (!fs14.existsSync(configPath)) return false;
     const config = readJsonc(configPath);
     const servers = config.mcp;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -21742,7 +22114,7 @@ var openCodeAdapter = {
     return true;
   },
   getArgentEntry(configPath) {
-    if (!fs13.existsSync(configPath)) return null;
+    if (!fs14.existsSync(configPath)) return null;
     const config = readJsonc(configPath);
     const servers = config.mcp;
     return normalizeServerEntry(servers?.[MCP_SERVER_KEY]);
@@ -21757,7 +22129,7 @@ var openCodeAdapter = {
   },
   removeAllowlist(root, scope) {
     const configPath = scope === "global" ? this.globalPath() : this.projectPath(root);
-    if (!configPath || !fs13.existsSync(configPath)) return;
+    if (!configPath || !fs14.existsSync(configPath)) return;
     const config = readJsonc(configPath);
     const tools = config.tools;
     if (!tools || !(OPENCODE_ALLOWLIST_PATTERN in tools)) return;
@@ -21768,13 +22140,13 @@ var KIRO_AUTO_APPROVE_ALL = ["*"];
 var kiroAdapter = {
   name: "Kiro",
   detect() {
-    return dirHasEditorEvidence(path14.join(homedir4(), ".kiro"), kiroDirLooksArgentOnly) || dirHasEditorEvidence(path14.join(process.cwd(), ".kiro"), kiroDirLooksArgentOnly);
+    return dirHasEditorEvidence(path15.join(homedir4(), ".kiro"), kiroDirLooksArgentOnly) || dirHasEditorEvidence(path15.join(process.cwd(), ".kiro"), kiroDirLooksArgentOnly);
   },
   projectPath(root) {
-    return path14.join(root, ".kiro", "settings", "mcp.json");
+    return path15.join(root, ".kiro", "settings", "mcp.json");
   },
   globalPath() {
-    return path14.join(homedir4(), ".kiro", "settings", "mcp.json");
+    return path15.join(homedir4(), ".kiro", "settings", "mcp.json");
   },
   // Kiro is a VS Code fork: .kiro/settings/mcp.json is JSONC. As with Cursor,
   // route write/remove/hasArgentEntry through readJsonc / editJsoncFile so
@@ -21788,7 +22160,7 @@ var kiroAdapter = {
     });
   },
   remove(configPath) {
-    if (!fs13.existsSync(configPath)) return false;
+    if (!fs14.existsSync(configPath)) return false;
     const config = readJsonc(configPath);
     const servers = config.mcpServers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -21796,7 +22168,7 @@ var kiroAdapter = {
     return true;
   },
   getArgentEntry(configPath) {
-    if (!fs13.existsSync(configPath)) return null;
+    if (!fs14.existsSync(configPath)) return null;
     const config = readJsonc(configPath);
     const servers = config.mcpServers;
     return normalizeServerEntry(servers?.[MCP_SERVER_KEY]);
@@ -21823,7 +22195,7 @@ var kiroAdapter = {
   },
   removeAllowlist(root, scope) {
     const configPath = scope === "global" ? this.globalPath() : this.projectPath(root);
-    if (!configPath || !fs13.existsSync(configPath)) return;
+    if (!configPath || !fs14.existsSync(configPath)) return;
     const config = readJsonc(configPath);
     const servers = config.mcpServers;
     const entry = servers?.[MCP_SERVER_KEY];
@@ -21868,7 +22240,7 @@ function findConfiguredAdapterScopes(adapters, projectRoot) {
   return results;
 }
 function addClaudePermission(root, scope) {
-  const settingsPath = scope === "global" ? path14.join(homedir4(), ".claude", "settings.json") : path14.join(root, ".claude", "settings.json");
+  const settingsPath = scope === "global" ? path15.join(homedir4(), ".claude", "settings.json") : path15.join(root, ".claude", "settings.json");
   const config = readJsonc(settingsPath);
   const permissions = config.permissions ?? {};
   const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
@@ -21876,8 +22248,8 @@ function addClaudePermission(root, scope) {
   editJsoncFile(settingsPath, ["permissions", "allow"], [...allow, PERMISSION_RULE]);
 }
 function removeClaudePermission(root, scope) {
-  const settingsPath = scope === "global" ? path14.join(homedir4(), ".claude", "settings.json") : path14.join(root, ".claude", "settings.json");
-  if (!fs13.existsSync(settingsPath)) return;
+  const settingsPath = scope === "global" ? path15.join(homedir4(), ".claude", "settings.json") : path15.join(root, ".claude", "settings.json");
+  if (!fs14.existsSync(settingsPath)) return;
   const config = readJsonc(settingsPath);
   const permissions = config?.permissions;
   const allow = permissions?.allow;
@@ -21886,13 +22258,17 @@ function removeClaudePermission(root, scope) {
   const next = allow.filter((rule) => rule !== PERMISSION_RULE);
   editJsoncFile(settingsPath, ["permissions", "allow"], next.length > 0 ? next : void 0);
 }
+function formatCopyDestination(target, writtenPath, root) {
+  if (writtenPath === target.targetPath) return target.label;
+  return `${target.label} -> ${formatManagedPathLabel(writtenPath, realpathOrSelf(root))}`;
+}
 function formatManagedPathLabel(targetPath, root) {
   const home = homedir4();
-  if (targetPath === home || targetPath.startsWith(`${home}${path14.sep}`)) {
+  if (targetPath === home || targetPath.startsWith(`${home}${path15.sep}`)) {
     return `~${targetPath.slice(home.length)}`;
   }
-  const relative5 = path14.relative(root, targetPath);
-  if (relative5 && !relative5.startsWith("..") && !path14.isAbsolute(relative5)) {
+  const relative5 = path15.relative(root, targetPath);
+  if (relative5 && !relative5.startsWith("..") && !path15.isAbsolute(relative5)) {
     return relative5;
   }
   return targetPath;
@@ -21906,7 +22282,7 @@ function addManagedTarget(targets, editorName, targetPath, root) {
 }
 function getAdapterBasePath(adapter, root, scope) {
   const configPath = scope === "global" ? adapter.globalPath() : adapter.projectPath(root);
-  return configPath ? path14.dirname(configPath) : null;
+  return configPath ? path15.dirname(configPath) : null;
 }
 function getManagedContentTargets(adapters, root, scope) {
   const targets = {
@@ -21920,13 +22296,13 @@ function getManagedContentTargets(adapters, root, scope) {
   addManagedTarget(
     targets.skillTargets,
     "skills",
-    path14.join(workspaceBase, ".agents", "skills"),
+    path15.join(workspaceBase, ".agents", "skills"),
     root
   );
   addManagedTarget(
     targets.skillsLockTargets,
     "skills",
-    path14.join(workspaceBase, "skills-lock.json"),
+    path15.join(workspaceBase, "skills-lock.json"),
     root
   );
   for (const adapter of adapters) {
@@ -21934,21 +22310,21 @@ function getManagedContentTargets(adapters, root, scope) {
       case "Cursor": {
         const base = getAdapterBasePath(adapter, root, scope);
         if (!base) break;
-        addManagedTarget(targets.skillTargets, adapter.name, path14.join(base, "skills"), root);
-        addManagedTarget(targets.ruleTargets, adapter.name, path14.join(base, "rules"), root);
+        addManagedTarget(targets.skillTargets, adapter.name, path15.join(base, "skills"), root);
+        addManagedTarget(targets.ruleTargets, adapter.name, path15.join(base, "rules"), root);
         break;
       }
       case "Claude Code": {
-        const claudeBase = scope === "global" ? path14.join(homedir4(), ".claude") : path14.join(root, ".claude");
-        addManagedTarget(targets.skillTargets, adapter.name, path14.join(claudeBase, "skills"), root);
-        addManagedTarget(targets.ruleTargets, adapter.name, path14.join(claudeBase, "rules"), root);
-        addManagedTarget(targets.agentTargets, adapter.name, path14.join(claudeBase, "agents"), root);
+        const claudeBase = scope === "global" ? path15.join(homedir4(), ".claude") : path15.join(root, ".claude");
+        addManagedTarget(targets.skillTargets, adapter.name, path15.join(claudeBase, "skills"), root);
+        addManagedTarget(targets.ruleTargets, adapter.name, path15.join(claudeBase, "rules"), root);
+        addManagedTarget(targets.agentTargets, adapter.name, path15.join(claudeBase, "agents"), root);
         break;
       }
       case "Gemini": {
-        const geminiBase = scope === "global" ? path14.join(homedir4(), ".gemini") : path14.join(root, ".gemini");
-        addManagedTarget(targets.ruleTargets, adapter.name, path14.join(geminiBase, "rules"), root);
-        addManagedTarget(targets.agentTargets, adapter.name, path14.join(geminiBase, "agents"), root);
+        const geminiBase = scope === "global" ? path15.join(homedir4(), ".gemini") : path15.join(root, ".gemini");
+        addManagedTarget(targets.ruleTargets, adapter.name, path15.join(geminiBase, "rules"), root);
+        addManagedTarget(targets.agentTargets, adapter.name, path15.join(geminiBase, "agents"), root);
         break;
       }
       case "Codex": {
@@ -21958,9 +22334,9 @@ function getManagedContentTargets(adapters, root, scope) {
         break;
       }
       case "opencode": {
-        const base = scope === "global" ? path14.join(homedir4(), ".config", "opencode") : path14.join(root, ".opencode");
-        addManagedTarget(targets.skillTargets, adapter.name, path14.join(base, "skills"), root);
-        addManagedTarget(targets.agentTargets, adapter.name, path14.join(base, "agents"), root);
+        const base = scope === "global" ? path15.join(homedir4(), ".config", "opencode") : path15.join(root, ".opencode");
+        addManagedTarget(targets.skillTargets, adapter.name, path15.join(base, "skills"), root);
+        addManagedTarget(targets.agentTargets, adapter.name, path15.join(base, "agents"), root);
         break;
       }
     }
@@ -21974,12 +22350,12 @@ function stripFrontmatter(content) {
   return match ? content.slice(match[0].length).trim() : content.trim();
 }
 function readAndConcatRules(rulesDir) {
-  if (!fs13.existsSync(rulesDir)) return null;
-  const files = fs13.readdirSync(rulesDir).filter((f) => f.endsWith(".md")).sort();
+  if (!fs14.existsSync(rulesDir)) return null;
+  const files = fs14.readdirSync(rulesDir).filter((f) => f.endsWith(".md")).sort();
   if (files.length === 0) return null;
   const parts = [];
   for (const file of files) {
-    const raw = fs13.readFileSync(path14.join(rulesDir, file), "utf8");
+    const raw = fs14.readFileSync(path15.join(rulesDir, file), "utf8");
     const stripped = stripFrontmatter(raw);
     if (stripped) parts.push(stripped);
   }
@@ -22014,7 +22390,7 @@ function injectCodexRules(configPath, rulesDir) {
   return configPath;
 }
 function removeCodexRules(configPath) {
-  if (!fs13.existsSync(configPath)) return false;
+  if (!fs14.existsSync(configPath)) return false;
   const config = readToml(configPath);
   const existing = config.developer_instructions;
   if (!existing || !existing.includes(ARGENT_RULES_START)) return false;
@@ -22032,10 +22408,9 @@ function copyRulesAndAgents(adapters, root, scope, rulesDir, agentsDir) {
   const managedTargets = getManagedContentTargets(adapters, root, scope);
   for (const target of managedTargets.ruleTargets) {
     try {
-      if (fs13.existsSync(rulesDir)) {
-        fs13.mkdirSync(target.targetPath, { recursive: true });
-        fs13.cpSync(rulesDir, target.targetPath, { recursive: true });
-        results.push(`  Copied rules to ${target.targetPath}`);
+      const written = copyDir(rulesDir, target.targetPath);
+      if (written) {
+        results.push(`  Copied rules to ${formatCopyDestination(target, written, root)}`);
       }
     } catch (err) {
       results.push(`  Could not copy rules to ${target.targetPath}: ${err}`);
@@ -22043,10 +22418,9 @@ function copyRulesAndAgents(adapters, root, scope, rulesDir, agentsDir) {
   }
   for (const target of managedTargets.agentTargets) {
     try {
-      if (fs13.existsSync(agentsDir)) {
-        fs13.mkdirSync(target.targetPath, { recursive: true });
-        fs13.cpSync(agentsDir, target.targetPath, { recursive: true });
-        results.push(`  Copied agents to ${target.targetPath}`);
+      const written = copyDir(agentsDir, target.targetPath);
+      if (written) {
+        results.push(`  Copied agents to ${formatCopyDestination(target, written, root)}`);
       }
     } catch (err) {
       results.push(`  Could not copy agents to ${target.targetPath}: ${err}`);
@@ -22304,7 +22678,7 @@ var ShellCommandError = class extends Error {
   signal;
 };
 function runShellCommand(cmd, opts = {}) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const child = spawn2(cmd.bin, cmd.args, {
       stdio: ["ignore", "pipe", "pipe"],
       shell: process.platform === "win32",
@@ -22315,7 +22689,7 @@ function runShellCommand(cmd, opts = {}) {
       stderr += chunk.toString();
     });
     child.on("close", (code, signal) => {
-      if (code === 0) resolve12();
+      if (code === 0) resolve13();
       else
         reject(
           new ShellCommandError(
@@ -22752,7 +23126,7 @@ async function chooseAdapters(opts) {
 // ../argent-installer/src/init-scope.ts
 var import_picocolors5 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync12 } from "node:fs";
-import { resolve as resolve7 } from "node:path";
+import { resolve as resolve8 } from "node:path";
 async function chooseScope(opts) {
   if (opts.installMode === "local") {
     return { scope: "local" };
@@ -22789,13 +23163,13 @@ async function chooseScope(opts) {
     placeholder: process.cwd(),
     validate(value) {
       if (!value?.trim()) return "Path cannot be empty.";
-      const resolved = resolve7(value.trim());
+      const resolved = resolve8(value.trim());
       if (!existsSync12(resolved))
         return `Path does not exist: ${resolved}. Please verify and enter a valid path.`;
     }
   });
   if (isCancel(customPathInput)) throw new InitCancelled("scope");
-  return { scope: "custom", customRoot: resolve7(customPathInput.trim()) };
+  return { scope: "custom", customRoot: resolve8(customPathInput.trim()) };
 }
 
 // ../argent-installer/src/init-mcp-write.ts
@@ -23190,7 +23564,7 @@ async function runSkillsStep(args) {
   return skillsMethod;
 }
 function runNpxSkills(args, interactive, cwd) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const npxCmd = process.platform === "win32" ? "npx.cmd" : "npx";
     const child = spawn3(npxCmd, args, {
       stdio: interactive ? "inherit" : ["ignore", "pipe", "pipe"],
@@ -23209,7 +23583,7 @@ function runNpxSkills(args, interactive, cwd) {
     }
     child.on("close", (code) => {
       if (code === 0) {
-        resolve12();
+        resolve13();
       } else {
         const output = [stderr, stdout2].filter(Boolean).join("\n").trim();
         reject(new Error(output || `npx skills exited with code ${code}`));
@@ -23482,7 +23856,7 @@ function printBanner() {
 // ../argent-installer/src/update.ts
 var import_picocolors11 = __toESM(require_picocolors(), 1);
 var import_semver3 = __toESM(require_semver2(), 1);
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 
 // ../argent-installer/src/update-target.ts
 var import_update_core = __toESM(require_dist2(), 1);
@@ -23501,17 +23875,17 @@ async function resolveInstallableUpdateTarget(pm, current) {
 
 // ../argent-tools-client/src/launcher.ts
 import * as net from "node:net";
-import * as fs14 from "node:fs";
-import * as path15 from "node:path";
+import * as fs15 from "node:fs";
+import * as path16 from "node:path";
 import * as readline from "node:readline";
 import { homedir as homedir5 } from "node:os";
 import { spawn as spawn4, execFileSync as execFileSync5 } from "node:child_process";
 import { createHash as createHash2, randomBytes } from "node:crypto";
 import { mkdir, writeFile, readFile, readdir, unlink, rename, chmod } from "node:fs/promises";
-var STATE_DIR = path15.join(homedir5(), ".argent");
-var STATE_FILE = path15.join(STATE_DIR, "tool-server.json");
-var LOG_FILE = path15.join(STATE_DIR, "tool-server.log");
-var LOCK_FILE = path15.join(STATE_DIR, "tool-server.lock");
+var STATE_DIR = path16.join(homedir5(), ".argent");
+var STATE_FILE = path16.join(STATE_DIR, "tool-server.json");
+var LOG_FILE = path16.join(STATE_DIR, "tool-server.log");
+var LOCK_FILE = path16.join(STATE_DIR, "tool-server.lock");
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -23522,7 +23896,7 @@ function isProcessAlive(pid) {
 }
 function stateFileForBundle(bundlePath) {
   const key = createHash2("sha256").update(bundlePath).digest("hex").slice(0, 12);
-  return path15.join(STATE_DIR, `tool-server-${key}.json`);
+  return path16.join(STATE_DIR, `tool-server-${key}.json`);
 }
 async function readStateFile(file) {
   try {
@@ -23564,7 +23938,7 @@ async function readAllToolsServerStates() {
   const out = [];
   for (const name of names) {
     if (!STATE_FILE_RE.test(name)) continue;
-    const file = path15.join(STATE_DIR, name);
+    const file = path16.join(STATE_DIR, name);
     const state2 = await readStateFile(file);
     if (state2) out.push({ file, state: state2 });
   }
@@ -23606,21 +23980,21 @@ async function killToolServer(bundlePath) {
   await clearToolsServerState(bundlePath ?? state2.bundlePath);
 }
 function isPathWithin(child, parent) {
-  const rel = path15.relative(parent, child);
-  return rel !== "" && !rel.startsWith("..") && !path15.isAbsolute(rel);
+  const rel = path16.relative(parent, child);
+  return rel !== "" && !rel.startsWith("..") && !path16.isAbsolute(rel);
 }
 function tryRealpath(p) {
   try {
-    return fs14.realpathSync(p);
+    return fs15.realpathSync(p);
   } catch {
     return p;
   }
 }
 async function killToolServerForInstallDir(packageDir) {
-  const parents = /* @__PURE__ */ new Set([path15.resolve(packageDir), tryRealpath(packageDir)]);
+  const parents = /* @__PURE__ */ new Set([path16.resolve(packageDir), tryRealpath(packageDir)]);
   let killed = 0;
   for (const { file, state: state2 } of await readAllToolsServerStates()) {
-    const bundles = /* @__PURE__ */ new Set([path15.resolve(state2.bundlePath), tryRealpath(state2.bundlePath)]);
+    const bundles = /* @__PURE__ */ new Set([path16.resolve(state2.bundlePath), tryRealpath(state2.bundlePath)]);
     const matches2 = [...bundles].some((b) => [...parents].some((p) => isPathWithin(b, p)));
     if (!matches2) continue;
     const fresh = await readStateFile(file);
@@ -23659,23 +24033,23 @@ function processCommandMatches(pid, marker) {
 }
 
 // ../argent-tools-client/src/link-config.ts
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 import { homedir as homedir6 } from "node:os";
 import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile2, unlink as unlink2, chmod as chmod2 } from "node:fs/promises";
-var LINK_DIR = path16.join(homedir6(), ".argent");
-var LINK_FILE = path16.join(LINK_DIR, "link.json");
+var LINK_DIR = path17.join(homedir6(), ".argent");
+var LINK_FILE = path17.join(LINK_DIR, "link.json");
 
 // ../argent-tools-client/src/file-inputs.ts
 import { createHash as createHash3, randomUUID as randomUUID6 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
 import { mkdir as mkdir3, readFile as readFile3, rm as rm2, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 
 // ../archive/src/index.ts
 import { execFile } from "node:child_process";
 import { rm, readdir as readdir2 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname11, join as join17, posix as posix2, resolve as resolve9, sep as sep5 } from "node:path";
+import { basename as basename2, dirname as dirname11, join as join18, posix as posix2, resolve as resolve10, sep as sep5 } from "node:path";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
 
@@ -23686,7 +24060,7 @@ var MAX_CONTENT_BYTES = 32 * 1024 * 1024;
 import { copyFile, mkdir as mkdir4, readFile as readFile4, realpath, rm as rm3, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { basename as basename4, dirname as dirname13, extname as extname2, isAbsolute as isAbsolute5, join as join19, normalize, resolve as resolve10, sep as sep6 } from "node:path";
+import { basename as basename4, dirname as dirname13, extname as extname2, isAbsolute as isAbsolute5, join as join20, normalize, resolve as resolve11, sep as sep6 } from "node:path";
 import { createHash as createHash4 } from "node:crypto";
 var ALLOWED_SAVE_DIRS = /* @__PURE__ */ new Set([normalize(".argent/recordings")]);
 var RECORDINGS_SAVE_DIR = normalize(".argent/recordings");
@@ -24045,7 +24419,7 @@ async function update(args) {
       process.exit(1);
     }
     const rootOverride = getProjectRootOverride(args);
-    const projectRoot = rootOverride ? path18.resolve(rootOverride) : resolveProjectRoot2(process.cwd());
+    const projectRoot = rootOverride ? path19.resolve(rootOverride) : resolveProjectRoot2(process.cwd());
     installMode = resolveInstallMode(projectRoot);
     const flags = parseTargetFlags(args);
     const localInstalled = installMode === "local" && probeLocalInstall(projectRoot).installed;
@@ -24216,8 +24590,8 @@ async function update(args) {
 // ../argent-installer/src/uninstall.ts
 var import_picocolors12 = __toESM(require_picocolors(), 1);
 var import_yaml3 = __toESM(require_dist(), 1);
-import * as fs15 from "node:fs";
-import * as path19 from "node:path";
+import * as fs16 from "node:fs";
+import * as path20 from "node:path";
 var UNINSTALL_TOOLSERVER_STOP_FAILED = {
   error_code: FAILURE_CODES.UNINSTALL_TOOLSERVER_STOP_FAILED,
   failure_stage: "installer_uninstall_toolserver_stop",
@@ -24238,10 +24612,10 @@ var UNINSTALL_UNCLASSIFIED_FAILED = {
 };
 function removeDirIfEmpty2(dirPath) {
   try {
-    if (!fs15.existsSync(dirPath)) return false;
-    if (!fs15.statSync(dirPath).isDirectory()) return false;
-    if (fs15.readdirSync(dirPath).length > 0) return false;
-    fs15.rmdirSync(dirPath);
+    if (!fs16.existsSync(dirPath)) return false;
+    if (!fs16.statSync(dirPath).isDirectory()) return false;
+    if (fs16.readdirSync(dirPath).length > 0) return false;
+    fs16.rmdirSync(dirPath);
     return true;
   } catch {
     return false;
@@ -24251,9 +24625,9 @@ function collectBundledPaths(sourceDir) {
   const files = [];
   const directories = [];
   function walk(currentDir, relativeDir = "") {
-    for (const entry of fs15.readdirSync(currentDir, { withFileTypes: true })) {
-      const relativePath = relativeDir ? path19.join(relativeDir, entry.name) : entry.name;
-      const absolutePath = path19.join(currentDir, entry.name);
+    for (const entry of fs16.readdirSync(currentDir, { withFileTypes: true })) {
+      const relativePath = relativeDir ? path20.join(relativeDir, entry.name) : entry.name;
+      const absolutePath = path20.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath, relativePath);
         directories.push(relativePath);
@@ -24266,52 +24640,52 @@ function collectBundledPaths(sourceDir) {
   return { files, directories };
 }
 function removeBundledContent(sourceDir, targetDir) {
-  if (!fs15.existsSync(sourceDir) || !fs15.existsSync(targetDir)) {
+  if (!fs16.existsSync(sourceDir) || !fs16.existsSync(targetDir)) {
     return { removedPaths: [], removedRoot: false };
   }
   const { files, directories } = collectBundledPaths(sourceDir);
   const removedPaths = [];
   for (const relativePath of files) {
-    const targetPath = path19.join(targetDir, relativePath);
+    const targetPath = path20.join(targetDir, relativePath);
     try {
-      if (!fs15.existsSync(targetPath)) continue;
-      if (fs15.lstatSync(targetPath).isDirectory()) continue;
-      fs15.rmSync(targetPath, { force: true });
+      if (!fs16.existsSync(targetPath)) continue;
+      if (fs16.lstatSync(targetPath).isDirectory()) continue;
+      fs16.rmSync(targetPath, { force: true });
       removedPaths.push(relativePath);
     } catch {
     }
   }
   directories.sort(
-    (a3, b) => b.split(path19.sep).length - a3.split(path19.sep).length || b.length - a3.length
+    (a3, b) => b.split(path20.sep).length - a3.split(path20.sep).length || b.length - a3.length
   );
   for (const relativePath of directories) {
-    const targetPath = path19.join(targetDir, relativePath);
+    const targetPath = path20.join(targetDir, relativePath);
     try {
-      if (!fs15.existsSync(targetPath)) continue;
-      if (!fs15.statSync(targetPath).isDirectory()) continue;
-      if (fs15.readdirSync(targetPath).length > 0) continue;
-      fs15.rmdirSync(targetPath);
+      if (!fs16.existsSync(targetPath)) continue;
+      if (!fs16.statSync(targetPath).isDirectory()) continue;
+      if (fs16.readdirSync(targetPath).length > 0) continue;
+      fs16.rmdirSync(targetPath);
     } catch {
     }
   }
   let removedRoot = false;
   try {
-    if (fs15.existsSync(targetDir) && fs15.statSync(targetDir).isDirectory()) {
-      if (fs15.readdirSync(targetDir).length === 0) {
-        fs15.rmdirSync(targetDir);
+    if (fs16.existsSync(targetDir) && fs16.statSync(targetDir).isDirectory()) {
+      if (fs16.readdirSync(targetDir).length === 0) {
+        fs16.rmdirSync(targetDir);
         removedRoot = true;
       }
     }
   } catch {
   }
   if (removedRoot) {
-    removeDirIfEmpty2(path19.dirname(targetDir));
+    removeDirIfEmpty2(path20.dirname(targetDir));
   }
   return { removedPaths, removedRoot };
 }
 function readBundledSkillName(skillFilePath, fallbackName) {
   try {
-    const content = fs15.readFileSync(skillFilePath, "utf8");
+    const content = fs16.readFileSync(skillFilePath, "utf8");
     const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1];
     if (!frontmatter) return fallbackName;
     const data = (0, import_yaml3.parse)(frontmatter);
@@ -24322,30 +24696,30 @@ function readBundledSkillName(skillFilePath, fallbackName) {
   }
 }
 function getBundledSkillNames(skillsDir) {
-  if (!fs15.existsSync(skillsDir)) return [];
+  if (!fs16.existsSync(skillsDir)) return [];
   const skillNames = [];
-  for (const entry of fs15.readdirSync(skillsDir, { withFileTypes: true })) {
+  for (const entry of fs16.readdirSync(skillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const skillFilePath = path19.join(skillsDir, entry.name, "SKILL.md");
-    if (!fs15.existsSync(skillFilePath)) continue;
+    const skillFilePath = path20.join(skillsDir, entry.name, "SKILL.md");
+    if (!fs16.existsSync(skillFilePath)) continue;
     skillNames.push(readBundledSkillName(skillFilePath, entry.name));
   }
   return [...new Set(skillNames)].sort();
 }
 function removeBundledSkillInstalls(skillNames, targetDir) {
-  if (!fs15.existsSync(targetDir)) {
+  if (!fs16.existsSync(targetDir)) {
     return { removedPaths: [], removedRoot: false };
   }
   const removedPaths = [];
   for (const skillName of skillNames) {
-    const targetPath = path19.join(targetDir, skillName);
+    const targetPath = path20.join(targetDir, skillName);
     try {
-      if (!fs15.existsSync(targetPath)) continue;
-      const stats = fs15.lstatSync(targetPath);
+      if (!fs16.existsSync(targetPath)) continue;
+      const stats = fs16.lstatSync(targetPath);
       if (stats.isDirectory() && !stats.isSymbolicLink()) {
-        fs15.rmSync(targetPath, { recursive: true, force: true });
+        fs16.rmSync(targetPath, { recursive: true, force: true });
       } else {
-        fs15.rmSync(targetPath, { force: true });
+        fs16.rmSync(targetPath, { force: true });
       }
       removedPaths.push(skillName);
     } catch {
@@ -24353,17 +24727,17 @@ function removeBundledSkillInstalls(skillNames, targetDir) {
   }
   const removedRoot = removeDirIfEmpty2(targetDir);
   if (removedRoot) {
-    removeDirIfEmpty2(path19.dirname(targetDir));
+    removeDirIfEmpty2(path20.dirname(targetDir));
   }
   return { removedPaths, removedRoot };
 }
 function cleanupSkillsLockFile(lockPath, skillNames) {
-  if (!fs15.existsSync(lockPath)) {
+  if (!fs16.existsSync(lockPath)) {
     return { removedSkills: [], removedFile: false };
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs15.readFileSync(lockPath, "utf8"));
+    parsed = JSON.parse(fs16.readFileSync(lockPath, "utf8"));
   } catch {
     return { removedSkills: [], removedFile: false };
   }
@@ -24390,10 +24764,10 @@ function cleanupSkillsLockFile(lockPath, skillNames) {
     parsed.skills && typeof parsed.skills === "object" && Object.keys(parsed.skills).length > 0
   );
   if (!hasSkills && otherKeys.length === 0) {
-    fs15.rmSync(lockPath, { force: true });
+    fs16.rmSync(lockPath, { force: true });
     return { removedSkills, removedFile: true };
   }
-  fs15.writeFileSync(lockPath, JSON.stringify(parsed, null, 2) + "\n");
+  fs16.writeFileSync(lockPath, JSON.stringify(parsed, null, 2) + "\n");
   return { removedSkills, removedFile: false };
 }
 function cleanupBundledSkills(skillNames, targets) {