@swmansion/argent 0.13.1-next.1 → 0.13.1-next.2

package/dist/installer.mjs

@@ -2238,17 +2238,17 @@ var require_visit = __commonJS({
     visit2.BREAK = BREAK;
     visit2.SKIP = SKIP;
     visit2.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path10) {
-      const ctrl = callVisitor(key, node, visitor, path10);
+    function visit_(key, node, visitor, path12) {
+      const ctrl = callVisitor(key, node, visitor, path12);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path10, ctrl);
-        return visit_(key, ctrl, visitor, path10);
+        replaceNode(key, path12, ctrl);
+        return visit_(key, ctrl, visitor, path12);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path10 = Object.freeze(path10.concat(node));
+          path12 = Object.freeze(path12.concat(node));
           for (let i2 = 0; i2 < node.items.length; ++i2) {
-            const ci = visit_(i2, node.items[i2], visitor, path10);
+            const ci = visit_(i2, node.items[i2], visitor, path12);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -2259,13 +2259,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path10 = Object.freeze(path10.concat(node));
-          const ck = visit_("key", node.key, visitor, path10);
+          path12 = Object.freeze(path12.concat(node));
+          const ck = visit_("key", node.key, visitor, path12);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path10);
+          const cv = visit_("value", node.value, visitor, path12);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -2286,17 +2286,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path10) {
-      const ctrl = await callVisitor(key, node, visitor, path10);
+    async function visitAsync_(key, node, visitor, path12) {
+      const ctrl = await callVisitor(key, node, visitor, path12);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path10, ctrl);
-        return visitAsync_(key, ctrl, visitor, path10);
+        replaceNode(key, path12, ctrl);
+        return visitAsync_(key, ctrl, visitor, path12);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path10 = Object.freeze(path10.concat(node));
+          path12 = Object.freeze(path12.concat(node));
           for (let i2 = 0; i2 < node.items.length; ++i2) {
-            const ci = await visitAsync_(i2, node.items[i2], visitor, path10);
+            const ci = await visitAsync_(i2, node.items[i2], visitor, path12);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -2307,13 +2307,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path10 = Object.freeze(path10.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path10);
+          path12 = Object.freeze(path12.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path12);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path10);
+          const cv = await visitAsync_("value", node.value, visitor, path12);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -2340,23 +2340,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path10) {
+    function callVisitor(key, node, visitor, path12) {
       if (typeof visitor === "function")
-        return visitor(key, node, path10);
+        return visitor(key, node, path12);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path10);
+        return visitor.Map?.(key, node, path12);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path10);
+        return visitor.Seq?.(key, node, path12);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path10);
+        return visitor.Pair?.(key, node, path12);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path10);
+        return visitor.Scalar?.(key, node, path12);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path10);
+        return visitor.Alias?.(key, node, path12);
       return void 0;
     }
-    function replaceNode(key, path10, node) {
-      const parent = path10[path10.length - 1];
+    function replaceNode(key, path12, node) {
+      const parent = path12[path12.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -2966,10 +2966,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path10, value) {
+    function collectionFromPath(schema, path12, value) {
       let v = value;
-      for (let i2 = path10.length - 1; i2 >= 0; --i2) {
-        const k = path10[i2];
+      for (let i2 = path12.length - 1; i2 >= 0; --i2) {
+        const k = path12[i2];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a3 = [];
           a3[k] = v;
@@ -2988,7 +2988,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path10) => path10 == null || typeof path10 === "object" && !!path10[Symbol.iterator]().next().done;
+    var isEmptyPath = (path12) => path12 == null || typeof path12 === "object" && !!path12[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -3018,11 +3018,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(path10, value) {
-        if (isEmptyPath(path10))
+      addIn(path12, value) {
+        if (isEmptyPath(path12))
           this.add(value);
         else {
-          const [key, ...rest] = path10;
+          const [key, ...rest] = path12;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -3036,8 +3036,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path10) {
-        const [key, ...rest] = path10;
+      deleteIn(path12) {
+        const [key, ...rest] = path12;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -3051,8 +3051,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path10, keepScalar) {
-        const [key, ...rest] = path10;
+      getIn(path12, keepScalar) {
+        const [key, ...rest] = path12;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -3070,8 +3070,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path10) {
-        const [key, ...rest] = path10;
+      hasIn(path12) {
+        const [key, ...rest] = path12;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -3081,8 +3081,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(path10, value) {
-        const [key, ...rest] = path10;
+      setIn(path12, value) {
+        const [key, ...rest] = path12;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -5597,9 +5597,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path10, value) {
+      addIn(path12, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path10, value);
+          this.contents.addIn(path12, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -5674,14 +5674,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path10) {
-        if (Collection.isEmptyPath(path10)) {
+      deleteIn(path12) {
+        if (Collection.isEmptyPath(path12)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path10) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path12) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -5696,10 +5696,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path10, keepScalar) {
-        if (Collection.isEmptyPath(path10))
+      getIn(path12, keepScalar) {
+        if (Collection.isEmptyPath(path12))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path10, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path12, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -5710,10 +5710,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path10) {
-        if (Collection.isEmptyPath(path10))
+      hasIn(path12) {
+        if (Collection.isEmptyPath(path12))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path10) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path12) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -5730,13 +5730,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(path10, value) {
-        if (Collection.isEmptyPath(path10)) {
+      setIn(path12, value) {
+        if (Collection.isEmptyPath(path12)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path10), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path12), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path10, value);
+          this.contents.setIn(path12, value);
         }
       }
       /**
@@ -7696,9 +7696,9 @@ var require_cst_visit = __commonJS({
     visit2.BREAK = BREAK;
     visit2.SKIP = SKIP;
     visit2.REMOVE = REMOVE;
-    visit2.itemAtPath = (cst, path10) => {
+    visit2.itemAtPath = (cst, path12) => {
       let item = cst;
-      for (const [field, index] of path10) {
+      for (const [field, index] of path12) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -7707,23 +7707,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit2.parentCollection = (cst, path10) => {
-      const parent = visit2.itemAtPath(cst, path10.slice(0, -1));
-      const field = path10[path10.length - 1][0];
+    visit2.parentCollection = (cst, path12) => {
+      const parent = visit2.itemAtPath(cst, path12.slice(0, -1));
+      const field = path12[path12.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path10, item, visitor) {
-      let ctrl = visitor(item, path10);
+    function _visit(path12, item, visitor) {
+      let ctrl = visitor(item, path12);
       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(path10.concat([[field, i2]])), token.items[i2], visitor);
+            const ci = _visit(Object.freeze(path12.concat([[field, i2]])), token.items[i2], visitor);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -7734,10 +7734,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path10);
+            ctrl = ctrl(item, path12);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path10) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path12) : ctrl;
     }
     exports.visit = visit2;
   }
@@ -9039,14 +9039,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs9 = this.flowScalar(this.type);
+              const fs10 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs9, sep: [] });
+                map.items.push({ start, key: fs10, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs9);
+                this.stack.push(fs10);
               } else {
-                Object.assign(it, { key: fs9, sep: [] });
+                Object.assign(it, { key: fs10, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -9174,13 +9174,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs9 = this.flowScalar(this.type);
+              const fs10 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs9, sep: [] });
+                fc.items.push({ start: [], key: fs10, sep: [] });
               else if (it.sep)
-                this.stack.push(fs9);
+                this.stack.push(fs10);
               else
-                Object.assign(it, { key: fs9, sep: [] });
+                Object.assign(it, { key: fs10, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -9593,13 +9593,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((resolve3) => {
+      return new Promise((resolve4) => {
         (0, node_child_process_1.exec)(p.command, { timeout: PROBE_TIMEOUT_MS2, windowsHide: true }, (err, stdout2) => {
           if (err) {
-            resolve3(0);
+            resolve4(0);
             return;
           }
-          resolve3(p.parse(stdout2));
+          resolve4(p.parse(stdout2));
         });
       });
     }
@@ -9632,12 +9632,12 @@ var require_registry = __commonJS({
     var node_https_1 = __importDefault(__require("node:https"));
     var REQUEST_TIMEOUT_MS = 1e4;
     function fetchRegistryInfo2(url) {
-      return new Promise((resolve3) => {
+      return new Promise((resolve4) => {
         let resolved = false;
         const safeResolve = (value) => {
           if (!resolved) {
             resolved = true;
-            resolve3(value);
+            resolve4(value);
           }
         };
         const req = node_https_1.default.get(url, { timeout: REQUEST_TIMEOUT_MS }, (res) => {
@@ -11120,8 +11120,8 @@ ${r2}
 
 // ../argent-installer/src/init.ts
 var import_picocolors3 = __toESM(require_picocolors(), 1);
-import { existsSync as existsSync5 } from "node:fs";
-import { resolve as resolve2 } from "node:path";
+import { existsSync as existsSync6 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
 import { spawn } from "node:child_process";
 
 // ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
@@ -11151,8 +11151,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? dirname2(proce
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path10) {
-  return path10.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path12) {
+  return path12.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 
 // ../../node_modules/@posthog/core/dist/featureFlagUtils.mjs
@@ -13704,15 +13704,15 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path10, ranges, output) {
-  return new Promise((resolve3) => {
-    const stream = createReadStream(path10);
+function getContextLinesFromFile(path12, ranges, output) {
+  return new Promise((resolve4) => {
+    const stream = createReadStream(path12);
     const lineReaded = createInterface2({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve3();
+      resolve4();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -13721,7 +13721,7 @@ function getContextLinesFromFile(path10, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path10, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path12, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -13782,8 +13782,8 @@ function clearLineContext(frame) {
   delete frame.context_line;
   delete frame.post_context;
 }
-function shouldSkipContextLinesForFile(path10) {
-  return path10.startsWith("node:") || path10.endsWith(".min.js") || path10.endsWith(".min.cjs") || path10.endsWith(".min.mjs") || path10.startsWith("data:");
+function shouldSkipContextLinesForFile(path12) {
+  return path12.startsWith("node:") || path12.endsWith(".min.js") || path12.endsWith(".min.cjs") || path12.endsWith(".min.mjs") || path12.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame) {
   if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
@@ -15009,9 +15009,9 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     if (!waitUntil) return;
     if (this.disabled || this.optedOut) return;
     if (!this._waitUntilCycle) {
-      let resolve3;
+      let resolve4;
       const promise = new Promise((r2) => {
-        resolve3 = r2;
+        resolve4 = r2;
       });
       try {
         waitUntil(promise);
@@ -15019,7 +15019,7 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
         return;
       }
       this._waitUntilCycle = {
-        resolve: resolve3,
+        resolve: resolve4,
         startedAt: Date.now(),
         timer: void 0
       };
@@ -15043,12 +15043,12 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     return cycle?.resolve;
   }
   async resolveWaitUntilFlush() {
-    const resolve3 = this._consumeWaitUntilCycle();
+    const resolve4 = this._consumeWaitUntilCycle();
     try {
       await super.flush();
     } catch {
     } finally {
-      resolve3?.();
+      resolve4?.();
     }
   }
   getPersistedProperty(key) {
@@ -15169,15 +15169,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((resolve3) => {
+    return new Promise((resolve4) => {
       const timeout = setTimeout(() => {
         cleanup();
-        resolve3(false);
+        resolve4(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count) => {
         clearTimeout(timeout);
         cleanup();
-        resolve3(count > 0);
+        resolve4(count > 0);
       });
     });
   }
@@ -15632,14 +15632,14 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     this.context?.enter(data, options);
   }
   async _shutdown(shutdownTimeoutMs) {
-    const resolve3 = this._consumeWaitUntilCycle();
+    const resolve4 = this._consumeWaitUntilCycle();
     await this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
     this.errorTracking.shutdown();
     try {
       return await super._shutdown(shutdownTimeoutMs);
     } finally {
       this.distinctIdHasSentFlagCalls = {};
-      resolve3?.();
+      resolve4?.();
     }
   }
   async _requestRemoteConfigPayload(flagKey) {
@@ -16477,9 +16477,9 @@ function isReplitAgent(env) {
 }
 var DEVIN_MARKER_PATH = "/opt/.devin";
 var JULES_MARKER_PATH = "/opt/environment_summary.sh";
-function safeExists(fileExists, path10) {
+function safeExists(fileExists, path12) {
   try {
-    return fileExists(path10);
+    return fileExists(path12);
   } catch {
     return false;
   }
@@ -16933,13 +16933,21 @@ function getBaseProps(runtime) {
 }
 
 // ../telemetry/src/identity.ts
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import * as path2 from "node:path";
+import * as crypto2 from "node:crypto";
+import * as fs3 from "node:fs";
+import * as path5 from "node:path";
 
 // ../telemetry/src/paths.ts
-import * as os from "node:os";
+import * as path4 from "node:path";
+
+// ../configuration-core/src/flags.ts
+import * as fs from "node:fs";
 import * as path from "node:path";
+import { homedir } from "node:os";
+
+// ../configuration-core/src/paths.ts
+import * as os from "node:os";
+import * as path2 from "node:path";
 function nonEmpty(value) {
   if (value == void 0) return null;
   const trimmed = value.trim();
@@ -16947,99 +16955,14 @@ function nonEmpty(value) {
 }
 function argentHomeDir() {
   const home = process.platform === "win32" ? nonEmpty(process.env.USERPROFILE) ?? os.homedir() : nonEmpty(process.env.HOME) ?? os.homedir();
-  return path.join(home, ".argent");
-}
-function identityFilePath() {
-  return path.join(argentHomeDir(), "telemetry-id");
+  return path2.join(home, ".argent");
 }
 function configFilePath() {
-  return path.join(argentHomeDir(), "config.json");
-}
-function debugLogPath() {
-  return path.join(argentHomeDir(), "telemetry-debug.log");
+  return path2.join(argentHomeDir(), "config.json");
 }
 
-// ../telemetry/src/identity.ts
-var cached = null;
-function readOrCreateAnonId() {
-  const finalPath = identityFilePath();
-  if (cached && cached.path === finalPath) return cached.id;
-  const existing = tryReadId(finalPath);
-  if (existing) {
-    cached = { path: finalPath, id: existing };
-    return existing;
-  }
-  fs.mkdirSync(argentHomeDir(), { recursive: true });
-  const uuid = crypto.randomUUID();
-  for (let attempt = 0; attempt < 3; attempt++) {
-    const tmpPath = path2.join(
-      argentHomeDir(),
-      `.telemetry-id.tmp.${process.pid}.${crypto.randomUUID()}`
-    );
-    let fd;
-    try {
-      fd = fs.openSync(tmpPath, "wx", 384);
-    } catch (err) {
-      if (err.code === "EEXIST") continue;
-      throw err;
-    }
-    try {
-      try {
-        fs.writeSync(fd, uuid);
-        fs.fsyncSync(fd);
-      } finally {
-        fs.closeSync(fd);
-      }
-      fs.linkSync(tmpPath, finalPath);
-      cached = { path: finalPath, id: uuid };
-      return uuid;
-    } catch (err) {
-      if (err.code === "EEXIST") {
-        const beatUs = tryReadId(finalPath);
-        if (beatUs) {
-          cached = { path: finalPath, id: beatUs };
-          return beatUs;
-        }
-        continue;
-      }
-      throw err;
-    } finally {
-      try {
-        fs.unlinkSync(tmpPath);
-      } catch {
-      }
-    }
-  }
-  throw new Error("telemetry: failed to create anonymous identity after retries");
-}
-function deleteAnonId() {
-  cached = null;
-  try {
-    fs.unlinkSync(identityFilePath());
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-}
-function tryReadId(filePath) {
-  let raw;
-  try {
-    const stats = fs.lstatSync(filePath);
-    if (!stats.isFile()) return null;
-    raw = fs.readFileSync(filePath, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT") return null;
-    return null;
-  }
-  const value = raw.trim();
-  if (/^[0-9a-fA-F-]{32,128}$/.test(value)) return value;
-  return null;
-}
-
-// ../telemetry/src/consent.ts
-import * as fs3 from "node:fs";
-
-// ../telemetry/src/config-file.ts
-import * as crypto2 from "node:crypto";
+// ../configuration-core/src/config.ts
+import * as crypto from "node:crypto";
 import * as fs2 from "node:fs";
 import * as path3 from "node:path";
 function readConfigObject() {
@@ -17102,7 +17025,7 @@ function updateConfig(mutate) {
     const next = readConfigObject();
     mutate(next);
     const finalPath = configFilePath();
-    const tmpPath = path3.join(argentHomeDir(), `.config.tmp.${process.pid}.${crypto2.randomUUID()}`);
+    const tmpPath = path3.join(argentHomeDir(), `.config.tmp.${process.pid}.${crypto.randomUUID()}`);
     const fd = fs2.openSync(tmpPath, "wx", 384);
     try {
       fs2.writeSync(fd, JSON.stringify(next, null, 2) + "\n");
@@ -17124,13 +17047,98 @@ function updateConfig(mutate) {
   }
 }
 
+// ../telemetry/src/paths.ts
+function identityFilePath() {
+  return path4.join(argentHomeDir(), "telemetry-id");
+}
+function debugLogPath() {
+  return path4.join(argentHomeDir(), "telemetry-debug.log");
+}
+
+// ../telemetry/src/identity.ts
+var cached = null;
+function readOrCreateAnonId() {
+  const finalPath = identityFilePath();
+  if (cached && cached.path === finalPath) return cached.id;
+  const existing = tryReadId(finalPath);
+  if (existing) {
+    cached = { path: finalPath, id: existing };
+    return existing;
+  }
+  fs3.mkdirSync(argentHomeDir(), { recursive: true });
+  const uuid = crypto2.randomUUID();
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const tmpPath = path5.join(
+      argentHomeDir(),
+      `.telemetry-id.tmp.${process.pid}.${crypto2.randomUUID()}`
+    );
+    let fd;
+    try {
+      fd = fs3.openSync(tmpPath, "wx", 384);
+    } catch (err) {
+      if (err.code === "EEXIST") continue;
+      throw err;
+    }
+    try {
+      try {
+        fs3.writeSync(fd, uuid);
+        fs3.fsyncSync(fd);
+      } finally {
+        fs3.closeSync(fd);
+      }
+      fs3.linkSync(tmpPath, finalPath);
+      cached = { path: finalPath, id: uuid };
+      return uuid;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        const beatUs = tryReadId(finalPath);
+        if (beatUs) {
+          cached = { path: finalPath, id: beatUs };
+          return beatUs;
+        }
+        continue;
+      }
+      throw err;
+    } finally {
+      try {
+        fs3.unlinkSync(tmpPath);
+      } catch {
+      }
+    }
+  }
+  throw new Error("telemetry: failed to create anonymous identity after retries");
+}
+function deleteAnonId() {
+  cached = null;
+  try {
+    fs3.unlinkSync(identityFilePath());
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+function tryReadId(filePath) {
+  let raw;
+  try {
+    const stats = fs3.lstatSync(filePath);
+    if (!stats.isFile()) return null;
+    raw = fs3.readFileSync(filePath, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    return null;
+  }
+  const value = raw.trim();
+  if (/^[0-9a-fA-F-]{32,128}$/.test(value)) return value;
+  return null;
+}
+
 // ../telemetry/src/consent.ts
+import * as fs4 from "node:fs";
 var cache = { current: null };
 var sessionOverride = null;
 function readConfigOverride() {
   let stats;
   try {
-    stats = fs3.lstatSync(configFilePath());
+    stats = fs4.lstatSync(configFilePath());
   } catch (err) {
     if (err.code === "ENOENT") {
       cache.current = { mtimeMs: null, fingerprint: null, enabledOverride: null };
@@ -17150,7 +17158,7 @@ function readConfigOverride() {
   }
   let parsedEnabled = null;
   try {
-    const raw = fs3.readFileSync(configFilePath(), "utf8");
+    const raw = fs4.readFileSync(configFilePath(), "utf8");
     const json = JSON.parse(raw);
     if (json && typeof json === "object") {
       const t2 = json.telemetry;
@@ -17214,7 +17222,7 @@ function setSessionConsentOverride(enabled) {
 }
 
 // ../telemetry/src/debug.ts
-import * as fs4 from "node:fs";
+import * as fs5 from "node:fs";
 function isDebugEnabled(env = process.env) {
   const v = env.ARGENT_TELEMETRY_DEBUG;
   if (!v) return false;
@@ -17241,8 +17249,8 @@ function emitDebugPayload(payload) {
   } catch {
   }
   try {
-    fs4.mkdirSync(argentHomeDir(), { recursive: true });
-    fs4.appendFileSync(debugLogPath(), line + "\n");
+    fs5.mkdirSync(argentHomeDir(), { recursive: true });
+    fs5.appendFileSync(debugLogPath(), line + "\n");
   } catch {
   }
 }
@@ -17384,7 +17392,7 @@ async function shutdown(timeoutMs = SHORT_FLUSH_TIMEOUT_MS) {
   try {
     await Promise.race([
       client2.shutdown(timeoutMs),
-      new Promise((resolve3) => setTimeout(resolve3, timeoutMs + 250).unref())
+      new Promise((resolve4) => setTimeout(resolve4, timeoutMs + 250).unref())
     ]);
   } catch (err) {
     emitDebugError("shutdown failed", err);
@@ -17398,10 +17406,10 @@ async function forget2(options) {
 }
 
 // ../argent-installer/src/mcp-configs.ts
-import * as fs6 from "node:fs";
-import * as path5 from "node:path";
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
 import { execFileSync } from "node:child_process";
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir4 } from "node:os";
 
 // ../argent-installer/src/constants.ts
 var PACKAGE_NAME = "@swmansion/argent";
@@ -17413,8 +17421,8 @@ var CURSOR_ALLOWLIST_PATTERN = "argent:*";
 
 // ../argent-installer/src/utils.ts
 var import_semver = __toESM(require_semver2(), 1);
-import * as fs5 from "node:fs";
-import * as path4 from "node:path";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
 import * as dns from "node:dns";
 import * as os2 from "node:os";
 import { execSync } from "node:child_process";
@@ -19039,12 +19047,12 @@ function parseTree(text2, errors = [], options = ParseOptions.DEFAULT) {
   }
   return result;
 }
-function findNodeAtLocation(root, path10) {
+function findNodeAtLocation(root, path12) {
   if (!root) {
     return void 0;
   }
   let node = root;
-  for (let segment of path10) {
+  for (let segment of path12) {
     if (typeof segment === "string") {
       if (node.type !== "object" || !Array.isArray(node.children)) {
         return void 0;
@@ -19398,14 +19406,14 @@ function getNodeType(value) {
 
 // ../../node_modules/jsonc-parser/lib/esm/impl/edit.js
 function setProperty(text2, originalPath, value, options) {
-  const path10 = originalPath.slice();
+  const path12 = originalPath.slice();
   const errors = [];
   const root = parseTree(text2, errors);
   let parent = void 0;
   let lastSegment = void 0;
-  while (path10.length > 0) {
-    lastSegment = path10.pop();
-    parent = findNodeAtLocation(root, path10);
+  while (path12.length > 0) {
+    lastSegment = path12.pop();
+    parent = findNodeAtLocation(root, path12);
     if (parent === void 0 && value !== void 0) {
       if (typeof lastSegment === "string") {
         value = { [lastSegment]: value };
@@ -19591,8 +19599,8 @@ var ParseErrorCode;
   ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
   ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
 })(ParseErrorCode || (ParseErrorCode = {}));
-function modify(text2, path10, value, options) {
-  return setProperty(text2, path10, value, options);
+function modify(text2, path12, value, options) {
+  return setProperty(text2, path12, value, options);
 }
 function applyEdits(text2, edits) {
   let sortedEdits = edits.slice(0).sort((a3, b) => {
@@ -19616,20 +19624,20 @@ function applyEdits(text2, edits) {
 }
 
 // ../argent-installer/src/utils.ts
-function resolvePackageRoot(dirname7) {
-  let current = path4.resolve(dirname7);
+function resolvePackageRoot(dirname8) {
+  let current = path6.resolve(dirname8);
   while (true) {
-    if (fs5.existsSync(path4.join(current, "package.json"))) return current;
-    const parent = path4.dirname(current);
-    if (parent === current) return path4.resolve(dirname7);
+    if (fs6.existsSync(path6.join(current, "package.json"))) return current;
+    const parent = path6.dirname(current);
+    if (parent === current) return path6.resolve(dirname8);
     current = parent;
   }
 }
 var PACKAGE_ROOT = resolvePackageRoot(import.meta.dirname);
 function resolveBundledDir(dirName) {
-  const packagedDir = path4.join(PACKAGE_ROOT, dirName);
-  if (fs5.existsSync(packagedDir)) return packagedDir;
-  return path4.resolve(PACKAGE_ROOT, "..", "skills", dirName);
+  const packagedDir = path6.join(PACKAGE_ROOT, dirName);
+  if (fs6.existsSync(packagedDir)) return packagedDir;
+  return path6.resolve(PACKAGE_ROOT, "..", "skills", dirName);
 }
 var SKILLS_DIR = resolveBundledDir("skills");
 var RULES_DIR = resolveBundledDir("rules");
@@ -19641,23 +19649,23 @@ function buildArgentSkillsSource(version2) {
 }
 function listBundledSkills(skillsDir = SKILLS_DIR) {
   try {
-    return fs5.readdirSync(skillsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => fs5.existsSync(path4.join(skillsDir, name, "SKILL.md"))).sort();
+    return fs6.readdirSync(skillsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => fs6.existsSync(path6.join(skillsDir, name, "SKILL.md"))).sort();
   } catch {
     return [];
   }
 }
 function getProjectSkillLockPath(cwd = process.cwd()) {
-  return path4.join(cwd, "skills-lock.json");
+  return path6.join(cwd, "skills-lock.json");
 }
 function getGlobalSkillLockPath() {
   const xdgStateHome = process.env.XDG_STATE_HOME;
-  if (xdgStateHome) return path4.join(xdgStateHome, "skills", ".skill-lock.json");
-  return path4.join(os2.homedir(), ".agents", ".skill-lock.json");
+  if (xdgStateHome) return path6.join(xdgStateHome, "skills", ".skill-lock.json");
+  return path6.join(os2.homedir(), ".agents", ".skill-lock.json");
 }
 var ARGENT_SKILL_PREFIX = "argent-";
 function listArgentSkillsInLock(lockPath) {
   try {
-    const raw = fs5.readFileSync(lockPath, "utf8");
+    const raw = fs6.readFileSync(lockPath, "utf8");
     const lock = JSON.parse(raw);
     const tracked = lock.skills ?? {};
     return Object.keys(tracked).filter((name) => name.startsWith(ARGENT_SKILL_PREFIX)).sort();
@@ -19680,17 +19688,17 @@ var PROJECT_ROOT_MARKERS = [
   "opencode.jsonc",
   "skills-lock.json"
 ];
-function resolveProjectRoot(startDir) {
-  const initialDir = path4.resolve(startDir);
+function resolveProjectRoot2(startDir) {
+  const initialDir = path6.resolve(startDir);
   let currentDir = initialDir;
   while (true) {
-    if (PROJECT_ROOT_MARKERS.some((marker) => fs5.existsSync(path4.join(currentDir, marker)))) {
+    if (PROJECT_ROOT_MARKERS.some((marker) => fs6.existsSync(path6.join(currentDir, marker)))) {
       return currentDir;
     }
-    if (fs5.existsSync(path4.join(currentDir, ".git"))) {
+    if (fs6.existsSync(path6.join(currentDir, ".git"))) {
       return currentDir;
     }
-    const parentDir = path4.dirname(currentDir);
+    const parentDir = path6.dirname(currentDir);
     if (parentDir === currentDir) {
       return initialDir;
     }
@@ -19698,20 +19706,20 @@ function resolveProjectRoot(startDir) {
   }
 }
 function readToml(filePath) {
-  if (!fs5.existsSync(filePath)) return {};
+  if (!fs6.existsSync(filePath)) return {};
   try {
-    return parse(fs5.readFileSync(filePath, "utf8"));
+    return parse(fs6.readFileSync(filePath, "utf8"));
   } catch {
     return {};
   }
 }
 function writeToml(filePath, data) {
-  fs5.mkdirSync(path4.dirname(filePath), { recursive: true });
-  fs5.writeFileSync(filePath, stringify(data) + "\n");
+  fs6.mkdirSync(path6.dirname(filePath), { recursive: true });
+  fs6.writeFileSync(filePath, stringify(data) + "\n");
 }
 function readYaml(filePath) {
-  if (!fs5.existsSync(filePath)) return new import_yaml.Document({});
-  const text2 = fs5.readFileSync(filePath, "utf8");
+  if (!fs6.existsSync(filePath)) return new import_yaml.Document({});
+  const text2 = fs6.readFileSync(filePath, "utf8");
   const doc = (0, import_yaml.parseDocument)(text2);
   if (doc.errors.length > 0) {
     const messages = doc.errors.map((e) => e.message).join("; ");
@@ -19720,20 +19728,20 @@ function readYaml(filePath) {
   return doc;
 }
 function writeYaml(filePath, doc) {
-  fs5.mkdirSync(path4.dirname(filePath), { recursive: true });
-  fs5.writeFileSync(filePath, doc.toString({ lineWidth: 0 }));
+  fs6.mkdirSync(path6.dirname(filePath), { recursive: true });
+  fs6.writeFileSync(filePath, doc.toString({ lineWidth: 0 }));
 }
 function readJson(filePath) {
-  if (!fs5.existsSync(filePath)) return {};
+  if (!fs6.existsSync(filePath)) return {};
   try {
-    return JSON.parse(fs5.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs6.readFileSync(filePath, "utf8"));
   } catch {
     return {};
   }
 }
 function writeJson(filePath, data) {
-  fs5.mkdirSync(path4.dirname(filePath), { recursive: true });
-  fs5.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  fs6.mkdirSync(path6.dirname(filePath), { recursive: true });
+  fs6.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 }
 var JSONC_FORMATTING = { tabSize: 2, insertSpaces: true };
 function setJsoncIn(text2, jsonPath, value) {
@@ -19741,8 +19749,8 @@ function setJsoncIn(text2, jsonPath, value) {
   return applyEdits(text2, edits);
 }
 function readJsoncFileRaw(filePath) {
-  if (!fs5.existsSync(filePath)) return { text: "{}", hadBom: false };
-  let text2 = fs5.readFileSync(filePath, "utf8");
+  if (!fs6.existsSync(filePath)) return { text: "{}", hadBom: false };
+  let text2 = fs6.readFileSync(filePath, "utf8");
   const hadBom = text2.charCodeAt(0) === 65279;
   if (hadBom) text2 = text2.slice(1);
   if (text2.trim() === "") text2 = "{}";
@@ -19761,16 +19769,16 @@ function isEmptyPlainObject(value) {
 }
 function rmEmptyDir(dirPath) {
   try {
-    if (!fs5.existsSync(dirPath)) return;
-    if (!fs5.statSync(dirPath).isDirectory()) return;
-    if (fs5.readdirSync(dirPath).length > 0) return;
-    fs5.rmdirSync(dirPath);
+    if (!fs6.existsSync(dirPath)) return;
+    if (!fs6.statSync(dirPath).isDirectory()) return;
+    if (fs6.readdirSync(dirPath).length > 0) return;
+    fs6.rmdirSync(dirPath);
   } catch {
   }
 }
 function readJsonc(filePath) {
-  if (!fs5.existsSync(filePath)) return {};
-  let raw = fs5.readFileSync(filePath, "utf8");
+  if (!fs6.existsSync(filePath)) return {};
+  let raw = fs6.readFileSync(filePath, "utf8");
   if (raw.charCodeAt(0) === 65279) raw = raw.slice(1);
   if (raw.trim() === "") return {};
   const parsed = parse3(raw, [], { allowTrailingComma: true });
@@ -19789,24 +19797,24 @@ function editJsoncFile(filePath, jsonPath, value) {
   }
   const parsed = parse3(text2, [], { allowTrailingComma: true });
   if (isEmptyPlainObject(parsed)) {
-    fs5.rmSync(filePath, { force: true });
-    rmEmptyDir(path4.dirname(filePath));
+    fs6.rmSync(filePath, { force: true });
+    rmEmptyDir(path6.dirname(filePath));
     return;
   }
-  fs5.mkdirSync(path4.dirname(filePath), { recursive: true });
-  fs5.writeFileSync(filePath, (hadBom ? "\uFEFF" : "") + text2);
+  fs6.mkdirSync(path6.dirname(filePath), { recursive: true });
+  fs6.writeFileSync(filePath, (hadBom ? "\uFEFF" : "") + text2);
 }
 function dirExists(p) {
   try {
-    return fs5.statSync(p).isDirectory();
+    return fs6.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function getInstalledVersion() {
   try {
-    const pkgPath = path4.join(PACKAGE_ROOT, "package.json");
-    const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf8"));
+    const pkgPath = path6.join(PACKAGE_ROOT, "package.json");
+    const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf8"));
     return pkg.version ?? null;
   } catch {
     return null;
@@ -19816,9 +19824,9 @@ function getGloballyInstalledVersion() {
   const binaryPath = getGlobalBinaryPath();
   if (!binaryPath) return null;
   try {
-    const realPath = fs5.realpathSync(binaryPath);
-    const pkgRoot = resolvePackageRoot(path4.dirname(realPath));
-    const pkg = JSON.parse(fs5.readFileSync(path4.join(pkgRoot, "package.json"), "utf8"));
+    const realPath = fs6.realpathSync(binaryPath);
+    const pkgRoot = resolvePackageRoot(path6.dirname(realPath));
+    const pkg = JSON.parse(fs6.readFileSync(path6.join(pkgRoot, "package.json"), "utf8"));
     return pkg.version ?? null;
   } catch {
     return null;
@@ -19882,12 +19890,12 @@ async function isOnline(timeoutMs = PROBE_TIMEOUT_MS) {
   } catch {
     return false;
   }
-  return new Promise((resolve3) => {
-    const timer = setTimeout(() => resolve3(false), timeoutMs);
+  return new Promise((resolve4) => {
+    const timer = setTimeout(() => resolve4(false), timeoutMs);
     timer.unref();
     dns.lookup(host, (err) => {
       clearTimeout(timer);
-      resolve3(!err);
+      resolve4(!err);
     });
   });
 }
@@ -19939,7 +19947,7 @@ function escapeStringRegexp(string) {
 }
 
 // ../argent-installer/src/mcp-configs.ts
-var TOOL_SERVER_BUNDLE = path5.join(import.meta.dirname, "tool-server.cjs");
+var TOOL_SERVER_BUNDLE = path7.join(import.meta.dirname, "tool-server.cjs");
 function getAvailableToolIds() {
   const out = execFileSync("node", [TOOL_SERVER_BUNDLE, "-t"], { encoding: "utf8" });
   const tools = JSON.parse(out);
@@ -19959,10 +19967,10 @@ function hasEnv(entry) {
 }
 function removeDirIfEmpty(dirPath) {
   try {
-    if (!fs6.existsSync(dirPath)) return;
-    if (!fs6.statSync(dirPath).isDirectory()) return;
-    if (fs6.readdirSync(dirPath).length > 0) return;
-    fs6.rmdirSync(dirPath);
+    if (!fs7.existsSync(dirPath)) return;
+    if (!fs7.statSync(dirPath).isDirectory()) return;
+    if (fs7.readdirSync(dirPath).length > 0) return;
+    fs7.rmdirSync(dirPath);
   } catch {
   }
 }
@@ -19986,8 +19994,8 @@ function isRecord(value) {
 function writeJsonOrRemove(filePath, data) {
   const cleaned = pruneEmptyConfig(data);
   if (!isRecord(cleaned)) {
-    fs6.rmSync(filePath, { force: true });
-    removeDirIfEmpty(path5.dirname(filePath));
+    fs7.rmSync(filePath, { force: true });
+    removeDirIfEmpty(path7.dirname(filePath));
     return;
   }
   writeJson(filePath, cleaned);
@@ -19995,8 +20003,8 @@ function writeJsonOrRemove(filePath, data) {
 function writeTomlOrRemove(filePath, data) {
   const cleaned = pruneEmptyConfig(data);
   if (!isRecord(cleaned)) {
-    fs6.rmSync(filePath, { force: true });
-    removeDirIfEmpty(path5.dirname(filePath));
+    fs7.rmSync(filePath, { force: true });
+    removeDirIfEmpty(path7.dirname(filePath));
     return;
   }
   writeToml(filePath, cleaned);
@@ -20004,13 +20012,13 @@ function writeTomlOrRemove(filePath, data) {
 var cursorAdapter = {
   name: "Cursor",
   detect() {
-    return dirExists(path5.join(homedir3(), ".cursor")) || dirExists(path5.join(process.cwd(), ".cursor"));
+    return dirExists(path7.join(homedir4(), ".cursor")) || dirExists(path7.join(process.cwd(), ".cursor"));
   },
   projectPath(root) {
-    return path5.join(root, ".cursor", "mcp.json");
+    return path7.join(root, ".cursor", "mcp.json");
   },
   globalPath() {
-    return path5.join(homedir3(), ".cursor", "mcp.json");
+    return path7.join(homedir4(), ".cursor", "mcp.json");
   },
   write(configPath, entry) {
     const config = readJson(configPath);
@@ -20024,7 +20032,7 @@ var cursorAdapter = {
     writeJson(configPath, config);
   },
   remove(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJson(configPath);
     const servers = config.mcpServers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -20033,13 +20041,13 @@ var cursorAdapter = {
     return true;
   },
   hasArgentEntry(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJson(configPath);
     const servers = config.mcpServers;
     return Boolean(servers?.[MCP_SERVER_KEY]);
   },
   addAllowlist() {
-    const permPath = path5.join(homedir3(), ".cursor", "permissions.json");
+    const permPath = path7.join(homedir4(), ".cursor", "permissions.json");
     const config = readJson(permPath);
     const list = config.mcpAllowlist ?? [];
     if (!list.includes(CURSOR_ALLOWLIST_PATTERN)) {
@@ -20049,8 +20057,8 @@ var cursorAdapter = {
     }
   },
   removeAllowlist() {
-    const permPath = path5.join(homedir3(), ".cursor", "permissions.json");
-    if (!fs6.existsSync(permPath)) return;
+    const permPath = path7.join(homedir4(), ".cursor", "permissions.json");
+    if (!fs7.existsSync(permPath)) return;
     const config = readJson(permPath);
     const list = config.mcpAllowlist;
     if (!Array.isArray(list)) return;
@@ -20064,13 +20072,13 @@ var cursorAdapter = {
 var claudeAdapter = {
   name: "Claude Code",
   detect() {
-    return fs6.existsSync(path5.join(process.cwd(), ".mcp.json")) || fs6.existsSync(path5.join(homedir3(), ".claude.json")) || dirExists(path5.join(process.cwd(), ".claude")) || dirExists(path5.join(homedir3(), ".claude"));
+    return fs7.existsSync(path7.join(process.cwd(), ".mcp.json")) || fs7.existsSync(path7.join(homedir4(), ".claude.json")) || dirExists(path7.join(process.cwd(), ".claude")) || dirExists(path7.join(homedir4(), ".claude"));
   },
   projectPath(root) {
-    return path5.join(root, ".mcp.json");
+    return path7.join(root, ".mcp.json");
   },
   globalPath() {
-    return path5.join(homedir3(), ".claude.json");
+    return path7.join(homedir4(), ".claude.json");
   },
   write(configPath, entry) {
     const config = readJson(configPath);
@@ -20085,7 +20093,7 @@ var claudeAdapter = {
     writeJson(configPath, config);
   },
   remove(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJson(configPath);
     const servers = config.mcpServers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -20094,7 +20102,7 @@ var claudeAdapter = {
     return true;
   },
   hasArgentEntry(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJson(configPath);
     const servers = config.mcpServers;
     return Boolean(servers?.[MCP_SERVER_KEY]);
@@ -20109,10 +20117,10 @@ var claudeAdapter = {
 var vscodeAdapter = {
   name: "VS Code",
   detect() {
-    return dirExists(path5.join(process.cwd(), ".vscode")) || dirExists(path5.join(homedir3(), ".vscode"));
+    return dirExists(path7.join(process.cwd(), ".vscode")) || dirExists(path7.join(homedir4(), ".vscode"));
   },
   projectPath(root) {
-    return path5.join(root, ".vscode", "mcp.json");
+    return path7.join(root, ".vscode", "mcp.json");
   },
   globalPath() {
     return null;
@@ -20130,7 +20138,7 @@ var vscodeAdapter = {
     writeJson(configPath, config);
   },
   remove(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJson(configPath);
     const servers = config.servers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -20139,7 +20147,7 @@ var vscodeAdapter = {
     return true;
   },
   hasArgentEntry(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJson(configPath);
     const servers = config.servers;
     return Boolean(servers?.[MCP_SERVER_KEY]);
@@ -20148,13 +20156,13 @@ var vscodeAdapter = {
 var windsurfAdapter = {
   name: "Windsurf",
   detect() {
-    return dirExists(path5.join(homedir3(), ".codeium", "windsurf"));
+    return dirExists(path7.join(homedir4(), ".codeium", "windsurf"));
   },
   projectPath() {
     return null;
   },
   globalPath() {
-    return path5.join(homedir3(), ".codeium", "windsurf", "mcp_config.json");
+    return path7.join(homedir4(), ".codeium", "windsurf", "mcp_config.json");
   },
   write(configPath, entry) {
     const config = readJson(configPath);
@@ -20168,7 +20176,7 @@ var windsurfAdapter = {
     writeJson(configPath, config);
   },
   remove(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJson(configPath);
     const servers = config.mcpServers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -20177,13 +20185,13 @@ var windsurfAdapter = {
     return true;
   },
   hasArgentEntry(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJson(configPath);
     const servers = config.mcpServers;
     return Boolean(servers?.[MCP_SERVER_KEY]);
   },
   addAllowlist() {
-    const configPath = path5.join(homedir3(), ".codeium", "windsurf", "mcp_config.json");
+    const configPath = path7.join(homedir4(), ".codeium", "windsurf", "mcp_config.json");
     const config = readJson(configPath);
     const servers = config.mcpServers ?? {};
     const entry = servers[MCP_SERVER_KEY];
@@ -20192,8 +20200,8 @@ var windsurfAdapter = {
     writeJson(configPath, config);
   },
   removeAllowlist() {
-    const configPath = path5.join(homedir3(), ".codeium", "windsurf", "mcp_config.json");
-    if (!fs6.existsSync(configPath)) return;
+    const configPath = path7.join(homedir4(), ".codeium", "windsurf", "mcp_config.json");
+    if (!fs7.existsSync(configPath)) return;
     const config = readJson(configPath);
     const servers = config.mcpServers ?? {};
     const entry = servers[MCP_SERVER_KEY];
@@ -20205,13 +20213,13 @@ var windsurfAdapter = {
 var zedAdapter = {
   name: "Zed",
   detect() {
-    return dirExists(path5.join(homedir3(), ".config", "zed"));
+    return dirExists(path7.join(homedir4(), ".config", "zed"));
   },
   projectPath(root) {
-    return path5.join(root, ".zed", "settings.json");
+    return path7.join(root, ".zed", "settings.json");
   },
   globalPath() {
-    return path5.join(homedir3(), ".config", "zed", "settings.json");
+    return path7.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
@@ -20227,7 +20235,7 @@ var zedAdapter = {
     });
   },
   remove(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJsonc(configPath);
     const servers = config.context_servers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -20235,7 +20243,7 @@ var zedAdapter = {
     return true;
   },
   hasArgentEntry(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJsonc(configPath);
     const servers = config.context_servers;
     return Boolean(servers?.[MCP_SERVER_KEY]);
@@ -20245,12 +20253,12 @@ var zedAdapter = {
   // documented opt-in; built-in security rules still protect against
   // destructive operations.
   addAllowlist(root, scope) {
-    const settingsPath = scope === "global" ? path5.join(homedir3(), ".config", "zed", "settings.json") : path5.join(root, ".zed", "settings.json");
+    const settingsPath = scope === "global" ? path7.join(homedir4(), ".config", "zed", "settings.json") : path7.join(root, ".zed", "settings.json");
     editJsoncFile(settingsPath, ["agent", "tool_permissions", "default"], "allow");
   },
   removeAllowlist(root, scope) {
-    const settingsPath = scope === "global" ? path5.join(homedir3(), ".config", "zed", "settings.json") : path5.join(root, ".zed", "settings.json");
-    if (!fs6.existsSync(settingsPath)) return;
+    const settingsPath = scope === "global" ? path7.join(homedir4(), ".config", "zed", "settings.json") : path7.join(root, ".zed", "settings.json");
+    if (!fs7.existsSync(settingsPath)) return;
     const config = readJsonc(settingsPath);
     const perms = config.agent?.tool_permissions;
     if (!perms || perms.default !== "allow") return;
@@ -20260,13 +20268,13 @@ var zedAdapter = {
 var geminiAdapter = {
   name: "Gemini",
   detect() {
-    return dirExists(path5.join(homedir3(), ".gemini")) || dirExists(path5.join(process.cwd(), ".gemini"));
+    return dirExists(path7.join(homedir4(), ".gemini")) || dirExists(path7.join(process.cwd(), ".gemini"));
   },
   projectPath(root) {
-    return path5.join(root, ".gemini", "settings.json");
+    return path7.join(root, ".gemini", "settings.json");
   },
   globalPath() {
-    return path5.join(homedir3(), ".gemini", "settings.json");
+    return path7.join(homedir4(), ".gemini", "settings.json");
   },
   write(configPath, entry) {
     const config = readJson(configPath);
@@ -20280,7 +20288,7 @@ var geminiAdapter = {
     writeJson(configPath, config);
   },
   remove(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJson(configPath);
     const servers = config.mcpServers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -20289,7 +20297,7 @@ var geminiAdapter = {
     return true;
   },
   hasArgentEntry(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJson(configPath);
     const servers = config.mcpServers;
     return Boolean(servers?.[MCP_SERVER_KEY]);
@@ -20308,7 +20316,7 @@ var geminiAdapter = {
   },
   removeAllowlist(root, scope) {
     const configPath = scope === "global" ? this.globalPath() : this.projectPath(root);
-    if (!configPath || !fs6.existsSync(configPath)) {
+    if (!configPath || !fs7.existsSync(configPath)) {
       return;
     }
     const config = readJson(configPath);
@@ -20323,13 +20331,13 @@ var CODEX_FILENAME = ".codex";
 var codexAdapter = {
   name: "Codex",
   detect() {
-    return dirExists(path5.join(homedir3(), CODEX_FILENAME)) || dirExists(path5.join(process.cwd(), CODEX_FILENAME));
+    return dirExists(path7.join(homedir4(), CODEX_FILENAME)) || dirExists(path7.join(process.cwd(), CODEX_FILENAME));
   },
   projectPath(root) {
-    return path5.join(root, CODEX_FILENAME, "config.toml");
+    return path7.join(root, CODEX_FILENAME, "config.toml");
   },
   globalPath() {
-    return path5.join(homedir3(), CODEX_FILENAME, "config.toml");
+    return path7.join(homedir4(), CODEX_FILENAME, "config.toml");
   },
   write(configPath, entry) {
     const config = readToml(configPath);
@@ -20343,7 +20351,7 @@ var codexAdapter = {
     writeToml(configPath, config);
   },
   remove(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readToml(configPath);
     const servers = config.mcp_servers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -20352,7 +20360,7 @@ var codexAdapter = {
     return true;
   },
   hasArgentEntry(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readToml(configPath);
     const servers = config.mcp_servers;
     return Boolean(servers?.[MCP_SERVER_KEY]);
@@ -20397,13 +20405,13 @@ var codexAdapter = {
 var hermesAdapter = {
   name: "Hermes",
   detect() {
-    return dirExists(path5.join(homedir3(), ".hermes"));
+    return dirExists(path7.join(homedir4(), ".hermes"));
   },
   projectPath() {
     return null;
   },
   globalPath() {
-    return path5.join(homedir3(), ".hermes", "config.yaml");
+    return path7.join(homedir4(), ".hermes", "config.yaml");
   },
   write(configPath, entry) {
     const doc = readYaml(configPath);
@@ -20422,7 +20430,7 @@ var hermesAdapter = {
     writeYaml(configPath, doc);
   },
   remove(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const doc = readYaml(configPath);
     const servers = doc.get("mcp_servers");
     if (!(0, import_yaml2.isMap)(servers)) return false;
@@ -20435,7 +20443,7 @@ var hermesAdapter = {
     return true;
   },
   hasArgentEntry(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const doc = readYaml(configPath);
     const servers = doc.get("mcp_servers");
     if (!(0, import_yaml2.isMap)(servers)) return false;
@@ -20457,10 +20465,10 @@ function hasOpenCodeBinary() {
 }
 function pickOpencodeConfig(dir, candidates) {
   for (const name of candidates) {
-    const candidate = path5.join(dir, name);
-    if (fs6.existsSync(candidate)) return candidate;
+    const candidate = path7.join(dir, name);
+    if (fs7.existsSync(candidate)) return candidate;
   }
-  return path5.join(dir, "opencode.json");
+  return path7.join(dir, "opencode.json");
 }
 var openCodeAdapter = {
   name: "opencode",
@@ -20471,7 +20479,7 @@ var openCodeAdapter = {
     return pickOpencodeConfig(root, OPENCODE_PROJECT_FILES);
   },
   globalPath() {
-    return pickOpencodeConfig(path5.join(homedir3(), ".config", "opencode"), OPENCODE_GLOBAL_FILES);
+    return pickOpencodeConfig(path7.join(homedir4(), ".config", "opencode"), OPENCODE_GLOBAL_FILES);
   },
   write(configPath, entry) {
     editJsoncFile(configPath, ["mcp", MCP_SERVER_KEY], {
@@ -20482,7 +20490,7 @@ var openCodeAdapter = {
     });
   },
   remove(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJsonc(configPath);
     const servers = config.mcp;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -20490,7 +20498,7 @@ var openCodeAdapter = {
     return true;
   },
   hasArgentEntry(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJsonc(configPath);
     const servers = config.mcp;
     return Boolean(servers?.[MCP_SERVER_KEY]);
@@ -20502,7 +20510,7 @@ var openCodeAdapter = {
   },
   removeAllowlist(root, scope) {
     const configPath = scope === "global" ? this.globalPath() : this.projectPath(root);
-    if (!configPath || !fs6.existsSync(configPath)) return;
+    if (!configPath || !fs7.existsSync(configPath)) return;
     const config = readJsonc(configPath);
     const tools = config.tools;
     if (!tools || !(OPENCODE_ALLOWLIST_PATTERN in tools)) return;
@@ -20513,13 +20521,13 @@ var KIRO_AUTO_APPROVE_ALL = ["*"];
 var kiroAdapter = {
   name: "Kiro",
   detect() {
-    return dirExists(path5.join(homedir3(), ".kiro")) || dirExists(path5.join(process.cwd(), ".kiro"));
+    return dirExists(path7.join(homedir4(), ".kiro")) || dirExists(path7.join(process.cwd(), ".kiro"));
   },
   projectPath(root) {
-    return path5.join(root, ".kiro", "settings", "mcp.json");
+    return path7.join(root, ".kiro", "settings", "mcp.json");
   },
   globalPath() {
-    return path5.join(homedir3(), ".kiro", "settings", "mcp.json");
+    return path7.join(homedir4(), ".kiro", "settings", "mcp.json");
   },
   write(configPath, entry) {
     const config = readJson(configPath);
@@ -20533,7 +20541,7 @@ var kiroAdapter = {
     writeJson(configPath, config);
   },
   remove(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJson(configPath);
     const servers = config.mcpServers;
     if (!servers?.[MCP_SERVER_KEY]) return false;
@@ -20542,7 +20550,7 @@ var kiroAdapter = {
     return true;
   },
   hasArgentEntry(configPath) {
-    if (!fs6.existsSync(configPath)) return false;
+    if (!fs7.existsSync(configPath)) return false;
     const config = readJson(configPath);
     const servers = config.mcpServers;
     return Boolean(servers?.[MCP_SERVER_KEY]);
@@ -20559,7 +20567,7 @@ var kiroAdapter = {
   },
   removeAllowlist(root, scope) {
     const configPath = scope === "global" ? this.globalPath() : this.projectPath(root);
-    if (!configPath || !fs6.existsSync(configPath)) return;
+    if (!configPath || !fs7.existsSync(configPath)) return;
     const config = readJson(configPath);
     const servers = config.mcpServers;
     const entry = servers?.[MCP_SERVER_KEY];
@@ -20605,7 +20613,7 @@ function findConfiguredAdapterScopes(adapters, projectRoot) {
   return results;
 }
 function addClaudePermission(root, scope) {
-  const settingsPath = scope === "global" ? path5.join(homedir3(), ".claude", "settings.json") : path5.join(root, ".claude", "settings.json");
+  const settingsPath = scope === "global" ? path7.join(homedir4(), ".claude", "settings.json") : path7.join(root, ".claude", "settings.json");
   const config = readJson(settingsPath);
   const permissions = config.permissions ?? {};
   const allow = permissions.allow ?? [];
@@ -20617,8 +20625,8 @@ function addClaudePermission(root, scope) {
   }
 }
 function removeClaudePermission(root, scope) {
-  const settingsPath = scope === "global" ? path5.join(homedir3(), ".claude", "settings.json") : path5.join(root, ".claude", "settings.json");
-  if (!fs6.existsSync(settingsPath)) return;
+  const settingsPath = scope === "global" ? path7.join(homedir4(), ".claude", "settings.json") : path7.join(root, ".claude", "settings.json");
+  if (!fs7.existsSync(settingsPath)) return;
   const config = readJson(settingsPath);
   const allow = config?.permissions?.allow;
   if (!Array.isArray(allow)) return;
@@ -20628,12 +20636,12 @@ function removeClaudePermission(root, scope) {
   writeJsonOrRemove(settingsPath, config);
 }
 function formatManagedPathLabel(targetPath, root) {
-  const home = homedir3();
-  if (targetPath === home || targetPath.startsWith(`${home}${path5.sep}`)) {
+  const home = homedir4();
+  if (targetPath === home || targetPath.startsWith(`${home}${path7.sep}`)) {
     return `~${targetPath.slice(home.length)}`;
   }
-  const relative3 = path5.relative(root, targetPath);
-  if (relative3 && !relative3.startsWith("..") && !path5.isAbsolute(relative3)) {
+  const relative3 = path7.relative(root, targetPath);
+  if (relative3 && !relative3.startsWith("..") && !path7.isAbsolute(relative3)) {
     return relative3;
   }
   return targetPath;
@@ -20647,7 +20655,7 @@ function addManagedTarget(targets, editorName, targetPath, root) {
 }
 function getAdapterBasePath(adapter, root, scope) {
   const configPath = scope === "global" ? adapter.globalPath() : adapter.projectPath(root);
-  return configPath ? path5.dirname(configPath) : null;
+  return configPath ? path7.dirname(configPath) : null;
 }
 function getManagedContentTargets(adapters, root, scope) {
   const targets = {
@@ -20657,17 +20665,17 @@ function getManagedContentTargets(adapters, root, scope) {
     codexConfigTargets: [],
     skillsLockTargets: []
   };
-  const workspaceBase = scope === "global" ? homedir3() : root;
+  const workspaceBase = scope === "global" ? homedir4() : root;
   addManagedTarget(
     targets.skillTargets,
     "skills",
-    path5.join(workspaceBase, ".agents", "skills"),
+    path7.join(workspaceBase, ".agents", "skills"),
     root
   );
   addManagedTarget(
     targets.skillsLockTargets,
     "skills",
-    path5.join(workspaceBase, "skills-lock.json"),
+    path7.join(workspaceBase, "skills-lock.json"),
     root
   );
   for (const adapter of adapters) {
@@ -20675,21 +20683,21 @@ function getManagedContentTargets(adapters, root, scope) {
       case "Cursor": {
         const base = getAdapterBasePath(adapter, root, scope);
         if (!base) break;
-        addManagedTarget(targets.skillTargets, adapter.name, path5.join(base, "skills"), root);
-        addManagedTarget(targets.ruleTargets, adapter.name, path5.join(base, "rules"), root);
+        addManagedTarget(targets.skillTargets, adapter.name, path7.join(base, "skills"), root);
+        addManagedTarget(targets.ruleTargets, adapter.name, path7.join(base, "rules"), root);
         break;
       }
       case "Claude Code": {
-        const claudeBase = scope === "global" ? path5.join(homedir3(), ".claude") : path5.join(root, ".claude");
-        addManagedTarget(targets.skillTargets, adapter.name, path5.join(claudeBase, "skills"), root);
-        addManagedTarget(targets.ruleTargets, adapter.name, path5.join(claudeBase, "rules"), root);
-        addManagedTarget(targets.agentTargets, adapter.name, path5.join(claudeBase, "agents"), root);
+        const claudeBase = scope === "global" ? path7.join(homedir4(), ".claude") : path7.join(root, ".claude");
+        addManagedTarget(targets.skillTargets, adapter.name, path7.join(claudeBase, "skills"), root);
+        addManagedTarget(targets.ruleTargets, adapter.name, path7.join(claudeBase, "rules"), root);
+        addManagedTarget(targets.agentTargets, adapter.name, path7.join(claudeBase, "agents"), root);
         break;
       }
       case "Gemini": {
-        const geminiBase = scope === "global" ? path5.join(homedir3(), ".gemini") : path5.join(root, ".gemini");
-        addManagedTarget(targets.ruleTargets, adapter.name, path5.join(geminiBase, "rules"), root);
-        addManagedTarget(targets.agentTargets, adapter.name, path5.join(geminiBase, "agents"), root);
+        const geminiBase = scope === "global" ? path7.join(homedir4(), ".gemini") : path7.join(root, ".gemini");
+        addManagedTarget(targets.ruleTargets, adapter.name, path7.join(geminiBase, "rules"), root);
+        addManagedTarget(targets.agentTargets, adapter.name, path7.join(geminiBase, "agents"), root);
         break;
       }
       case "Codex": {
@@ -20699,9 +20707,9 @@ function getManagedContentTargets(adapters, root, scope) {
         break;
       }
       case "opencode": {
-        const base = scope === "global" ? path5.join(homedir3(), ".config", "opencode") : path5.join(root, ".opencode");
-        addManagedTarget(targets.skillTargets, adapter.name, path5.join(base, "skills"), root);
-        addManagedTarget(targets.agentTargets, adapter.name, path5.join(base, "agents"), root);
+        const base = scope === "global" ? path7.join(homedir4(), ".config", "opencode") : path7.join(root, ".opencode");
+        addManagedTarget(targets.skillTargets, adapter.name, path7.join(base, "skills"), root);
+        addManagedTarget(targets.agentTargets, adapter.name, path7.join(base, "agents"), root);
         break;
       }
     }
@@ -20715,12 +20723,12 @@ function stripFrontmatter(content) {
   return match ? content.slice(match[0].length).trim() : content.trim();
 }
 function readAndConcatRules(rulesDir) {
-  if (!fs6.existsSync(rulesDir)) return null;
-  const files = fs6.readdirSync(rulesDir).filter((f) => f.endsWith(".md")).sort();
+  if (!fs7.existsSync(rulesDir)) return null;
+  const files = fs7.readdirSync(rulesDir).filter((f) => f.endsWith(".md")).sort();
   if (files.length === 0) return null;
   const parts = [];
   for (const file of files) {
-    const raw = fs6.readFileSync(path5.join(rulesDir, file), "utf8");
+    const raw = fs7.readFileSync(path7.join(rulesDir, file), "utf8");
     const stripped = stripFrontmatter(raw);
     if (stripped) parts.push(stripped);
   }
@@ -20755,7 +20763,7 @@ function injectCodexRules(configPath, rulesDir) {
   return configPath;
 }
 function removeCodexRules(configPath) {
-  if (!fs6.existsSync(configPath)) return false;
+  if (!fs7.existsSync(configPath)) return false;
   const config = readToml(configPath);
   const existing = config.developer_instructions;
   if (!existing || !existing.includes(ARGENT_RULES_START)) return false;
@@ -20773,9 +20781,9 @@ function copyRulesAndAgents(adapters, root, scope, rulesDir, agentsDir) {
   const managedTargets = getManagedContentTargets(adapters, root, scope);
   for (const target of managedTargets.ruleTargets) {
     try {
-      if (fs6.existsSync(rulesDir)) {
-        fs6.mkdirSync(target.targetPath, { recursive: true });
-        fs6.cpSync(rulesDir, target.targetPath, { recursive: true });
+      if (fs7.existsSync(rulesDir)) {
+        fs7.mkdirSync(target.targetPath, { recursive: true });
+        fs7.cpSync(rulesDir, target.targetPath, { recursive: true });
         results.push(`  Copied rules to ${target.targetPath}`);
       }
     } catch (err) {
@@ -20784,9 +20792,9 @@ function copyRulesAndAgents(adapters, root, scope, rulesDir, agentsDir) {
   }
   for (const target of managedTargets.agentTargets) {
     try {
-      if (fs6.existsSync(agentsDir)) {
-        fs6.mkdirSync(target.targetPath, { recursive: true });
-        fs6.cpSync(agentsDir, target.targetPath, { recursive: true });
+      if (fs7.existsSync(agentsDir)) {
+        fs7.mkdirSync(target.targetPath, { recursive: true });
+        fs7.cpSync(agentsDir, target.targetPath, { recursive: true });
         results.push(`  Copied agents to ${target.targetPath}`);
       }
     } catch (err) {
@@ -21014,7 +21022,7 @@ var INSTALL_UNCLASSIFIED_FAILED = {
   error_kind: "unknown"
 };
 function runShellCommand(cmd) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const isWin = process.platform === "win32";
     const child = spawn(isWin ? `${cmd.bin}.cmd` : cmd.bin, cmd.args, {
       stdio: ["ignore", "pipe", "pipe"],
@@ -21025,7 +21033,7 @@ function runShellCommand(cmd) {
       stderr += chunk.toString();
     });
     child.on("close", (code) => {
-      if (code === 0) resolve3();
+      if (code === 0) resolve4();
       else reject(new Error(stderr.trim() || `Command exited with code ${code}`));
     });
     child.on("error", reject);
@@ -21204,7 +21212,7 @@ async function init2(args) {
               updateSpinner.stop(import_picocolors3.default.green(`Updated to v${latest}.`));
               version2 = getInstalledVersion() ?? version2;
               await trackPackageAction("init_triggered_update", updateStartedAt, true);
-              const skillRefreshResults = refreshArgentSkills(resolveProjectRoot(process.cwd()));
+              const skillRefreshResults = refreshArgentSkills(resolveProjectRoot2(process.cwd()));
               const skillSummary = formatSkillRefreshSummary(skillRefreshResults);
               if (skillSummary) {
                 note(skillSummary, "Skills Updated");
@@ -21320,8 +21328,8 @@ async function init2(args) {
           placeholder: process.cwd(),
           validate(value) {
             if (!value?.trim()) return "Path cannot be empty.";
-            const resolved = resolve2(value.trim());
-            if (!existsSync5(resolved))
+            const resolved = resolve3(value.trim());
+            if (!existsSync6(resolved))
               return `Path does not exist: ${resolved}. Please verify and enter a valid path.`;
           }
         });
@@ -21331,10 +21339,10 @@ async function init2(args) {
           cancel("Initialization cancelled.");
           process.exit(0);
         }
-        customRoot = resolve2(customPathInput.trim());
+        customRoot = resolve3(customPathInput.trim());
       }
     }
-    const projectRoot = resolveProjectRoot(process.cwd());
+    const projectRoot = resolveProjectRoot2(process.cwd());
     const effectiveRoot = scope === "custom" ? customRoot : projectRoot;
     const normalizedScope = scope === "global" ? "global" : "local";
     track("installation:editors_select", {
@@ -21604,7 +21612,7 @@ function printBanner() {
   console.log();
 }
 function runNpxSkills(args, interactive, cwd) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const npxCmd = process.platform === "win32" ? "npx.cmd" : "npx";
     const child = spawn(npxCmd, args, {
       stdio: interactive ? "inherit" : ["ignore", "pipe", "pipe"],
@@ -21623,7 +21631,7 @@ function runNpxSkills(args, interactive, cwd) {
     }
     child.on("close", (code) => {
       if (code === 0) {
-        resolve3();
+        resolve4();
       } else {
         const output = [stderr, stdout2].filter(Boolean).join("\n").trim();
         reject(new Error(output || `npx skills exited with code ${code}`));
@@ -21655,17 +21663,17 @@ async function resolveInstallableUpdateTarget(pm, current) {
 
 // ../argent-tools-client/src/launcher.ts
 import * as net from "node:net";
-import * as fs7 from "node:fs";
-import * as path6 from "node:path";
+import * as fs8 from "node:fs";
+import * as path8 from "node:path";
 import * as readline from "node:readline";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 import { spawn as spawn2, execFileSync as execFileSync3 } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { mkdir, writeFile, readFile, unlink, rename, chmod } from "node:fs/promises";
-var STATE_DIR = path6.join(homedir4(), ".argent");
-var STATE_FILE = path6.join(STATE_DIR, "tool-server.json");
-var LOG_FILE = path6.join(STATE_DIR, "tool-server.log");
-var LOCK_FILE = path6.join(STATE_DIR, "tool-server.lock");
+var STATE_DIR = path8.join(homedir5(), ".argent");
+var STATE_FILE = path8.join(STATE_DIR, "tool-server.json");
+var LOG_FILE = path8.join(STATE_DIR, "tool-server.log");
+var LOCK_FILE = path8.join(STATE_DIR, "tool-server.lock");
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -21726,22 +21734,22 @@ async function killToolServer() {
 }
 
 // ../argent-tools-client/src/link-config.ts
-import * as path7 from "node:path";
-import { homedir as homedir5 } from "node:os";
+import * as path9 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 = path7.join(homedir5(), ".argent");
-var LINK_FILE = path7.join(LINK_DIR, "link.json");
+var LINK_DIR = path9.join(homedir6(), ".argent");
+var LINK_FILE = path9.join(LINK_DIR, "link.json");
 
 // ../argent-tools-client/src/file-inputs.ts
 import { mkdir as mkdir3, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
 import { readFile as readFile3 } from "node:fs/promises";
-import * as path8 from "node:path";
+import * as path10 from "node:path";
 var MAX_CONTENT_BYTES = 32 * 1024 * 1024;
 
 // ../argent-tools-client/src/artifacts.ts
 import { mkdir as mkdir4, readFile as readFile4, rm, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { basename as basename2, join as join9 } from "node:path";
+import { basename as basename2, join as join11 } from "node:path";
 import { createHash } from "node:crypto";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -21996,7 +22004,7 @@ async function update(args) {
       }
     }
     spinner2.start("Refreshing workspace configuration...");
-    const projectRoot = resolveProjectRoot(process.cwd());
+    const projectRoot = resolveProjectRoot2(process.cwd());
     const mcpEntry = getMcpEntry();
     const results = [];
     const configuredScopes = findConfiguredAdapterScopes(ALL_ADAPTERS, projectRoot);
@@ -22058,8 +22066,8 @@ async function update(args) {
 // ../argent-installer/src/uninstall.ts
 var import_picocolors5 = __toESM(require_picocolors(), 1);
 var import_yaml3 = __toESM(require_dist(), 1);
-import * as fs8 from "node:fs";
-import * as path9 from "node:path";
+import * as fs9 from "node:fs";
+import * as path11 from "node:path";
 import { execFileSync as execFileSync5 } from "node:child_process";
 var UNINSTALL_TOOLSERVER_STOP_FAILED = {
   error_code: FAILURE_CODES.UNINSTALL_TOOLSERVER_STOP_FAILED,
@@ -22081,10 +22089,10 @@ var UNINSTALL_UNCLASSIFIED_FAILED = {
 };
 function removeDirIfEmpty2(dirPath) {
   try {
-    if (!fs8.existsSync(dirPath)) return false;
-    if (!fs8.statSync(dirPath).isDirectory()) return false;
-    if (fs8.readdirSync(dirPath).length > 0) return false;
-    fs8.rmdirSync(dirPath);
+    if (!fs9.existsSync(dirPath)) return false;
+    if (!fs9.statSync(dirPath).isDirectory()) return false;
+    if (fs9.readdirSync(dirPath).length > 0) return false;
+    fs9.rmdirSync(dirPath);
     return true;
   } catch {
     return false;
@@ -22094,9 +22102,9 @@ function collectBundledPaths(sourceDir) {
   const files = [];
   const directories = [];
   function walk(currentDir, relativeDir = "") {
-    for (const entry of fs8.readdirSync(currentDir, { withFileTypes: true })) {
-      const relativePath = relativeDir ? path9.join(relativeDir, entry.name) : entry.name;
-      const absolutePath = path9.join(currentDir, entry.name);
+    for (const entry of fs9.readdirSync(currentDir, { withFileTypes: true })) {
+      const relativePath = relativeDir ? path11.join(relativeDir, entry.name) : entry.name;
+      const absolutePath = path11.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath, relativePath);
         directories.push(relativePath);
@@ -22109,52 +22117,52 @@ function collectBundledPaths(sourceDir) {
   return { files, directories };
 }
 function removeBundledContent(sourceDir, targetDir) {
-  if (!fs8.existsSync(sourceDir) || !fs8.existsSync(targetDir)) {
+  if (!fs9.existsSync(sourceDir) || !fs9.existsSync(targetDir)) {
     return { removedPaths: [], removedRoot: false };
   }
   const { files, directories } = collectBundledPaths(sourceDir);
   const removedPaths = [];
   for (const relativePath of files) {
-    const targetPath = path9.join(targetDir, relativePath);
+    const targetPath = path11.join(targetDir, relativePath);
     try {
-      if (!fs8.existsSync(targetPath)) continue;
-      if (fs8.lstatSync(targetPath).isDirectory()) continue;
-      fs8.rmSync(targetPath, { force: true });
+      if (!fs9.existsSync(targetPath)) continue;
+      if (fs9.lstatSync(targetPath).isDirectory()) continue;
+      fs9.rmSync(targetPath, { force: true });
       removedPaths.push(relativePath);
     } catch {
     }
   }
   directories.sort(
-    (a3, b) => b.split(path9.sep).length - a3.split(path9.sep).length || b.length - a3.length
+    (a3, b) => b.split(path11.sep).length - a3.split(path11.sep).length || b.length - a3.length
   );
   for (const relativePath of directories) {
-    const targetPath = path9.join(targetDir, relativePath);
+    const targetPath = path11.join(targetDir, relativePath);
     try {
-      if (!fs8.existsSync(targetPath)) continue;
-      if (!fs8.statSync(targetPath).isDirectory()) continue;
-      if (fs8.readdirSync(targetPath).length > 0) continue;
-      fs8.rmdirSync(targetPath);
+      if (!fs9.existsSync(targetPath)) continue;
+      if (!fs9.statSync(targetPath).isDirectory()) continue;
+      if (fs9.readdirSync(targetPath).length > 0) continue;
+      fs9.rmdirSync(targetPath);
     } catch {
     }
   }
   let removedRoot = false;
   try {
-    if (fs8.existsSync(targetDir) && fs8.statSync(targetDir).isDirectory()) {
-      if (fs8.readdirSync(targetDir).length === 0) {
-        fs8.rmdirSync(targetDir);
+    if (fs9.existsSync(targetDir) && fs9.statSync(targetDir).isDirectory()) {
+      if (fs9.readdirSync(targetDir).length === 0) {
+        fs9.rmdirSync(targetDir);
         removedRoot = true;
       }
     }
   } catch {
   }
   if (removedRoot) {
-    removeDirIfEmpty2(path9.dirname(targetDir));
+    removeDirIfEmpty2(path11.dirname(targetDir));
   }
   return { removedPaths, removedRoot };
 }
 function readBundledSkillName(skillFilePath, fallbackName) {
   try {
-    const content = fs8.readFileSync(skillFilePath, "utf8");
+    const content = fs9.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);
@@ -22165,30 +22173,30 @@ function readBundledSkillName(skillFilePath, fallbackName) {
   }
 }
 function getBundledSkillNames(skillsDir) {
-  if (!fs8.existsSync(skillsDir)) return [];
+  if (!fs9.existsSync(skillsDir)) return [];
   const skillNames = [];
-  for (const entry of fs8.readdirSync(skillsDir, { withFileTypes: true })) {
+  for (const entry of fs9.readdirSync(skillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const skillFilePath = path9.join(skillsDir, entry.name, "SKILL.md");
-    if (!fs8.existsSync(skillFilePath)) continue;
+    const skillFilePath = path11.join(skillsDir, entry.name, "SKILL.md");
+    if (!fs9.existsSync(skillFilePath)) continue;
     skillNames.push(readBundledSkillName(skillFilePath, entry.name));
   }
   return [...new Set(skillNames)].sort();
 }
 function removeBundledSkillInstalls(skillNames, targetDir) {
-  if (!fs8.existsSync(targetDir)) {
+  if (!fs9.existsSync(targetDir)) {
     return { removedPaths: [], removedRoot: false };
   }
   const removedPaths = [];
   for (const skillName of skillNames) {
-    const targetPath = path9.join(targetDir, skillName);
+    const targetPath = path11.join(targetDir, skillName);
     try {
-      if (!fs8.existsSync(targetPath)) continue;
-      const stats = fs8.lstatSync(targetPath);
+      if (!fs9.existsSync(targetPath)) continue;
+      const stats = fs9.lstatSync(targetPath);
       if (stats.isDirectory() && !stats.isSymbolicLink()) {
-        fs8.rmSync(targetPath, { recursive: true, force: true });
+        fs9.rmSync(targetPath, { recursive: true, force: true });
       } else {
-        fs8.rmSync(targetPath, { force: true });
+        fs9.rmSync(targetPath, { force: true });
       }
       removedPaths.push(skillName);
     } catch {
@@ -22196,17 +22204,17 @@ function removeBundledSkillInstalls(skillNames, targetDir) {
   }
   const removedRoot = removeDirIfEmpty2(targetDir);
   if (removedRoot) {
-    removeDirIfEmpty2(path9.dirname(targetDir));
+    removeDirIfEmpty2(path11.dirname(targetDir));
   }
   return { removedPaths, removedRoot };
 }
 function cleanupSkillsLockFile(lockPath, skillNames) {
-  if (!fs8.existsSync(lockPath)) {
+  if (!fs9.existsSync(lockPath)) {
     return { removedSkills: [], removedFile: false };
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs8.readFileSync(lockPath, "utf8"));
+    parsed = JSON.parse(fs9.readFileSync(lockPath, "utf8"));
   } catch {
     return { removedSkills: [], removedFile: false };
   }
@@ -22233,10 +22241,10 @@ function cleanupSkillsLockFile(lockPath, skillNames) {
     parsed.skills && typeof parsed.skills === "object" && Object.keys(parsed.skills).length > 0
   );
   if (!hasSkills && otherKeys.length === 0) {
-    fs8.rmSync(lockPath, { force: true });
+    fs9.rmSync(lockPath, { force: true });
     return { removedSkills, removedFile: true };
   }
-  fs8.writeFileSync(lockPath, JSON.stringify(parsed, null, 2) + "\n");
+  fs9.writeFileSync(lockPath, JSON.stringify(parsed, null, 2) + "\n");
   return { removedSkills, removedFile: false };
 }
 function cleanupBundledSkills(skillNames, targets) {
@@ -22306,7 +22314,7 @@ async function uninstall(args) {
         process.exit(0);
       }
     }
-    const projectRoot = resolveProjectRoot(process.cwd());
+    const projectRoot = resolveProjectRoot2(process.cwd());
     const results = [];
     log.step(import_picocolors5.default.bold("Removing MCP server entries..."));
     for (const adapter of ALL_ADAPTERS) {