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

package/dist/cli-cmds.mjs

@@ -124,17 +124,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path23) {
-      const ctrl = callVisitor(key, node, visitor, path23);
+    function visit_(key, node, visitor, path24) {
+      const ctrl = callVisitor(key, node, visitor, path24);
       if (identity2.isNode(ctrl) || identity2.isPair(ctrl)) {
-        replaceNode(key, path23, ctrl);
-        return visit_(key, ctrl, visitor, path23);
+        replaceNode(key, path24, ctrl);
+        return visit_(key, ctrl, visitor, path24);
       }
       if (typeof ctrl !== "symbol") {
         if (identity2.isCollection(node)) {
-          path23 = Object.freeze(path23.concat(node));
+          path24 = Object.freeze(path24.concat(node));
           for (let i2 = 0; i2 < node.items.length; ++i2) {
-            const ci = visit_(i2, node.items[i2], visitor, path23);
+            const ci = visit_(i2, node.items[i2], visitor, path24);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -145,13 +145,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity2.isPair(node)) {
-          path23 = Object.freeze(path23.concat(node));
-          const ck = visit_("key", node.key, visitor, path23);
+          path24 = Object.freeze(path24.concat(node));
+          const ck = visit_("key", node.key, visitor, path24);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path23);
+          const cv = visit_("value", node.value, visitor, path24);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -172,17 +172,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path23) {
-      const ctrl = await callVisitor(key, node, visitor, path23);
+    async function visitAsync_(key, node, visitor, path24) {
+      const ctrl = await callVisitor(key, node, visitor, path24);
       if (identity2.isNode(ctrl) || identity2.isPair(ctrl)) {
-        replaceNode(key, path23, ctrl);
-        return visitAsync_(key, ctrl, visitor, path23);
+        replaceNode(key, path24, ctrl);
+        return visitAsync_(key, ctrl, visitor, path24);
       }
       if (typeof ctrl !== "symbol") {
         if (identity2.isCollection(node)) {
-          path23 = Object.freeze(path23.concat(node));
+          path24 = Object.freeze(path24.concat(node));
           for (let i2 = 0; i2 < node.items.length; ++i2) {
-            const ci = await visitAsync_(i2, node.items[i2], visitor, path23);
+            const ci = await visitAsync_(i2, node.items[i2], visitor, path24);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -193,13 +193,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity2.isPair(node)) {
-          path23 = Object.freeze(path23.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path23);
+          path24 = Object.freeze(path24.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path24);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path23);
+          const cv = await visitAsync_("value", node.value, visitor, path24);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -226,23 +226,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path23) {
+    function callVisitor(key, node, visitor, path24) {
       if (typeof visitor === "function")
-        return visitor(key, node, path23);
+        return visitor(key, node, path24);
       if (identity2.isMap(node))
-        return visitor.Map?.(key, node, path23);
+        return visitor.Map?.(key, node, path24);
       if (identity2.isSeq(node))
-        return visitor.Seq?.(key, node, path23);
+        return visitor.Seq?.(key, node, path24);
       if (identity2.isPair(node))
-        return visitor.Pair?.(key, node, path23);
+        return visitor.Pair?.(key, node, path24);
       if (identity2.isScalar(node))
-        return visitor.Scalar?.(key, node, path23);
+        return visitor.Scalar?.(key, node, path24);
       if (identity2.isAlias(node))
-        return visitor.Alias?.(key, node, path23);
+        return visitor.Alias?.(key, node, path24);
       return void 0;
     }
-    function replaceNode(key, path23, node) {
-      const parent = path23[path23.length - 1];
+    function replaceNode(key, path24, node) {
+      const parent = path24[path24.length - 1];
       if (identity2.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity2.isPair(parent)) {
@@ -852,10 +852,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity2 = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path23, value) {
+    function collectionFromPath(schema, path24, value) {
       let v = value;
-      for (let i2 = path23.length - 1; i2 >= 0; --i2) {
-        const k = path23[i2];
+      for (let i2 = path24.length - 1; i2 >= 0; --i2) {
+        const k = path24[i2];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a2 = [];
           a2[k] = v;
@@ -874,7 +874,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path23) => path23 == null || typeof path23 === "object" && !!path23[Symbol.iterator]().next().done;
+    var isEmptyPath = (path24) => path24 == null || typeof path24 === "object" && !!path24[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -904,11 +904,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(path23, value) {
-        if (isEmptyPath(path23))
+      addIn(path24, value) {
+        if (isEmptyPath(path24))
           this.add(value);
         else {
-          const [key, ...rest] = path23;
+          const [key, ...rest] = path24;
           const node = this.get(key, true);
           if (identity2.isCollection(node))
             node.addIn(rest, value);
@@ -922,8 +922,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path23) {
-        const [key, ...rest] = path23;
+      deleteIn(path24) {
+        const [key, ...rest] = path24;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -937,8 +937,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path23, keepScalar) {
-        const [key, ...rest] = path23;
+      getIn(path24, keepScalar) {
+        const [key, ...rest] = path24;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity2.isScalar(node) ? node.value : node;
@@ -956,8 +956,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path23) {
-        const [key, ...rest] = path23;
+      hasIn(path24) {
+        const [key, ...rest] = path24;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -967,8 +967,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(path23, value) {
-        const [key, ...rest] = path23;
+      setIn(path24, value) {
+        const [key, ...rest] = path24;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3483,9 +3483,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path23, value) {
+      addIn(path24, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path23, value);
+          this.contents.addIn(path24, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3560,14 +3560,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path23) {
-        if (Collection.isEmptyPath(path23)) {
+      deleteIn(path24) {
+        if (Collection.isEmptyPath(path24)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path23) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path24) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3582,10 +3582,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path23, keepScalar) {
-        if (Collection.isEmptyPath(path23))
+      getIn(path24, keepScalar) {
+        if (Collection.isEmptyPath(path24))
           return !keepScalar && identity2.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity2.isCollection(this.contents) ? this.contents.getIn(path23, keepScalar) : void 0;
+        return identity2.isCollection(this.contents) ? this.contents.getIn(path24, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3596,10 +3596,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path23) {
-        if (Collection.isEmptyPath(path23))
+      hasIn(path24) {
+        if (Collection.isEmptyPath(path24))
           return this.contents !== void 0;
-        return identity2.isCollection(this.contents) ? this.contents.hasIn(path23) : false;
+        return identity2.isCollection(this.contents) ? this.contents.hasIn(path24) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3616,13 +3616,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(path23, value) {
-        if (Collection.isEmptyPath(path23)) {
+      setIn(path24, value) {
+        if (Collection.isEmptyPath(path24)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path23), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path24), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path23, value);
+          this.contents.setIn(path24, value);
         }
       }
       /**
@@ -5582,9 +5582,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path23) => {
+    visit.itemAtPath = (cst, path24) => {
       let item = cst;
-      for (const [field, index] of path23) {
+      for (const [field, index] of path24) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5593,23 +5593,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path23) => {
-      const parent = visit.itemAtPath(cst, path23.slice(0, -1));
-      const field = path23[path23.length - 1][0];
+    visit.parentCollection = (cst, path24) => {
+      const parent = visit.itemAtPath(cst, path24.slice(0, -1));
+      const field = path24[path24.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path23, item, visitor) {
-      let ctrl = visitor(item, path23);
+    function _visit(path24, item, visitor) {
+      let ctrl = visitor(item, path24);
       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(path23.concat([[field, i2]])), token.items[i2], visitor);
+            const ci = _visit(Object.freeze(path24.concat([[field, i2]])), token.items[i2], visitor);
             if (typeof ci === "number")
               i2 = ci - 1;
             else if (ci === BREAK)
@@ -5620,10 +5620,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path23);
+            ctrl = ctrl(item, path24);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path23) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path24) : ctrl;
     }
     exports.visit = visit;
   }
@@ -7378,7 +7378,7 @@ var require_dist = __commonJS({
 var require_main = __commonJS({
   "../../node_modules/dotenv/lib/main.js"(exports, module) {
     var fs18 = __require("fs");
-    var path23 = __require("path");
+    var path24 = __require("path");
     var os4 = __require("os");
     var crypto3 = __require("crypto");
     var TIPS = [
@@ -7517,7 +7517,7 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path23.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path24.resolve(process.cwd(), ".env.vault");
       }
       if (fs18.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
@@ -7525,7 +7525,7 @@ var require_main = __commonJS({
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path23.join(os4.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path24.join(os4.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
@@ -7542,7 +7542,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path23.resolve(process.cwd(), ".env");
+      const dotenvPath = path24.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       let processEnv = process.env;
       if (options && options.processEnv != null) {
@@ -7570,13 +7570,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path24 of optionPaths) {
+      for (const path25 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs18.readFileSync(path24, { encoding }));
+          const parsed = DotenvModule.parse(fs18.readFileSync(path25, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`failed to load ${path24} ${e.message}`);
+            _debug(`failed to load ${path25} ${e.message}`);
           }
           lastError = e;
         }
@@ -7589,7 +7589,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative3 = path23.relative(process.cwd(), filePath);
+            const relative3 = path24.relative(process.cwd(), filePath);
             shortPaths.push(relative3);
           } catch (e) {
             if (debug) {
@@ -8841,7 +8841,7 @@ var require_src = __commonJS({
 
 // ../argent-cli/src/run.ts
 import * as fs11 from "node:fs";
-import * as path15 from "node:path";
+import * as path16 from "node:path";
 
 // ../argent-tools-client/src/launcher.ts
 import * as net from "node:net";
@@ -8882,7 +8882,7 @@ function generateAuthToken() {
   return generateToken();
 }
 function findFreePort() {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const srv = net.createServer();
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
@@ -8893,7 +8893,7 @@ function findFreePort() {
       const port = addr.port;
       srv.close((err) => {
         if (err) reject(err);
-        else resolve11(port);
+        else resolve12(port);
       });
     });
     srv.on("error", reject);
@@ -8994,7 +8994,7 @@ function killSpawnedChild(child, pid) {
   }
 }
 function spawnToolsServer(paths, port, options = {}) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     let logFd;
     try {
       fs.mkdirSync(STATE_DIR, { recursive: true });
@@ -9040,7 +9040,7 @@ function spawnToolsServer(paths, port, options = {}) {
         rl.close();
         child.stdout?.resume();
         child.stdout?.unref?.();
-        settle(() => resolve11({ port: actualPort, pid }));
+        settle(() => resolve12({ port: actualPort, pid }));
       }
     });
     child.on("error", (err) => {
@@ -9353,6 +9353,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";
@@ -9363,6 +9369,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(file2) {
+  const name = file2.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: path24 }) {
+  return spec.kind === "file" && spec.path === `\${${spec.target}}` && path24.startsWith("/") && hasToolFileExtension(path24);
+}
 
 // ../registry/src/flow-file-refs.ts
 import * as fs2 from "node:fs/promises";
@@ -9391,6 +9426,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;
@@ -9404,11 +9441,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");
@@ -9424,6 +9467,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 = {
@@ -10545,10 +10608,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path23) {
-  if (!path23)
+function getElementAtPath(obj, path24) {
+  if (!path24)
     return obj;
-  return path23.reduce((acc, key) => acc?.[key], obj);
+  return path24.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -10957,11 +11020,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path23, issues) {
+function prefixIssues(path24, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path23);
+    iss.path.unshift(path24);
     return iss;
   });
 }
@@ -11108,16 +11171,16 @@ function flattenError(error52, mapper = (issue2) => issue2.message) {
 }
 function formatError(error52, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error53, path23 = []) => {
+  const processError = (error53, path24 = []) => {
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path23, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path24, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path23, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path24, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path23, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path24, ...issue2.path]);
       } else {
-        const fullpath = [...path23, ...issue2.path];
+        const fullpath = [...path24, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -11144,17 +11207,17 @@ function formatError(error52, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error52, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error53, path23 = []) => {
+  const processError = (error53, path24 = []) => {
     var _a3, _b;
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path23, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path24, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path23, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path24, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path23, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path24, ...issue2.path]);
       } else {
-        const fullpath = [...path23, ...issue2.path];
+        const fullpath = [...path24, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -11186,8 +11249,8 @@ function treeifyError(error52, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path23 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path23) {
+  const path24 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path24) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -23879,13 +23942,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path23 = ref.slice(1).split("/").filter(Boolean);
-  if (path23.length === 0) {
+  const path24 = ref.slice(1).split("/").filter(Boolean);
+  if (path24.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path23[0] === defsKey) {
-    const key = path23[1];
+  if (path24[0] === defsKey) {
+    const key = path24[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -24297,9 +24360,9 @@ config(en_default());
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 var resolvedDuringInvocation = new AsyncLocalStorage();
-function valueAtPath(root, path23) {
+function valueAtPath(root, path24) {
   let current = root;
-  for (const key of path23) {
+  for (const key of path24) {
     if (current === null || typeof current !== "object") return void 0;
     if (!Object.hasOwn(current, key)) return void 0;
     current = current[key];
@@ -24459,8 +24522,8 @@ function parseLinkTarget(input) {
   const host = u3.hostname.startsWith("[") ? u3.hostname.slice(1, -1) : u3.hostname;
   if (!host) throw new Error(`URL "${input}" is missing a host.`);
   const port = u3.port ? Number(u3.port) : u3.protocol === "https:" ? 443 : 80;
-  const path23 = u3.pathname === "/" ? "" : u3.pathname.replace(/\/+$/, "");
-  const url2 = `${u3.protocol}//${u3.host}${path23}`;
+  const path24 = u3.pathname === "/" ? "" : u3.pathname.replace(/\/+$/, "");
+  const url2 = `${u3.protocol}//${u3.host}${path24}`;
   const token = u3.username ? decodeURIComponent(u3.username) : void 0;
   return { url: url2, host, port, ...token ? { token } : {} };
 }
@@ -24649,9 +24712,9 @@ function untrackArchive(archive) {
   process.removeListener("exit", removePendingArchives);
 }
 function sha256File(filePath) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const hash2 = createHash2("sha256");
-    createReadStream(filePath).on("data", (chunk) => hash2.update(chunk)).on("end", () => resolve11(hash2.digest("hex"))).on("error", reject);
+    createReadStream(filePath).on("data", (chunk) => hash2.update(chunk)).on("end", () => resolve12(hash2.digest("hex"))).on("error", reject);
   });
 }
 function toolServerError(text2) {
@@ -24759,6 +24822,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) {
@@ -24885,14 +24951,14 @@ function printable(text2) {
     (c2) => c2 < " " || c2 === "\x7F" ? `\\u${c2.charCodeAt(0).toString(16).padStart(4, "0")}` : c2
   ).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);
 }
@@ -24978,6 +25044,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(file2, roots, budget, opts) {
+  const member = { role: "tool", key: file2, path: file2 };
+  const refuse = (reason) => ({
+    member: { ...member, state: "refused", error: reason },
+    sent: `refused (${reason})`
+  });
+  const { canonical } = await landing(file2);
+  if (!roots.some((root) => isWithin(canonical, root))) {
+    return refuse(`${file2} is outside every root this client serves (${roots.join(", ")})`);
+  }
+  if (!hasToolFileExtension(canonical)) {
+    return refuse(`${file2} 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;
@@ -25032,51 +25121,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 file2 = path5.join(dir, name);
-    const member = { role: "baseline", key: file2, path: file2 };
-    const entry = await baselineEntry(file2, 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 tools2 = /* @__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 log2 = opts.log ?? ((line) => void process.stderr.write(`${line}
@@ -25086,42 +25139,194 @@ async function collectFlowMembers(rootPath, rootBytes, args, opts) {
     const subject = member.role === "flow" ? member.canonical : member.key;
     if (logging) log2(printable(`[flow-files] ${member.role} ${subject}: ${sent}`));
   };
-  const queue = [{ canonical, text: rootBytes.toString("utf8"), hop: 0 }];
-  for (let file2 = queue.shift(); file2 !== void 0; file2 = queue.shift()) {
-    let doc;
-    try {
-      doc = (0, import_yaml.parse)(file2.text.trim(), { logLevel: "error" });
-    } catch {
-      continue;
-    }
-    const requests = collectFlowRequests(doc);
-    for (const name of requests.snapshots) snapshots.add(name);
-    const anchorDir = path5.dirname(file2.canonical);
-    for (const target of requests.runTargets) {
-      const key = flowMemberKey(anchorDir, target);
-      if (seen.has(key)) continue;
-      seen.add(key);
-      const { member, text: text2, sent } = await readFlowMember(anchorDir, target, roots, budget, opts);
-      emit(member, sent);
-      if (text2 !== void 0 && file2.hop + 1 < MAX_RUN_DEPTH) {
-        queue.push({ canonical: member.canonical, text: text2, hop: file2.hop + 1 });
+  async function flow2(anchorDir, target) {
+    const key = flowMemberKey(anchorDir, target);
+    const known = flows.get(key);
+    if (known !== void 0) return known;
+    const { member, text: text2, sent } = await readFlowMember(anchorDir, target, roots, budget, opts);
+    const entry = { member, ...text2 === void 0 ? {} : { text: text2 } };
+    flows.set(key, entry);
+    emit(member, sent);
+    return entry;
+  }
+  async function toolFiles(step) {
+    if (step.tool === "flow-execute") return;
+    for (const file2 of toolStepFiles(opts.toolFileInputs?.(step.tool), step.args)) {
+      const { unwrapWhenSet } = file2.spec;
+      if (unwrapWhenSet !== void 0 && step.args[unwrapWhenSet] !== void 0) continue;
+      if (!isClientFileArgument(file2) || tools2.has(file2.path)) continue;
+      tools2.add(file2.path);
+      const read = await readToolMember(file2.path, roots, budget, opts);
+      emit(read.member, read.sent);
+    }
+  }
+  async function nestedRun(target, hop, updates, platform) {
+    const { member, text: text2 } = await flow2(path5.dirname(target.path), `${target.name}.yaml`);
+    if (text2 === void 0 || hop >= MAX_RUN_DEPTH) return void 0;
+    return { canonical: member.canonical, text: text2, flowName: target.name, hop, updates, platform };
+  }
+  async function walk(start) {
+    const queue = [...start];
+    for (let run2 = queue.shift(); run2 !== void 0; run2 = queue.shift()) {
+      const id = [run2.canonical, run2.flowName, run2.updates, run2.platform ?? ""].join("\0");
+      if (runs.has(id)) continue;
+      runs.add(id);
+      const snapshots = /* @__PURE__ */ new Set();
+      const visited = /* @__PURE__ */ new Set();
+      const files = [{ canonical: run2.canonical, text: run2.text, hop: run2.hop }];
+      for (let file2 = files.shift(); file2 !== void 0; file2 = files.shift()) {
+        let doc;
+        try {
+          doc = (0, import_yaml.parse)(file2.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(file2.canonical);
+        for (const target of requests.runTargets) {
+          const key = flowMemberKey(anchorDir, target);
+          if (visited.has(key)) continue;
+          visited.add(key);
+          const { member, text: text2 } = await flow2(anchorDir, target);
+          if (text2 !== void 0 && file2.hop + 1 < MAX_RUN_DEPTH) {
+            files.push({ canonical: member.canonical, text: text2, hop: file2.hop + 1 });
+          }
+        }
+        for (const { target, args } of requests.nested) {
+          if (target.kind !== "name") continue;
+          const next = await nestedRun(
+            target,
+            file2.hop + 1,
+            nestedRunUpdates(run2.updates, args),
+            run2.platform
+          );
+          if (next !== void 0) queue.push(next);
+        }
+      }
+      if (snapshots.size === 0) continue;
+      const dir = path5.join(
+        path5.dirname(run2.canonical),
+        "__baselines__",
+        baselineKeyFor(run2.canonical, run2.flowName)
+      );
+      const entry = baselineDirs.get(dir) ?? { prefixes: /* @__PURE__ */ new Set(), updates: false };
+      baselineDirs.set(dir, entry);
+      if (run2.updates) {
+        entry.updates = true;
+      } else {
+        const platform = run2.platform === void 0 ? "" : `${run2.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 file2 = path5.join(dir, name);
+        if (tools2.has(file2)) continue;
+        const member = { role: "baseline", key: file2, path: file2 };
+        const entry = await baselineEntry(file2, 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: flow2, 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: text2 } = args;
+  if (typeof command !== "string") return void 0;
+  if (text2 === void 0) return { tool: command, args: {} };
+  if (typeof text2 !== "string") return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(text2);
+  } catch {
+    return void 0;
   }
-  return { canonical, spelling, members };
+  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 self2 = 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(self2.member.canonical), `${target.name}.yaml`);
+      const run2 = await collector.nestedRun(
+        target,
+        0,
+        runArgs.updateBaselines === true,
+        callPlatform(runArgs)
+      );
+      if (run2 !== void 0) await collector.walk([run2]);
+    }
+  }
+  await collector.sendBaselines();
+  return collector.members;
 }
 
 // ../argent-tools-client/src/tools-client.ts
@@ -25282,7 +25487,8 @@ function createToolsClient(options = {}) {
     opts?.signal?.throwIfAborted();
     const { url: url2, token, remote } = await route();
     let finalArgs = args;
-    const meta3 = await fetchTool(name, { signal: opts?.signal });
+    const tools2 = await fetchTools({ signal: opts?.signal });
+    const meta3 = tools2.find((t2) => t2.name === name) ?? null;
     const baselineDirs = [];
     if (meta3?.fileInputs?.length) {
       if (remote) assertRequiredPresent(meta3, args);
@@ -25292,6 +25498,8 @@ function createToolsClient(options = {}) {
         log: diagnose,
         baselineDirs,
         collectMembers: collectFlowMembers,
+        collectStepMembers,
+        toolFileInputs: (tool) => tools2.find((t2) => t2.name === tool)?.fileInputs,
         signal: opts?.signal
       });
     }
@@ -25301,7 +25509,11 @@ function createToolsClient(options = {}) {
         diagnose(`The baseline ${file2} was not written on this client: ${error52}`);
       }
       if (process.env.ARGENT_FLOW_FILES_LOG === "1") {
-        for (const file2 of applied.written) diagnose(`[flow-files] baseline ${file2}: written`);
+        for (const file2 of applied.written) {
+          if (baselineDirs.includes(path6.dirname(file2))) {
+            diagnose(`[flow-files] baseline ${file2}: written`);
+          }
+        }
       }
       return applied.result;
     };
@@ -25313,6 +25525,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" } : {},
@@ -25373,12 +25588,12 @@ 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 FLAG_REGISTRY = [
   {
@@ -25420,26 +25635,26 @@ function getFlagDefinition(name, registry2 = FLAG_REGISTRY) {
 }
 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;
@@ -25466,7 +25681,7 @@ function readFlagsFile(filePath) {
 function writeFlagsFile(filePath, flags2) {
   if (Object.keys(flags2).length === 0) {
     if (fs3.existsSync(filePath)) fs3.rmSync(filePath, { force: true });
-    const parent = path6.dirname(filePath);
+    const parent = path7.dirname(filePath);
     try {
       if (fs3.existsSync(parent) && fs3.readdirSync(parent).length === 0) {
         fs3.rmdirSync(parent);
@@ -25475,7 +25690,7 @@ function writeFlagsFile(filePath, flags2) {
     }
     return;
   }
-  fs3.mkdirSync(path6.dirname(filePath), { recursive: true });
+  fs3.mkdirSync(path7.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${process.pid}.tmp`;
   fs3.writeFileSync(tmp, JSON.stringify({ flags: flags2 }, null, 2) + "\n");
   fs3.renameSync(tmp, filePath);
@@ -25507,7 +25722,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();
@@ -25518,23 +25733,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");
@@ -25652,7 +25867,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");
@@ -25677,7 +25892,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";
 var SECRET_ENV_PREFIX = "ARGENT_SECRET_";
 var SECRETS_FILE_NAME = "secrets.env";
 var SHARED_ENV_FILES = [".env.local", ".env"];
@@ -25739,20 +25954,20 @@ function secretSources(options = {}) {
   const filePaths = [];
   if (projectRoot) {
     filePaths.push({
-      path: path9.join(projectRoot, ".argent", SECRETS_FILE_NAME),
+      path: path10.join(projectRoot, ".argent", SECRETS_FILE_NAME),
       exposure: "dedicated"
     });
     for (const name of SHARED_ENV_FILES) {
-      filePaths.push({ path: path9.join(projectRoot, name), exposure: "shared" });
+      filePaths.push({ path: path10.join(projectRoot, name), exposure: "shared" });
     }
   }
   filePaths.push({
-    path: path9.join(resolveHomeDir(options), ".argent", SECRETS_FILE_NAME),
+    path: path10.join(resolveHomeDir(options), ".argent", SECRETS_FILE_NAME),
     exposure: "dedicated"
   });
   const seen = /* @__PURE__ */ new Set();
   for (const entry of filePaths) {
-    const resolved = path9.resolve(entry.path);
+    const resolved = path10.resolve(entry.path);
     if (seen.has(resolved)) continue;
     seen.add(resolved);
     sources.push(fileSource(resolved, entry.exposure));
@@ -25817,7 +26032,7 @@ function applyMergePolicy(policy, local, global2) {
 }
 
 // ../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;
 }
@@ -25899,7 +26114,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",
@@ -25950,7 +26165,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);
@@ -26110,7 +26325,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");
@@ -26124,9 +26339,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) {
@@ -26159,10 +26374,10 @@ async function writeDurableUnique(dir, filename, write) {
   const stem = filename.slice(0, filename.length - ext.length);
   for (let i2 = 1; i2 <= 1e3; i2++) {
     const candidate = i2 === 1 ? filename : `${stem} (${i2})${ext}`;
-    const path23 = join11(dir, candidate);
+    const path24 = join11(dir, candidate);
     try {
-      await write(path23);
-      return path23;
+      await write(path24);
+      return path24;
     } catch (err) {
       if (err?.code === "EEXIST") continue;
       throw err;
@@ -26173,7 +26388,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;
@@ -26768,8 +26983,8 @@ var Deferred = class {
   _resolve;
   _reject;
   constructor() {
-    this._promise = new Promise((resolve11, reject) => {
-      this._resolve = resolve11;
+    this._promise = new Promise((resolve12, reject) => {
+      this._resolve = resolve12;
       this._reject = reject;
     });
   }
@@ -27662,8 +27877,8 @@ var ExportOperation = class {
   _metrics;
   _exportScheduledResolve;
   constructor(exporter, logRecords, exportTimeoutMillis, metrics) {
-    this._exportScheduledPromise = new Promise((resolve11) => {
-      this._exportScheduledResolve = resolve11;
+    this._exportScheduledPromise = new Promise((resolve12) => {
+      this._exportScheduledResolve = resolve12;
     });
     this._exportCompleted = this._executeExport(exporter, logRecords, exportTimeoutMillis);
     this._metrics = metrics;
@@ -27688,7 +27903,7 @@ var ExportOperation = class {
     }
   }
   async _exportWithTimeout(exporter, logRecords, exportTimeoutMillis) {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const timer = setTimeout(() => {
         reject(new Error("Timeout"));
       }, exportTimeoutMillis);
@@ -27696,7 +27911,7 @@ var ExportOperation = class {
         this._metrics.finishLogs(logRecords.length, result.error);
         clearTimeout(timer);
         if (result.code === ExportResultCode.SUCCESS) {
-          resolve11();
+          resolve12();
         } else {
           reject(result.error ?? new Error("BatchLogRecordProcessor: log record export failed"));
         }
@@ -28477,7 +28692,7 @@ function parseRetryAfterToMills(retryAfter) {
 var DEFAULT_USER_AGENT = `OTel-OTLP-Exporter-JavaScript/${VERSION4}`;
 var MAX_RESPONSE_BODY_SIZE = 4 * 1024 * 1024;
 function sendWithHttp(request, url2, headers, compression, userAgent, agent, data, timeoutMillis) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const parsedUrl = new URL(url2);
     if (userAgent) {
       headers["User-Agent"] = `${userAgent} ${DEFAULT_USER_AGENT}`;
@@ -28496,7 +28711,7 @@ function sendWithHttp(request, url2, headers, compression, userAgent, agent, dat
         responseSize += chunk.length;
         if (responseSize > MAX_RESPONSE_BODY_SIZE) {
           const sizeError = new Error(`OTLP export response body exceeded size limit of ${MAX_RESPONSE_BODY_SIZE} bytes`);
-          resolve11({ status: "failure", error: sizeError });
+          resolve12({ status: "failure", error: sizeError });
           res.destroy();
           return;
         }
@@ -28504,18 +28719,18 @@ function sendWithHttp(request, url2, headers, compression, userAgent, agent, dat
       });
       res.on("end", () => {
         if (res.statusCode && res.statusCode <= 299) {
-          resolve11({
+          resolve12({
             status: "success",
             data: Buffer.concat(responseData)
           });
         } else if (res.statusCode && isExportHTTPErrorRetryable(res.statusCode)) {
-          resolve11({
+          resolve12({
             status: "retryable",
             retryInMillis: parseRetryAfterToMills(res.headers["retry-after"])
           });
         } else {
           const error52 = new OTLPExporterError(res.statusMessage, res.statusCode, Buffer.concat(responseData).toString());
-          resolve11({
+          resolve12({
             status: "failure",
             error: error52
           });
@@ -28523,17 +28738,17 @@ function sendWithHttp(request, url2, headers, compression, userAgent, agent, dat
       });
       res.on("error", (error52) => {
         if (res.statusCode && res.statusCode <= 299) {
-          resolve11({
+          resolve12({
             status: "success"
           });
         } else if (res.statusCode && isExportHTTPErrorRetryable(res.statusCode)) {
-          resolve11({
+          resolve12({
             status: "retryable",
             error: error52,
             retryInMillis: parseRetryAfterToMills(res.headers["retry-after"])
           });
         } else {
-          resolve11({
+          resolve12({
             status: "failure",
             error: error52
           });
@@ -28542,26 +28757,26 @@ function sendWithHttp(request, url2, headers, compression, userAgent, agent, dat
     });
     req.setTimeout(timeoutMillis, () => {
       req.destroy();
-      resolve11({
+      resolve12({
         status: "retryable",
         error: new Error("Request timed out")
       });
     });
     req.on("error", (error52) => {
       if (isHttpTransportNetworkErrorRetryable(error52)) {
-        resolve11({
+        resolve12({
           status: "retryable",
           error: error52
         });
       } else {
-        resolve11({
+        resolve12({
           status: "failure",
           error: error52
         });
       }
     });
     compressAndSend(req, compression, data, (error52) => {
-      resolve11({
+      resolve12({
         status: "failure",
         error: error52
       });
@@ -28651,9 +28866,9 @@ var RetryingTransport = class {
     this._transport = transport;
   }
   retry(data, timeoutMillis, inMillis) {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       setTimeout(() => {
-        this._transport.send(data, timeoutMillis).then(resolve11, reject);
+        this._transport.send(data, timeoutMillis).then(resolve12, reject);
       }, inMillis);
     });
   }
@@ -28767,7 +28982,7 @@ init_esm();
 
 // ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-env-configuration.js
 import * as fs6 from "fs";
-import * as path11 from "path";
+import * as path12 from "path";
 init_esm();
 function getStaticHeadersFromEnv(signalIdentifier) {
   const signalSpecificRawHeaders = getStringFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_HEADERS`);
@@ -28788,7 +29003,7 @@ function appendRootPathToUrlIfNeeded(url2) {
     return void 0;
   }
 }
-function appendResourcePathToUrl(url2, path23) {
+function appendResourcePathToUrl(url2, path24) {
   try {
     new URL(url2);
   } catch {
@@ -28798,11 +29013,11 @@ function appendResourcePathToUrl(url2, path23) {
   if (!url2.endsWith("/")) {
     url2 = url2 + "/";
   }
-  url2 += path23;
+  url2 += path24;
   try {
     new URL(url2);
   } catch {
-    diag2.warn(`Configuration: Provided URL appended with '${path23}' is not a valid URL, using 'undefined' instead of '${url2}'`);
+    diag2.warn(`Configuration: Provided URL appended with '${path24}' is not a valid URL, using 'undefined' instead of '${url2}'`);
     return void 0;
   }
   return url2;
@@ -28827,7 +29042,7 @@ function readFileFromEnv(signalSpecificEnvVar, nonSignalSpecificEnvVar, warningM
   const filePath = signalSpecificPath ?? nonSignalSpecificPath;
   if (filePath != null) {
     try {
-      return fs6.readFileSync(path11.resolve(process.cwd(), filePath));
+      return fs6.readFileSync(path12.resolve(process.cwd(), filePath));
     } catch {
       diag2.warn(warningMessage);
       return void 0;
@@ -28916,12 +29131,12 @@ init_esm();
 import * as fs7 from "node:fs";
 
 // ../telemetry/src/paths.ts
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 function identityFilePath() {
-  return path12.join(argentHomeDir(), "telemetry-id");
+  return path13.join(argentHomeDir(), "telemetry-id");
 }
 function debugLogPath() {
-  return path12.join(argentHomeDir(), "telemetry-debug.log");
+  return path13.join(argentHomeDir(), "telemetry-debug.log");
 }
 
 // ../telemetry/src/debug.ts
@@ -29454,9 +29669,9 @@ function isReplitAgent(env) {
 }
 var DEVIN_MARKER_PATH = "/opt/.devin";
 var JULES_MARKER_PATH = "/opt/environment_summary.sh";
-function safeExists(fileExists, path23) {
+function safeExists(fileExists, path24) {
   try {
-    return fileExists(path23);
+    return fileExists(path24);
   } catch {
     return false;
   }
@@ -29877,7 +30092,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID2 = randomUUID5();
 function readCliVersion() {
   if (true) {
-    return "0.27.1-next.21";
+    return "0.27.1-next.23";
   }
   return "0.0.0";
 }
@@ -29911,7 +30126,7 @@ function getBaseProps(runtime) {
 // ../telemetry/src/identity.ts
 import * as crypto2 from "node:crypto";
 import * as fs8 from "node:fs";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 var FINGERPRINT_PATTERN = /^[0-9a-f]{64}$/;
 var cached2 = null;
 var fingerprintResolved = null;
@@ -30024,7 +30239,7 @@ function writeIdFileAtomic(finalPath, id) {
   if (occupant && !occupant.isFile()) {
     throw new Error("telemetry: refusing to replace a non-regular file at the identity path");
   }
-  const tmpPath = path13.join(
+  const tmpPath = path14.join(
     argentHomeDir(),
     `.telemetry-id.tmp.${process.pid}.${crypto2.randomUUID()}`
   );
@@ -30048,7 +30263,7 @@ function mintRandomId(finalPath) {
   fs8.mkdirSync(argentHomeDir(), { recursive: true });
   let value = crypto2.randomUUID();
   for (let attempt = 0; attempt < 3; attempt++) {
-    const tmpPath = path13.join(
+    const tmpPath = path14.join(
       argentHomeDir(),
       `.telemetry-id.tmp.${process.pid}.${crypto2.randomUUID()}`
     );
@@ -30093,7 +30308,7 @@ function mintRandomId(finalPath) {
   throw new Error("telemetry: failed to create identity after retries");
 }
 function claimCorruptOccupant(finalPath) {
-  const claimed = path13.join(
+  const claimed = path14.join(
     argentHomeDir(),
     `.telemetry-id.corrupt.${process.pid}.${crypto2.randomUUID()}`
   );
@@ -30135,12 +30350,12 @@ function tryReadId(filePath) {
 import { execFileSync as execFileSync2, spawn as spawn2 } from "node:child_process";
 
 // ../native-devtools-ios/src/index.ts
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 import * as fs9 from "node:fs";
-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");
+var DYLIB_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_DIR ?? path15.join(__dirname, "..", "dylibs");
+var BIN_DIR = process.env.ARGENT_SIMULATOR_SERVER_DIR ?? path15.join(__dirname, "..", "bin");
+var DYLIB_TCP_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_TCP_DIR ?? path15.join(DYLIB_DIR, "tcp");
+var DYLIB_TVOS_DIR = path15.join(DYLIB_DIR, "tvos");
 function hostPlatformKey() {
   if (process.platform === "linux" && process.arch === "arm64") {
     return "linux-arm64";
@@ -30151,13 +30366,13 @@ function simulatorServerBinaryName() {
   return process.platform === "win32" ? "simulator-server.exe" : "simulator-server";
 }
 function platformBinDir() {
-  return path14.join(BIN_DIR, hostPlatformKey());
+  return path15.join(BIN_DIR, hostPlatformKey());
 }
 function simulatorServerBinaryPath() {
   const binaryName = simulatorServerBinaryName();
-  const p = path14.join(platformBinDir(), binaryName);
+  const p = path15.join(platformBinDir(), binaryName);
   if (!fs9.existsSync(p)) {
-    const flat = path14.join(BIN_DIR, binaryName);
+    const flat = path15.join(BIN_DIR, binaryName);
     const migrationHint = fs9.existsSync(flat) ? ` Found a binary at the old flat path ${flat}; move it to ${p} or update ARGENT_SIMULATOR_SERVER_DIR to point at the parent of the platform subdirectory.` : "";
     throw new Error(
       `simulator-server binary not found for platform "${hostPlatformKey()}" at ${p}. Supported hosts today: darwin, linux (x86_64 and arm64), win32.${migrationHint}`
@@ -30187,12 +30402,12 @@ function resolveHostFingerprint() {
   }
 }
 function resolveHostFingerprintAsync() {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     let binary;
     try {
       binary = simulatorServerBinaryPath();
     } catch {
-      resolve11(null);
+      resolve12(null);
       return;
     }
     let settled = false;
@@ -30205,7 +30420,7 @@ function resolveHostFingerprintAsync() {
         child?.kill("SIGKILL");
       } catch {
       }
-      resolve11(value);
+      resolve12(value);
     };
     const watchdog = setTimeout(() => finish(null), FINGERPRINT_TIMEOUT_MS);
     watchdog.unref?.();
@@ -30419,7 +30634,7 @@ var DRAIN_GRACE_MS = 250;
 async function raceDrain(client2, timeoutMs) {
   await Promise.race([
     client2.shutdown(timeoutMs),
-    new Promise((resolve11) => setTimeout(resolve11, timeoutMs + DRAIN_GRACE_MS).unref())
+    new Promise((resolve12) => setTimeout(resolve12, timeoutMs + DRAIN_GRACE_MS).unref())
   ]);
 }
 async function shutdown(timeoutMs = SHORT_FLUSH_TIMEOUT_MS) {
@@ -30843,13 +31058,13 @@ function splitOptions(argv) {
   return { json: json2, outPath, argvForFlags: rest };
 }
 async function readStdin() {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve11(data));
+    process.stdin.on("end", () => resolve12(data));
     process.stdin.on("error", reject);
   });
 }
@@ -30881,7 +31096,7 @@ async function fetchImageToFile(result, outPath) {
   const res = await fetch(url2);
   if (!res.ok) throw new Error(`Failed to download image: ${res.status} ${res.statusText}`);
   const buf = Buffer.from(await res.arrayBuffer());
-  fs11.mkdirSync(path15.dirname(path15.resolve(outPath)), { recursive: true });
+  fs11.mkdirSync(path16.dirname(path16.resolve(outPath)), { recursive: true });
   fs11.writeFileSync(outPath, buf);
 }
 function renderResult(result, outputHint, images, json2) {
@@ -31076,7 +31291,7 @@ Examples:
   if (outPath && meta3.outputHint === "image") {
     try {
       if (images.length > 0) {
-        fs11.mkdirSync(path15.dirname(path15.resolve(outPath)), { recursive: true });
+        fs11.mkdirSync(path16.dirname(path16.resolve(outPath)), { recursive: true });
         fs11.writeFileSync(outPath, images[0].data);
       } else if (result && typeof result === "object") {
         await fetchImageToFile(result, outPath);
@@ -31103,7 +31318,7 @@ Examples:
 import * as fsp from "node:fs/promises";
 import { constants as fsConstants2 } from "node:fs";
 import { createHash as createHash5 } from "node:crypto";
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 
 // ../argent-cli/src/command-args.ts
 var UsageError = class extends Error {
@@ -31230,12 +31445,22 @@ counts the remaining flows skipped.
 
 The CLI sends a run to its tool-server: the local one that starts
 automatically, or the one that \`argent link\` or ARGENT_TOOLS_URL names. Over
-a link, the CLI uploads the flow file, the run: fragments that it reaches and
-the snapshot baselines that the run compares. The CLI writes the new baselines
-that the run returns. The tool-server rejects the flow before the first step
-when the flow or a fragment has one of these steps:
-  - script:
-  - a tool: step that takes a file or records a flow
+a link, the CLI uploads these files and writes the new baselines that the run
+returns:
+  - the flow file and the run: fragments that it reaches
+  - each flow that a tool: flow-execute step names with name (a nested flow)
+  - the snapshot baselines of each run
+  - each .png or .yaml file that a tool: step takes as a file argument by an
+    absolute path
+The tool-server rejects the flow before the first step when the flow, a
+fragment or a nested flow has one of these steps:
+  - a script: step
+  - a tool: flow-execute step that does not name its flow with name and an
+    absolute project_root that has no .. segment
+  - a tool: step that records a flow
+  - a tool: step that takes a directory, an app or an output directory
+  - a tool: step whose tool builds a file path from several arguments
+  - a tool: step that names a relative path or a file other than .png or .yaml
 Without a link, all step kinds run.
 
 Subcommands:
@@ -31248,7 +31473,9 @@ Options (run):
   --device <id>          Device id to run against (auto-detected when omitted)
   --platform <p>         ios | android | chromium | vega | ios-remote \u2014 narrow
                          auto-detection (ios never picks a remote simulator)
-  --update-baselines     Write/refresh screenshot baselines instead of diffing
+  --update-baselines     Write/refresh screenshot baselines instead of diffing,
+                         also those of flows that tool: flow-execute steps run,
+                         unless such a step sets updateBaselines
   --output <dir>         Also write failed snapshot images (baseline/current/diff)
                          and failed-step screenshots (step-<n>-screen.png)
                          under <dir>/<flow>/ \u2014 a stable path for CI artifact
@@ -31423,28 +31650,28 @@ function renderFailedFlows(failed) {
 }
 var SAFE_ARTIFACT_NAME = FLOW_NAME_PATTERN;
 var SAFE_FLOW_NAME = FLOW_NAME_PATTERN;
-var FLOWS_DIR = path16.join(".argent", "flows");
+var FLOWS_DIR = path17.join(".argent", "flows");
 var SHELL_SAFE_ARG = /^(?!=)[A-Za-z0-9_@%+=:,./-]+$/;
 function shellQuoteArg(arg) {
   if (SHELL_SAFE_ARG.test(arg)) return arg;
   return `'${arg.replaceAll("'", "'\\''")}'`;
 }
 function rerunCommand(flowPath, rel, projectRoot, args) {
-  const pathArg = (p) => shellQuoteArg(p.startsWith("-") ? `.${path16.sep}${p}` : p);
-  const fromCwd = path16.relative(projectRoot, flowPath);
-  const shown = path16.isAbsolute(fromCwd) || fromCwd.split(/[\\/]+/).includes("..") ? flowPath : fromCwd;
+  const pathArg = (p) => shellQuoteArg(p.startsWith("-") ? `.${path17.sep}${p}` : p);
+  const fromCwd = path17.relative(projectRoot, flowPath);
+  const shown = path17.isAbsolute(fromCwd) || fromCwd.split(/[\\/]+/).includes("..") ? flowPath : fromCwd;
   const parts = ["argent flow run", pathArg(shown)];
   if (args.device) parts.push("--device", shellQuoteArg(args.device));
   if (args.platform) parts.push("--platform", shellQuoteArg(args.platform));
   if (args.updateBaselines) parts.push("--update-baselines");
-  if (args.output) parts.push("--output", pathArg(path16.join(args.output, path16.dirname(rel))));
+  if (args.output) parts.push("--output", pathArg(path17.join(args.output, path17.dirname(rel))));
   return parts.join(" ");
 }
 var EXPORT_SOURCE_MARKER = ".argent-flow-source";
 var MARKER_READ_RETRIES = 4;
 var MARKER_READ_DELAY_MS = 5;
 async function readExportMarker(dir) {
-  const marker = path16.join(dir, EXPORT_SOURCE_MARKER);
+  const marker = path17.join(dir, EXPORT_SOURCE_MARKER);
   for (let attempt = 0; ; attempt++) {
     let owner;
     try {
@@ -31454,7 +31681,7 @@ async function readExportMarker(dir) {
     }
     if (owner) return owner;
     if (attempt === MARKER_READ_RETRIES) return null;
-    await new Promise((resolve11) => setTimeout(resolve11, MARKER_READ_DELAY_MS));
+    await new Promise((resolve12) => setTimeout(resolve12, MARKER_READ_DELAY_MS));
   }
 }
 async function classifyExportDir(dir, flowPath) {
@@ -31479,7 +31706,7 @@ function occupiedBy(owner) {
 async function takeExportDir(dir, flowPath) {
   try {
     await fsp.mkdir(dir, { recursive: true });
-    await fsp.writeFile(path16.join(dir, EXPORT_SOURCE_MARKER), `${flowPath}
+    await fsp.writeFile(path17.join(dir, EXPORT_SOURCE_MARKER), `${flowPath}
 `, { flag: "wx" });
     return null;
   } catch (err) {
@@ -31498,7 +31725,7 @@ async function claimExportDirName(outputDir, flowPath, stem) {
   }
   const avoided = [];
   for (const name of candidates) {
-    const dir = path16.join(outputDir, name);
+    const dir = path17.join(outputDir, name);
     const claim = await classifyExportDir(dir, flowPath);
     const reason = claim.state === "foreign" ? occupiedBy(claim.owner) : await takeExportDir(dir, flowPath);
     if (reason !== null) {
@@ -31518,7 +31745,7 @@ async function claimExportDirName(outputDir, flowPath, stem) {
   return null;
 }
 async function exportFailureArtifacts(report, outputDir, flowPath, ctx) {
-  const stem = path16.basename(flowPath, ".yaml");
+  const stem = path17.basename(flowPath, ".yaml");
   if (!SAFE_ARTIFACT_NAME.test(stem)) {
     console.error(
       `warning: skipping artifact export for unsafe flow filename ${JSON.stringify(stem)}`
@@ -31551,11 +31778,11 @@ async function exportFailureArtifacts(report, outputDir, flowPath, ctx) {
       if (dir === null) {
         const dirName = await claimExportDirName(outputDir, flowPath, stem);
         if (dirName === null) return;
-        dir = path16.join(outputDir, dirName);
+        dir = path17.join(outputDir, dirName);
       }
-      const dest = path16.join(dir, fileName(role));
-      const rel = path16.relative(outputDir, dest);
-      if (rel.startsWith("..") || path16.isAbsolute(rel)) continue;
+      const dest = path17.join(dir, fileName(role));
+      const rel = path17.relative(outputDir, dest);
+      if (rel.startsWith("..") || path17.isAbsolute(rel)) continue;
       try {
         await fsp.copyFile(value, dest);
         s.artifacts[role] = dest;
@@ -31570,7 +31797,7 @@ async function exportFailureArtifacts(report, outputDir, flowPath, ctx) {
 function keyFromBaselinePath(artifacts) {
   const baseline = artifacts.baseline;
   if (typeof baseline !== "string") return null;
-  return path16.basename(baseline).replace(/\.png$/, "");
+  return path17.basename(baseline).replace(/\.png$/, "");
 }
 function resolveArtifactDisplayPaths(report) {
   for (const s of report.steps) {
@@ -31582,7 +31809,7 @@ function resolveArtifactDisplayPaths(report) {
 }
 function exitAfterFlush(code, streams = [process.stdout, process.stderr]) {
   return Promise.all(
-    streams.map((s) => new Promise((resolve11) => s.write("", () => resolve11())))
+    streams.map((s) => new Promise((resolve12) => s.write("", () => resolve12())))
   ).then(() => process.exit(code));
 }
 function renderReport(report) {
@@ -31627,36 +31854,36 @@ async function collectRunnableFlowPaths(dir, relDir = "") {
   const found = [];
   const entries = await fsp.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const rel = relDir ? path16.join(relDir, entry.name) : entry.name;
+    const rel = relDir ? path17.join(relDir, entry.name) : entry.name;
     if (entry.isDirectory()) {
       if (entry.name === "__baselines__") continue;
       found.push(
-        ...await collectRunnableFlowPaths(path16.join(dir, entry.name), rel).catch(() => [])
+        ...await collectRunnableFlowPaths(path17.join(dir, entry.name), rel).catch(() => [])
       );
       continue;
     }
     if (!entry.name.endsWith(".yaml")) continue;
-    if (!SAFE_FLOW_NAME.test(path16.basename(entry.name, ".yaml"))) continue;
-    if (await isRunnableFlowFile(path16.join(dir, entry.name))) found.push(rel);
+    if (!SAFE_FLOW_NAME.test(path17.basename(entry.name, ".yaml"))) continue;
+    if (await isRunnableFlowFile(path17.join(dir, entry.name))) found.push(rel);
   }
   return found;
 }
 function resolveFlowRef(ref) {
   if (!SAFE_FLOW_NAME.test(ref)) return { suppliedPath: ref, fromName: false };
-  return { suppliedPath: path16.join(FLOWS_DIR, `${ref}.yaml`), fromName: true };
+  return { suppliedPath: path17.join(FLOWS_DIR, `${ref}.yaml`), fromName: true };
 }
 async function savedFlowHint(projectRoot, missingPath) {
-  const dir = path16.resolve(projectRoot, FLOWS_DIR);
-  const within = path16.relative(dir, missingPath);
-  if (!within.startsWith("..") && !path16.isAbsolute(within)) return "";
-  const wanted = `${path16.basename(missingPath, ".yaml")}.yaml`;
+  const dir = path17.resolve(projectRoot, FLOWS_DIR);
+  const within = path17.relative(dir, missingPath);
+  if (!within.startsWith("..") && !path17.isAbsolute(within)) return "";
+  const wanted = `${path17.basename(missingPath, ".yaml")}.yaml`;
   const entries = await fsp.readdir(dir).catch(() => null);
   if (entries === null) return "";
   const actual = entries.includes(wanted) ? wanted : entries.find((name2) => name2.toLowerCase() === wanted.toLowerCase());
   if (actual === void 0) return "";
-  const name = path16.basename(actual, ".yaml");
+  const name = path17.basename(actual, ".yaml");
   if (!SAFE_FLOW_NAME.test(name)) return "";
-  if (!await isRunnableFlowFile(path16.join(dir, actual))) return "";
+  if (!await isRunnableFlowFile(path17.join(dir, actual))) return "";
   return `
 A flow named "${name}" is saved under ${FLOWS_DIR} \u2014 did you mean: argent flow run ${name}`;
 }
@@ -31664,17 +31891,17 @@ async function collectFlowFiles(dir, recursive) {
   const found = [];
   const walk = async (current, rel) => {
     for (const entry of await fsp.readdir(current, { withFileTypes: true })) {
-      const entryRel = rel ? path16.join(rel, entry.name) : entry.name;
+      const entryRel = rel ? path17.join(rel, entry.name) : entry.name;
       if (entry.isDirectory()) {
         if (recursive && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-          await walk(path16.join(current, entry.name), entryRel).catch(() => {
+          await walk(path17.join(current, entry.name), entryRel).catch(() => {
           });
         }
         continue;
       }
       if (!entry.name.endsWith(".yaml")) continue;
-      if (!SAFE_FLOW_NAME.test(path16.basename(entry.name, ".yaml"))) continue;
-      if (await isRunnableFlowFile(path16.join(current, entry.name))) found.push(entryRel);
+      if (!SAFE_FLOW_NAME.test(path17.basename(entry.name, ".yaml"))) continue;
+      if (await isRunnableFlowFile(path17.join(current, entry.name))) found.push(entryRel);
     }
   };
   await walk(dir, "");
@@ -31802,7 +32029,7 @@ async function runFlowDirectory(dir, args, projectRoot, options) {
     );
   }
   const { callTool, baseUrl } = runToolsClient(args, options);
-  const outputBase = args.output ? path16.resolve(args.output) : void 0;
+  const outputBase = args.output ? path17.resolve(args.output) : void 0;
   const results = [];
   const failures = [];
   const batchStartedAt = Date.now();
@@ -31815,7 +32042,7 @@ async function runFlowDirectory(dir, args, projectRoot, options) {
       if (!args.json) console.log(`  ${STATUS_GLYPH.skip} not run (batch stopped)`);
       continue;
     }
-    const flowPath = path16.join(dir, rel);
+    const flowPath = path17.join(dir, rel);
     const rerun = rerunCommand(flowPath, rel, projectRoot, args);
     let report;
     try {
@@ -31848,7 +32075,7 @@ async function runFlowDirectory(dir, args, projectRoot, options) {
     }
     await exportAndResolveArtifacts(
       report,
-      outputBase ? path16.join(outputBase, path16.dirname(rel)) : void 0,
+      outputBase ? path17.join(outputBase, path17.dirname(rel)) : void 0,
       flowPath,
       baseUrl
     );
@@ -31893,9 +32120,9 @@ async function flow(argv, options) {
     return;
   }
   if (sub === "list") {
-    const dir = path16.join(process.cwd(), FLOWS_DIR);
+    const dir = path17.join(process.cwd(), FLOWS_DIR);
     try {
-      const paths = (await collectRunnableFlowPaths(dir)).sort().map((rel) => path16.join(FLOWS_DIR, rel));
+      const paths = (await collectRunnableFlowPaths(dir)).sort().map((rel) => path17.join(FLOWS_DIR, rel));
       if (paths.length === 0) console.log("No flows found in .argent/flows");
       else console.log(paths.join("\n"));
     } catch {
@@ -31947,10 +32174,10 @@ async function flow(argv, options) {
   const { suppliedPath, fromName } = resolveFlowRef(args.flowRef);
   if (suppliedPath.split(/[\\/]+/).includes("..")) {
     let recovery = "Pass the fully resolved path to the flow's YAML.";
-    const suppliedBase2 = path16.basename(suppliedPath);
+    const suppliedBase2 = path17.basename(suppliedPath);
     if (suppliedBase2 !== ".." && suppliedBase2 !== ".") {
       try {
-        const resolved = path16.join(await fsp.realpath(path16.dirname(suppliedPath)), suppliedBase2);
+        const resolved = path17.join(await fsp.realpath(path17.dirname(suppliedPath)), suppliedBase2);
         await fsp.stat(resolved);
         recovery = `Did you mean: argent flow run ${shellQuoteArg(resolved)}`;
       } catch {
@@ -31962,7 +32189,7 @@ async function flow(argv, options) {
       2
     );
   }
-  const resolvedPath = path16.resolve(projectRoot, suppliedPath);
+  const resolvedPath = path17.resolve(projectRoot, suppliedPath);
   let isDirectory = false;
   try {
     isDirectory = (await fsp.stat(resolvedPath)).isDirectory();
@@ -31985,16 +32212,16 @@ async function flow(argv, options) {
   }
   const separatorTrimmedPath = suppliedPath.replace(/[\\/]+$/, "");
   if (separatorTrimmedPath !== suppliedPath && separatorTrimmedPath !== "") {
-    const hint = SAFE_FLOW_NAME.test(separatorTrimmedPath) ? `.${path16.sep}${separatorTrimmedPath}` : separatorTrimmedPath;
+    const hint = SAFE_FLOW_NAME.test(separatorTrimmedPath) ? `.${path17.sep}${separatorTrimmedPath}` : separatorTrimmedPath;
     return fail(
       `Flow path must not end in a path separator \u2014 the separator claims a directory, which the kernel would refuse to open as a file, so the CLI would run a file this string does not name: ${suppliedPath}
 Did you mean: argent flow run ${shellQuoteArg(hint)}`,
       2
     );
   }
-  if (path16.extname(suppliedPath) !== ".yaml") {
-    const looksLikeName = !suppliedPath.includes("/") && !suppliedPath.includes("\\") && path16.extname(suppliedPath) === "";
-    if (path16.basename(suppliedPath).toLowerCase() === ".yaml") {
+  if (path17.extname(suppliedPath) !== ".yaml") {
+    const looksLikeName = !suppliedPath.includes("/") && !suppliedPath.includes("\\") && path17.extname(suppliedPath) === "";
+    if (path17.basename(suppliedPath).toLowerCase() === ".yaml") {
       return fail(
         `Flow filename must have a non-empty name containing only letters, numbers, "_", or "-": ${suppliedPath}`,
         2
@@ -32007,15 +32234,15 @@ Names run \`${FLOWS_DIR}/<name>.yaml\`; pass a path ending in .yaml to run a flo
         2
       );
     }
-    if (path16.extname(suppliedPath).toLowerCase() === ".yaml") {
+    if (path17.extname(suppliedPath).toLowerCase() === ".yaml") {
       return fail(
-        `Flow extension must be lowercase .yaml, not ${path16.extname(suppliedPath)}: ${suppliedPath}`,
+        `Flow extension must be lowercase .yaml, not ${path17.extname(suppliedPath)}: ${suppliedPath}`,
         2
       );
     }
     return fail(`Flow path must end in .yaml: ${suppliedPath}`, 2);
   }
-  const flowName = path16.basename(suppliedPath, ".yaml");
+  const flowName = path17.basename(suppliedPath, ".yaml");
   if (!SAFE_FLOW_NAME.test(flowName)) {
     return fail(
       `Flow filename must have a non-empty name containing only letters, numbers, "_", or "-": ${suppliedPath}`,
@@ -32039,12 +32266,12 @@ No flow named "${args.flowRef}" is saved there \u2014 run \`argent flow list\` t
     }
     return fail(`${detail}: ${flowPath}${recovery}`, 2);
   }
-  const suppliedBase = path16.basename(flowPath);
-  const siblings = await fsp.readdir(path16.dirname(flowPath)).catch(() => null);
+  const suppliedBase = path17.basename(flowPath);
+  const siblings = await fsp.readdir(path17.dirname(flowPath)).catch(() => null);
   if (siblings !== null && !siblings.includes(suppliedBase)) {
     const actual = siblings.find((name) => name.toLowerCase() === suppliedBase.toLowerCase());
-    const actualRunnable = actual !== void 0 && path16.extname(actual) === ".yaml" && SAFE_FLOW_NAME.test(path16.basename(actual, ".yaml"));
-    const recovery = actualRunnable ? fromName ? `Did you mean: argent flow run ${path16.basename(actual, ".yaml")}` : `Did you mean: argent flow run ${shellQuoteArg(path16.join(path16.dirname(suppliedPath), actual))}` : actual !== void 0 ? `Rename ${actual} to ${suppliedBase} to run it \u2014 flow files must be lowercase .yaml.` : "Pass the flow file's name exactly as it appears on disk.";
+    const actualRunnable = actual !== void 0 && path17.extname(actual) === ".yaml" && SAFE_FLOW_NAME.test(path17.basename(actual, ".yaml"));
+    const recovery = actualRunnable ? fromName ? `Did you mean: argent flow run ${path17.basename(actual, ".yaml")}` : `Did you mean: argent flow run ${shellQuoteArg(path17.join(path17.dirname(suppliedPath), actual))}` : actual !== void 0 ? `Rename ${actual} to ${suppliedBase} to run it \u2014 flow files must be lowercase .yaml.` : "Pass the flow file's name exactly as it appears on disk.";
     return fail(
       `Flow path must name the file as it appears on disk \u2014 this filesystem matched ${JSON.stringify(suppliedBase)} case-insensitively${actual !== void 0 ? ` to ${JSON.stringify(actual)}` : ""}, so the flow name (which keys the report, __baselines__/, and --output) would be one no file carries: ${suppliedPath}
 ${recovery}`,
@@ -32102,7 +32329,7 @@ ${recovery}`,
   try {
     await exportAndResolveArtifacts(
       report,
-      args.output ? path16.resolve(args.output) : void 0,
+      args.output ? path17.resolve(args.output) : void 0,
       flowPath,
       baseUrl
     );
@@ -32217,11 +32444,11 @@ Listing tools contacts the argent tool-server, starting one if none is running.
 
 // ../argent-cli/src/server.ts
 import * as fs12 from "node:fs";
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 import { homedir as homedir5, networkInterfaces } from "node:os";
 import { spawn as spawn3 } from "node:child_process";
-var STATE_DIR2 = path17.join(homedir5(), ".argent");
-var LOG_FILE2 = path17.join(STATE_DIR2, "tool-server.log");
+var STATE_DIR2 = path18.join(homedir5(), ".argent");
+var LOG_FILE2 = path18.join(STATE_DIR2, "tool-server.log");
 async function describeForeignServers(ownBundlePath) {
   const others = (await readAllToolsServerStates()).filter(
     ({ state: state2 }) => state2.bundlePath !== ownBundlePath && isToolsServerProcessAlive(state2.pid)
@@ -32607,7 +32834,7 @@ async function server(argv, options) {
 // ../argent-cli/src/lens.ts
 import * as fs13 from "node:fs";
 import * as os2 from "node:os";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 
 // ../argent-cli/src/lens-terminal.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
@@ -32825,12 +33052,12 @@ function isSessionAlive(session) {
 // ../argent-cli/src/lens-pty.ts
 import { chmodSync as chmodSync2, readdirSync as readdirSync2 } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname as dirname10, join as join17 } from "node:path";
+import { dirname as dirname11, join as join17 } from "node:path";
 var nodeRequire = createRequire(import.meta.url);
 function ensureSpawnHelperExecutable(req = nodeRequire) {
   if (process.platform !== "darwin") return;
   try {
-    const prebuilds = join17(dirname10(req.resolve("node-pty/package.json")), "prebuilds");
+    const prebuilds = join17(dirname11(req.resolve("node-pty/package.json")), "prebuilds");
     for (const entry of readdirSync2(prebuilds)) {
       try {
         chmodSync2(join17(prebuilds, entry, "spawn-helper"), 493);
@@ -32865,7 +33092,7 @@ function ptyInjectBeats(text2) {
   ];
 }
 function sleep(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
 var DEFAULT_COLS = 80;
 var DEFAULT_ROWS = 24;
@@ -33086,7 +33313,7 @@ var SPAWN_GRACE_MS = 8e3;
 var DEATH_CONFIRMATIONS = 3;
 var SSE_RECONNECT_MS = 1e3;
 function sleep2(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
 var TRUST_PROMPT_RE = /trust this folder|do you trust|yes,? i trust|trust the files in this/i;
 async function dismissTrustPrompt(session) {
@@ -33357,7 +33584,7 @@ async function lens(argv, options) {
     await endSession(baseUrl);
     process.exit(1);
   }
-  const seedFile = path18.join(os2.tmpdir(), `argent-lens-seed-${process.pid}-${Date.now()}.txt`);
+  const seedFile = path19.join(os2.tmpdir(), `argent-lens-seed-${process.pid}-${Date.now()}.txt`);
   fs13.writeFileSync(seedFile, buildSeedPrompt(), "utf8");
   const launchCmd = agent.launch(shellQuote(process.cwd()), shellQuote(seedFile));
   const removeSeedFile = () => {
@@ -33721,7 +33948,7 @@ Options:
 
 // ../argent-cli/src/config.ts
 var import_picocolors2 = __toESM(require_picocolors(), 1);
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 function config2(argv) {
   if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
     printUsage();
@@ -33892,16 +34119,16 @@ function wantsHelp(argv) {
 }
 function scopeLabel(scope) {
   if (scope === "global") return "global";
-  return `project: ${path19.dirname(configDir("project"))}`;
+  return `project: ${path20.dirname(configDir("project"))}`;
 }
 function degenerateProjectScopeWarning(scope) {
   if (scope !== "project") return null;
   const projDir = configDir("project");
-  if (path19.resolve(projDir) === path19.resolve(configDir("global"))) {
-    return `WARNING: no project found between ${process.cwd()} and your home directory \u2014 "project" scope resolved to the home directory, so this writes the GLOBAL config file (${path19.join(projDir, "config.json")}).`;
+  if (path20.resolve(projDir) === path20.resolve(configDir("global"))) {
+    return `WARNING: no project found between ${process.cwd()} and your home directory \u2014 "project" scope resolved to the home directory, so this writes the GLOBAL config file (${path20.join(projDir, "config.json")}).`;
   }
   if (findProjectRoot(process.cwd()) === null) {
-    return `WARNING: no project markers (.argent, .git, package.json) found above ${process.cwd()} \u2014 treating it as the project root and creating ${path19.join(projDir, "config.json")}.`;
+    return `WARNING: no project markers (.argent, .git, package.json) found above ${process.cwd()} \u2014 treating it as the project root and creating ${path20.join(projDir, "config.json")}.`;
   }
   return null;
 }
@@ -34803,7 +35030,7 @@ import { styleText as styleText2, stripVTControlCharacters } from "node:util";
 import process$1 from "node:process";
 var import_sisteransi2 = __toESM(require_src(), 1);
 import { existsSync as existsSync7, lstatSync as lstatSync3, readdirSync as readdirSync3 } from "node:fs";
-import { dirname as dirname12, join as join20 } from "node:path";
+import { dirname as dirname13, join as join20 } from "node:path";
 function isUnicodeSupported() {
   if (process$1.platform !== "win32") {
     return process$1.env.TERM !== "linux";
@@ -35788,7 +36015,7 @@ async function cmdDisable(scope) {
 // ../argent-cli/src/providers.ts
 var import_picocolors7 = __toESM(require_picocolors(), 1);
 import * as fs17 from "node:fs";
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 
 // ../device-providers/src/contract.ts
 var PROVIDER_SCHEMA_VERSION = 1;
@@ -35935,7 +36162,7 @@ var providerEnvelopeSchema = providerRecordSchema.extend({
 // ../device-providers/src/read.ts
 import * as fs14 from "node:fs";
 import * as os3 from "node:os";
-import * as path20 from "node:path";
+import * as path21 from "node:path";
 var DISABLE_ENV = "ARGENT_DISABLE_DEVICE_PROVIDERS";
 var OVERRIDE_ENV = "ARGENT_DEVICE_PROVIDERS";
 function resolveHomeDir2() {
@@ -35944,7 +36171,7 @@ function resolveHomeDir2() {
   return trimmed ? raw : os3.homedir();
 }
 function providersDirectory() {
-  return path20.join(resolveHomeDir2(), ".argent", "providers");
+  return path21.join(resolveHomeDir2(), ".argent", "providers");
 }
 function discoveryDisabled() {
   const raw = process.env[DISABLE_ENV];
@@ -36010,7 +36237,7 @@ function discoverProviders() {
 function descriptorFiles() {
   const directory = providersDirectory();
   try {
-    return fs14.readdirSync(directory).filter((name) => name.endsWith(".json")).sort().map((name) => path20.join(directory, name));
+    return fs14.readdirSync(directory).filter((name) => name.endsWith(".json")).sort().map((name) => path21.join(directory, name));
   } catch {
     return [];
   }
@@ -36018,7 +36245,7 @@ function descriptorFiles() {
 
 // ../device-providers/src/write.ts
 import * as fs15 from "node:fs";
-import * as path21 from "node:path";
+import * as path22 from "node:path";
 var ProviderValidationError = class extends Error {
   /** One line per problem, `path: message`, in the order zod reported them. */
   issues;
@@ -36070,7 +36297,7 @@ function publishProvider(record2, options = {}) {
     );
   }
   const directory = providersDirectory();
-  const file2 = path21.join(directory, `${validated.id}.json`);
+  const file2 = path22.join(directory, `${validated.id}.json`);
   const body = JSON.stringify(canonicalize(candidate), null, 2) + "\n";
   try {
     if (fs15.readFileSync(file2, "utf8") === body) return { changed: false, path: file2 };
@@ -36094,7 +36321,7 @@ function withdrawProvider(id) {
   if (!PROVIDER_ID_SHAPE.test(id)) {
     throw new Error(`'${id}' is not a valid provider id (${String(PROVIDER_ID_SHAPE)}).`);
   }
-  const file2 = path21.join(providersDirectory(), `${id}.json`);
+  const file2 = path22.join(providersDirectory(), `${id}.json`);
   try {
     fs15.unlinkSync(file2);
     return true;
@@ -36599,7 +36826,7 @@ function runWithdraw(args) {
     throw new UsageError2(`'${id}' is not a valid provider id (${String(PROVIDER_ID_SHAPE)})`);
   }
   const removed = withdrawProvider(id);
-  const file2 = path22.join(providersDirectory(), `${id}.json`);
+  const file2 = path23.join(providersDirectory(), `${id}.json`);
   if (args.json) {
     console.log(JSON.stringify({ ok: true, path: file2, removed }, null, 2));
     return;