@swmansion/argent 0.27.1-next.21 → 0.27.1-next.23

package/dist/mcp-server.mjs

@@ -2990,7 +2990,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve8.call(this, root, ref);
+      let _sch = resolve9.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
         const { schemaId } = this.opts;
@@ -3017,7 +3017,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve8(root, ref) {
+    function resolve9(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3235,8 +3235,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path15) {
-      let input = path15;
+    function removeDotSegments(path16) {
+      let input = path16;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3488,8 +3488,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path15, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path15 && path15 !== "/" ? path15 : void 0;
+        const [path16, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path16 && path16 !== "/" ? path16 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -3648,7 +3648,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve8(baseURI, relativeURI, options) {
+    function resolve9(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3906,7 +3906,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize: normalize3,
-      resolve: resolve8,
+      resolve: resolve9,
       resolveComponent,
       equal,
       serialize,
@@ -6972,17 +6972,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path15) {
-      const ctrl = callVisitor(key, node, visitor, path15);
+    function visit_(key, node, visitor, path16) {
+      const ctrl = callVisitor(key, node, visitor, path16);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path15, ctrl);
-        return visit_(key, ctrl, visitor, path15);
+        replaceNode(key, path16, ctrl);
+        return visit_(key, ctrl, visitor, path16);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path15 = Object.freeze(path15.concat(node));
+          path16 = Object.freeze(path16.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path15);
+            const ci = visit_(i, node.items[i], visitor, path16);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -6993,13 +6993,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path15 = Object.freeze(path15.concat(node));
-          const ck = visit_("key", node.key, visitor, path15);
+          path16 = Object.freeze(path16.concat(node));
+          const ck = visit_("key", node.key, visitor, path16);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path15);
+          const cv = visit_("value", node.value, visitor, path16);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -7020,17 +7020,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path15) {
-      const ctrl = await callVisitor(key, node, visitor, path15);
+    async function visitAsync_(key, node, visitor, path16) {
+      const ctrl = await callVisitor(key, node, visitor, path16);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path15, ctrl);
-        return visitAsync_(key, ctrl, visitor, path15);
+        replaceNode(key, path16, ctrl);
+        return visitAsync_(key, ctrl, visitor, path16);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path15 = Object.freeze(path15.concat(node));
+          path16 = Object.freeze(path16.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path15);
+            const ci = await visitAsync_(i, node.items[i], visitor, path16);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -7041,13 +7041,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path15 = Object.freeze(path15.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path15);
+          path16 = Object.freeze(path16.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path16);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path15);
+          const cv = await visitAsync_("value", node.value, visitor, path16);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -7074,23 +7074,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path15) {
+    function callVisitor(key, node, visitor, path16) {
       if (typeof visitor === "function")
-        return visitor(key, node, path15);
+        return visitor(key, node, path16);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path15);
+        return visitor.Map?.(key, node, path16);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path15);
+        return visitor.Seq?.(key, node, path16);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path15);
+        return visitor.Pair?.(key, node, path16);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path15);
+        return visitor.Scalar?.(key, node, path16);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path15);
+        return visitor.Alias?.(key, node, path16);
       return void 0;
     }
-    function replaceNode(key, path15, node) {
-      const parent = path15[path15.length - 1];
+    function replaceNode(key, path16, node) {
+      const parent = path16[path16.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -7700,10 +7700,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path15, value) {
+    function collectionFromPath(schema, path16, value) {
       let v = value;
-      for (let i = path15.length - 1; i >= 0; --i) {
-        const k = path15[i];
+      for (let i = path16.length - 1; i >= 0; --i) {
+        const k = path16[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -7722,7 +7722,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path15) => path15 == null || typeof path15 === "object" && !!path15[Symbol.iterator]().next().done;
+    var isEmptyPath = (path16) => path16 == null || typeof path16 === "object" && !!path16[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -7752,11 +7752,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(path15, value) {
-        if (isEmptyPath(path15))
+      addIn(path16, value) {
+        if (isEmptyPath(path16))
           this.add(value);
         else {
-          const [key, ...rest] = path15;
+          const [key, ...rest] = path16;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -7770,8 +7770,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path15) {
-        const [key, ...rest] = path15;
+      deleteIn(path16) {
+        const [key, ...rest] = path16;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -7785,8 +7785,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path15, keepScalar) {
-        const [key, ...rest] = path15;
+      getIn(path16, keepScalar) {
+        const [key, ...rest] = path16;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -7804,8 +7804,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path15) {
-        const [key, ...rest] = path15;
+      hasIn(path16) {
+        const [key, ...rest] = path16;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -7815,8 +7815,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(path15, value) {
-        const [key, ...rest] = path15;
+      setIn(path16, value) {
+        const [key, ...rest] = path16;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -10331,9 +10331,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path15, value) {
+      addIn(path16, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path15, value);
+          this.contents.addIn(path16, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -10408,14 +10408,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path15) {
-        if (Collection.isEmptyPath(path15)) {
+      deleteIn(path16) {
+        if (Collection.isEmptyPath(path16)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path15) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path16) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -10430,10 +10430,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path15, keepScalar) {
-        if (Collection.isEmptyPath(path15))
+      getIn(path16, keepScalar) {
+        if (Collection.isEmptyPath(path16))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path15, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path16, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -10444,10 +10444,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path15) {
-        if (Collection.isEmptyPath(path15))
+      hasIn(path16) {
+        if (Collection.isEmptyPath(path16))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path15) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path16) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -10464,13 +10464,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(path15, value) {
-        if (Collection.isEmptyPath(path15)) {
+      setIn(path16, value) {
+        if (Collection.isEmptyPath(path16)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path15), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path16), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path15, value);
+          this.contents.setIn(path16, value);
         }
       }
       /**
@@ -12430,9 +12430,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path15) => {
+    visit.itemAtPath = (cst, path16) => {
       let item = cst;
-      for (const [field, index] of path15) {
+      for (const [field, index] of path16) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -12441,23 +12441,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path15) => {
-      const parent = visit.itemAtPath(cst, path15.slice(0, -1));
-      const field = path15[path15.length - 1][0];
+    visit.parentCollection = (cst, path16) => {
+      const parent = visit.itemAtPath(cst, path16.slice(0, -1));
+      const field = path16[path16.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path15, item, visitor) {
-      let ctrl = visitor(item, path15);
+    function _visit(path16, item, visitor) {
+      let ctrl = visitor(item, path16);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path15.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path16.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -12468,10 +12468,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path15);
+            ctrl = ctrl(item, path16);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path15) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path16) : ctrl;
     }
     exports.visit = visit;
   }
@@ -14226,7 +14226,7 @@ var require_dist2 = __commonJS({
 var require_main = __commonJS({
   "../../node_modules/dotenv/lib/main.js"(exports, module) {
     var fs11 = __require("fs");
-    var path15 = __require("path");
+    var path16 = __require("path");
     var os2 = __require("os");
     var crypto3 = __require("crypto");
     var TIPS = [
@@ -14365,7 +14365,7 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path15.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path16.resolve(process.cwd(), ".env.vault");
       }
       if (fs11.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
@@ -14373,7 +14373,7 @@ var require_main = __commonJS({
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path15.join(os2.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path16.join(os2.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
@@ -14390,7 +14390,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path15.resolve(process.cwd(), ".env");
+      const dotenvPath = path16.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       let processEnv = process.env;
       if (options && options.processEnv != null) {
@@ -14418,13 +14418,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path16 of optionPaths) {
+      for (const path17 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs11.readFileSync(path16, { encoding }));
+          const parsed = DotenvModule.parse(fs11.readFileSync(path17, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`failed to load ${path16} ${e.message}`);
+            _debug(`failed to load ${path17} ${e.message}`);
           }
           lastError = e;
         }
@@ -14437,7 +14437,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative2 = path15.relative(process.cwd(), filePath);
+            const relative2 = path16.relative(process.cwd(), filePath);
             shortPaths.push(relative2);
           } catch (e) {
             if (debug) {
@@ -14543,7 +14543,7 @@ var require_main = __commonJS({
 
 // ../argent-mcp/src/mcp-server.ts
 import { appendFile, mkdir as mkdir5 } from "node:fs/promises";
-import { dirname as dirname8 } from "node:path";
+import { dirname as dirname9 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 
 // ../../node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
@@ -14789,10 +14789,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path15) {
-  if (!path15)
+function getElementAtPath(obj, path16) {
+  if (!path16)
     return obj;
-  return path15.reduce((acc, key) => acc?.[key], obj);
+  return path16.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -15201,11 +15201,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path15, issues) {
+function prefixIssues(path16, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path15);
+    iss.path.unshift(path16);
     return iss;
   });
 }
@@ -15352,16 +15352,16 @@ function flattenError(error2, mapper = (issue2) => issue2.message) {
 }
 function formatError(error2, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error3, path15 = []) => {
+  const processError = (error3, path16 = []) => {
     for (const issue2 of error3.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path15, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
       } else {
-        const fullpath = [...path15, ...issue2.path];
+        const fullpath = [...path16, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -21353,12 +21353,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve8();
+        resolve9();
       } else {
-        this._stdout.once("drain", resolve8);
+        this._stdout.once("drain", resolve9);
       }
     });
   }
@@ -21956,7 +21956,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve8) => setTimeout(resolve8, pollInterval));
+        await new Promise((resolve9) => setTimeout(resolve9, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -21973,7 +21973,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -22051,7 +22051,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve8(parseResult.data);
+            resolve9(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -22312,12 +22312,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve8, interval);
+      const timeoutId = setTimeout(resolve9, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -23142,7 +23142,7 @@ function generateToken() {
   return randomBytes(AUTH_TOKEN_BYTES).toString("hex");
 }
 function findFreePort() {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const srv = net.createServer();
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
@@ -23153,7 +23153,7 @@ function findFreePort() {
       const port = addr.port;
       srv.close((err) => {
         if (err) reject(err);
-        else resolve8(port);
+        else resolve9(port);
       });
     });
     srv.on("error", reject);
@@ -23251,7 +23251,7 @@ function killSpawnedChild(child, pid) {
   }
 }
 function spawnToolsServer(paths, port, options = {}) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     let logFd;
     try {
       fs.mkdirSync(STATE_DIR, { recursive: true });
@@ -23297,7 +23297,7 @@ function spawnToolsServer(paths, port, options = {}) {
         rl.close();
         child.stdout?.resume();
         child.stdout?.unref?.();
-        settle(() => resolve8({ port: actualPort, pid }));
+        settle(() => resolve9({ port: actualPort, pid }));
       }
     });
     child.on("error", (err) => {
@@ -23591,6 +23591,12 @@ async function ensureToolsServer(paths) {
   }
 }
 
+// ../argent-tools-client/src/tools-client.ts
+import * as path6 from "node:path";
+
+// ../registry/src/types.ts
+var LINKED_CALL_HEADER = "x-argent-linked";
+
 // ../registry/src/artifacts.ts
 import { stat } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
@@ -23601,6 +23607,35 @@ 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$`);
 var SCRIPT_FILE_NAME_PATTERN = new RegExp(`^${FLOW_NAME_CHARSET}\\.mjs$`);
+function interpolateFileInputPath(template, args) {
+  let missing = false;
+  const out = template.replace(/\$\{([A-Za-z0-9_]+)\}/g, (_m, name) => {
+    const v = args[name];
+    if (typeof v !== "string" || v.length === 0) {
+      missing = true;
+      return "";
+    }
+    return v;
+  });
+  return missing ? null : out;
+}
+var TOOL_FILE_EXTENSIONS = [".png", ".yaml"];
+function hasToolFileExtension(file) {
+  const name = file.toLowerCase();
+  return TOOL_FILE_EXTENSIONS.some((extension) => name.endsWith(extension));
+}
+function toolStepFiles(specs, args) {
+  const files = [];
+  for (const spec of specs ?? []) {
+    if (spec.skipWhenSet !== void 0 && args[spec.skipWhenSet] !== void 0) continue;
+    const filled = interpolateFileInputPath(spec.path, args);
+    if (filled !== null) files.push({ spec, path: filled });
+  }
+  return files;
+}
+function isClientFileArgument({ spec, path: path16 }) {
+  return spec.kind === "file" && spec.path === `\${${spec.target}}` && path16.startsWith("/") && hasToolFileExtension(path16);
+}
 
 // ../registry/src/flow-file-refs.ts
 import * as fs2 from "node:fs/promises";
@@ -23629,6 +23664,8 @@ function isRecord(value) {
 function collectFlowRequests(doc) {
   const runTargets = /* @__PURE__ */ new Set();
   const snapshots = /* @__PURE__ */ new Set();
+  const toolSteps = [];
+  const nested = [];
   const seen = /* @__PURE__ */ new Set();
   const visit = (steps, depth) => {
     if (!Array.isArray(steps) || depth > MAX_BLOCK_NESTING || seen.has(steps)) return;
@@ -23642,11 +23679,17 @@ function collectFlowRequests(doc) {
       }
       const snapshot = isRecord(step.snapshot) ? step.snapshot.name : step.snapshot;
       if (typeof snapshot === "string" && FLOW_NAME_PATTERN.test(snapshot)) snapshots.add(snapshot);
+      if (typeof step.tool === "string") {
+        const args = isRecord(step.args) ? step.args : {};
+        toolSteps.push({ tool: step.tool, args });
+        const target = step.tool === "flow-execute" ? nestedFlowTarget(args) : void 0;
+        if (target !== void 0) nested.push({ target, args });
+      }
       visit(step.steps, depth + 1);
     }
   };
   if (isRecord(doc)) visit(doc.steps, 0);
-  return { runTargets: [...runTargets], snapshots: [...snapshots] };
+  return { runTargets: [...runTargets], snapshots: [...snapshots], toolSteps, nested };
 }
 function baselineKeyFor(canonicalPath, flowName) {
   const stem = path2.basename(canonicalPath, ".yaml");
@@ -23662,6 +23705,26 @@ async function classifyOnDiskSpelling(dir, base, addressable = FLOW_FILE_NAME_PA
   if (actual === void 0) return { state: "absent" };
   return { state: "case_folded", actual, addressable: addressable.test(actual) };
 }
+function nestedFlowTarget(args) {
+  if (typeof args !== "object" || args === null || Array.isArray(args)) return void 0;
+  const { name, project_root: projectRoot, flow_path: flowPath } = args;
+  if (flowPath === void 0) {
+    if (typeof name !== "string" || !FLOW_NAME_PATTERN.test(name)) return void 0;
+    if (!isResolvedAbsolute(projectRoot)) return void 0;
+    return {
+      kind: "name",
+      projectRoot,
+      name,
+      path: path2.join(projectRoot, ".argent", "flows", `${name}.yaml`)
+    };
+  }
+  if (name !== void 0 || !isResolvedAbsolute(flowPath)) return void 0;
+  if (!FLOW_FILE_NAME_PATTERN.test(path2.basename(flowPath))) return void 0;
+  return { kind: "flow_path", path: flowPath };
+}
+function isResolvedAbsolute(value) {
+  return typeof value === "string" && path2.isAbsolute(value) && !value.split(/[\\/]+/).includes("..");
+}
 
 // ../registry/src/failure-codes.ts
 var FAILURE_CODES = {
@@ -24021,9 +24084,9 @@ var FAILURE_SPAWN_CODE_SET = new Set(FAILURE_SPAWN_CODES);
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 var resolvedDuringInvocation = new AsyncLocalStorage();
-function valueAtPath(root, path15) {
+function valueAtPath(root, path16) {
   let current = root;
-  for (const key of path15) {
+  for (const key of path16) {
     if (current === null || typeof current !== "object") return void 0;
     if (!Object.hasOwn(current, key)) return void 0;
     current = current[key];
@@ -24307,9 +24370,9 @@ function untrackArchive(archive) {
   process.removeListener("exit", removePendingArchives);
 }
 function sha256File(filePath) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const hash = createHash2("sha256");
-    createReadStream(filePath).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve8(hash.digest("hex"))).on("error", reject);
+    createReadStream(filePath).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve9(hash.digest("hex"))).on("error", reject);
   });
 }
 function toolServerError(text) {
@@ -24417,6 +24480,9 @@ async function prepareFileInputs(specs, args, opts) {
         );
       }
     }
+    if (spec.kind === "probe" && spec.collect === "step" && opts.includeContent && opts.collectStepMembers) {
+      wire.members = await opts.collectStepMembers(record2, opts);
+    }
     if (spec.kind === "tar-upload") {
       const st = await stat2(filePath).catch(() => null);
       if (st) {
@@ -24543,14 +24609,14 @@ function printable(text) {
     (c) => c < " " || c === "\x7F" ? `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}` : c
   ).join("");
 }
-function isResolvedAbsolute(value) {
+function isResolvedAbsolute2(value) {
   return typeof value === "string" && path5.isAbsolute(value) && !value.split(/[\\/]+/).includes("..");
 }
 function namesValidFlow(args) {
   const { project_root, flow_path, name } = args;
-  if (!isResolvedAbsolute(project_root)) return false;
+  if (!isResolvedAbsolute2(project_root)) return false;
   if (name === void 0) {
-    return isResolvedAbsolute(flow_path) && FLOW_FILE_NAME_PATTERN.test(path5.basename(flow_path));
+    return isResolvedAbsolute2(flow_path) && FLOW_FILE_NAME_PATTERN.test(path5.basename(flow_path));
   }
   return flow_path === void 0 && typeof name === "string" && FLOW_NAME_PATTERN.test(name);
 }
@@ -24636,6 +24702,29 @@ async function readFlowMember(anchorDir, target, roots, budget, opts) {
   const sent = await sendBytes(member, canonical, budget, opts);
   return { ...sent, text: sent.bytes?.toString("utf8") };
 }
+async function readToolMember(file, roots, budget, opts) {
+  const member = { role: "tool", key: file, path: file };
+  const refuse = (reason) => ({
+    member: { ...member, state: "refused", error: reason },
+    sent: `refused (${reason})`
+  });
+  const { canonical } = await landing(file);
+  if (!roots.some((root) => isWithin(canonical, root))) {
+    return refuse(`${file} is outside every root this client serves (${roots.join(", ")})`);
+  }
+  if (!hasToolFileExtension(canonical)) {
+    return refuse(`${file} links to a file that is not one of ${TOOL_FILE_EXTENSIONS.join(", ")}`);
+  }
+  const st = await stat3(canonical).catch((err) => err);
+  if (st instanceof Error) {
+    if (st.code === "ENOENT" || st.code === "ENOTDIR") {
+      return { member: { ...member, state: "missing" }, sent: "missing" };
+    }
+    return refuse(st.message);
+  }
+  if (st.isDirectory()) return refuse("EISDIR: illegal operation on a directory, read");
+  return sendBytes(member, canonical, budget, opts);
+}
 function callPlatform(args) {
   if (typeof args.device === "string" && args.device.startsWith("chromium-cdp-")) return "chromium";
   if (typeof args.platform !== "string") return void 0;
@@ -24690,51 +24779,15 @@ async function sendBytes(member, real, budget, opts) {
     bytes
   };
 }
-async function collectBaselineMembers(canonical, flowName, snapshots, args, roots, budget, opts, emit) {
-  const dir = path5.join(
-    path5.dirname(canonical),
-    "__baselines__",
-    baselineKeyFor(canonical, flowName)
-  );
-  const real = (await landing(dir)).canonical;
-  if (!roots.some((root) => isWithin(real, root))) return;
-  const updates = args.updateBaselines === true;
-  if (updates) opts.baselineDirs?.push(dir);
-  const platform = callPlatform(args);
-  const prefixes = snapshots.map(
-    (name) => `${name}__${platform === void 0 ? "" : `${platform}-`}`
-  );
-  const names = await readdir4(dir).catch(() => []);
-  for (const name of names.sort()) {
-    if (!name.endsWith(".png")) continue;
-    if (!updates && !prefixes.some((prefix) => name.startsWith(prefix))) continue;
-    const file = path5.join(dir, name);
-    const member = { role: "baseline", key: file, path: file };
-    const entry = await baselineEntry(file, roots, updates);
-    if (entry.state === "refused") {
-      emit({ ...member, state: "refused", error: entry.error }, `refused (${entry.error})`);
-    } else if (entry.state === "missing") {
-      emit({ ...member, state: "missing" }, "missing");
-    } else if (updates) {
-      emit({ ...member, state: "listed" }, "listed");
-    } else {
-      const sent = await sendBytes(member, entry.real, budget, opts);
-      emit(sent.member, sent.sent);
-    }
-  }
+function nestedRunUpdates(parentUpdates, args) {
+  return args.updateBaselines === true || parentUpdates && args.updateBaselines === void 0;
 }
-async function collectFlowMembers(rootPath, rootBytes, args, opts) {
-  if (!namesValidFlow(args)) return {};
-  const canonical = await canonicalFlowPath(rootPath);
-  const spelling = await classifyOnDiskSpelling(
-    path5.dirname(rootPath),
-    path5.basename(rootPath),
-    FLOW_FILE_NAME_PATTERN
-  );
-  const roots = await closureRoots(rootPath, canonical, args.project_root);
+function memberCollector(roots, opts) {
   const members = [];
-  const seen = /* @__PURE__ */ new Set();
-  const snapshots = /* @__PURE__ */ new Set();
+  const flows = /* @__PURE__ */ new Map();
+  const tools = /* @__PURE__ */ new Set();
+  const runs = /* @__PURE__ */ new Set();
+  const baselineDirs = /* @__PURE__ */ new Map();
   const budget = { inline: 0 };
   const logging = process.env[FLOW_FILES_LOG_ENV] === "1";
   const log = opts.log ?? ((line) => void process.stderr.write(`${line}
@@ -24744,42 +24797,194 @@ async function collectFlowMembers(rootPath, rootBytes, args, opts) {
     const subject = member.role === "flow" ? member.canonical : member.key;
     if (logging) log(printable(`[flow-files] ${member.role} ${subject}: ${sent}`));
   };
-  const queue = [{ canonical, text: rootBytes.toString("utf8"), hop: 0 }];
-  for (let file = queue.shift(); file !== void 0; file = queue.shift()) {
-    let doc;
-    try {
-      doc = (0, import_yaml.parse)(file.text.trim(), { logLevel: "error" });
-    } catch {
-      continue;
-    }
-    const requests = collectFlowRequests(doc);
-    for (const name of requests.snapshots) snapshots.add(name);
-    const anchorDir = path5.dirname(file.canonical);
-    for (const target of requests.runTargets) {
-      const key = flowMemberKey(anchorDir, target);
-      if (seen.has(key)) continue;
-      seen.add(key);
-      const { member, text, sent } = await readFlowMember(anchorDir, target, roots, budget, opts);
-      emit(member, sent);
-      if (text !== void 0 && file.hop + 1 < MAX_RUN_DEPTH) {
-        queue.push({ canonical: member.canonical, text, hop: file.hop + 1 });
+  async function flow(anchorDir, target) {
+    const key = flowMemberKey(anchorDir, target);
+    const known = flows.get(key);
+    if (known !== void 0) return known;
+    const { member, text, sent } = await readFlowMember(anchorDir, target, roots, budget, opts);
+    const entry = { member, ...text === void 0 ? {} : { text } };
+    flows.set(key, entry);
+    emit(member, sent);
+    return entry;
+  }
+  async function toolFiles(step) {
+    if (step.tool === "flow-execute") return;
+    for (const file of toolStepFiles(opts.toolFileInputs?.(step.tool), step.args)) {
+      const { unwrapWhenSet } = file.spec;
+      if (unwrapWhenSet !== void 0 && step.args[unwrapWhenSet] !== void 0) continue;
+      if (!isClientFileArgument(file) || tools.has(file.path)) continue;
+      tools.add(file.path);
+      const read = await readToolMember(file.path, roots, budget, opts);
+      emit(read.member, read.sent);
+    }
+  }
+  async function nestedRun(target, hop, updates, platform) {
+    const { member, text } = await flow(path5.dirname(target.path), `${target.name}.yaml`);
+    if (text === void 0 || hop >= MAX_RUN_DEPTH) return void 0;
+    return { canonical: member.canonical, text, flowName: target.name, hop, updates, platform };
+  }
+  async function walk(start) {
+    const queue = [...start];
+    for (let run = queue.shift(); run !== void 0; run = queue.shift()) {
+      const id = [run.canonical, run.flowName, run.updates, run.platform ?? ""].join("\0");
+      if (runs.has(id)) continue;
+      runs.add(id);
+      const snapshots = /* @__PURE__ */ new Set();
+      const visited = /* @__PURE__ */ new Set();
+      const files = [{ canonical: run.canonical, text: run.text, hop: run.hop }];
+      for (let file = files.shift(); file !== void 0; file = files.shift()) {
+        let doc;
+        try {
+          doc = (0, import_yaml.parse)(file.text.trim(), { logLevel: "error" });
+        } catch {
+          continue;
+        }
+        const requests = collectFlowRequests(doc);
+        for (const name of requests.snapshots) snapshots.add(name);
+        for (const step of requests.toolSteps) await toolFiles(step);
+        const anchorDir = path5.dirname(file.canonical);
+        for (const target of requests.runTargets) {
+          const key = flowMemberKey(anchorDir, target);
+          if (visited.has(key)) continue;
+          visited.add(key);
+          const { member, text } = await flow(anchorDir, target);
+          if (text !== void 0 && file.hop + 1 < MAX_RUN_DEPTH) {
+            files.push({ canonical: member.canonical, text, hop: file.hop + 1 });
+          }
+        }
+        for (const { target, args } of requests.nested) {
+          if (target.kind !== "name") continue;
+          const next = await nestedRun(
+            target,
+            file.hop + 1,
+            nestedRunUpdates(run.updates, args),
+            run.platform
+          );
+          if (next !== void 0) queue.push(next);
+        }
+      }
+      if (snapshots.size === 0) continue;
+      const dir = path5.join(
+        path5.dirname(run.canonical),
+        "__baselines__",
+        baselineKeyFor(run.canonical, run.flowName)
+      );
+      const entry = baselineDirs.get(dir) ?? { prefixes: /* @__PURE__ */ new Set(), updates: false };
+      baselineDirs.set(dir, entry);
+      if (run.updates) {
+        entry.updates = true;
+      } else {
+        const platform = run.platform === void 0 ? "" : `${run.platform}-`;
+        for (const name of snapshots) entry.prefixes.add(`${name}__${platform}`);
+      }
+    }
+  }
+  async function sendBaselines() {
+    for (const [dir, { prefixes, updates }] of baselineDirs) {
+      const real = (await landing(dir)).canonical;
+      if (!roots.some((root) => isWithin(real, root))) continue;
+      if (updates) opts.baselineDirs?.push(dir);
+      const names = await readdir4(dir).catch(() => []);
+      for (const name of names.sort()) {
+        if (!name.endsWith(".png")) continue;
+        const compared = [...prefixes].some((prefix) => name.startsWith(prefix));
+        if (!updates && !compared) continue;
+        const file = path5.join(dir, name);
+        if (tools.has(file)) continue;
+        const member = { role: "baseline", key: file, path: file };
+        const entry = await baselineEntry(file, roots, updates && !compared);
+        if (entry.state === "refused") {
+          emit({ ...member, state: "refused", error: entry.error }, `refused (${entry.error})`);
+        } else if (entry.state === "missing") {
+          emit({ ...member, state: "missing" }, "missing");
+        } else if (!compared) {
+          emit({ ...member, state: "listed" }, "listed");
+        } else {
+          const sent = await sendBytes(member, entry.real, budget, opts);
+          emit(sent.member, sent.sent);
+        }
       }
     }
   }
-  if (snapshots.size > 0) {
-    const flowName = path5.basename(rootPath, ".yaml");
-    await collectBaselineMembers(
+  return { members, flow, toolFiles, nestedRun, walk, sendBaselines };
+}
+async function collectFlowMembers(rootPath, rootBytes, args, opts) {
+  if (!namesValidFlow(args)) return {};
+  const canonical = await canonicalFlowPath(rootPath);
+  const spelling = await classifyOnDiskSpelling(
+    path5.dirname(rootPath),
+    path5.basename(rootPath),
+    FLOW_FILE_NAME_PATTERN
+  );
+  const collector = memberCollector(
+    await closureRoots(rootPath, canonical, args.project_root),
+    opts
+  );
+  await collector.walk([
+    {
       canonical,
-      flowName,
-      [...snapshots],
-      args,
-      roots,
-      budget,
-      opts,
-      emit
-    );
+      text: rootBytes.toString("utf8"),
+      flowName: path5.basename(rootPath, ".yaml"),
+      hop: 0,
+      updates: args.updateBaselines === true,
+      platform: callPlatform(args)
+    }
+  ]);
+  await collector.sendBaselines();
+  return { canonical, spelling, members: collector.members };
+}
+function recordedStep(args) {
+  const { command, args: text } = args;
+  if (typeof command !== "string") return void 0;
+  if (text === void 0) return { tool: command, args: {} };
+  if (typeof text !== "string") return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+  return { tool: command, args: parsed };
+}
+async function collectStepMembers(args, opts) {
+  const { name, project_root: projectRoot } = args;
+  const step = recordedStep(args);
+  if (typeof name !== "string" || !FLOW_NAME_PATTERN.test(name) || typeof projectRoot !== "string" || !path5.isAbsolute(projectRoot) || step === void 0) {
+    return [];
+  }
+  const recording = path5.join(projectRoot, ".argent", "flows", `${name}.yaml`);
+  const collector = memberCollector(
+    await closureRoots(recording, (await landing(recording)).canonical, projectRoot),
+    opts
+  );
+  await collector.toolFiles(step);
+  if (step.tool === "flow-execute") {
+    const self = await collector.flow(path5.dirname(recording), path5.basename(recording));
+    let runArgs = step.args;
+    const named = nestedFlowTarget(runArgs);
+    if (named?.kind === "flow_path") {
+      const stem = path5.basename(named.path, ".yaml");
+      if (path5.resolve(path5.dirname(named.path)) === path5.resolve(path5.dirname(recording))) {
+        await collector.flow(path5.dirname(recording), path5.basename(named.path));
+        runArgs = { ...runArgs, name: stem };
+        delete runArgs.flow_path;
+      }
+    }
+    const target = nestedFlowTarget(runArgs);
+    if (target?.kind === "name") {
+      await collector.flow(path5.dirname(self.member.canonical), `${target.name}.yaml`);
+      const run = await collector.nestedRun(
+        target,
+        0,
+        runArgs.updateBaselines === true,
+        callPlatform(runArgs)
+      );
+      if (run !== void 0) await collector.walk([run]);
+    }
   }
-  return { canonical, spelling, members };
+  await collector.sendBaselines();
+  return collector.members;
 }
 
 // ../argent-tools-client/src/tools-client.ts
@@ -24940,7 +25145,8 @@ function createToolsClient(options = {}) {
     opts?.signal?.throwIfAborted();
     const { url, token, remote } = await route();
     let finalArgs = args;
-    const meta2 = await fetchTool(name, { signal: opts?.signal });
+    const tools = await fetchTools({ signal: opts?.signal });
+    const meta2 = tools.find((t) => t.name === name) ?? null;
     const baselineDirs = [];
     if (meta2?.fileInputs?.length) {
       if (remote) assertRequiredPresent(meta2, args);
@@ -24950,6 +25156,8 @@ function createToolsClient(options = {}) {
         log: diagnose,
         baselineDirs,
         collectMembers: collectFlowMembers,
+        collectStepMembers,
+        toolFileInputs: (tool) => tools.find((t) => t.name === tool)?.fileInputs,
         signal: opts?.signal
       });
     }
@@ -24959,7 +25167,11 @@ function createToolsClient(options = {}) {
         diagnose(`The baseline ${file} was not written on this client: ${error2}`);
       }
       if (process.env.ARGENT_FLOW_FILES_LOG === "1") {
-        for (const file of applied.written) diagnose(`[flow-files] baseline ${file}: written`);
+        for (const file of applied.written) {
+          if (baselineDirs.includes(path6.dirname(file))) {
+            diagnose(`[flow-files] baseline ${file}: written`);
+          }
+        }
       }
       return applied.result;
     };
@@ -24971,6 +25183,9 @@ function createToolsClient(options = {}) {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
+          // Tells the tool-server the call came over a link, a link to
+          // 127.0.0.1 included, which nothing else in the request shows.
+          ...remote ? { [LINKED_CALL_HEADER]: "1" } : {},
           // A proxy that compresses the stream holds each line until its buffer
           // fills. `identity` keeps the stream uncompressed end to end.
           ...stream ? { "Accept": "application/x-ndjson", "Accept-Encoding": "identity" } : {},
@@ -25031,35 +25246,35 @@ function createToolsClient(options = {}) {
 import { copyFile, mkdir as mkdir4, readFile as readFile5, realpath as realpath4, rm as rm3, stat as stat4, writeFile as writeFile4 } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { basename as basename6, dirname as dirname7, extname as extname2, isAbsolute as isAbsolute5, join as join11, normalize as normalize2, resolve as resolve6, sep as sep4 } from "node:path";
+import { basename as basename6, dirname as dirname8, extname as extname2, isAbsolute as isAbsolute6, join as join11, normalize as normalize2, resolve as resolve7, sep as sep4 } from "node:path";
 import { createHash as createHash3 } from "node:crypto";
 
 // ../configuration-core/src/flags.ts
 import * as fs3 from "node:fs";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 import { homedir as homedir3 } from "node:os";
 var PROJECT_MARKERS = [".argent", ".git", "package.json"];
 function findProjectRoot(startDir) {
-  let current = path6.resolve(startDir);
+  let current = path7.resolve(startDir);
   while (true) {
     for (const marker of PROJECT_MARKERS) {
-      if (fs3.existsSync(path6.join(current, marker))) return current;
+      if (fs3.existsSync(path7.join(current, marker))) return current;
     }
-    const parent = path6.dirname(current);
+    const parent = path7.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function resolveProjectRoot(startDir) {
-  return findProjectRoot(startDir) ?? path6.resolve(startDir);
+  return findProjectRoot(startDir) ?? path7.resolve(startDir);
 }
 function getFlagsPath(scope, options = {}) {
   const home = options.homeDir ?? homedir3();
   if (scope === "global") {
-    return path6.join(home, ".argent", "flags.json");
+    return path7.join(home, ".argent", "flags.json");
   }
   const cwd = options.cwd ?? process.cwd();
-  return path6.join(resolveProjectRoot(cwd), ".argent", "flags.json");
+  return path7.join(resolveProjectRoot(cwd), ".argent", "flags.json");
 }
 function readFlagsFile(filePath) {
   let raw;
@@ -25096,7 +25311,7 @@ function isFlagEnabled(name, options = {}) {
 
 // ../configuration-core/src/paths.ts
 import * as os from "node:os";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 function nonEmpty(value) {
   if (value == void 0) return null;
   const trimmed = value.trim();
@@ -25107,23 +25322,23 @@ function resolveHomeDir(options = {}) {
   return process.platform === "win32" ? nonEmpty(process.env.USERPROFILE) ?? os.homedir() : nonEmpty(process.env.HOME) ?? os.homedir();
 }
 function argentHomeDir() {
-  return path7.join(resolveHomeDir(), ".argent");
+  return path8.join(resolveHomeDir(), ".argent");
 }
 function configDir(scope = "global", options = {}) {
   if (scope === "global") {
-    return path7.join(resolveHomeDir(options), ".argent");
+    return path8.join(resolveHomeDir(options), ".argent");
   }
   const cwd = options.cwd ?? process.cwd();
-  return path7.join(resolveProjectRoot(cwd), ".argent");
+  return path8.join(resolveProjectRoot(cwd), ".argent");
 }
 function configFilePath(scope = "global", options = {}) {
-  return path7.join(configDir(scope, options), "config.json");
+  return path8.join(configDir(scope, options), "config.json");
 }
 
 // ../configuration-core/src/config.ts
 import * as crypto from "node:crypto";
 import * as fs4 from "node:fs";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 function readConfigObject(scope = "global", options = {}) {
   try {
     const raw = fs4.readFileSync(configFilePath(scope, options), "utf8");
@@ -25210,7 +25425,7 @@ function updateConfig(mutate, scope = "global", options = {}) {
   try {
     const next = readConfigObject(scope, options);
     mutate(next);
-    const tmpPath = path8.join(dir, `.config.tmp.${process.pid}.${crypto.randomUUID()}`);
+    const tmpPath = path9.join(dir, `.config.tmp.${process.pid}.${crypto.randomUUID()}`);
     const fd = fs4.openSync(tmpPath, "wx", 384);
     try {
       fs4.writeSync(fd, JSON.stringify(next, null, 2) + "\n");
@@ -25235,7 +25450,7 @@ function updateConfig(mutate, scope = "global", options = {}) {
 // ../configuration-core/src/secrets.ts
 var import_dotenv = __toESM(require_main(), 1);
 import * as fs5 from "node:fs";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 
 // ../configuration-core/src/merge.ts
 function mergeRestrictive(local, global) {
@@ -25289,7 +25504,7 @@ function applyMergePolicy(policy, local, global) {
 }
 
 // ../configuration-core/src/config-schema.ts
-import { isAbsolute as isAbsolute4 } from "node:path";
+import { isAbsolute as isAbsolute5 } from "node:path";
 function asBoolean(raw) {
   return typeof raw === "boolean" ? raw : void 0;
 }
@@ -25358,7 +25573,7 @@ var CONFIG_SCHEMA = [
     scopes: ["project", "global"],
     parse: (raw) => {
       const value = asString(raw);
-      return value !== void 0 && (value === "~" || value.startsWith("~/") || isAbsolute4(value)) ? value : void 0;
+      return value !== void 0 && (value === "~" || value.startsWith("~/") || isAbsolute5(value)) ? value : void 0;
     },
     expected: "an absolute path, or one starting with `~/`",
     merge: "prioritize-local",
@@ -25409,7 +25624,7 @@ function getConfigDefinition(key, registry2 = CONFIG_SCHEMA) {
 }
 
 // ../configuration-core/src/config-access.ts
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 function readScopeValue(def, scope, options) {
   if (!def.scopes.includes(scope)) return void 0;
   const raw = getAtPath(readConfigObject(scope, options), def.key);
@@ -25473,7 +25688,7 @@ function artifactDir(deviceId) {
 }
 function durableBaseDir() {
   const projectRoot = findProjectRoot(process.cwd());
-  return projectRoot ?? dirname7(argentHomeDir());
+  return projectRoot ?? dirname8(argentHomeDir());
 }
 var ALLOWED_SAVE_DIRS = /* @__PURE__ */ new Set([normalize2(".argent/recordings")]);
 var RECORDINGS_SAVE_DIR = normalize2(".argent/recordings");
@@ -25487,9 +25702,9 @@ function configuredRecordingsDir() {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
   if (trimmed === "") return null;
-  const home = dirname7(argentHomeDir());
+  const home = dirname8(argentHomeDir());
   const expanded = trimmed === "~" ? home : trimmed.startsWith("~/") || trimmed.startsWith(`~${sep4}`) ? join11(home, trimmed.slice(2)) : trimmed;
-  return resolve6(durableBaseDir(), expanded);
+  return resolve7(durableBaseDir(), expanded);
 }
 var MAX_DURABLE_BYTES = 2 * 1024 * 1024 * 1024;
 async function readCapped(res, cap) {
@@ -25522,10 +25737,10 @@ async function writeDurableUnique(dir, filename, write) {
   const stem = filename.slice(0, filename.length - ext.length);
   for (let i = 1; i <= 1e3; i++) {
     const candidate = i === 1 ? filename : `${stem} (${i})${ext}`;
-    const path15 = join11(dir, candidate);
+    const path16 = join11(dir, candidate);
     try {
-      await write(path15);
-      return path15;
+      await write(path16);
+      return path16;
     } catch (err) {
       if (err?.code === "EEXIST") continue;
       throw err;
@@ -25536,7 +25751,7 @@ async function writeDurableUnique(dir, filename, write) {
 function durableSaveTarget(handle) {
   if (typeof handle.saveDir !== "string" || !handle.saveDir || handle.archive) return null;
   const rel = normalize2(handle.saveDir);
-  if (isAbsolute5(rel) || rel === ".." || rel.startsWith(`..${sep4}`) || rel.split(sep4).includes("..")) {
+  if (isAbsolute6(rel) || rel === ".." || rel.startsWith(`..${sep4}`) || rel.split(sep4).includes("..")) {
     return null;
   }
   if (!ALLOWED_SAVE_DIRS.has(rel)) return null;
@@ -25711,7 +25926,7 @@ function getDeviceIdFromArgs(args) {
 import * as fs6 from "node:fs";
 
 // ../telemetry/src/paths.ts
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 
 // ../telemetry/src/events.ts
 var PLATFORMS = [
@@ -26400,18 +26615,18 @@ var SESSION_ID2 = randomUUID5();
 // ../telemetry/src/identity.ts
 import * as crypto2 from "node:crypto";
 import * as fs7 from "node:fs";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 
 // ../telemetry/src/fingerprint.ts
 import { execFileSync as execFileSync2, spawn as spawn2 } from "node:child_process";
 
 // ../native-devtools-ios/src/index.ts
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 import * as fs8 from "node:fs";
-var DYLIB_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_DIR ?? path13.join(__dirname, "..", "dylibs");
-var BIN_DIR = process.env.ARGENT_SIMULATOR_SERVER_DIR ?? path13.join(__dirname, "..", "bin");
-var DYLIB_TCP_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_TCP_DIR ?? path13.join(DYLIB_DIR, "tcp");
-var DYLIB_TVOS_DIR = path13.join(DYLIB_DIR, "tvos");
+var DYLIB_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_DIR ?? path14.join(__dirname, "..", "dylibs");
+var BIN_DIR = process.env.ARGENT_SIMULATOR_SERVER_DIR ?? path14.join(__dirname, "..", "bin");
+var DYLIB_TCP_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_TCP_DIR ?? path14.join(DYLIB_DIR, "tcp");
+var DYLIB_TVOS_DIR = path14.join(DYLIB_DIR, "tvos");
 
 // ../telemetry/src/consent.ts
 import * as fs9 from "node:fs";
@@ -26712,9 +26927,9 @@ async function flowRunToMcpContent(result, ctx) {
     }
   }
   for (const write of result.baselineWrites ?? []) {
-    const { path: path15, error: error2 } = isRecord2(write) ? write : {};
-    if (typeof path15 === "string" && typeof error2 === "string") {
-      blocks.push({ type: "text", text: `\u2717 baseline not written: ${path15}: ${error2}` });
+    const { path: path16, error: error2 } = isRecord2(write) ? write : {};
+    if (typeof path16 === "string" && typeof error2 === "string") {
+      blocks.push({ type: "text", text: `\u2717 baseline not written: ${path16}: ${error2}` });
     }
   }
   if (result.ok !== void 0) {
@@ -26872,10 +27087,10 @@ function toMcpToolList(tools) {
 
 // ../argent-mcp/src/installed-version.ts
 import * as fs10 from "node:fs";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 function getInstalledVersion() {
   try {
-    const pkgPath = path14.resolve(import.meta.dirname, "..", "package.json");
+    const pkgPath = path15.resolve(import.meta.dirname, "..", "package.json");
     const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf8"));
     return pkg.version ?? "unknown";
   } catch {
@@ -27020,7 +27235,7 @@ async function startMcpServer(options) {
   async function spyLog(entry) {
     try {
       if (!logDirReady) {
-        await mkdir5(dirname8(LOG_FILE2), { recursive: true });
+        await mkdir5(dirname9(LOG_FILE2), { recursive: true });
         logDirReady = true;
       }
       await appendFile(LOG_FILE2, JSON.stringify(entry) + "\n");