@swmansion/argent 0.18.1-next.8 → 0.19.0

package/dist/cli-cmds.mjs

@@ -5,7 +5,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a2, b) => (typeof require !== "undefined" ? require : a2)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
   try {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   } catch (e) {
@@ -33,6 +39,325 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../../node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "../../node_modules/dotenv/lib/main.js"(exports, module) {
+    var fs12 = __require("fs");
+    var path17 = __require("path");
+    var os3 = __require("os");
+    var crypto3 = __require("crypto");
+    var TIPS = [
+      "\u25C8 encrypted .env [www.dotenvx.com]",
+      "\u25C8 secrets for agents [www.dotenvx.com]",
+      "\u2301 auth for agents [www.vestauth.com]",
+      "\u2318 custom filepath { path: '/custom/path/.env' }",
+      "\u2318 enable debugging { debug: true }",
+      "\u2318 override existing { override: true }",
+      "\u2318 suppress logs { quiet: true }",
+      "\u2318 multiple files { path: ['.env.local', '.env'] }"
+    ];
+    function _getRandomTip() {
+      return TIPS[Math.floor(Math.random() * TIPS.length)];
+    }
+    function parseBoolean(value) {
+      if (typeof value === "string") {
+        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+      }
+      return Boolean(value);
+    }
+    function supportsAnsi() {
+      return process.stdout.isTTY;
+    }
+    function dim(text2) {
+      return supportsAnsi() ? `\x1B[2m${text2}\x1B[0m` : text2;
+    }
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      options = options || {};
+      const vaultPath = _vaultPath(options);
+      options.path = vaultPath;
+      const result = DotenvModule.configDotenv(options);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i2 = 0; i2 < length; i2++) {
+        try {
+          const key = keys[i2].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i2 + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.error(`\u26A0 ${message}`);
+    }
+    function _debug(message) {
+      console.log(`\u2506 ${message}`);
+    }
+    function _log(message) {
+      console.log(`\u25C7 ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs12.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path17.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs12.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path17.join(os3.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (debug || !quiet) {
+        _log("loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path17.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("no encoding is specified (UTF-8 is used by default)");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path18 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs12.readFileSync(path18, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`failed to load ${path18} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      const populated = DotenvModule.populate(processEnv, parsedAll, options);
+      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(populated).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative4 = path17.relative(process.cwd(), filePath);
+            shortPaths.push(relative4);
+          } catch (e) {
+            if (debug) {
+              _debug(`failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injected env (${keysCount}) from ${shortPaths.join(",")} ${dim(`// tip: ${_getRandomTip()}`)}`);
+      }
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config2(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`you set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto3.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      const populated = {};
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+            populated[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+      }
+      return populated;
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config: config2,
+      decrypt,
+      parse,
+      populate
+    };
+    module.exports.configDotenv = DotenvModule.configDotenv;
+    module.exports._configVault = DotenvModule._configVault;
+    module.exports._parseVault = DotenvModule._parseVault;
+    module.exports.config = DotenvModule.config;
+    module.exports.decrypt = DotenvModule.decrypt;
+    module.exports.parse = DotenvModule.parse;
+    module.exports.populate = DotenvModule.populate;
+    module.exports = DotenvModule;
+  }
+});
+
 // ../../node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS({
   "../../node_modules/picocolors/picocolors.js"(exports, module) {
@@ -162,8 +487,8 @@ var require_src = __commonJS({
 });
 
 // ../argent-cli/src/run.ts
-import * as fs8 from "node:fs";
-import * as path11 from "node:path";
+import * as fs9 from "node:fs";
+import * as path12 from "node:path";
 
 // ../argent-tools-client/src/launcher.ts
 import * as net from "node:net";
@@ -204,7 +529,7 @@ function generateAuthToken() {
   return generateToken();
 }
 function findFreePort() {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const srv = net.createServer();
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
@@ -215,7 +540,7 @@ function findFreePort() {
       const port = addr.port;
       srv.close((err) => {
         if (err) reject(err);
-        else resolve9(port);
+        else resolve10(port);
       });
     });
     srv.on("error", reject);
@@ -316,7 +641,7 @@ function killSpawnedChild(child, pid) {
   }
 }
 function spawnToolsServer(paths, port, options = {}) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     let logFd;
     try {
       fs.mkdirSync(STATE_DIR, { recursive: true });
@@ -353,7 +678,7 @@ function spawnToolsServer(paths, port, options = {}) {
         rl.close();
         child.stdout?.resume();
         child.stdout?.unref?.();
-        settle(() => resolve9({ port: actualPort, pid }));
+        settle(() => resolve10({ port: actualPort, pid }));
       }
     });
     child.on("error", (err) => {
@@ -742,16 +1067,16 @@ 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 path16 = u3.pathname === "/" ? "" : u3.pathname.replace(/\/+$/, "");
-  const url = `${u3.protocol}//${u3.host}${path16}`;
+  const path17 = u3.pathname === "/" ? "" : u3.pathname.replace(/\/+$/, "");
+  const url = `${u3.protocol}//${u3.host}${path17}`;
   const token = u3.username ? decodeURIComponent(u3.username) : void 0;
   return { url, host, port, ...token ? { token } : {} };
 }
 
 // ../argent-tools-client/src/file-inputs.ts
-import { createHash as createHash2, randomUUID } from "node:crypto";
+import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { mkdir as mkdir3, readFile as readFile3, rm as rm2, stat, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile3, rm as rm2, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import * as path3 from "node:path";
 
@@ -857,193 +1182,525 @@ async function safeExtractTarGz(tarPath, destDir, expectedName) {
   return resolveMember(destDir, expectedName);
 }
 
-// ../argent-tools-client/src/file-inputs.ts
-var FILE_INPUT_MARKER = "__argentFileInput";
-var CLIENT_FILE_MARKER = "__argentClientFile";
-var MAX_CONTENT_BYTES = 32 * 1024 * 1024;
-function interpolatePath(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;
-}
-async function tarball(sourcePath) {
-  const tarPath = path3.join(tmpdir(), `argent-upload-${randomUUID()}.tar.gz`);
-  await createTarGzFile(sourcePath, tarPath);
-  return tarPath;
-}
-function sha256File(filePath) {
-  return new Promise((resolve9, reject) => {
-    const hash = createHash2("sha256");
-    createReadStream(filePath).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve9(hash.digest("hex"))).on("error", reject);
-  });
-}
-async function uploadTar(tarPath, endpoint) {
-  const init2 = {
-    method: "POST",
-    headers: {
-      "content-type": "application/gzip",
-      ...endpoint.token ? { Authorization: `Bearer ${endpoint.token}` } : {}
-    },
-    body: createReadStream(tarPath),
-    duplex: "half"
-  };
-  const res = await fetch(`${endpoint.url}/upload`, init2);
-  if (!res.ok) {
-    throw new Error(`Upload to ${endpoint.url}/upload failed: ${res.status} ${res.statusText}`);
-  }
-  const json = await res.json();
-  return json.uploadId;
-}
-async function prepareFileInputs(specs, args, opts) {
-  if (!specs || specs.length === 0 || typeof args !== "object" || args === null) {
-    return args;
-  }
-  const record = args;
-  let out = null;
-  for (const spec of specs) {
-    if (spec.target in record && typeof record[spec.target] !== "string") continue;
-    const filePath = interpolatePath(spec.path, record);
-    if (filePath === null) continue;
-    if (spec.target in record && record[spec.target] !== filePath) continue;
-    const wire = { [FILE_INPUT_MARKER]: true, path: filePath };
-    if (spec.kind === "file") {
-      try {
-        const st = await stat(filePath);
-        if (st.isFile()) {
-          wire.size = st.size;
-          wire.mtimeMs = st.mtimeMs;
-          if (opts.includeContent && st.size <= MAX_CONTENT_BYTES) {
-            wire.content = (await readFile3(filePath)).toString("base64");
-          } else if (opts.includeContent) {
-            wire.contentOmitted = "size-limit";
-          }
-        }
-      } catch {
-      }
-    }
-    if (spec.kind === "tar-upload") {
-      const st = await stat(filePath).catch(() => null);
-      if (st) {
-        wire.size = st.size;
-        wire.mtimeMs = st.mtimeMs;
-      }
-      if (opts.uploadEndpoint && st) {
-        let tarPath = null;
-        try {
-          process.stderr.write(
-            `Uploading ${path3.basename(filePath)} to the remote tool-server...
-`
-          );
-          tarPath = await tarball(filePath);
-          wire.contentHash = await sha256File(tarPath);
-          wire.uploadId = await uploadTar(tarPath, opts.uploadEndpoint);
-        } finally {
-          if (tarPath) await rm2(tarPath, { force: true }).catch(() => {
-          });
-        }
-      }
-    }
-    out = out ?? { ...record };
-    out[spec.target] = wire;
-  }
-  return out ?? args;
-}
-function isAllowedClientFilePath(p) {
-  if (!path3.isAbsolute(p)) return false;
-  const segments = p.split(/[\\/]+/);
-  if (segments.includes("..")) return false;
-  const file = segments[segments.length - 1] ?? "";
-  if (!/^[A-Za-z0-9_-]+\.yaml$/.test(file)) return false;
-  return segments[segments.length - 3] === ".argent" && segments[segments.length - 2] === "flows";
-}
-function isClientFileDirective(value) {
-  return !!value && typeof value === "object" && value[CLIENT_FILE_MARKER] === true && typeof value.path === "string" && typeof value.content === "string";
-}
-async function applyClientFileDirectives(result) {
-  const written = [];
-  async function walk(value) {
-    if (isClientFileDirective(value)) {
-      if (!isAllowedClientFilePath(value.path)) return null;
-      try {
-        await mkdir3(path3.dirname(value.path), { recursive: true });
-        await writeFile3(value.path, value.content, "utf8");
-        written.push(value.path);
-        return value.path;
-      } catch {
-        return null;
-      }
-    }
-    if (Array.isArray(value)) {
-      return Promise.all(value.map(walk));
-    }
-    if (value && typeof value === "object") {
-      const out = {};
-      for (const [k, v] of Object.entries(value)) {
-        out[k] = await walk(v);
-      }
-      return out;
-    }
-    return value;
-  }
-  const rewritten = await walk(result);
-  return { result: rewritten, written };
-}
+// ../registry/src/artifacts.ts
+import { stat } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { basename as basename2, extname } from "node:path";
 
-// ../argent-tools-client/src/tools-client.ts
-function authHeaders2(token) {
-  return token ? { Authorization: `Bearer ${token}` } : {};
-}
-async function consumeToolStream(body, onProgress) {
-  let final;
-  const handleLine = (line) => {
-    if (!line.trim()) return;
-    const msg = JSON.parse(line);
-    if (msg.event === "progress") onProgress(msg.data);
-    else if (msg.event === "result") final = { data: msg.data, note: msg.note };
-    else if (msg.event === "error") throw new Error(msg.error ?? "tool invocation failed");
-  };
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffered = "";
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffered += decoder.decode(value, { stream: true });
-      let newline;
-      while ((newline = buffered.indexOf("\n")) !== -1) {
-        const line = buffered.slice(0, newline);
-        buffered = buffered.slice(newline + 1);
-        handleLine(line);
-      }
-    }
-    buffered += decoder.decode();
-    if (buffered.trim()) handleLine(buffered);
-  } catch (err) {
-    void reader.cancel().catch(() => {
-    });
-    throw err;
-  }
-  if (!final) {
-    throw new Error("tool stream ended without a result \u2014 connection lost mid-run?");
-  }
-  const { result: data } = await applyClientFileDirectives(final.data);
-  return { data, note: final.note };
-}
-function createToolsClient(options = {}) {
-  let cached2 = null;
-  async function baseUrl() {
-    const resolved = await getResolvedToolsUrl();
-    if (resolved.url) {
-      return { url: resolved.url, token: resolved.token ?? "" };
-    }
+// ../registry/src/file-inputs.ts
+var FLOW_NAME_CHARSET = "[A-Za-z0-9_-]+";
+var FLOW_NAME_PATTERN = new RegExp(`^${FLOW_NAME_CHARSET}$`);
+var FLOW_FILE_NAME_PATTERN = new RegExp(`^${FLOW_NAME_CHARSET}\\.yaml$`);
+
+// ../registry/src/failure-codes.ts
+var FAILURE_CODES = {
+  ARGENT_UNCLASSIFIED_FAILURE: "ARGENT_UNCLASSIFIED_FAILURE",
+  REGISTRY_SERVICE_NOT_FOUND: "REGISTRY_SERVICE_NOT_FOUND",
+  REGISTRY_SERVICE_INITIALIZATION_FAILED: "REGISTRY_SERVICE_INITIALIZATION_FAILED",
+  REGISTRY_TOOL_NOT_FOUND: "REGISTRY_TOOL_NOT_FOUND",
+  REGISTRY_TOOL_EXECUTION_FAILED: "REGISTRY_TOOL_EXECUTION_FAILED",
+  REGISTRY_TOOL_FAILURE_UNCLASSIFIED: "REGISTRY_TOOL_FAILURE_UNCLASSIFIED",
+  HTTP_TOOL_NOT_FOUND: "HTTP_TOOL_NOT_FOUND",
+  HTTP_ZOD_VALIDATION_FAILED: "HTTP_ZOD_VALIDATION_FAILED",
+  HTTP_CAPABILITY_UNSUPPORTED_OPERATION: "HTTP_CAPABILITY_UNSUPPORTED_OPERATION",
+  HTTP_DEVICE_RESOLUTION_FAILED: "HTTP_DEVICE_RESOLUTION_FAILED",
+  HTTP_DEPENDENCY_PREFLIGHT_MISSING: "HTTP_DEPENDENCY_PREFLIGHT_MISSING",
+  CLI_RUN_TOOL_NOT_FOUND: "CLI_RUN_TOOL_NOT_FOUND",
+  CLI_RUN_FLAG_PARSE_FAILED: "CLI_RUN_FLAG_PARSE_FAILED",
+  CLI_RUN_ARGS_NOT_OBJECT: "CLI_RUN_ARGS_NOT_OBJECT",
+  CLI_RUN_ARGS_JSON_INVALID: "CLI_RUN_ARGS_JSON_INVALID",
+  CLI_RUN_INPUT_VALIDATION_FAILED: "CLI_RUN_INPUT_VALIDATION_FAILED",
+  CLI_RUN_TOOL_CALL_FAILED: "CLI_RUN_TOOL_CALL_FAILED",
+  CLI_RUN_SAVE_IMAGE_FAILED: "CLI_RUN_SAVE_IMAGE_FAILED",
+  TOOL_CAPABILITY_UNSUPPORTED_OPERATION: "TOOL_CAPABILITY_UNSUPPORTED_OPERATION",
+  TOOL_PLATFORM_NOT_IMPLEMENTED: "TOOL_PLATFORM_NOT_IMPLEMENTED",
+  TOOL_DEPENDENCY_MISSING: "TOOL_DEPENDENCY_MISSING",
+  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
+  TOOLSERVER_UNHANDLED_REJECTION: "TOOLSERVER_UNHANDLED_REJECTION",
+  TOOLSERVER_UNCAUGHT_EXCEPTION: "TOOLSERVER_UNCAUGHT_EXCEPTION",
+  INSTALL_GLOBAL_PACKAGE_FAILED: "INSTALL_GLOBAL_PACKAGE_FAILED",
+  INSTALL_LOCAL_PACKAGE_FAILED: "INSTALL_LOCAL_PACKAGE_FAILED",
+  INSTALL_LOCAL_PRECONDITION_FAILED: "INSTALL_LOCAL_PRECONDITION_FAILED",
+  INSTALL_MODE_FLAG_CONFLICT: "INSTALL_MODE_FLAG_CONFLICT",
+  INSTALL_FROM_TAR_PACKAGE_FAILED: "INSTALL_FROM_TAR_PACKAGE_FAILED",
+  INSTALL_INIT_TRIGGERED_UPDATE_FAILED: "INSTALL_INIT_TRIGGERED_UPDATE_FAILED",
+  INSTALL_SKILLS_REFRESH_FAILED: "INSTALL_SKILLS_REFRESH_FAILED",
+  INSTALL_UNCLASSIFIED_FAILED: "INSTALL_UNCLASSIFIED_FAILED",
+  UPDATE_INSTALLED_VERSION_DETECT_FAILED: "UPDATE_INSTALLED_VERSION_DETECT_FAILED",
+  UPDATE_INVALID_TARGET_VERSION: "UPDATE_INVALID_TARGET_VERSION",
+  UPDATE_REGISTRY_CHECK_FAILED: "UPDATE_REGISTRY_CHECK_FAILED",
+  UPDATE_TOOLSERVER_STOP_FAILED: "UPDATE_TOOLSERVER_STOP_FAILED",
+  UPDATE_PACKAGE_ACTION_FAILED: "UPDATE_PACKAGE_ACTION_FAILED",
+  UPDATE_UNCLASSIFIED_FAILED: "UPDATE_UNCLASSIFIED_FAILED",
+  UNINSTALL_TOOLSERVER_STOP_FAILED: "UNINSTALL_TOOLSERVER_STOP_FAILED",
+  UNINSTALL_PACKAGE_ACTION_FAILED: "UNINSTALL_PACKAGE_ACTION_FAILED",
+  UNINSTALL_UNCLASSIFIED_FAILED: "UNINSTALL_UNCLASSIFIED_FAILED",
+  VEGA_CLI_COMMAND_FAILED: "VEGA_CLI_COMMAND_FAILED",
+  VEGA_INPUT_UNAVAILABLE: "VEGA_INPUT_UNAVAILABLE",
+  VEGA_DEVICE_NOT_FOUND: "VEGA_DEVICE_NOT_FOUND",
+  VEGA_DEVICE_NOT_REGISTERED: "VEGA_DEVICE_NOT_REGISTERED",
+  VEGA_MULTIPLE_DEVICES: "VEGA_MULTIPLE_DEVICES",
+  VEGA_BOOT_TIMEOUT: "VEGA_BOOT_TIMEOUT",
+  VEGA_IMAGE_NOT_FOUND: "VEGA_IMAGE_NOT_FOUND",
+  VEGA_ALREADY_RUNNING: "VEGA_ALREADY_RUNNING",
+  VEGA_SCREENSHOT_FAILED: "VEGA_SCREENSHOT_FAILED",
+  VEGA_TEXT_INVALID: "VEGA_TEXT_INVALID",
+  ANDROID_ADB_NOT_FOUND: "ANDROID_ADB_NOT_FOUND",
+  ANDROID_EMULATOR_NOT_FOUND: "ANDROID_EMULATOR_NOT_FOUND",
+  ANDROID_ADB_COMMAND_FAILED: "ANDROID_ADB_COMMAND_FAILED",
+  ANDROID_ADB_BOOT_TERMINAL_STATE: "ANDROID_ADB_BOOT_TERMINAL_STATE",
+  ANDROID_ADB_BOOT_TIMEOUT: "ANDROID_ADB_BOOT_TIMEOUT",
+  SIMULATOR_NETWORK_TIMEOUT: "SIMULATOR_NETWORK_TIMEOUT",
+  SIMULATOR_NETWORK_CONNECTION_REFUSED: "SIMULATOR_NETWORK_CONNECTION_REFUSED",
+  SIMULATOR_NETWORK_CONNECTION_RESET: "SIMULATOR_NETWORK_CONNECTION_RESET",
+  SIMULATOR_NETWORK_ERROR: "SIMULATOR_NETWORK_ERROR",
+  SIMULATOR_NON_JSON_RESPONSE: "SIMULATOR_NON_JSON_RESPONSE",
+  SIMULATOR_HTTP_ERROR_RESPONSE: "SIMULATOR_HTTP_ERROR_RESPONSE",
+  SIMULATOR_MISSING_RESPONSE_FIELDS: "SIMULATOR_MISSING_RESPONSE_FIELDS",
+  SIMULATOR_SCREENSHOT_FAILED: "SIMULATOR_SCREENSHOT_FAILED",
+  SIMULATOR_SERVER_FACTORY_OPTIONS_MISSING: "SIMULATOR_SERVER_FACTORY_OPTIONS_MISSING",
+  SIMULATOR_SERVER_DEVICE_ID_INVALID: "SIMULATOR_SERVER_DEVICE_ID_INVALID",
+  SIMULATOR_SERVER_READY_EXITED: "SIMULATOR_SERVER_READY_EXITED",
+  SIMULATOR_SERVER_READY_TIMEOUT: "SIMULATOR_SERVER_READY_TIMEOUT",
+  SIMULATOR_SERVER_PROCESS_ERROR: "SIMULATOR_SERVER_PROCESS_ERROR",
+  SIMULATOR_SERVER_TERMINATED: "SIMULATOR_SERVER_TERMINATED",
+  AX_QUERY_TIMEOUT: "AX_QUERY_TIMEOUT",
+  AX_DAEMON_READY_TIMEOUT: "AX_DAEMON_READY_TIMEOUT",
+  AX_DAEMON_EXITED_BEFORE_READY: "AX_DAEMON_EXITED_BEFORE_READY",
+  AX_DAEMON_PROCESS_ERROR: "AX_DAEMON_PROCESS_ERROR",
+  AX_FACTORY_OPTIONS_MISSING: "AX_FACTORY_OPTIONS_MISSING",
+  AX_WRONG_PLATFORM: "AX_WRONG_PLATFORM",
+  AX_DEVICE_ID_INVALID: "AX_DEVICE_ID_INVALID",
+  AX_DESCRIBE_ERROR: "AX_DESCRIBE_ERROR",
+  AX_QUERY_FAILED: "AX_QUERY_FAILED",
+  ANDROID_LAUNCH_ACTIVITY_RESOLVE_FAILED: "ANDROID_LAUNCH_ACTIVITY_RESOLVE_FAILED",
+  ANDROID_LAUNCH_AM_START_FAILED: "ANDROID_LAUNCH_AM_START_FAILED",
+  ANDROID_OPEN_URL_FAILED: "ANDROID_OPEN_URL_FAILED",
+  ANDROID_REINSTALL_INSTALL_FAILED: "ANDROID_REINSTALL_INSTALL_FAILED",
+  ANDROID_RESTART_FAILED: "ANDROID_RESTART_FAILED",
+  ANDROID_SETTINGS_PERMISSION_FAILED: "ANDROID_SETTINGS_PERMISSION_FAILED",
+  IOS_LAUNCH_SIMCTL_FAILED: "IOS_LAUNCH_SIMCTL_FAILED",
+  IOS_OPEN_URL_FAILED: "IOS_OPEN_URL_FAILED",
+  IOS_REINSTALL_INSTALL_FAILED: "IOS_REINSTALL_INSTALL_FAILED",
+  IOS_RESTART_LAUNCH_FAILED: "IOS_RESTART_LAUNCH_FAILED",
+  IOS_SETTINGS_PERMISSION_FAILED: "IOS_SETTINGS_PERMISSION_FAILED",
+  SETTINGS_PERMISSION_UNSUPPORTED: "SETTINGS_PERMISSION_UNSUPPORTED",
+  NATIVE_DEVTOOLS_DESCRIBE_ERROR: "NATIVE_DEVTOOLS_DESCRIBE_ERROR",
+  NATIVE_DEVTOOLS_VIEW_AT_POINT_ERROR: "NATIVE_DEVTOOLS_VIEW_AT_POINT_ERROR",
+  NATIVE_DEVTOOLS_USER_INTERACTABLE_VIEW_AT_POINT_ERROR: "NATIVE_DEVTOOLS_USER_INTERACTABLE_VIEW_AT_POINT_ERROR",
+  NATIVE_DEVTOOLS_FIND_VIEWS_ERROR: "NATIVE_DEVTOOLS_FIND_VIEWS_ERROR",
+  NATIVE_DEVTOOLS_FACTORY_OPTIONS_MISSING: "NATIVE_DEVTOOLS_FACTORY_OPTIONS_MISSING",
+  NATIVE_DEVTOOLS_WRONG_PLATFORM: "NATIVE_DEVTOOLS_WRONG_PLATFORM",
+  NATIVE_DEVTOOLS_NOT_INJECTABLE: "NATIVE_DEVTOOLS_NOT_INJECTABLE",
+  NATIVE_DEVTOOLS_NOT_CONNECTED: "NATIVE_DEVTOOLS_NOT_CONNECTED",
+  NATIVE_DEVTOOLS_RPC_TIMEOUT: "NATIVE_DEVTOOLS_RPC_TIMEOUT",
+  NATIVE_DEVTOOLS_RPC_ERROR: "NATIVE_DEVTOOLS_RPC_ERROR",
+  NATIVE_DEVTOOLS_SERVICE_DISPOSED: "NATIVE_DEVTOOLS_SERVICE_DISPOSED",
+  NATIVE_DEVTOOLS_SOCKET_BIND_FAILED: "NATIVE_DEVTOOLS_SOCKET_BIND_FAILED",
+  NATIVE_TARGET_NO_CONNECTED_APPS: "NATIVE_TARGET_NO_CONNECTED_APPS",
+  NATIVE_TARGET_SINGLE_APP_NOT_FOREGROUND: "NATIVE_TARGET_SINGLE_APP_NOT_FOREGROUND",
+  NATIVE_TARGET_MULTIPLE_APPS_AMBIGUOUS: "NATIVE_TARGET_MULTIPLE_APPS_AMBIGUOUS",
+  ANDROID_DEVTOOLS_ADB_NOT_FOUND: "ANDROID_DEVTOOLS_ADB_NOT_FOUND",
+  ANDROID_DEVTOOLS_ADB_FORWARD_UNEXPECTED: "ANDROID_DEVTOOLS_ADB_FORWARD_UNEXPECTED",
+  ANDROID_DEVTOOLS_HELPER_EXITED_BEFORE_READY: "ANDROID_DEVTOOLS_HELPER_EXITED_BEFORE_READY",
+  ANDROID_DEVTOOLS_HELPER_PROCESS_ERROR: "ANDROID_DEVTOOLS_HELPER_PROCESS_ERROR",
+  ANDROID_DEVTOOLS_HELPER_READY_TIMEOUT: "ANDROID_DEVTOOLS_HELPER_READY_TIMEOUT",
+  ANDROID_DEVTOOLS_FACTORY_OPTIONS_MISSING: "ANDROID_DEVTOOLS_FACTORY_OPTIONS_MISSING",
+  ANDROID_DEVTOOLS_WRONG_PLATFORM: "ANDROID_DEVTOOLS_WRONG_PLATFORM",
+  ANDROID_DEVTOOLS_DEVICE_ID_INVALID: "ANDROID_DEVTOOLS_DEVICE_ID_INVALID",
+  ANDROID_DEVTOOLS_HELPER_TERMINATED: "ANDROID_DEVTOOLS_HELPER_TERMINATED",
+  ANDROID_DEVTOOLS_RPC_CLIENT_CLOSED: "ANDROID_DEVTOOLS_RPC_CLIENT_CLOSED",
+  ANDROID_DEVTOOLS_RPC_ERROR: "ANDROID_DEVTOOLS_RPC_ERROR",
+  ANDROID_DEVTOOLS_RPC_TIMEOUT: "ANDROID_DEVTOOLS_RPC_TIMEOUT",
+  ANDROID_DEVTOOLS_SOCKET_CLOSED: "ANDROID_DEVTOOLS_SOCKET_CLOSED",
+  ANDROID_SCREEN_SIZE_PARSE_FAILED: "ANDROID_SCREEN_SIZE_PARSE_FAILED",
+  ANDROID_SCREEN_SIZE_NON_POSITIVE: "ANDROID_SCREEN_SIZE_NON_POSITIVE",
+  ANDROID_UIAUTOMATOR_PARSE_FAILED: "ANDROID_UIAUTOMATOR_PARSE_FAILED",
+  ANDROID_UIAUTOMATOR_CAPTURE_FAILED: "ANDROID_UIAUTOMATOR_CAPTURE_FAILED",
+  DEBUGGER_METRO_NOT_RUNNING: "DEBUGGER_METRO_NOT_RUNNING",
+  DEBUGGER_METRO_NO_TARGETS: "DEBUGGER_METRO_NO_TARGETS",
+  DEBUGGER_CDP_RUNTIME_EXCEPTION: "DEBUGGER_CDP_RUNTIME_EXCEPTION",
+  DEBUGGER_CDP_BINDING_TIMEOUT: "DEBUGGER_CDP_BINDING_TIMEOUT",
+  DEBUGGER_CDP_BINDING_UNAVAILABLE: "DEBUGGER_CDP_BINDING_UNAVAILABLE",
+  DEBUGGER_CDP_PROTOCOL_ERROR: "DEBUGGER_CDP_PROTOCOL_ERROR",
+  DEBUGGER_RELOAD_FAILED: "DEBUGGER_RELOAD_FAILED",
+  JS_RUNTIME_CONSOLE_SERVER_BIND_FAILED: "JS_RUNTIME_CONSOLE_SERVER_BIND_FAILED",
+  JS_RUNTIME_PAYLOAD_INVALID: "JS_RUNTIME_PAYLOAD_INVALID",
+  JS_RUNTIME_PAYLOAD_DEVICE_MISSING: "JS_RUNTIME_PAYLOAD_DEVICE_MISSING",
+  JS_RUNTIME_PAYLOAD_PORT_INVALID: "JS_RUNTIME_PAYLOAD_PORT_INVALID",
+  JS_RUNTIME_CDP_DISCONNECTED: "JS_RUNTIME_CDP_DISCONNECTED",
+  NETWORK_INSPECTOR_CDP_DISCONNECTED: "NETWORK_INSPECTOR_CDP_DISCONNECTED",
+  REACT_PROFILER_NO_ACTIVE_SESSION: "REACT_PROFILER_NO_ACTIVE_SESSION",
+  REACT_PROFILER_CDP_CONNECTION_LOST: "REACT_PROFILER_CDP_CONNECTION_LOST",
+  REACT_PROFILER_NO_CPU_PROFILE: "REACT_PROFILER_NO_CPU_PROFILE",
+  REACT_PROFILER_RUNTIME_EXCEPTION: "REACT_PROFILER_RUNTIME_EXCEPTION",
+  REACT_PROFILER_NO_RUNTIME_DATA: "REACT_PROFILER_NO_RUNTIME_DATA",
+  REACT_PROFILER_SESSION_PAYLOAD_INVALID: "REACT_PROFILER_SESSION_PAYLOAD_INVALID",
+  REACT_PROFILER_SESSION_PAYLOAD_DEVICE_MISSING: "REACT_PROFILER_SESSION_PAYLOAD_DEVICE_MISSING",
+  REACT_PROFILER_SESSION_CDP_DISCONNECTED: "REACT_PROFILER_SESSION_CDP_DISCONNECTED",
+  REACT_PROFILER_CDP_NOT_CONNECTED: "REACT_PROFILER_CDP_NOT_CONNECTED",
+  REACT_PROFILER_STATE_READ_FAILED: "REACT_PROFILER_STATE_READ_FAILED",
+  REACT_PROFILER_DEVTOOLS_HOOK_MISSING: "REACT_PROFILER_DEVTOOLS_HOOK_MISSING",
+  REACT_PROFILER_DEVTOOLS_BACKEND_ATTACH_FAILED: "REACT_PROFILER_DEVTOOLS_BACKEND_ATTACH_FAILED",
+  REACT_PROFILER_DEVTOOLS_BACKEND_BOOTSTRAP_FAILED: "REACT_PROFILER_DEVTOOLS_BACKEND_BOOTSTRAP_FAILED",
+  REACT_PROFILER_DEVTOOLS_RENDERER_MISSING: "REACT_PROFILER_DEVTOOLS_RENDERER_MISSING",
+  REACT_PROFILER_START_FAILED: "REACT_PROFILER_START_FAILED",
+  REACT_PROFILER_START_VERIFY_FAILED: "REACT_PROFILER_START_VERIFY_FAILED",
+  REACT_PROFILER_HOOK_ERROR: "REACT_PROFILER_HOOK_ERROR",
+  REACT_PROFILER_ANALYZE_NO_DATA: "REACT_PROFILER_ANALYZE_NO_DATA",
+  NATIVE_PROFILER_FACTORY_OPTIONS_MISSING: "NATIVE_PROFILER_FACTORY_OPTIONS_MISSING",
+  NATIVE_PROFILER_WRONG_PLATFORM: "NATIVE_PROFILER_WRONG_PLATFORM",
+  NATIVE_PROFILER_APP_PROCESS_LIST_FAILED: "NATIVE_PROFILER_APP_PROCESS_LIST_FAILED",
+  NATIVE_PROFILER_APP_LIST_FAILED: "NATIVE_PROFILER_APP_LIST_FAILED",
+  NATIVE_PROFILER_NO_RUNNING_APPS: "NATIVE_PROFILER_NO_RUNNING_APPS",
+  NATIVE_PROFILER_NO_RUNNING_USER_APPS: "NATIVE_PROFILER_NO_RUNNING_USER_APPS",
+  NATIVE_PROFILER_MULTIPLE_RUNNING_USER_APPS: "NATIVE_PROFILER_MULTIPLE_RUNNING_USER_APPS",
+  NATIVE_PROFILER_MALLOC_DEGRADED_XCODE: "NATIVE_PROFILER_MALLOC_DEGRADED_XCODE",
+  NATIVE_PROFILER_MALLOC_STRATEGY_OVERRIDE: "NATIVE_PROFILER_MALLOC_STRATEGY_OVERRIDE",
+  NATIVE_PROFILER_APP_BUNDLE_PATH_FAILED: "NATIVE_PROFILER_APP_BUNDLE_PATH_FAILED",
+  NATIVE_PROFILER_LAUNCH_APP_NOT_FOUND: "NATIVE_PROFILER_LAUNCH_APP_NOT_FOUND",
+  NATIVE_PROFILER_LAUNCH_APP_AMBIGUOUS: "NATIVE_PROFILER_LAUNCH_APP_AMBIGUOUS",
+  NATIVE_PROFILER_SESSION_ALREADY_RUNNING: "NATIVE_PROFILER_SESSION_ALREADY_RUNNING",
+  NATIVE_PROFILER_XCTRACE_NO_PID: "NATIVE_PROFILER_XCTRACE_NO_PID",
+  NATIVE_PROFILER_XCTRACE_PROCESS_NOT_FOUND: "NATIVE_PROFILER_XCTRACE_PROCESS_NOT_FOUND",
+  NATIVE_PROFILER_XCTRACE_READY_EXITED: "NATIVE_PROFILER_XCTRACE_READY_EXITED",
+  NATIVE_PROFILER_XCTRACE_PROCESS_ERROR: "NATIVE_PROFILER_XCTRACE_PROCESS_ERROR",
+  NATIVE_PROFILER_XCTRACE_READY_TIMEOUT: "NATIVE_PROFILER_XCTRACE_READY_TIMEOUT",
+  NATIVE_PROFILER_TRACE_TEMPLATE_MISSING: "NATIVE_PROFILER_TRACE_TEMPLATE_MISSING",
+  NATIVE_PROFILER_NO_ACTIVE_SESSION: "NATIVE_PROFILER_NO_ACTIVE_SESSION",
+  NATIVE_PROFILER_APP_PROCESS_NOT_FOUND: "NATIVE_PROFILER_APP_PROCESS_NOT_FOUND",
+  NATIVE_PROFILER_NO_EXPORTED_TRACE: "NATIVE_PROFILER_NO_EXPORTED_TRACE",
+  // Android perfetto start-failure modes — mirror the iOS xctrace set so a
+  // failed recording start is classified rather than falling through to the
+  // generic tool-execution bucket.
+  NATIVE_PROFILER_PERFETTO_PROCESS_ERROR: "NATIVE_PROFILER_PERFETTO_PROCESS_ERROR",
+  NATIVE_PROFILER_PERFETTO_READY_TIMEOUT: "NATIVE_PROFILER_PERFETTO_READY_TIMEOUT",
+  NATIVE_PROFILER_PERFETTO_READY_EXITED: "NATIVE_PROFILER_PERFETTO_READY_EXITED",
+  // screen-recording-start / screen-recording-stop. One capture path for every
+  // platform (simulator-server's frame stream into ffmpeg), so the stages name
+  // the step that failed rather than the device family.
+  SCREEN_RECORDING_FACTORY_OPTIONS_MISSING: "SCREEN_RECORDING_FACTORY_OPTIONS_MISSING",
+  SCREEN_RECORDING_WRONG_PLATFORM: "SCREEN_RECORDING_WRONG_PLATFORM",
+  SCREEN_RECORDING_ALREADY_ACTIVE: "SCREEN_RECORDING_ALREADY_ACTIVE",
+  SCREEN_RECORDING_NO_ACTIVE_SESSION: "SCREEN_RECORDING_NO_ACTIVE_SESSION",
+  SCREEN_RECORDING_STOP_IN_PROGRESS: "SCREEN_RECORDING_STOP_IN_PROGRESS",
+  SCREEN_RECORDING_START_EXITED: "SCREEN_RECORDING_START_EXITED",
+  SCREEN_RECORDING_START_TIMEOUT: "SCREEN_RECORDING_START_TIMEOUT",
+  SCREEN_RECORDING_PROCESS_ERROR: "SCREEN_RECORDING_PROCESS_ERROR",
+  SCREEN_RECORDING_OUTPUT_MISSING: "SCREEN_RECORDING_OUTPUT_MISSING",
+  SCREEN_RECORDING_SERVER_SHUTTING_DOWN: "SCREEN_RECORDING_SERVER_SHUTTING_DOWN",
+  SCREEN_RECORDING_STREAM_UNAVAILABLE: "SCREEN_RECORDING_STREAM_UNAVAILABLE",
+  SCREEN_RECORDING_FFMPEG_NOT_FOUND: "SCREEN_RECORDING_FFMPEG_NOT_FOUND",
+  FLOW_PROJECT_ROOT_REQUIRED: "FLOW_PROJECT_ROOT_REQUIRED",
+  FLOW_PROJECT_ROOT_INVALID: "FLOW_PROJECT_ROOT_INVALID",
+  FLOW_NAME_INVALID: "FLOW_NAME_INVALID",
+  FLOW_NO_ACTIVE_RECORDING: "FLOW_NO_ACTIVE_RECORDING",
+  FLOW_FILE_INVALID: "FLOW_FILE_INVALID",
+  FLOW_ENTRY_UNRECOGNIZED: "FLOW_ENTRY_UNRECOGNIZED",
+  FLOW_E2E_HAS_PREREQUISITE: "FLOW_E2E_HAS_PREREQUISITE",
+  FLOW_DEVICE_RESOLUTION: "FLOW_DEVICE_RESOLUTION",
+  PROFILER_QUERY_MODE_INVALID: "PROFILER_QUERY_MODE_INVALID",
+  PROFILER_QUERY_REQUIRED_PARAM_MISSING: "PROFILER_QUERY_REQUIRED_PARAM_MISSING",
+  PROFILER_DATA_NOT_LOADED: "PROFILER_DATA_NOT_LOADED",
+  PROFILER_NATIVE_TRACE_MISSING: "PROFILER_NATIVE_TRACE_MISSING",
+  PROFILER_NATIVE_METADATA_MISSING: "PROFILER_NATIVE_METADATA_MISSING",
+  PROFILER_NATIVE_METADATA_INVALID: "PROFILER_NATIVE_METADATA_INVALID",
+  CHROMIUM_CDP_UNREACHABLE: "CHROMIUM_CDP_UNREACHABLE",
+  CHROMIUM_CDP_NO_PAGE_TARGET: "CHROMIUM_CDP_NO_PAGE_TARGET",
+  CHROMIUM_CDP_INVALID_RESPONSE: "CHROMIUM_CDP_INVALID_RESPONSE",
+  CHROMIUM_DEVICE_ID_INVALID: "CHROMIUM_DEVICE_ID_INVALID",
+  CHROMIUM_PARAM_INVALID: "CHROMIUM_PARAM_INVALID",
+  CHROMIUM_INPUT_INVALID: "CHROMIUM_INPUT_INVALID",
+  CHROMIUM_WINDOW_HIDDEN: "CHROMIUM_WINDOW_HIDDEN",
+  CHROMIUM_VIEWPORT_READ_FAILED: "CHROMIUM_VIEWPORT_READ_FAILED",
+  CHROMIUM_SCREENSHOT_FAILED: "CHROMIUM_SCREENSHOT_FAILED",
+  CHROMIUM_STORAGE_EVAL_FAILED: "CHROMIUM_STORAGE_EVAL_FAILED",
+  CHROMIUM_TAB_NOT_FOUND: "CHROMIUM_TAB_NOT_FOUND",
+  CHROMIUM_TAB_OPEN_FAILED: "CHROMIUM_TAB_OPEN_FAILED",
+  CHROMIUM_DESCRIBE_FAILED: "CHROMIUM_DESCRIBE_FAILED",
+  CHROMIUM_ELECTRON_APP_PATH_INVALID: "CHROMIUM_ELECTRON_APP_PATH_INVALID",
+  CHROMIUM_ELECTRON_SPAWN_FAILED: "CHROMIUM_ELECTRON_SPAWN_FAILED",
+  CHROMIUM_ELECTRON_CDP_TIMEOUT: "CHROMIUM_ELECTRON_CDP_TIMEOUT",
+  CHROMIUM_ELECTRON_EXITED_BEFORE_READY: "CHROMIUM_ELECTRON_EXITED_BEFORE_READY",
+  KEYBOARD_KEY_UNSUPPORTED: "KEYBOARD_KEY_UNSUPPORTED",
+  KEYBOARD_CHARACTER_UNSUPPORTED: "KEYBOARD_CHARACTER_UNSUPPORTED",
+  SECRET_PLACEHOLDER_UNKNOWN: "SECRET_PLACEHOLDER_UNKNOWN",
+  SCREENSHOT_DIFF_INPUT_INVALID: "SCREENSHOT_DIFF_INPUT_INVALID",
+  BOOT_DEVICE_TARGET_SELECTION_INVALID: "BOOT_DEVICE_TARGET_SELECTION_INVALID",
+  BOOT_IOS_UNSUPPORTED_HOST: "BOOT_IOS_UNSUPPORTED_HOST",
+  BOOT_ANDROID_NO_AVDS: "BOOT_ANDROID_NO_AVDS",
+  BOOT_ANDROID_AVD_NOT_FOUND: "BOOT_ANDROID_AVD_NOT_FOUND",
+  BOOT_ANDROID_ADB_UNAVAILABLE: "BOOT_ANDROID_ADB_UNAVAILABLE",
+  BOOT_ANDROID_GPU_MODE_INVALID: "BOOT_ANDROID_GPU_MODE_INVALID",
+  BOOT_ANDROID_ADB_REGISTER_TIMEOUT: "BOOT_ANDROID_ADB_REGISTER_TIMEOUT",
+  BOOT_ANDROID_HOT_BOOT_FRAME_UNUSABLE: "BOOT_ANDROID_HOT_BOOT_FRAME_UNUSABLE",
+  BOOT_ANDROID_FIRST_FRAME_TIMEOUT: "BOOT_ANDROID_FIRST_FRAME_TIMEOUT",
+  BOOT_ANDROID_PACKAGE_MANAGER_UNAVAILABLE: "BOOT_ANDROID_PACKAGE_MANAGER_UNAVAILABLE",
+  BOOT_ANDROID_COLD_BOOT_FAILED: "BOOT_ANDROID_COLD_BOOT_FAILED"
+};
+
+// ../registry/src/errors.ts
+var FAILURE_AREAS = ["cli", "http", "registry", "tool_server", "installer"];
+var FAILURE_KINDS = [
+  "validation",
+  "not_found",
+  "dependency_missing",
+  "unsupported",
+  "not_implemented",
+  "timeout",
+  "network",
+  "subprocess",
+  "crash",
+  "unknown"
+];
+var FAILURE_COMMANDS = [
+  "adb",
+  "emulator",
+  "vega",
+  "xcrun_simctl",
+  "xctrace",
+  "native_devtools",
+  "android_devtools",
+  "ax_service",
+  "simulator_server",
+  "ffmpeg",
+  "cdp",
+  "electron",
+  "npm",
+  "npx",
+  "unknown"
+];
+var FAILURE_SIGNAL_NAMES = [
+  "SIGABRT",
+  "SIGHUP",
+  "SIGINT",
+  "SIGKILL",
+  "SIGQUIT",
+  "SIGTERM"
+];
+var FAILURE_SPAWN_CODES = ["EACCES", "ENOENT", "EPERM", "ETIMEDOUT"];
+var NETWORK_FAILURES = [
+  "timeout",
+  "connection_refused",
+  "connection_reset",
+  "invalid_response",
+  "other"
+];
+var FALLBACK_SIGNAL = {
+  error_code: FAILURE_CODES.ARGENT_UNCLASSIFIED_FAILURE,
+  failure_stage: "unclassified",
+  failure_area: "registry",
+  error_kind: "unknown"
+};
+var FAILURE_SIGNAL_NAME_SET = new Set(FAILURE_SIGNAL_NAMES);
+var FAILURE_SPAWN_CODE_SET = new Set(FAILURE_SPAWN_CODES);
+
+// ../registry/src/registry.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// ../argent-tools-client/src/file-inputs.ts
+var FILE_INPUT_MARKER2 = "__argentFileInput";
+var CLIENT_FILE_MARKER2 = "__argentClientFile";
+var MAX_CONTENT_BYTES = 32 * 1024 * 1024;
+function interpolatePath(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;
+}
+async function tarball(sourcePath) {
+  const tarPath = path3.join(tmpdir(), `argent-upload-${randomUUID3()}.tar.gz`);
+  await createTarGzFile(sourcePath, tarPath);
+  return tarPath;
+}
+function sha256File(filePath) {
+  return new Promise((resolve10, reject) => {
+    const hash = createHash2("sha256");
+    createReadStream(filePath).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve10(hash.digest("hex"))).on("error", reject);
+  });
+}
+async function uploadTar(tarPath, endpoint) {
+  const init2 = {
+    method: "POST",
+    headers: {
+      "content-type": "application/gzip",
+      ...endpoint.token ? { Authorization: `Bearer ${endpoint.token}` } : {}
+    },
+    body: createReadStream(tarPath),
+    duplex: "half"
+  };
+  const res = await fetch(`${endpoint.url}/upload`, init2);
+  if (!res.ok) {
+    throw new Error(`Upload to ${endpoint.url}/upload failed: ${res.status} ${res.statusText}`);
+  }
+  const json = await res.json();
+  return json.uploadId;
+}
+async function prepareFileInputs(specs, args, opts) {
+  if (!specs || specs.length === 0 || typeof args !== "object" || args === null) {
+    return args;
+  }
+  const record = args;
+  let out = null;
+  for (const spec of specs) {
+    if (spec.skipWhenSet && record[spec.skipWhenSet] !== void 0) continue;
+    if (spec.target in record && typeof record[spec.target] !== "string") continue;
+    const filePath = interpolatePath(spec.path, record);
+    if (filePath === null) continue;
+    if (spec.target in record && record[spec.target] !== filePath) continue;
+    const wire = { [FILE_INPUT_MARKER2]: true, path: filePath };
+    if (spec.kind === "file") {
+      try {
+        const st = await stat2(filePath);
+        if (st.isFile()) {
+          wire.size = st.size;
+          wire.mtimeMs = st.mtimeMs;
+          if (opts.includeContent && st.size <= MAX_CONTENT_BYTES) {
+            wire.content = (await readFile3(filePath)).toString("base64");
+          } else if (opts.includeContent) {
+            wire.contentOmitted = "size-limit";
+          }
+        }
+      } catch {
+      }
+    }
+    if (spec.kind === "tar-upload") {
+      const st = await stat2(filePath).catch(() => null);
+      if (st) {
+        wire.size = st.size;
+        wire.mtimeMs = st.mtimeMs;
+      }
+      if (opts.uploadEndpoint && st) {
+        let tarPath = null;
+        try {
+          process.stderr.write(
+            `Uploading ${path3.basename(filePath)} to the remote tool-server...
+`
+          );
+          tarPath = await tarball(filePath);
+          wire.contentHash = await sha256File(tarPath);
+          wire.uploadId = await uploadTar(tarPath, opts.uploadEndpoint);
+        } finally {
+          if (tarPath) await rm2(tarPath, { force: true }).catch(() => {
+          });
+        }
+      }
+    }
+    out = out ?? { ...record };
+    out[spec.target] = wire;
+  }
+  return out ?? args;
+}
+function isAllowedClientFilePath(p) {
+  if (!path3.isAbsolute(p)) return false;
+  const segments = p.split(/[\\/]+/);
+  if (segments.includes("..")) return false;
+  const file = segments[segments.length - 1] ?? "";
+  if (!FLOW_FILE_NAME_PATTERN.test(file)) return false;
+  return segments[segments.length - 3] === ".argent" && segments[segments.length - 2] === "flows";
+}
+function isClientFileDirective2(value) {
+  return !!value && typeof value === "object" && value[CLIENT_FILE_MARKER2] === true && typeof value.path === "string" && typeof value.content === "string";
+}
+async function applyClientFileDirectives(result) {
+  const written = [];
+  async function walk(value) {
+    if (isClientFileDirective2(value)) {
+      if (!isAllowedClientFilePath(value.path)) return null;
+      try {
+        await mkdir3(path3.dirname(value.path), { recursive: true });
+        await writeFile3(value.path, value.content, "utf8");
+        written.push(value.path);
+        return value.path;
+      } catch {
+        return null;
+      }
+    }
+    if (Array.isArray(value)) {
+      return Promise.all(value.map(walk));
+    }
+    if (value && typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = await walk(v);
+      }
+      return out;
+    }
+    return value;
+  }
+  const rewritten = await walk(result);
+  return { result: rewritten, written };
+}
+
+// ../argent-tools-client/src/tools-client.ts
+var ToolInvocationError = class extends Error {
+  errorCode;
+  errorKind;
+  constructor(message, signal) {
+    super(message);
+    this.name = "ToolInvocationError";
+    this.errorCode = signal?.errorCode;
+    this.errorKind = signal?.errorKind;
+  }
+};
+function authHeaders2(token) {
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}
+async function consumeToolStream(body, onProgress) {
+  let final;
+  const handleLine = (line) => {
+    if (!line.trim()) return;
+    const msg = JSON.parse(line);
+    if (msg.event === "progress") onProgress(msg.data);
+    else if (msg.event === "result") final = { data: msg.data, note: msg.note };
+    else if (msg.event === "error") {
+      throw new ToolInvocationError(msg.error ?? "tool invocation failed", {
+        errorCode: msg.error_code,
+        errorKind: msg.error_kind
+      });
+    }
+  };
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffered += decoder.decode(value, { stream: true });
+      let newline;
+      while ((newline = buffered.indexOf("\n")) !== -1) {
+        const line = buffered.slice(0, newline);
+        buffered = buffered.slice(newline + 1);
+        handleLine(line);
+      }
+    }
+    buffered += decoder.decode();
+    if (buffered.trim()) handleLine(buffered);
+  } catch (err) {
+    void reader.cancel().catch(() => {
+    });
+    throw err;
+  }
+  if (!final) {
+    throw new Error("tool stream ended without a result \u2014 connection lost mid-run?");
+  }
+  const { result: data } = await applyClientFileDirectives(final.data);
+  return { data, note: final.note };
+}
+function createToolsClient(options = {}) {
+  let cached2 = null;
+  async function baseUrl() {
+    const resolved = await getResolvedToolsUrl();
+    if (resolved.url) {
+      return { url: resolved.url, token: resolved.token ?? "" };
+    }
     if (cached2) return cached2;
     if (!options.paths) {
       throw new Error(
@@ -1091,7 +1748,13 @@ function createToolsClient(options = {}) {
     }
     const json = await res.json().catch(() => ({}));
     if (!res.ok) {
-      throw new Error(json.error ?? json.message ?? `${res.status} ${res.statusText}`);
+      throw new ToolInvocationError(
+        json.error ?? json.message ?? `${res.status} ${res.statusText}`,
+        {
+          errorCode: json.error_code,
+          errorKind: json.error_kind
+        }
+      );
     }
     const { result: data } = await applyClientFileDirectives(json.data);
     return { data, note: json.note };
@@ -1100,10 +1763,10 @@ function createToolsClient(options = {}) {
 }
 
 // ../argent-tools-client/src/artifacts.ts
-import { copyFile, mkdir as mkdir4, readFile as readFile4, realpath, rm as rm3, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
+import { copyFile, mkdir as mkdir4, readFile as readFile4, realpath, rm as rm3, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { basename as basename3, dirname as dirname5, extname, isAbsolute as isAbsolute3, join as join8, normalize, resolve as resolve5, sep as sep2 } from "node:path";
+import { basename as basename4, dirname as dirname5, extname as extname2, isAbsolute as isAbsolute3, join as join9, normalize, resolve as resolve6, sep as sep2 } from "node:path";
 import { createHash as createHash3 } from "node:crypto";
 
 // ../configuration-core/src/flags.ts
@@ -1304,15 +1967,20 @@ function setAtPath(obj, dottedKey, value) {
 }
 function deleteAtPath(obj, dottedKey) {
   const parts = splitKey(dottedKey);
-  let cur = obj;
+  const chain = [obj];
   for (let i2 = 0; i2 < parts.length - 1; i2++) {
-    const next = cur[parts[i2]];
+    const next = chain[i2][parts[i2]];
     if (!isPlainObject(next)) return false;
-    cur = next;
+    chain.push(next);
   }
+  const parent = chain[parts.length - 1];
   const leaf = parts[parts.length - 1];
-  if (!Object.hasOwn(cur, leaf)) return false;
-  delete cur[leaf];
+  if (!Object.hasOwn(parent, leaf)) return false;
+  delete parent[leaf];
+  for (let i2 = chain.length - 1; i2 >= 1; i2--) {
+    if (Object.keys(chain[i2]).length > 0) break;
+    delete chain[i2 - 1][parts[i2 - 1]];
+  }
   return true;
 }
 var LOCK_STALE_MS2 = 1e4;
@@ -1387,6 +2055,97 @@ function updateConfig(mutate, scope = "global", options = {}) {
   }
 }
 
+// ../configuration-core/src/secrets.ts
+var import_dotenv = __toESM(require_main(), 1);
+import * as fs4 from "node:fs";
+import * as path7 from "node:path";
+var SECRET_ENV_PREFIX = "ARGENT_SECRET_";
+var SECRETS_FILE_NAME = "secrets.env";
+var SHARED_ENV_FILES = [".env.local", ".env"];
+var SECRET_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function envSource(env) {
+  const values = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(env)) {
+    if (value === void 0 || !key.startsWith(SECRET_ENV_PREFIX)) continue;
+    const name = key.slice(SECRET_ENV_PREFIX.length);
+    if (SECRET_NAME_RE.test(name)) values.set(name, value);
+  }
+  return {
+    label: `environment (${SECRET_ENV_PREFIX}*)`,
+    kind: "env",
+    present: true,
+    names: [...values.keys()].sort(),
+    values
+  };
+}
+function fileSource(filePath, exposure) {
+  const label = filePath;
+  const absent = {
+    label,
+    kind: "file",
+    present: false,
+    names: [],
+    values: /* @__PURE__ */ new Map()
+  };
+  if (!fs4.statSync(filePath, { throwIfNoEntry: false })) return absent;
+  let content;
+  try {
+    content = fs4.readFileSync(filePath, "utf8");
+  } catch {
+    return absent;
+  }
+  const values = /* @__PURE__ */ new Map();
+  let skippedUnprefixed = false;
+  for (const [key, value] of Object.entries((0, import_dotenv.parse)(content))) {
+    const prefixed = key.startsWith(SECRET_ENV_PREFIX);
+    if (exposure === "shared" && !prefixed) {
+      skippedUnprefixed = true;
+      continue;
+    }
+    const name = prefixed ? key.slice(SECRET_ENV_PREFIX.length) : key;
+    if (SECRET_NAME_RE.test(name)) values.set(name, value);
+  }
+  return {
+    label,
+    kind: "file",
+    present: true,
+    names: [...values.keys()].sort(),
+    values,
+    ...values.size === 0 && skippedUnprefixed ? { needsPrefix: true } : {}
+  };
+}
+function secretSources(options = {}) {
+  const sources = [envSource(options.env ?? process.env)];
+  const projectRoot = findProjectRoot(options.cwd ?? process.cwd());
+  const filePaths = [];
+  if (projectRoot) {
+    filePaths.push({
+      path: path7.join(projectRoot, ".argent", SECRETS_FILE_NAME),
+      exposure: "dedicated"
+    });
+    for (const name of SHARED_ENV_FILES) {
+      filePaths.push({ path: path7.join(projectRoot, name), exposure: "shared" });
+    }
+  }
+  filePaths.push({
+    path: path7.join(resolveHomeDir(options), ".argent", SECRETS_FILE_NAME),
+    exposure: "dedicated"
+  });
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of filePaths) {
+    const resolved = path7.resolve(entry.path);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    sources.push(fileSource(resolved, entry.exposure));
+  }
+  return sources;
+}
+function secretNames(sources) {
+  const names = /* @__PURE__ */ new Set();
+  for (const source of sources) for (const name of source.names) names.add(name);
+  return [...names].sort();
+}
+
 // ../configuration-core/src/merge.ts
 function mergeRestrictive(local, global2) {
   if (local === void 0) return global2;
@@ -1447,6 +2206,9 @@ function asString(raw) {
   const trimmed = raw.trim();
   return trimmed === "" ? void 0 : trimmed;
 }
+function asNumber(raw) {
+  return typeof raw === "number" && Number.isFinite(raw) ? raw : void 0;
+}
 function asStringArray(raw) {
   if (!Array.isArray(raw)) return void 0;
   const out = [];
@@ -1455,6 +2217,15 @@ function asStringArray(raw) {
   }
   return out;
 }
+var PARSER_EXPECTATIONS = /* @__PURE__ */ new Map([
+  [asBoolean, "a boolean (true or false)"],
+  [asString, "a non-empty string"],
+  [asNumber, "a number"],
+  [asStringArray, "an array of strings"]
+]);
+function describeExpectedValue(def) {
+  return def.expected ?? PARSER_EXPECTATIONS.get(def.parse);
+}
 var CONFIG_SCHEMA = [
   {
     key: "telemetry.enabled",
@@ -1512,7 +2283,7 @@ function getConfigDefinition(key, registry = CONFIG_SCHEMA) {
 }
 
 // ../configuration-core/src/config-access.ts
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 function readScopeValue(def, scope, options) {
   if (!def.scopes.includes(scope)) return void 0;
   const raw = getAtPath(readConfigObject(scope, options), def.key);
@@ -1560,12 +2331,18 @@ var ConfigScopeError = class extends Error {
   allowed;
 };
 var ConfigValidationError = class extends Error {
-  constructor(key) {
-    super(`Invalid value for config key "${key}".`);
+  constructor(key, expected, example) {
+    super(
+      expected ? `Invalid value for config key "${key}": expected ${expected}.` : `Invalid value for config key "${key}".`
+    );
     this.key = key;
+    this.expected = expected;
+    this.example = example;
     this.name = "ConfigValidationError";
   }
   key;
+  expected;
+  example;
 };
 var ConfigManagedElsewhereError = class extends Error {
   constructor(key, command) {
@@ -1582,7 +2359,8 @@ function setConfigValue(key, rawValue, scope = "global", options = {}, registry
   if (def.manageCommand) throw new ConfigManagedElsewhereError(key, def.manageCommand);
   if (!def.scopes.includes(scope)) throw new ConfigScopeError(key, scope, def.scopes);
   const parsed = def.parse(rawValue);
-  if (parsed === void 0) throw new ConfigValidationError(key);
+  if (parsed === void 0)
+    throw new ConfigValidationError(def.key, describeExpectedValue(def), def.example);
   updateConfig((config2) => setAtPath(config2, key, parsed), scope, options);
   return parsed;
 }
@@ -1607,6 +2385,8 @@ function listConfig(options = {}, registry = CONFIG_SCHEMA) {
     description: def.description,
     scopes: def.scopes,
     ...def.manageCommand ? { manageCommand: def.manageCommand } : {},
+    ...describeExpectedValue(def) ? { expected: describeExpectedValue(def) } : {},
+    ...def.example ? { example: def.example } : {},
     effective: getConfigValue(def, options),
     project: readScopeValue(def, "project", options),
     global: readScopeValue(def, "global", options)
@@ -1632,9 +2412,9 @@ function clearRememberedAgent(options = {}) {
 }
 
 // ../argent-tools-client/src/artifacts.ts
-var ARTIFACT_MARKER = "__argentArtifact";
+var ARTIFACT_MARKER2 = "__argentArtifact";
 function isArtifactHandle(value) {
-  return !!value && typeof value === "object" && value[ARTIFACT_MARKER] === true && typeof value.id === "string" && typeof value.filename === "string";
+  return !!value && typeof value === "object" && value[ARTIFACT_MARKER2] === true && typeof value.id === "string" && typeof value.filename === "string";
 }
 var SESSION_ID = null;
 function sessionId() {
@@ -1650,16 +2430,16 @@ function sanitizeSegment(segment) {
 function projectSlug() {
   const cwd = process.cwd();
   const hash = createHash3("sha1").update(cwd).digest("hex").slice(0, 6);
-  const name = sanitizeSegment(basename3(cwd)) || "root";
+  const name = sanitizeSegment(basename4(cwd)) || "root";
   return `${name}-${hash}`;
 }
 function artifactsRoot() {
-  return process.env.ARGENT_ARTIFACTS_DIR ?? join8(tmpdir2(), "argent-artifacts");
+  return process.env.ARGENT_ARTIFACTS_DIR ?? join9(tmpdir2(), "argent-artifacts");
 }
 function artifactDir(deviceId) {
   const parts = [artifactsRoot(), projectSlug(), sessionId()];
   if (deviceId) parts.push(sanitizeSegment(deviceId));
-  return join8(...parts);
+  return join9(...parts);
 }
 function durableBaseDir() {
   const projectRoot = findProjectRoot(process.cwd());
@@ -1678,8 +2458,8 @@ function configuredRecordingsDir() {
   const trimmed = value.trim();
   if (trimmed === "") return null;
   const home = dirname5(argentHomeDir());
-  const expanded = trimmed === "~" ? home : trimmed.startsWith("~/") || trimmed.startsWith(`~${sep2}`) ? join8(home, trimmed.slice(2)) : trimmed;
-  return resolve5(durableBaseDir(), expanded);
+  const expanded = trimmed === "~" ? home : trimmed.startsWith("~/") || trimmed.startsWith(`~${sep2}`) ? join9(home, trimmed.slice(2)) : trimmed;
+  return resolve6(durableBaseDir(), expanded);
 }
 var MAX_DURABLE_BYTES = 2 * 1024 * 1024 * 1024;
 async function readCapped(res, cap) {
@@ -1708,14 +2488,14 @@ async function readCapped(res, cap) {
   return Buffer.concat(chunks);
 }
 async function writeDurableUnique(dir, filename, write) {
-  const ext = extname(filename);
+  const ext = extname2(filename);
   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 path16 = join8(dir, candidate);
+    const path17 = join9(dir, candidate);
     try {
-      await write(path16);
-      return path16;
+      await write(path17);
+      return path17;
     } catch (err) {
       if (err?.code === "EEXIST") continue;
       throw err;
@@ -1735,21 +2515,21 @@ function durableSaveTarget(handle) {
     if (configured) {
       return {
         dir: configured,
-        path: join8(configured, sanitizeSegment(handle.filename)),
+        path: join9(configured, sanitizeSegment(handle.filename)),
         base: configured,
         rel: ""
       };
     }
   }
   const base = durableBaseDir();
-  const dir = join8(base, rel);
-  return { dir, path: join8(dir, sanitizeSegment(handle.filename)), base, rel };
+  const dir = join9(base, rel);
+  return { dir, path: join9(dir, sanitizeSegment(handle.filename)), base, rel };
 }
 async function confineToRealBase(dir, base, rel) {
   try {
     const realDir = await realpath(dir);
     const realBase = await realpath(base);
-    return realDir === join8(realBase, rel);
+    return realDir === join9(realBase, rel);
   } catch {
     return false;
   }
@@ -1757,7 +2537,7 @@ async function confineToRealBase(dir, base, rel) {
 async function resolveLocalFile(handle) {
   if (!handle.hostPath) return null;
   try {
-    const st = await stat2(handle.hostPath);
+    const st = await stat3(handle.hostPath);
     if (handle.archive) {
       return st.isDirectory() ? handle.hostPath : null;
     }
@@ -1772,7 +2552,7 @@ async function resolveLocalFile(handle) {
   }
 }
 async function downloadAndExtractArchive(handle, data, dir) {
-  const tarball2 = join8(dir, `${sanitizeSegment(handle.filename)}.tar.gz`);
+  const tarball2 = join9(dir, `${sanitizeSegment(handle.filename)}.tar.gz`);
   try {
     await writeFile4(tarball2, data);
     return await safeExtractTarGz(tarball2, dir, handle.filename);
@@ -1800,7 +2580,7 @@ async function materializeArtifacts(result, ctx) {
       const localPath = await resolveLocalFile(value);
       const saveTarget = durableSaveTarget(value);
       if (saveTarget) {
-        const filename = basename3(saveTarget.path);
+        const filename = basename4(saveTarget.path);
         try {
           await mkdir4(saveTarget.dir, { recursive: true });
           if (!await confineToRealBase(saveTarget.dir, saveTarget.base, saveTarget.rel)) {
@@ -1862,7 +2642,7 @@ async function materializeArtifacts(result, ctx) {
           return await downloadAndExtractArchive(value, data, dir);
         }
         if (value.size > 0 && data.length !== value.size) return null;
-        const downloadedPath = join8(dir, sanitizeSegment(value.filename));
+        const downloadedPath = join9(dir, sanitizeSegment(value.filename));
         await writeFile4(downloadedPath, data);
         if (value.mimeType.startsWith("image/")) {
           images.push({ localPath: downloadedPath, data, mimeType: value.mimeType });
@@ -1922,8 +2702,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? dirname6(proce
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path16) {
-  return path16.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path17) {
+  return path17.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 
 // ../../node_modules/@posthog/core/dist/featureFlagUtils.mjs
@@ -4475,15 +5255,15 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path16, ranges, output) {
-  return new Promise((resolve9) => {
-    const stream = createReadStream2(path16);
+function getContextLinesFromFile(path17, ranges, output) {
+  return new Promise((resolve10) => {
+    const stream = createReadStream2(path17);
     const lineReaded = createInterface2({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve9();
+      resolve10();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -4492,7 +5272,7 @@ function getContextLinesFromFile(path16, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path16, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path17, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -4553,8 +5333,8 @@ function clearLineContext(frame) {
   delete frame.context_line;
   delete frame.post_context;
 }
-function shouldSkipContextLinesForFile(path16) {
-  return path16.startsWith("node:") || path16.endsWith(".min.js") || path16.endsWith(".min.cjs") || path16.endsWith(".min.mjs") || path16.startsWith("data:");
+function shouldSkipContextLinesForFile(path17) {
+  return path17.startsWith("node:") || path17.endsWith(".min.js") || path17.endsWith(".min.cjs") || path17.endsWith(".min.mjs") || path17.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame) {
   if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
@@ -5780,9 +6560,9 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     if (!waitUntil) return;
     if (this.disabled || this.optedOut) return;
     if (!this._waitUntilCycle) {
-      let resolve9;
+      let resolve10;
       const promise = new Promise((r2) => {
-        resolve9 = r2;
+        resolve10 = r2;
       });
       try {
         waitUntil(promise);
@@ -5790,7 +6570,7 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
         return;
       }
       this._waitUntilCycle = {
-        resolve: resolve9,
+        resolve: resolve10,
         startedAt: Date.now(),
         timer: void 0
       };
@@ -5814,12 +6594,12 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     return cycle?.resolve;
   }
   async resolveWaitUntilFlush() {
-    const resolve9 = this._consumeWaitUntilCycle();
+    const resolve10 = this._consumeWaitUntilCycle();
     try {
       await super.flush();
     } catch {
     } finally {
-      resolve9?.();
+      resolve10?.();
     }
   }
   getPersistedProperty(key) {
@@ -5940,15 +6720,15 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
   async waitForLocalEvaluationReady(timeoutMs = THIRTY_SECONDS) {
     if (this.isLocalEvaluationReady()) return true;
     if (void 0 === this.featureFlagsPoller) return false;
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       const timeout = setTimeout(() => {
         cleanup();
-        resolve9(false);
+        resolve10(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count) => {
         clearTimeout(timeout);
         cleanup();
-        resolve9(count > 0);
+        resolve10(count > 0);
       });
     });
   }
@@ -6403,14 +7183,14 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     this.context?.enter(data, options);
   }
   async _shutdown(shutdownTimeoutMs) {
-    const resolve9 = this._consumeWaitUntilCycle();
+    const resolve10 = this._consumeWaitUntilCycle();
     await this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
     this.errorTracking.shutdown();
     try {
       return await super._shutdown(shutdownTimeoutMs);
     } finally {
       this.distinctIdHasSentFlagCalls = {};
-      resolve9?.();
+      resolve10?.();
     }
   }
   async _requestRemoteConfigPayload(flagKey) {
@@ -6649,452 +7429,142 @@ var PostHogContext = class {
       properties: {
         ...current.properties || {},
         ...context.properties || {}
-      }
-    };
-  }
-};
-
-// ../../node_modules/posthog-node/dist/extensions/sentry-integration.mjs
-var NAME = "posthog-node";
-function createEventProcessor(_posthog, { organization, projectId, prefix, severityAllowList = [
-  "error"
-], sendExceptionsToPostHog = true } = {}) {
-  return (event) => {
-    const shouldProcessLevel = "*" === severityAllowList || severityAllowList.includes(event.level);
-    if (!shouldProcessLevel) return event;
-    if (!event.tags) event.tags = {};
-    const userId = event.tags[PostHogSentryIntegration.POSTHOG_ID_TAG];
-    if (void 0 === userId) return event;
-    const uiHost = _posthog.options.host ?? "https://us.i.posthog.com";
-    const personUrl = new URL(`/project/${_posthog.apiKey}/person/${userId}`, uiHost).toString();
-    event.tags["PostHog Person URL"] = personUrl;
-    const exceptions = event.exception?.values || [];
-    const exceptionList = exceptions.map((exception) => ({
-      ...exception,
-      stacktrace: exception.stacktrace ? {
-        ...exception.stacktrace,
-        type: "raw",
-        frames: (exception.stacktrace.frames || []).map((frame) => ({
-          ...frame,
-          platform: "node:javascript"
-        }))
-      } : void 0
-    }));
-    const properties = {
-      $exception_message: exceptions[0]?.value || event.message,
-      $exception_type: exceptions[0]?.type,
-      $exception_level: event.level,
-      $exception_list: exceptionList,
-      $sentry_event_id: event.event_id,
-      $sentry_exception: event.exception,
-      $sentry_exception_message: exceptions[0]?.value || event.message,
-      $sentry_exception_type: exceptions[0]?.type,
-      $sentry_tags: event.tags
-    };
-    if (organization && projectId) properties["$sentry_url"] = (prefix || "https://sentry.io/organizations/") + organization + "/issues/?project=" + projectId + "&query=" + event.event_id;
-    if (sendExceptionsToPostHog) _posthog.capture({
-      event: "$exception",
-      distinctId: userId,
-      properties
-    });
-    return event;
-  };
-}
-var PostHogSentryIntegration = class {
-  static #_ = this.POSTHOG_ID_TAG = "posthog_distinct_id";
-  constructor(_posthog, organization, prefix, severityAllowList, sendExceptionsToPostHog) {
-    this.name = NAME;
-    this.name = NAME;
-    this.setupOnce = function(addGlobalEventProcessor, getCurrentHub) {
-      const projectId = getCurrentHub()?.getClient()?.getDsn()?.projectId;
-      addGlobalEventProcessor(createEventProcessor(_posthog, {
-        organization,
-        projectId,
-        prefix,
-        severityAllowList,
-        sendExceptionsToPostHog: sendExceptionsToPostHog ?? true
-      }));
-    };
-  }
-};
-
-// ../../node_modules/posthog-node/dist/entrypoints/index.node.mjs
-var PostHog = class extends PostHogBackendClient {
-  getLibraryId() {
-    return "posthog-node";
-  }
-  initializeContext() {
-    return new PostHogContext();
-  }
-  createErrorPropertiesBuilder() {
-    return new error_tracking_exports.ErrorPropertiesBuilder([
-      new error_tracking_exports.EventCoercer(),
-      new error_tracking_exports.ErrorCoercer(),
-      new error_tracking_exports.ObjectCoercer(),
-      new error_tracking_exports.StringCoercer(),
-      new error_tracking_exports.PrimitiveCoercer()
-    ], error_tracking_exports.createStackParser("node:javascript", error_tracking_exports.nodeStackLineParser), [
-      createModulerModifier(),
-      addSourceContext,
-      createRelativePathModifier()
-    ]);
-  }
-};
-
-// ../telemetry/src/posthog.ts
-var POSTHOG_HOST = "https://eu.i.posthog.com";
-var POSTHOG_PROJECT_TOKEN = "phc_mebZhuUmASbeeXkdv7E2wqTZdtstPxQqHBhZfLSeQ5YL";
-function readProjectToken() {
-  const g = globalThis;
-  const override = g.__ARGENT_POSTHOG_KEY_TEST;
-  if (typeof override === "string") return override;
-  return POSTHOG_PROJECT_TOKEN;
-}
-function resolveConfig() {
-  const key = readProjectToken();
-  const isUsable = key !== "" && key !== "phc_disabled" && key.startsWith("phc_");
-  return { key, isUsable };
-}
-var client;
-function getClient() {
-  if (client !== void 0) return client;
-  const config2 = resolveConfig();
-  if (!config2.isUsable) {
-    client = null;
-    return null;
-  }
-  const opts = {
-    host: POSTHOG_HOST,
-    disableGeoip: true,
-    requestTimeout: 3e3,
-    flushAt: 20,
-    flushInterval: 1e4,
-    fetchRetryCount: 0
-  };
-  try {
-    client = new PostHog(config2.key, opts);
-  } catch {
-    client = null;
-    return null;
-  }
-  return client;
-}
-function getConstructedClient() {
-  return client ?? null;
-}
-function resetClient() {
-  client = void 0;
-}
-
-// ../registry/src/artifacts.ts
-import { stat as stat3 } from "node:fs/promises";
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { basename as basename4, extname as extname2 } from "node:path";
+      }
+    };
+  }
+};
 
-// ../registry/src/failure-codes.ts
-var FAILURE_CODES = {
-  ARGENT_UNCLASSIFIED_FAILURE: "ARGENT_UNCLASSIFIED_FAILURE",
-  REGISTRY_SERVICE_NOT_FOUND: "REGISTRY_SERVICE_NOT_FOUND",
-  REGISTRY_SERVICE_INITIALIZATION_FAILED: "REGISTRY_SERVICE_INITIALIZATION_FAILED",
-  REGISTRY_TOOL_NOT_FOUND: "REGISTRY_TOOL_NOT_FOUND",
-  REGISTRY_TOOL_EXECUTION_FAILED: "REGISTRY_TOOL_EXECUTION_FAILED",
-  REGISTRY_TOOL_FAILURE_UNCLASSIFIED: "REGISTRY_TOOL_FAILURE_UNCLASSIFIED",
-  HTTP_TOOL_NOT_FOUND: "HTTP_TOOL_NOT_FOUND",
-  HTTP_ZOD_VALIDATION_FAILED: "HTTP_ZOD_VALIDATION_FAILED",
-  HTTP_CAPABILITY_UNSUPPORTED_OPERATION: "HTTP_CAPABILITY_UNSUPPORTED_OPERATION",
-  HTTP_DEVICE_RESOLUTION_FAILED: "HTTP_DEVICE_RESOLUTION_FAILED",
-  HTTP_DEPENDENCY_PREFLIGHT_MISSING: "HTTP_DEPENDENCY_PREFLIGHT_MISSING",
-  CLI_RUN_TOOL_NOT_FOUND: "CLI_RUN_TOOL_NOT_FOUND",
-  CLI_RUN_FLAG_PARSE_FAILED: "CLI_RUN_FLAG_PARSE_FAILED",
-  CLI_RUN_ARGS_NOT_OBJECT: "CLI_RUN_ARGS_NOT_OBJECT",
-  CLI_RUN_ARGS_JSON_INVALID: "CLI_RUN_ARGS_JSON_INVALID",
-  CLI_RUN_TOOL_CALL_FAILED: "CLI_RUN_TOOL_CALL_FAILED",
-  CLI_RUN_SAVE_IMAGE_FAILED: "CLI_RUN_SAVE_IMAGE_FAILED",
-  TOOL_CAPABILITY_UNSUPPORTED_OPERATION: "TOOL_CAPABILITY_UNSUPPORTED_OPERATION",
-  TOOL_PLATFORM_NOT_IMPLEMENTED: "TOOL_PLATFORM_NOT_IMPLEMENTED",
-  TOOL_DEPENDENCY_MISSING: "TOOL_DEPENDENCY_MISSING",
-  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
-  TOOLSERVER_UNHANDLED_REJECTION: "TOOLSERVER_UNHANDLED_REJECTION",
-  TOOLSERVER_UNCAUGHT_EXCEPTION: "TOOLSERVER_UNCAUGHT_EXCEPTION",
-  INSTALL_GLOBAL_PACKAGE_FAILED: "INSTALL_GLOBAL_PACKAGE_FAILED",
-  INSTALL_LOCAL_PACKAGE_FAILED: "INSTALL_LOCAL_PACKAGE_FAILED",
-  INSTALL_LOCAL_PRECONDITION_FAILED: "INSTALL_LOCAL_PRECONDITION_FAILED",
-  INSTALL_MODE_FLAG_CONFLICT: "INSTALL_MODE_FLAG_CONFLICT",
-  INSTALL_FROM_TAR_PACKAGE_FAILED: "INSTALL_FROM_TAR_PACKAGE_FAILED",
-  INSTALL_INIT_TRIGGERED_UPDATE_FAILED: "INSTALL_INIT_TRIGGERED_UPDATE_FAILED",
-  INSTALL_SKILLS_REFRESH_FAILED: "INSTALL_SKILLS_REFRESH_FAILED",
-  INSTALL_UNCLASSIFIED_FAILED: "INSTALL_UNCLASSIFIED_FAILED",
-  UPDATE_INSTALLED_VERSION_DETECT_FAILED: "UPDATE_INSTALLED_VERSION_DETECT_FAILED",
-  UPDATE_INVALID_TARGET_VERSION: "UPDATE_INVALID_TARGET_VERSION",
-  UPDATE_REGISTRY_CHECK_FAILED: "UPDATE_REGISTRY_CHECK_FAILED",
-  UPDATE_TOOLSERVER_STOP_FAILED: "UPDATE_TOOLSERVER_STOP_FAILED",
-  UPDATE_PACKAGE_ACTION_FAILED: "UPDATE_PACKAGE_ACTION_FAILED",
-  UPDATE_UNCLASSIFIED_FAILED: "UPDATE_UNCLASSIFIED_FAILED",
-  UNINSTALL_TOOLSERVER_STOP_FAILED: "UNINSTALL_TOOLSERVER_STOP_FAILED",
-  UNINSTALL_PACKAGE_ACTION_FAILED: "UNINSTALL_PACKAGE_ACTION_FAILED",
-  UNINSTALL_UNCLASSIFIED_FAILED: "UNINSTALL_UNCLASSIFIED_FAILED",
-  VEGA_CLI_COMMAND_FAILED: "VEGA_CLI_COMMAND_FAILED",
-  VEGA_INPUT_UNAVAILABLE: "VEGA_INPUT_UNAVAILABLE",
-  VEGA_DEVICE_NOT_FOUND: "VEGA_DEVICE_NOT_FOUND",
-  VEGA_DEVICE_NOT_REGISTERED: "VEGA_DEVICE_NOT_REGISTERED",
-  VEGA_MULTIPLE_DEVICES: "VEGA_MULTIPLE_DEVICES",
-  VEGA_BOOT_TIMEOUT: "VEGA_BOOT_TIMEOUT",
-  VEGA_IMAGE_NOT_FOUND: "VEGA_IMAGE_NOT_FOUND",
-  VEGA_ALREADY_RUNNING: "VEGA_ALREADY_RUNNING",
-  VEGA_SCREENSHOT_FAILED: "VEGA_SCREENSHOT_FAILED",
-  VEGA_TEXT_INVALID: "VEGA_TEXT_INVALID",
-  ANDROID_ADB_NOT_FOUND: "ANDROID_ADB_NOT_FOUND",
-  ANDROID_EMULATOR_NOT_FOUND: "ANDROID_EMULATOR_NOT_FOUND",
-  ANDROID_ADB_COMMAND_FAILED: "ANDROID_ADB_COMMAND_FAILED",
-  ANDROID_ADB_BOOT_TERMINAL_STATE: "ANDROID_ADB_BOOT_TERMINAL_STATE",
-  ANDROID_ADB_BOOT_TIMEOUT: "ANDROID_ADB_BOOT_TIMEOUT",
-  SIMULATOR_NETWORK_TIMEOUT: "SIMULATOR_NETWORK_TIMEOUT",
-  SIMULATOR_NETWORK_CONNECTION_REFUSED: "SIMULATOR_NETWORK_CONNECTION_REFUSED",
-  SIMULATOR_NETWORK_CONNECTION_RESET: "SIMULATOR_NETWORK_CONNECTION_RESET",
-  SIMULATOR_NETWORK_ERROR: "SIMULATOR_NETWORK_ERROR",
-  SIMULATOR_NON_JSON_RESPONSE: "SIMULATOR_NON_JSON_RESPONSE",
-  SIMULATOR_HTTP_ERROR_RESPONSE: "SIMULATOR_HTTP_ERROR_RESPONSE",
-  SIMULATOR_MISSING_RESPONSE_FIELDS: "SIMULATOR_MISSING_RESPONSE_FIELDS",
-  SIMULATOR_SCREENSHOT_FAILED: "SIMULATOR_SCREENSHOT_FAILED",
-  SIMULATOR_SERVER_FACTORY_OPTIONS_MISSING: "SIMULATOR_SERVER_FACTORY_OPTIONS_MISSING",
-  SIMULATOR_SERVER_DEVICE_ID_INVALID: "SIMULATOR_SERVER_DEVICE_ID_INVALID",
-  SIMULATOR_SERVER_READY_EXITED: "SIMULATOR_SERVER_READY_EXITED",
-  SIMULATOR_SERVER_READY_TIMEOUT: "SIMULATOR_SERVER_READY_TIMEOUT",
-  SIMULATOR_SERVER_PROCESS_ERROR: "SIMULATOR_SERVER_PROCESS_ERROR",
-  SIMULATOR_SERVER_TERMINATED: "SIMULATOR_SERVER_TERMINATED",
-  AX_QUERY_TIMEOUT: "AX_QUERY_TIMEOUT",
-  AX_DAEMON_READY_TIMEOUT: "AX_DAEMON_READY_TIMEOUT",
-  AX_DAEMON_EXITED_BEFORE_READY: "AX_DAEMON_EXITED_BEFORE_READY",
-  AX_DAEMON_PROCESS_ERROR: "AX_DAEMON_PROCESS_ERROR",
-  AX_FACTORY_OPTIONS_MISSING: "AX_FACTORY_OPTIONS_MISSING",
-  AX_WRONG_PLATFORM: "AX_WRONG_PLATFORM",
-  AX_DEVICE_ID_INVALID: "AX_DEVICE_ID_INVALID",
-  AX_DESCRIBE_ERROR: "AX_DESCRIBE_ERROR",
-  AX_QUERY_FAILED: "AX_QUERY_FAILED",
-  ANDROID_LAUNCH_ACTIVITY_RESOLVE_FAILED: "ANDROID_LAUNCH_ACTIVITY_RESOLVE_FAILED",
-  ANDROID_LAUNCH_AM_START_FAILED: "ANDROID_LAUNCH_AM_START_FAILED",
-  ANDROID_OPEN_URL_FAILED: "ANDROID_OPEN_URL_FAILED",
-  ANDROID_REINSTALL_INSTALL_FAILED: "ANDROID_REINSTALL_INSTALL_FAILED",
-  ANDROID_RESTART_FAILED: "ANDROID_RESTART_FAILED",
-  ANDROID_SETTINGS_PERMISSION_FAILED: "ANDROID_SETTINGS_PERMISSION_FAILED",
-  IOS_LAUNCH_SIMCTL_FAILED: "IOS_LAUNCH_SIMCTL_FAILED",
-  IOS_OPEN_URL_FAILED: "IOS_OPEN_URL_FAILED",
-  IOS_REINSTALL_INSTALL_FAILED: "IOS_REINSTALL_INSTALL_FAILED",
-  IOS_RESTART_LAUNCH_FAILED: "IOS_RESTART_LAUNCH_FAILED",
-  IOS_SETTINGS_PERMISSION_FAILED: "IOS_SETTINGS_PERMISSION_FAILED",
-  SETTINGS_PERMISSION_UNSUPPORTED: "SETTINGS_PERMISSION_UNSUPPORTED",
-  NATIVE_DEVTOOLS_DESCRIBE_ERROR: "NATIVE_DEVTOOLS_DESCRIBE_ERROR",
-  NATIVE_DEVTOOLS_VIEW_AT_POINT_ERROR: "NATIVE_DEVTOOLS_VIEW_AT_POINT_ERROR",
-  NATIVE_DEVTOOLS_USER_INTERACTABLE_VIEW_AT_POINT_ERROR: "NATIVE_DEVTOOLS_USER_INTERACTABLE_VIEW_AT_POINT_ERROR",
-  NATIVE_DEVTOOLS_FIND_VIEWS_ERROR: "NATIVE_DEVTOOLS_FIND_VIEWS_ERROR",
-  NATIVE_DEVTOOLS_FACTORY_OPTIONS_MISSING: "NATIVE_DEVTOOLS_FACTORY_OPTIONS_MISSING",
-  NATIVE_DEVTOOLS_WRONG_PLATFORM: "NATIVE_DEVTOOLS_WRONG_PLATFORM",
-  NATIVE_DEVTOOLS_NOT_INJECTABLE: "NATIVE_DEVTOOLS_NOT_INJECTABLE",
-  NATIVE_DEVTOOLS_NOT_CONNECTED: "NATIVE_DEVTOOLS_NOT_CONNECTED",
-  NATIVE_DEVTOOLS_RPC_TIMEOUT: "NATIVE_DEVTOOLS_RPC_TIMEOUT",
-  NATIVE_DEVTOOLS_RPC_ERROR: "NATIVE_DEVTOOLS_RPC_ERROR",
-  NATIVE_DEVTOOLS_SERVICE_DISPOSED: "NATIVE_DEVTOOLS_SERVICE_DISPOSED",
-  NATIVE_DEVTOOLS_SOCKET_BIND_FAILED: "NATIVE_DEVTOOLS_SOCKET_BIND_FAILED",
-  NATIVE_TARGET_NO_CONNECTED_APPS: "NATIVE_TARGET_NO_CONNECTED_APPS",
-  NATIVE_TARGET_SINGLE_APP_NOT_FOREGROUND: "NATIVE_TARGET_SINGLE_APP_NOT_FOREGROUND",
-  NATIVE_TARGET_MULTIPLE_APPS_AMBIGUOUS: "NATIVE_TARGET_MULTIPLE_APPS_AMBIGUOUS",
-  ANDROID_DEVTOOLS_ADB_NOT_FOUND: "ANDROID_DEVTOOLS_ADB_NOT_FOUND",
-  ANDROID_DEVTOOLS_ADB_FORWARD_UNEXPECTED: "ANDROID_DEVTOOLS_ADB_FORWARD_UNEXPECTED",
-  ANDROID_DEVTOOLS_HELPER_EXITED_BEFORE_READY: "ANDROID_DEVTOOLS_HELPER_EXITED_BEFORE_READY",
-  ANDROID_DEVTOOLS_HELPER_PROCESS_ERROR: "ANDROID_DEVTOOLS_HELPER_PROCESS_ERROR",
-  ANDROID_DEVTOOLS_HELPER_READY_TIMEOUT: "ANDROID_DEVTOOLS_HELPER_READY_TIMEOUT",
-  ANDROID_DEVTOOLS_FACTORY_OPTIONS_MISSING: "ANDROID_DEVTOOLS_FACTORY_OPTIONS_MISSING",
-  ANDROID_DEVTOOLS_WRONG_PLATFORM: "ANDROID_DEVTOOLS_WRONG_PLATFORM",
-  ANDROID_DEVTOOLS_DEVICE_ID_INVALID: "ANDROID_DEVTOOLS_DEVICE_ID_INVALID",
-  ANDROID_DEVTOOLS_HELPER_TERMINATED: "ANDROID_DEVTOOLS_HELPER_TERMINATED",
-  ANDROID_DEVTOOLS_RPC_CLIENT_CLOSED: "ANDROID_DEVTOOLS_RPC_CLIENT_CLOSED",
-  ANDROID_DEVTOOLS_RPC_ERROR: "ANDROID_DEVTOOLS_RPC_ERROR",
-  ANDROID_DEVTOOLS_RPC_TIMEOUT: "ANDROID_DEVTOOLS_RPC_TIMEOUT",
-  ANDROID_DEVTOOLS_SOCKET_CLOSED: "ANDROID_DEVTOOLS_SOCKET_CLOSED",
-  ANDROID_SCREEN_SIZE_PARSE_FAILED: "ANDROID_SCREEN_SIZE_PARSE_FAILED",
-  ANDROID_SCREEN_SIZE_NON_POSITIVE: "ANDROID_SCREEN_SIZE_NON_POSITIVE",
-  ANDROID_UIAUTOMATOR_PARSE_FAILED: "ANDROID_UIAUTOMATOR_PARSE_FAILED",
-  ANDROID_UIAUTOMATOR_CAPTURE_FAILED: "ANDROID_UIAUTOMATOR_CAPTURE_FAILED",
-  DEBUGGER_METRO_NOT_RUNNING: "DEBUGGER_METRO_NOT_RUNNING",
-  DEBUGGER_METRO_NO_TARGETS: "DEBUGGER_METRO_NO_TARGETS",
-  DEBUGGER_CDP_RUNTIME_EXCEPTION: "DEBUGGER_CDP_RUNTIME_EXCEPTION",
-  DEBUGGER_CDP_BINDING_TIMEOUT: "DEBUGGER_CDP_BINDING_TIMEOUT",
-  DEBUGGER_CDP_BINDING_UNAVAILABLE: "DEBUGGER_CDP_BINDING_UNAVAILABLE",
-  DEBUGGER_CDP_PROTOCOL_ERROR: "DEBUGGER_CDP_PROTOCOL_ERROR",
-  DEBUGGER_RELOAD_FAILED: "DEBUGGER_RELOAD_FAILED",
-  JS_RUNTIME_CONSOLE_SERVER_BIND_FAILED: "JS_RUNTIME_CONSOLE_SERVER_BIND_FAILED",
-  JS_RUNTIME_PAYLOAD_INVALID: "JS_RUNTIME_PAYLOAD_INVALID",
-  JS_RUNTIME_PAYLOAD_DEVICE_MISSING: "JS_RUNTIME_PAYLOAD_DEVICE_MISSING",
-  JS_RUNTIME_PAYLOAD_PORT_INVALID: "JS_RUNTIME_PAYLOAD_PORT_INVALID",
-  JS_RUNTIME_CDP_DISCONNECTED: "JS_RUNTIME_CDP_DISCONNECTED",
-  NETWORK_INSPECTOR_CDP_DISCONNECTED: "NETWORK_INSPECTOR_CDP_DISCONNECTED",
-  REACT_PROFILER_NO_ACTIVE_SESSION: "REACT_PROFILER_NO_ACTIVE_SESSION",
-  REACT_PROFILER_CDP_CONNECTION_LOST: "REACT_PROFILER_CDP_CONNECTION_LOST",
-  REACT_PROFILER_NO_CPU_PROFILE: "REACT_PROFILER_NO_CPU_PROFILE",
-  REACT_PROFILER_RUNTIME_EXCEPTION: "REACT_PROFILER_RUNTIME_EXCEPTION",
-  REACT_PROFILER_NO_RUNTIME_DATA: "REACT_PROFILER_NO_RUNTIME_DATA",
-  REACT_PROFILER_SESSION_PAYLOAD_INVALID: "REACT_PROFILER_SESSION_PAYLOAD_INVALID",
-  REACT_PROFILER_SESSION_PAYLOAD_DEVICE_MISSING: "REACT_PROFILER_SESSION_PAYLOAD_DEVICE_MISSING",
-  REACT_PROFILER_SESSION_CDP_DISCONNECTED: "REACT_PROFILER_SESSION_CDP_DISCONNECTED",
-  REACT_PROFILER_CDP_NOT_CONNECTED: "REACT_PROFILER_CDP_NOT_CONNECTED",
-  REACT_PROFILER_STATE_READ_FAILED: "REACT_PROFILER_STATE_READ_FAILED",
-  REACT_PROFILER_DEVTOOLS_HOOK_MISSING: "REACT_PROFILER_DEVTOOLS_HOOK_MISSING",
-  REACT_PROFILER_DEVTOOLS_BACKEND_ATTACH_FAILED: "REACT_PROFILER_DEVTOOLS_BACKEND_ATTACH_FAILED",
-  REACT_PROFILER_DEVTOOLS_BACKEND_BOOTSTRAP_FAILED: "REACT_PROFILER_DEVTOOLS_BACKEND_BOOTSTRAP_FAILED",
-  REACT_PROFILER_DEVTOOLS_RENDERER_MISSING: "REACT_PROFILER_DEVTOOLS_RENDERER_MISSING",
-  REACT_PROFILER_START_FAILED: "REACT_PROFILER_START_FAILED",
-  REACT_PROFILER_START_VERIFY_FAILED: "REACT_PROFILER_START_VERIFY_FAILED",
-  REACT_PROFILER_HOOK_ERROR: "REACT_PROFILER_HOOK_ERROR",
-  REACT_PROFILER_ANALYZE_NO_DATA: "REACT_PROFILER_ANALYZE_NO_DATA",
-  NATIVE_PROFILER_FACTORY_OPTIONS_MISSING: "NATIVE_PROFILER_FACTORY_OPTIONS_MISSING",
-  NATIVE_PROFILER_WRONG_PLATFORM: "NATIVE_PROFILER_WRONG_PLATFORM",
-  NATIVE_PROFILER_APP_PROCESS_LIST_FAILED: "NATIVE_PROFILER_APP_PROCESS_LIST_FAILED",
-  NATIVE_PROFILER_APP_LIST_FAILED: "NATIVE_PROFILER_APP_LIST_FAILED",
-  NATIVE_PROFILER_NO_RUNNING_APPS: "NATIVE_PROFILER_NO_RUNNING_APPS",
-  NATIVE_PROFILER_NO_RUNNING_USER_APPS: "NATIVE_PROFILER_NO_RUNNING_USER_APPS",
-  NATIVE_PROFILER_MULTIPLE_RUNNING_USER_APPS: "NATIVE_PROFILER_MULTIPLE_RUNNING_USER_APPS",
-  NATIVE_PROFILER_MALLOC_DEGRADED_XCODE: "NATIVE_PROFILER_MALLOC_DEGRADED_XCODE",
-  NATIVE_PROFILER_MALLOC_STRATEGY_OVERRIDE: "NATIVE_PROFILER_MALLOC_STRATEGY_OVERRIDE",
-  NATIVE_PROFILER_APP_BUNDLE_PATH_FAILED: "NATIVE_PROFILER_APP_BUNDLE_PATH_FAILED",
-  NATIVE_PROFILER_LAUNCH_APP_NOT_FOUND: "NATIVE_PROFILER_LAUNCH_APP_NOT_FOUND",
-  NATIVE_PROFILER_LAUNCH_APP_AMBIGUOUS: "NATIVE_PROFILER_LAUNCH_APP_AMBIGUOUS",
-  NATIVE_PROFILER_SESSION_ALREADY_RUNNING: "NATIVE_PROFILER_SESSION_ALREADY_RUNNING",
-  NATIVE_PROFILER_XCTRACE_NO_PID: "NATIVE_PROFILER_XCTRACE_NO_PID",
-  NATIVE_PROFILER_XCTRACE_PROCESS_NOT_FOUND: "NATIVE_PROFILER_XCTRACE_PROCESS_NOT_FOUND",
-  NATIVE_PROFILER_XCTRACE_READY_EXITED: "NATIVE_PROFILER_XCTRACE_READY_EXITED",
-  NATIVE_PROFILER_XCTRACE_PROCESS_ERROR: "NATIVE_PROFILER_XCTRACE_PROCESS_ERROR",
-  NATIVE_PROFILER_XCTRACE_READY_TIMEOUT: "NATIVE_PROFILER_XCTRACE_READY_TIMEOUT",
-  NATIVE_PROFILER_TRACE_TEMPLATE_MISSING: "NATIVE_PROFILER_TRACE_TEMPLATE_MISSING",
-  NATIVE_PROFILER_NO_ACTIVE_SESSION: "NATIVE_PROFILER_NO_ACTIVE_SESSION",
-  NATIVE_PROFILER_APP_PROCESS_NOT_FOUND: "NATIVE_PROFILER_APP_PROCESS_NOT_FOUND",
-  NATIVE_PROFILER_NO_EXPORTED_TRACE: "NATIVE_PROFILER_NO_EXPORTED_TRACE",
-  // Android perfetto start-failure modes — mirror the iOS xctrace set so a
-  // failed recording start is classified rather than falling through to the
-  // generic tool-execution bucket.
-  NATIVE_PROFILER_PERFETTO_PROCESS_ERROR: "NATIVE_PROFILER_PERFETTO_PROCESS_ERROR",
-  NATIVE_PROFILER_PERFETTO_READY_TIMEOUT: "NATIVE_PROFILER_PERFETTO_READY_TIMEOUT",
-  NATIVE_PROFILER_PERFETTO_READY_EXITED: "NATIVE_PROFILER_PERFETTO_READY_EXITED",
-  // screen-recording-start / screen-recording-stop. One capture path for every
-  // platform (simulator-server's frame stream into ffmpeg), so the stages name
-  // the step that failed rather than the device family.
-  SCREEN_RECORDING_FACTORY_OPTIONS_MISSING: "SCREEN_RECORDING_FACTORY_OPTIONS_MISSING",
-  SCREEN_RECORDING_WRONG_PLATFORM: "SCREEN_RECORDING_WRONG_PLATFORM",
-  SCREEN_RECORDING_ALREADY_ACTIVE: "SCREEN_RECORDING_ALREADY_ACTIVE",
-  SCREEN_RECORDING_NO_ACTIVE_SESSION: "SCREEN_RECORDING_NO_ACTIVE_SESSION",
-  SCREEN_RECORDING_STOP_IN_PROGRESS: "SCREEN_RECORDING_STOP_IN_PROGRESS",
-  SCREEN_RECORDING_START_EXITED: "SCREEN_RECORDING_START_EXITED",
-  SCREEN_RECORDING_START_TIMEOUT: "SCREEN_RECORDING_START_TIMEOUT",
-  SCREEN_RECORDING_PROCESS_ERROR: "SCREEN_RECORDING_PROCESS_ERROR",
-  SCREEN_RECORDING_OUTPUT_MISSING: "SCREEN_RECORDING_OUTPUT_MISSING",
-  SCREEN_RECORDING_SERVER_SHUTTING_DOWN: "SCREEN_RECORDING_SERVER_SHUTTING_DOWN",
-  SCREEN_RECORDING_STREAM_UNAVAILABLE: "SCREEN_RECORDING_STREAM_UNAVAILABLE",
-  SCREEN_RECORDING_FFMPEG_NOT_FOUND: "SCREEN_RECORDING_FFMPEG_NOT_FOUND",
-  FLOW_PROJECT_ROOT_REQUIRED: "FLOW_PROJECT_ROOT_REQUIRED",
-  FLOW_PROJECT_ROOT_INVALID: "FLOW_PROJECT_ROOT_INVALID",
-  FLOW_NAME_INVALID: "FLOW_NAME_INVALID",
-  FLOW_NO_ACTIVE_RECORDING: "FLOW_NO_ACTIVE_RECORDING",
-  FLOW_FILE_INVALID: "FLOW_FILE_INVALID",
-  FLOW_ENTRY_UNRECOGNIZED: "FLOW_ENTRY_UNRECOGNIZED",
-  FLOW_E2E_HAS_PREREQUISITE: "FLOW_E2E_HAS_PREREQUISITE",
-  FLOW_DEVICE_RESOLUTION: "FLOW_DEVICE_RESOLUTION",
-  PROFILER_QUERY_MODE_INVALID: "PROFILER_QUERY_MODE_INVALID",
-  PROFILER_QUERY_REQUIRED_PARAM_MISSING: "PROFILER_QUERY_REQUIRED_PARAM_MISSING",
-  PROFILER_DATA_NOT_LOADED: "PROFILER_DATA_NOT_LOADED",
-  PROFILER_NATIVE_TRACE_MISSING: "PROFILER_NATIVE_TRACE_MISSING",
-  PROFILER_NATIVE_METADATA_MISSING: "PROFILER_NATIVE_METADATA_MISSING",
-  PROFILER_NATIVE_METADATA_INVALID: "PROFILER_NATIVE_METADATA_INVALID",
-  CHROMIUM_CDP_UNREACHABLE: "CHROMIUM_CDP_UNREACHABLE",
-  CHROMIUM_CDP_NO_PAGE_TARGET: "CHROMIUM_CDP_NO_PAGE_TARGET",
-  CHROMIUM_CDP_INVALID_RESPONSE: "CHROMIUM_CDP_INVALID_RESPONSE",
-  CHROMIUM_DEVICE_ID_INVALID: "CHROMIUM_DEVICE_ID_INVALID",
-  CHROMIUM_PARAM_INVALID: "CHROMIUM_PARAM_INVALID",
-  CHROMIUM_INPUT_INVALID: "CHROMIUM_INPUT_INVALID",
-  CHROMIUM_WINDOW_HIDDEN: "CHROMIUM_WINDOW_HIDDEN",
-  CHROMIUM_VIEWPORT_READ_FAILED: "CHROMIUM_VIEWPORT_READ_FAILED",
-  CHROMIUM_SCREENSHOT_FAILED: "CHROMIUM_SCREENSHOT_FAILED",
-  CHROMIUM_STORAGE_EVAL_FAILED: "CHROMIUM_STORAGE_EVAL_FAILED",
-  CHROMIUM_TAB_NOT_FOUND: "CHROMIUM_TAB_NOT_FOUND",
-  CHROMIUM_TAB_OPEN_FAILED: "CHROMIUM_TAB_OPEN_FAILED",
-  CHROMIUM_DESCRIBE_FAILED: "CHROMIUM_DESCRIBE_FAILED",
-  CHROMIUM_ELECTRON_APP_PATH_INVALID: "CHROMIUM_ELECTRON_APP_PATH_INVALID",
-  CHROMIUM_ELECTRON_SPAWN_FAILED: "CHROMIUM_ELECTRON_SPAWN_FAILED",
-  CHROMIUM_ELECTRON_CDP_TIMEOUT: "CHROMIUM_ELECTRON_CDP_TIMEOUT",
-  CHROMIUM_ELECTRON_EXITED_BEFORE_READY: "CHROMIUM_ELECTRON_EXITED_BEFORE_READY",
-  KEYBOARD_KEY_UNSUPPORTED: "KEYBOARD_KEY_UNSUPPORTED",
-  KEYBOARD_CHARACTER_UNSUPPORTED: "KEYBOARD_CHARACTER_UNSUPPORTED",
-  SECRET_PLACEHOLDER_UNKNOWN: "SECRET_PLACEHOLDER_UNKNOWN",
-  SCREENSHOT_DIFF_INPUT_INVALID: "SCREENSHOT_DIFF_INPUT_INVALID",
-  BOOT_DEVICE_TARGET_SELECTION_INVALID: "BOOT_DEVICE_TARGET_SELECTION_INVALID",
-  BOOT_IOS_UNSUPPORTED_HOST: "BOOT_IOS_UNSUPPORTED_HOST",
-  BOOT_ANDROID_NO_AVDS: "BOOT_ANDROID_NO_AVDS",
-  BOOT_ANDROID_AVD_NOT_FOUND: "BOOT_ANDROID_AVD_NOT_FOUND",
-  BOOT_ANDROID_ADB_UNAVAILABLE: "BOOT_ANDROID_ADB_UNAVAILABLE",
-  BOOT_ANDROID_GPU_MODE_INVALID: "BOOT_ANDROID_GPU_MODE_INVALID",
-  BOOT_ANDROID_ADB_REGISTER_TIMEOUT: "BOOT_ANDROID_ADB_REGISTER_TIMEOUT",
-  BOOT_ANDROID_HOT_BOOT_FRAME_UNUSABLE: "BOOT_ANDROID_HOT_BOOT_FRAME_UNUSABLE",
-  BOOT_ANDROID_FIRST_FRAME_TIMEOUT: "BOOT_ANDROID_FIRST_FRAME_TIMEOUT",
-  BOOT_ANDROID_PACKAGE_MANAGER_UNAVAILABLE: "BOOT_ANDROID_PACKAGE_MANAGER_UNAVAILABLE",
-  BOOT_ANDROID_COLD_BOOT_FAILED: "BOOT_ANDROID_COLD_BOOT_FAILED"
+// ../../node_modules/posthog-node/dist/extensions/sentry-integration.mjs
+var NAME = "posthog-node";
+function createEventProcessor(_posthog, { organization, projectId, prefix, severityAllowList = [
+  "error"
+], sendExceptionsToPostHog = true } = {}) {
+  return (event) => {
+    const shouldProcessLevel = "*" === severityAllowList || severityAllowList.includes(event.level);
+    if (!shouldProcessLevel) return event;
+    if (!event.tags) event.tags = {};
+    const userId = event.tags[PostHogSentryIntegration.POSTHOG_ID_TAG];
+    if (void 0 === userId) return event;
+    const uiHost = _posthog.options.host ?? "https://us.i.posthog.com";
+    const personUrl = new URL(`/project/${_posthog.apiKey}/person/${userId}`, uiHost).toString();
+    event.tags["PostHog Person URL"] = personUrl;
+    const exceptions = event.exception?.values || [];
+    const exceptionList = exceptions.map((exception) => ({
+      ...exception,
+      stacktrace: exception.stacktrace ? {
+        ...exception.stacktrace,
+        type: "raw",
+        frames: (exception.stacktrace.frames || []).map((frame) => ({
+          ...frame,
+          platform: "node:javascript"
+        }))
+      } : void 0
+    }));
+    const properties = {
+      $exception_message: exceptions[0]?.value || event.message,
+      $exception_type: exceptions[0]?.type,
+      $exception_level: event.level,
+      $exception_list: exceptionList,
+      $sentry_event_id: event.event_id,
+      $sentry_exception: event.exception,
+      $sentry_exception_message: exceptions[0]?.value || event.message,
+      $sentry_exception_type: exceptions[0]?.type,
+      $sentry_tags: event.tags
+    };
+    if (organization && projectId) properties["$sentry_url"] = (prefix || "https://sentry.io/organizations/") + organization + "/issues/?project=" + projectId + "&query=" + event.event_id;
+    if (sendExceptionsToPostHog) _posthog.capture({
+      event: "$exception",
+      distinctId: userId,
+      properties
+    });
+    return event;
+  };
+}
+var PostHogSentryIntegration = class {
+  static #_ = this.POSTHOG_ID_TAG = "posthog_distinct_id";
+  constructor(_posthog, organization, prefix, severityAllowList, sendExceptionsToPostHog) {
+    this.name = NAME;
+    this.name = NAME;
+    this.setupOnce = function(addGlobalEventProcessor, getCurrentHub) {
+      const projectId = getCurrentHub()?.getClient()?.getDsn()?.projectId;
+      addGlobalEventProcessor(createEventProcessor(_posthog, {
+        organization,
+        projectId,
+        prefix,
+        severityAllowList,
+        sendExceptionsToPostHog: sendExceptionsToPostHog ?? true
+      }));
+    };
+  }
 };
 
-// ../registry/src/errors.ts
-var FAILURE_AREAS = ["cli", "http", "registry", "tool_server", "installer"];
-var FAILURE_KINDS = [
-  "validation",
-  "not_found",
-  "dependency_missing",
-  "unsupported",
-  "not_implemented",
-  "timeout",
-  "network",
-  "subprocess",
-  "crash",
-  "unknown"
-];
-var FAILURE_COMMANDS = [
-  "adb",
-  "emulator",
-  "vega",
-  "xcrun_simctl",
-  "xctrace",
-  "native_devtools",
-  "android_devtools",
-  "ax_service",
-  "simulator_server",
-  "ffmpeg",
-  "cdp",
-  "electron",
-  "npm",
-  "npx",
-  "unknown"
-];
-var FAILURE_SIGNAL_NAMES = [
-  "SIGABRT",
-  "SIGHUP",
-  "SIGINT",
-  "SIGKILL",
-  "SIGQUIT",
-  "SIGTERM"
-];
-var FAILURE_SPAWN_CODES = ["EACCES", "ENOENT", "EPERM", "ETIMEDOUT"];
-var NETWORK_FAILURES = [
-  "timeout",
-  "connection_refused",
-  "connection_reset",
-  "invalid_response",
-  "other"
-];
-var FALLBACK_SIGNAL = {
-  error_code: FAILURE_CODES.ARGENT_UNCLASSIFIED_FAILURE,
-  failure_stage: "unclassified",
-  failure_area: "registry",
-  error_kind: "unknown"
+// ../../node_modules/posthog-node/dist/entrypoints/index.node.mjs
+var PostHog = class extends PostHogBackendClient {
+  getLibraryId() {
+    return "posthog-node";
+  }
+  initializeContext() {
+    return new PostHogContext();
+  }
+  createErrorPropertiesBuilder() {
+    return new error_tracking_exports.ErrorPropertiesBuilder([
+      new error_tracking_exports.EventCoercer(),
+      new error_tracking_exports.ErrorCoercer(),
+      new error_tracking_exports.ObjectCoercer(),
+      new error_tracking_exports.StringCoercer(),
+      new error_tracking_exports.PrimitiveCoercer()
+    ], error_tracking_exports.createStackParser("node:javascript", error_tracking_exports.nodeStackLineParser), [
+      createModulerModifier(),
+      addSourceContext,
+      createRelativePathModifier()
+    ]);
+  }
 };
-var FAILURE_SIGNAL_NAME_SET = new Set(FAILURE_SIGNAL_NAMES);
-var FAILURE_SPAWN_CODE_SET = new Set(FAILURE_SPAWN_CODES);
 
-// ../registry/src/registry.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+// ../telemetry/src/posthog.ts
+var POSTHOG_HOST = "https://eu.i.posthog.com";
+var POSTHOG_PROJECT_TOKEN = "phc_mebZhuUmASbeeXkdv7E2wqTZdtstPxQqHBhZfLSeQ5YL";
+function readProjectToken() {
+  const g = globalThis;
+  const override = g.__ARGENT_POSTHOG_KEY_TEST;
+  if (typeof override === "string") return override;
+  return POSTHOG_PROJECT_TOKEN;
+}
+function resolveConfig() {
+  const key = readProjectToken();
+  const isUsable = key !== "" && key !== "phc_disabled" && key.startsWith("phc_");
+  return { key, isUsable };
+}
+var client;
+function getClient() {
+  if (client !== void 0) return client;
+  const config2 = resolveConfig();
+  if (!config2.isUsable) {
+    client = null;
+    return null;
+  }
+  const opts = {
+    host: POSTHOG_HOST,
+    disableGeoip: true,
+    requestTimeout: 3e3,
+    flushAt: 20,
+    flushInterval: 1e4,
+    fetchRetryCount: 0
+  };
+  try {
+    client = new PostHog(config2.key, opts);
+  } catch {
+    client = null;
+    return null;
+  }
+  return client;
+}
+function getConstructedClient() {
+  return client ?? null;
+}
+function resetClient() {
+  client = void 0;
+}
 
 // ../telemetry/src/events.ts
 var PLATFORMS = [
@@ -7396,9 +7866,9 @@ function isReplitAgent(env) {
 }
 var DEVIN_MARKER_PATH = "/opt/.devin";
 var JULES_MARKER_PATH = "/opt/environment_summary.sh";
-function safeExists(fileExists, path16) {
+function safeExists(fileExists, path17) {
   try {
-    return fileExists(path16);
+    return fileExists(path17);
   } catch {
     return false;
   }
@@ -7819,7 +8289,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID2 = randomUUID5();
 function readCliVersion() {
   if (true) {
-    return "0.18.1";
+    return "0.19.0";
   }
   return "0.0.0";
 }
@@ -7853,16 +8323,16 @@ function getBaseProps(runtime) {
 
 // ../telemetry/src/identity.ts
 import * as crypto2 from "node:crypto";
-import * as fs4 from "node:fs";
-import * as path9 from "node:path";
+import * as fs5 from "node:fs";
+import * as path10 from "node:path";
 
 // ../telemetry/src/paths.ts
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 function identityFilePath() {
-  return path8.join(argentHomeDir(), "telemetry-id");
+  return path9.join(argentHomeDir(), "telemetry-id");
 }
 function debugLogPath() {
-  return path8.join(argentHomeDir(), "telemetry-debug.log");
+  return path9.join(argentHomeDir(), "telemetry-debug.log");
 }
 
 // ../telemetry/src/identity.ts
@@ -7961,66 +8431,66 @@ function resolveFingerprintOnce(resolveFingerprint) {
 function isCorruptIdFile(filePath) {
   let isRegularFile;
   try {
-    isRegularFile = fs4.lstatSync(filePath).isFile();
+    isRegularFile = fs5.lstatSync(filePath).isFile();
   } catch {
     return false;
   }
   return isRegularFile && tryReadId(filePath) === null;
 }
 function writeIdFileAtomic(finalPath, id) {
-  fs4.mkdirSync(argentHomeDir(), { recursive: true });
+  fs5.mkdirSync(argentHomeDir(), { recursive: true });
   let occupant;
   try {
-    occupant = fs4.lstatSync(finalPath);
+    occupant = fs5.lstatSync(finalPath);
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
   if (occupant && !occupant.isFile()) {
     throw new Error("telemetry: refusing to replace a non-regular file at the identity path");
   }
-  const tmpPath = path9.join(
+  const tmpPath = path10.join(
     argentHomeDir(),
     `.telemetry-id.tmp.${process.pid}.${crypto2.randomUUID()}`
   );
-  const fd = fs4.openSync(tmpPath, "wx", 384);
+  const fd = fs5.openSync(tmpPath, "wx", 384);
   try {
     try {
-      fs4.writeSync(fd, id);
-      fs4.fsyncSync(fd);
+      fs5.writeSync(fd, id);
+      fs5.fsyncSync(fd);
     } finally {
-      fs4.closeSync(fd);
+      fs5.closeSync(fd);
     }
-    fs4.renameSync(tmpPath, finalPath);
+    fs5.renameSync(tmpPath, finalPath);
   } finally {
     try {
-      fs4.unlinkSync(tmpPath);
+      fs5.unlinkSync(tmpPath);
     } catch {
     }
   }
 }
 function mintRandomId(finalPath) {
-  fs4.mkdirSync(argentHomeDir(), { recursive: true });
+  fs5.mkdirSync(argentHomeDir(), { recursive: true });
   let value = crypto2.randomUUID();
   for (let attempt = 0; attempt < 3; attempt++) {
-    const tmpPath = path9.join(
+    const tmpPath = path10.join(
       argentHomeDir(),
       `.telemetry-id.tmp.${process.pid}.${crypto2.randomUUID()}`
     );
     let fd;
     try {
-      fd = fs4.openSync(tmpPath, "wx", 384);
+      fd = fs5.openSync(tmpPath, "wx", 384);
     } catch (err) {
       if (err.code === "EEXIST") continue;
       throw err;
     }
     try {
       try {
-        fs4.writeSync(fd, value);
-        fs4.fsyncSync(fd);
+        fs5.writeSync(fd, value);
+        fs5.fsyncSync(fd);
       } finally {
-        fs4.closeSync(fd);
+        fs5.closeSync(fd);
       }
-      fs4.linkSync(tmpPath, finalPath);
+      fs5.linkSync(tmpPath, finalPath);
       cached = { path: finalPath, id: value };
       return value;
     } catch (err) {
@@ -8039,7 +8509,7 @@ function mintRandomId(finalPath) {
       throw err;
     } finally {
       try {
-        fs4.unlinkSync(tmpPath);
+        fs5.unlinkSync(tmpPath);
       } catch {
       }
     }
@@ -8047,12 +8517,12 @@ function mintRandomId(finalPath) {
   throw new Error("telemetry: failed to create identity after retries");
 }
 function claimCorruptOccupant(finalPath) {
-  const claimed = path9.join(
+  const claimed = path10.join(
     argentHomeDir(),
     `.telemetry-id.corrupt.${process.pid}.${crypto2.randomUUID()}`
   );
   try {
-    fs4.renameSync(finalPath, claimed);
+    fs5.renameSync(finalPath, claimed);
   } catch {
     return null;
   }
@@ -8061,7 +8531,7 @@ function claimCorruptOccupant(finalPath) {
     grabbed = tryReadId(claimed);
   } finally {
     try {
-      fs4.unlinkSync(claimed);
+      fs5.unlinkSync(claimed);
     } catch {
     }
   }
@@ -8073,9 +8543,9 @@ function peekAnonId() {
 function tryReadId(filePath) {
   let raw;
   try {
-    const stats = fs4.lstatSync(filePath);
+    const stats = fs5.lstatSync(filePath);
     if (!stats.isFile()) return null;
-    raw = fs4.readFileSync(filePath, "utf8");
+    raw = fs5.readFileSync(filePath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     return null;
@@ -8089,12 +8559,12 @@ function tryReadId(filePath) {
 import { execFileSync as execFileSync2, spawn as spawn2 } from "node:child_process";
 
 // ../native-devtools-ios/src/index.ts
-import * as path10 from "node:path";
-import * as fs5 from "node:fs";
-var DYLIB_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_DIR ?? path10.join(__dirname, "..", "dylibs");
-var BIN_DIR = process.env.ARGENT_SIMULATOR_SERVER_DIR ?? path10.join(__dirname, "..", "bin");
-var DYLIB_TCP_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_TCP_DIR ?? path10.join(DYLIB_DIR, "tcp");
-var DYLIB_TVOS_DIR = path10.join(DYLIB_DIR, "tvos");
+import * as path11 from "node:path";
+import * as fs6 from "node:fs";
+var DYLIB_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_DIR ?? path11.join(__dirname, "..", "dylibs");
+var BIN_DIR = process.env.ARGENT_SIMULATOR_SERVER_DIR ?? path11.join(__dirname, "..", "bin");
+var DYLIB_TCP_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_TCP_DIR ?? path11.join(DYLIB_DIR, "tcp");
+var DYLIB_TVOS_DIR = path11.join(DYLIB_DIR, "tvos");
 function hostPlatformKey() {
   if (process.platform === "linux" && process.arch === "arm64") {
     return "linux-arm64";
@@ -8105,14 +8575,14 @@ function simulatorServerBinaryName() {
   return process.platform === "win32" ? "simulator-server.exe" : "simulator-server";
 }
 function platformBinDir() {
-  return path10.join(BIN_DIR, hostPlatformKey());
+  return path11.join(BIN_DIR, hostPlatformKey());
 }
 function simulatorServerBinaryPath() {
   const binaryName = simulatorServerBinaryName();
-  const p = path10.join(platformBinDir(), binaryName);
-  if (!fs5.existsSync(p)) {
-    const flat = path10.join(BIN_DIR, binaryName);
-    const migrationHint = fs5.existsSync(flat) ? ` Found a binary at the old flat path ${flat}; move it to ${p} or update ARGENT_SIMULATOR_SERVER_DIR to point at the parent of the platform subdirectory.` : "";
+  const p = path11.join(platformBinDir(), binaryName);
+  if (!fs6.existsSync(p)) {
+    const flat = path11.join(BIN_DIR, binaryName);
+    const migrationHint = fs6.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}`
     );
@@ -8145,12 +8615,12 @@ function resolveHostFingerprint() {
   }
 }
 function resolveHostFingerprintAsync() {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     let binary;
     try {
       binary = simulatorServerBinaryPath();
     } catch {
-      resolve9(null);
+      resolve10(null);
       return;
     }
     let settled = false;
@@ -8163,7 +8633,7 @@ function resolveHostFingerprintAsync() {
         child?.kill("SIGKILL");
       } catch {
       }
-      resolve9(value);
+      resolve10(value);
     };
     const watchdog = setTimeout(() => finish(null), FINGERPRINT_TIMEOUT_MS);
     watchdog.unref?.();
@@ -8196,13 +8666,13 @@ function resolveHostFingerprintAsync() {
 }
 
 // ../telemetry/src/consent.ts
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 var cache = { current: null };
 var sessionOverride = null;
 function readConfigOverride() {
   let stats;
   try {
-    stats = fs6.lstatSync(configFilePath());
+    stats = fs7.lstatSync(configFilePath());
   } catch (err) {
     if (err.code === "ENOENT") {
       cache.current = { mtimeMs: null, fingerprint: null, enabledOverride: null };
@@ -8222,7 +8692,7 @@ function readConfigOverride() {
   }
   let parsedEnabled = null;
   try {
-    const raw = fs6.readFileSync(configFilePath(), "utf8");
+    const raw = fs7.readFileSync(configFilePath(), "utf8");
     const json = JSON.parse(raw);
     if (json && typeof json === "object") {
       const t2 = json.telemetry;
@@ -8283,7 +8753,7 @@ function writeConsentFlag(enabled) {
 }
 
 // ../telemetry/src/debug.ts
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 function isDebugEnabled(env = process.env) {
   const v = env.ARGENT_TELEMETRY_DEBUG;
   if (!v) return false;
@@ -8310,8 +8780,8 @@ function emitDebugPayload(payload) {
   } catch {
   }
   try {
-    fs7.mkdirSync(argentHomeDir(), { recursive: true });
-    fs7.appendFileSync(debugLogPath(), line + "\n");
+    fs8.mkdirSync(argentHomeDir(), { recursive: true });
+    fs8.appendFileSync(debugLogPath(), line + "\n");
   } catch {
   }
 }
@@ -8405,7 +8875,7 @@ async function shutdown(timeoutMs = SHORT_FLUSH_TIMEOUT_MS) {
   try {
     await Promise.race([
       client2.shutdown(timeoutMs),
-      new Promise((resolve9) => setTimeout(resolve9, timeoutMs + 250).unref())
+      new Promise((resolve10) => setTimeout(resolve10, timeoutMs + 250).unref())
     ]);
   } catch (err) {
     emitDebugError("shutdown failed", err);
@@ -8425,7 +8895,7 @@ async function markDisabled() {
       try {
         await Promise.race([
           client2.shutdown(SHORT_FLUSH_TIMEOUT_MS),
-          new Promise((resolve9) => setTimeout(resolve9, SHORT_FLUSH_TIMEOUT_MS).unref())
+          new Promise((resolve10) => setTimeout(resolve10, SHORT_FLUSH_TIMEOUT_MS).unref())
         ]);
       } catch {
       }
@@ -8458,6 +8928,18 @@ var FlagParseException = class extends Error {
 function isScalarType(type) {
   return type === "string" || type === "number" || type === "integer" || type === "boolean";
 }
+function isJsonField(prop) {
+  return prop?.type === "object" || prop?.type === "array" && !isScalarType(prop.items?.type);
+}
+function flagNameFor(name, prop) {
+  return isJsonField(prop) ? `--${name}-json` : `--${name}`;
+}
+function booleanLiteral(raw) {
+  const value = raw.trim().toLowerCase();
+  if (value === "true" || value === "1") return true;
+  if (value === "false" || value === "0") return false;
+  return void 0;
+}
 function coerceScalar(raw, type, field) {
   if (type === "number") {
     if (raw.trim() === "")
@@ -8475,9 +8957,9 @@ function coerceScalar(raw, type, field) {
     return n2;
   }
   if (type === "boolean") {
-    if (raw === "true" || raw === "1") return true;
-    if (raw === "false" || raw === "0") return false;
-    throw new FlagParseException(`--${field} expected true/false, got "${raw}"`);
+    const value = booleanLiteral(raw);
+    if (value !== void 0) return value;
+    throw new FlagParseException(`--${field} expected true/false (or 1/0), got "${raw}"`);
   }
   return raw;
 }
@@ -8554,6 +9036,12 @@ function parseFlags(argv, schema) {
         if (inlineValue !== void 0) {
           throw new FlagParseException(`--no-${fieldName} does not take a value`);
         }
+        const following = i2 + 1 < argv.length ? booleanLiteral(argv[i2 + 1]) : void 0;
+        if (following !== void 0) {
+          throw new FlagParseException(
+            `--no-${fieldName} does not take a value; use --${fieldName} ${following}`
+          );
+        }
         args[fieldName] = false;
         continue;
       }
@@ -8562,6 +9050,12 @@ function parseFlags(argv, schema) {
     if (propSchema?.type === "boolean") {
       if (inlineValue !== void 0) {
         args[flag] = coerceScalar(inlineValue, "boolean", flag);
+        continue;
+      }
+      const next = i2 + 1 < argv.length ? booleanLiteral(argv[i2 + 1]) : void 0;
+      if (next !== void 0) {
+        args[flag] = next;
+        i2 += 1;
       } else {
         args[flag] = true;
       }
@@ -8619,14 +9113,19 @@ function formatSchemaUsage(schema) {
     const desc = prop.description ? `  ${prop.description}` : "";
     lines.push(`  ${flag}  ${typeLabel}${req}${desc}`);
   }
+  if (entries.some(([, prop]) => prop.type === "boolean")) {
+    lines.push(
+      "",
+      "  Booleans: --flag, --flag true, or --flag 1 sets true; --flag false, --flag 0, --flag=false, or --no-flag sets false."
+    );
+  }
   return lines.join("\n");
 }
 function renderFlagName(name, prop) {
-  if (prop.type === "object" || prop.type === "array" && !isScalarType(prop.items?.type)) {
-    return `--${name}-json <json>`;
-  }
-  if (prop.type === "boolean") return `--${name}`;
-  return `--${name} <value>`;
+  const flag = flagNameFor(name, prop);
+  if (isJsonField(prop)) return `${flag} <json>`;
+  if (prop.type === "boolean") return flag;
+  return `${flag} <value>`;
 }
 function renderType(prop) {
   if (prop.enum && Array.isArray(prop.enum)) {
@@ -8640,6 +9139,93 @@ function renderType(prop) {
   return prop.type ?? "any";
 }
 
+// ../argent-cli/src/run-validation.ts
+function findMissingRequired(payload, schema) {
+  const required = new Set(schema?.required ?? []);
+  if (required.size === 0) return [];
+  const declared = Object.keys(schema?.properties ?? {});
+  const names = [...declared.filter((n2) => required.has(n2))];
+  for (const name of required) {
+    if (!names.includes(name)) names.push(name);
+  }
+  return names.filter((name) => !Object.hasOwn(payload, name));
+}
+function describeServerValidationFailure(err, payload, schema) {
+  const message = err instanceof Error ? err.message : typeof err === "string" ? err : null;
+  if (message === null) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(message);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0) return null;
+  if (!parsed.every(isValidationIssue)) return null;
+  const properties = schema?.properties ?? {};
+  const addressesThisTool = (issue) => issue.path.length === 0 || typeof issue.path[0] === "string" && Object.hasOwn(properties, issue.path[0]);
+  if (!parsed.every(addressesThisTool)) return null;
+  const required = new Set(schema?.required ?? []);
+  const missing = [];
+  const invalid = [];
+  for (const issue of parsed) {
+    const head = issue.path[0];
+    if (issue.path.length === 1 && typeof head === "string" && required.has(head) && !Object.hasOwn(payload, head)) {
+      missing.push(head);
+    } else {
+      invalid.push({ path: issue.path, message: issue.message });
+    }
+  }
+  return { missing: sortBySchemaOrder(missing, schema), invalid, rawIssues: parsed };
+}
+function formatValidationError(report, schema) {
+  const properties = schema?.properties ?? {};
+  const lines = [];
+  if (report.missing.length > 0) {
+    const flags2 = sortBySchemaOrder(report.missing, schema).map(
+      (name) => flagNameFor(name, properties[name])
+    );
+    const noun = flags2.length === 1 ? "flag" : "flags";
+    lines.push(`missing required ${noun} ${flags2.join(", ")}`);
+  }
+  for (const field of report.invalid) {
+    lines.push(describeInvalidField(field, properties));
+  }
+  return lines.join("\n       ");
+}
+function missingFlagNames(report, schema) {
+  const properties = schema?.properties ?? {};
+  return sortBySchemaOrder(report.missing, schema).map(
+    (name) => flagNameFor(name, properties[name])
+  );
+}
+function describeInvalidField(field, properties) {
+  if (field.path.length === 0) return field.message;
+  const [head, ...rest] = field.path;
+  if (typeof head !== "string") return field.message;
+  const flag = flagNameFor(head, properties[head]);
+  const nested = rest.length > 0 ? ` ${head}${renderPathTail(rest)}` : "";
+  return `${flag}${nested} ${field.message}`;
+}
+function renderPathTail(rest) {
+  return rest.map((part) => typeof part === "number" ? `[${part}]` : `.${part}`).join("");
+}
+function sortBySchemaOrder(names, schema) {
+  const order = Object.keys(schema?.properties ?? {});
+  return [...names].sort((a2, b) => {
+    const ia = order.indexOf(a2);
+    const ib = order.indexOf(b);
+    if (ia === -1 && ib === -1) return a2.localeCompare(b);
+    if (ia === -1) return 1;
+    if (ib === -1) return -1;
+    return ia - ib;
+  });
+}
+function isValidationIssue(value) {
+  if (value === null || typeof value !== "object") return false;
+  const issue = value;
+  return typeof issue.code === "string" && Array.isArray(issue.path) && typeof issue.message === "string";
+}
+
 // ../argent-cli/src/run.ts
 function splitOptions(argv) {
   let json = false;
@@ -8667,13 +9253,13 @@ function splitOptions(argv) {
   return { json, outPath, argvForFlags: rest };
 }
 async function readStdin() {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve9(data));
+    process.stdin.on("end", () => resolve10(data));
     process.stdin.on("error", reject);
   });
 }
@@ -8705,8 +9291,8 @@ async function fetchImageToFile(result, outPath) {
   const res = await fetch(url);
   if (!res.ok) throw new Error(`Failed to download image: ${res.status} ${res.statusText}`);
   const buf = Buffer.from(await res.arrayBuffer());
-  fs8.mkdirSync(path11.dirname(path11.resolve(outPath)), { recursive: true });
-  fs8.writeFileSync(outPath, buf);
+  fs9.mkdirSync(path12.dirname(path12.resolve(outPath)), { recursive: true });
+  fs9.writeFileSync(outPath, buf);
 }
 function renderResult(result, outputHint, images, json) {
   if (json) return JSON.stringify(result, null, 2);
@@ -8751,7 +9337,25 @@ Examples:
 `);
     return;
   }
-  const { json, outPath, argvForFlags } = splitOptions(rest);
+  let cliOptions;
+  try {
+    cliOptions = splitOptions(rest);
+  } catch (err) {
+    if (err instanceof FlagParseException) {
+      console.error(`Error: ${err.message}
+`);
+      console.error(`Run \`argent run ${toolName} --help\` to see this tool's flags.`);
+      await trackRunFailure(toolName, startedAt, {
+        error_code: FAILURE_CODES.CLI_RUN_FLAG_PARSE_FAILED,
+        failure_stage: "cli_run_split_options",
+        failure_area: "cli",
+        error_kind: "validation"
+      });
+      process.exit(2);
+    }
+    throw err;
+  }
+  const { json, outPath, argvForFlags } = cliOptions;
   const meta = await fetchTool(toolName);
   if (!meta) {
     console.error(`Tool "${toolName}" not found. Run \`argent tools\` to list available tools.`);
@@ -8763,9 +9367,37 @@ Examples:
     });
     process.exit(1);
   }
+  const schema = meta.inputSchema;
+  const failValidation = async (report, stage) => {
+    const summary = formatValidationError(report, schema);
+    if (json) {
+      console.error(
+        JSON.stringify(
+          {
+            error: summary,
+            missing: missingFlagNames(report, schema),
+            issues: report.rawIssues ?? []
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(`Error: ${summary}
+`);
+      printToolHelp(meta);
+    }
+    await trackRunFailure(toolName, startedAt, {
+      error_code: FAILURE_CODES.CLI_RUN_INPUT_VALIDATION_FAILED,
+      failure_stage: stage,
+      failure_area: "cli",
+      error_kind: "validation"
+    });
+    process.exit(2);
+  };
   let parsed;
   try {
-    parsed = parseFlags(argvForFlags, meta.inputSchema);
+    parsed = parseFlags(argvForFlags, schema);
   } catch (err) {
     if (err instanceof FlagParseException) {
       console.error(`Error: ${err.message}
@@ -8785,6 +9417,11 @@ Examples:
     printToolHelp(meta);
     return;
   }
+  if (parsed.positional.length > 0) {
+    console.error(
+      `Note: ignoring unused argument(s): ${parsed.positional.join(", ")}. Pass values as --flag <value> or --flag=<value>.`
+    );
+  }
   let payload = {};
   if (parsed.rawArgs !== null) {
     let rawJson = parsed.rawArgs;
@@ -8818,6 +9455,10 @@ Examples:
   for (const [k, v] of Object.entries(parsed.args)) {
     payload[k] = v;
   }
+  const missing = findMissingRequired(payload, schema);
+  if (missing.length > 0) {
+    await failValidation({ missing, invalid: [], rawIssues: null }, "cli_run_required_flags");
+  }
   let result;
   let note;
   let images = [];
@@ -8833,6 +9474,10 @@ Examples:
     images = materialized.images;
     note = resp.note;
   } catch (err) {
+    const report = describeServerValidationFailure(err, payload, schema);
+    if (report) {
+      await failValidation(report, "cli_run_server_validation");
+    }
     console.error(err instanceof Error ? err.message : String(err));
     await trackRunFailure(toolName, startedAt, {
       error_code: FAILURE_CODES.CLI_RUN_TOOL_CALL_FAILED,
@@ -8845,8 +9490,8 @@ Examples:
   if (outPath && meta.outputHint === "image") {
     try {
       if (images.length > 0) {
-        fs8.mkdirSync(path11.dirname(path11.resolve(outPath)), { recursive: true });
-        fs8.writeFileSync(outPath, images[0].data);
+        fs9.mkdirSync(path12.dirname(path12.resolve(outPath)), { recursive: true });
+        fs9.writeFileSync(outPath, images[0].data);
       } else if (result && typeof result === "object") {
         await fetchImageToFile(result, outPath);
       }
@@ -8870,7 +9515,9 @@ Examples:
 
 // ../argent-cli/src/flow.ts
 import * as fsp from "node:fs/promises";
-import * as path12 from "node:path";
+import { constants as fsConstants2 } from "node:fs";
+import { createHash as createHash5 } from "node:crypto";
+import * as path13 from "node:path";
 var STATUS_GLYPH = {
   pass: "\u2713",
   fail: "\u2717",
@@ -8885,36 +9532,83 @@ function stepIndent(depth) {
 function printHelp() {
   console.log(`Usage: argent flow <subcommand> [options]
 
-Run a saved flow without an LLM in the loop. Flows live in
-\`.argent/flows/<name>.yaml\` under the current working directory. A flow that
-begins with a \`launch\` step runs its app from scratch; any other flow (a
-fragment) runs against the device's current state \u2014 handy while authoring one.
+Run a YAML flow without an LLM in the loop. \`run\` takes any of these forms:
+
+  a name   A flow saved under .argent/flows \u2014 "checkout" runs
+           .argent/flows/checkout.yaml, resolved from the current directory
+  a path   Any .yaml file on the local filesystem, resolved from the current
+           directory. It must not contain ".." segments (pass the resolved
+           path instead); a path is what reaches flows kept elsewhere, and
+           what \`argent flow list\` prints for nested ones
+  a dir    Every flow in that directory, run sequentially
+
+For a name and for a file path alike, the
+filename (minus .yaml) names the run's report and artifacts, so it must
+contain only letters, numbers, "_", or "-" \u2014 the same charset a name must
+match. A flow that begins with a \`launch\` step runs its app from scratch; any
+other flow (a fragment) runs against the device's current state \u2014 handy while
+authoring one.
+
+A directory run prints only failing steps plus a final flow summary;
+--recursive walks subdirectories too (dot-directories and node_modules are
+skipped). An invalid flow file fails alone and the batch continues; an infra
+error stops the batch and counts the remaining flows skipped.
+
+Runs require the auto-started local tool server;
+ARGENT_TOOLS_URL and \`argent link\` routing are not supported.
 
 Subcommands:
-  run <name>        Run a flow and report pass/fail (exit code reflects result)
-  list              List flows in .argent/flows
+  run <flow|flow.yaml|dir>   Run a saved flow by name, a YAML file by path, or
+                             every flow in a directory, and report pass/fail
+                             (exit reflects result)
+  list                       List runnable YAML paths in .argent/flows
 
 Options (run):
   --device <id>          Device id to run against (auto-detected when omitted)
   --platform <p>         ios | android | chromium | vega \u2014 narrow auto-detection
   --update-baselines     Write/refresh screenshot baselines instead of diffing
   --output <dir>         Also write failed snapshot images (baseline/current/diff)
-                         under <dir>/<flow>/ \u2014 a stable path for CI artifact upload
+                         under <dir>/<flow>/ \u2014 a stable path for CI artifact
+                         upload; a directory run keys nested flows as
+                         <dir>/<subdir>/<flow>/. A different flow file with the
+                         same filename sharing <dir> exports to <flow>-<pathhash>/
+                         instead (with a warning), so no flow's evidence is
+                         overwritten
+  -r, --recursive        With a directory path, also run flows in subdirectories
   --json                 Print the raw JSON report
   --help, -h             Show this help
+  --                     End of options \u2014 only needed for a flow whose name
+                         starts with "-" (\`argent flow run -- -nightly\`)
 
 Examples:
   argent flow run checkout --platform ios
-  argent flow run checkout --device <UDID> --update-baselines
-  argent flow run checkout --output flow-artifacts --json
+  argent flow run .argent/flows/checkout.yaml --output flow-artifacts --json
+  argent flow run ~/shared-flows/checkout.yaml --device <UDID> --update-baselines
+  argent flow run .argent/flows --recursive
 `);
 }
 function parseRunArgs(argv) {
-  const out = { updateBaselines: false, json: false };
+  const out = {
+    updateBaselines: false,
+    recursive: false,
+    json: false
+  };
+  const takePositional = (tok) => {
+    if (out.flowRef !== void 0) {
+      throw new FlagParseException(
+        `unexpected argument ${JSON.stringify(tok)}; flow run accepts one flow name, YAML file path, or directory path`
+      );
+    }
+    out.flowRef = tok;
+  };
   for (let i2 = 0; i2 < argv.length; i2++) {
     const tok = argv[i2];
+    if (tok === "--") {
+      for (const rest of argv.slice(i2 + 1)) takePositional(rest);
+      break;
+    }
     if (!tok.startsWith("-")) {
-      if (!out.name) out.name = tok;
+      takePositional(tok);
       continue;
     }
     const eq = tok.startsWith("--") ? tok.indexOf("=") : -1;
@@ -8934,6 +9628,12 @@ function parseRunArgs(argv) {
     };
     const noValue = (name) => {
       if (inline !== void 0) throw new FlagParseException(`${name} does not take a value`);
+      const next = argv[i2 + 1]?.trim().toLowerCase();
+      if (next === "true" || next === "false") {
+        throw new FlagParseException(
+          `${name} does not take a value \u2014 it is a switch; omit it to leave the option off`
+        );
+      }
     };
     if (flag === "--update-baselines") {
       noValue("--update-baselines");
@@ -8941,6 +9641,9 @@ function parseRunArgs(argv) {
     } else if (flag === "--json") {
       noValue("--json");
       out.json = true;
+    } else if (flag === "--recursive" || flag === "-r") {
+      noValue("--recursive");
+      out.recursive = true;
     } else if (flag === "--device") out.device = takeValue("--device");
     else if (flag === "--platform") out.platform = takeValue("--platform");
     else if (flag === "--output") out.output = takeValue("--output");
@@ -8971,8 +9674,10 @@ function renderUnderStepLine(s, n2, text2) {
 function renderSummary(report, opts = {}) {
   const warnings = report.steps.filter((s) => s.warning).length;
   const warningsNote = warnings ? `, ${warnings} warning${warnings === 1 ? "" : "s"}` : "";
-  const where = opts.withDevice ? ` on ${report.device}` : "";
-  return `${report.ok ? "PASS" : "FAIL"}${where} \u2014 ${report.passed} passed, ${report.failed} failed, ${report.errored} errored, ${report.skipped} skipped${warningsNote}`;
+  const where = opts.withDevice && report.device ? ` on ${report.device}` : "";
+  const nothingCounted = report.ok && report.passed + report.failed + report.errored + report.skipped === 0;
+  const note = nothingCounted ? " (no test steps)" : "";
+  return `${report.ok ? "PASS" : "FAIL"}${where} \u2014 ${report.passed} passed, ${report.failed} failed, ${report.errored} errored, ${report.skipped} skipped${warningsNote}${note}`;
 }
 function renderArtifactLines(report) {
   const lines = [];
@@ -8988,28 +9693,137 @@ function renderArtifactLines(report) {
   }
   return lines;
 }
-var SAFE_ARTIFACT_NAME = /^[A-Za-z0-9_-]+$/;
-async function exportFailureArtifacts(report, outputDir, ctx) {
-  if (!SAFE_ARTIFACT_NAME.test(report.flow)) {
+function renderFailedSteps(report) {
+  const lines = [];
+  let n2 = 0;
+  for (const s of report.steps) {
+    if (s.kind === "echo") continue;
+    n2++;
+    if (s.status !== "fail" && s.status !== "error") continue;
+    lines.push(renderStepLine(s, n2, report.flow));
+    if (s.warning) lines.push(renderUnderStepLine(s, n2, `\u26A0 ${s.warning}`));
+    if (s.artifacts && typeof s.artifacts === "object") {
+      for (const [k, v] of Object.entries(s.artifacts)) {
+        if (typeof v === "string") lines.push(renderUnderStepLine(s, n2, `${k}: ${v}`));
+      }
+    }
+  }
+  return lines;
+}
+function renderBatchSummary(counts) {
+  return `${counts.failed === 0 ? "PASS" : "FAIL"} \u2014 ${counts.total} flow${counts.total === 1 ? "" : "s"}: ${counts.passed} passed, ${counts.failed} failed, ${counts.skipped} skipped`;
+}
+var SAFE_ARTIFACT_NAME = FLOW_NAME_PATTERN;
+var SAFE_FLOW_NAME = FLOW_NAME_PATTERN;
+var FLOWS_DIR = path13.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("'", "'\\''")}'`;
+}
+var EXPORT_SOURCE_MARKER = ".argent-flow-source";
+var MARKER_READ_RETRIES = 4;
+var MARKER_READ_DELAY_MS = 5;
+async function readExportMarker(dir) {
+  const marker = path13.join(dir, EXPORT_SOURCE_MARKER);
+  for (let attempt = 0; ; attempt++) {
+    let owner;
+    try {
+      owner = (await fsp.readFile(marker, "utf8")).trim();
+    } catch {
+      return void 0;
+    }
+    if (owner) return owner;
+    if (attempt === MARKER_READ_RETRIES) return null;
+    await new Promise((resolve10) => setTimeout(resolve10, MARKER_READ_DELAY_MS));
+  }
+}
+async function classifyExportDir(dir, flowPath) {
+  let owner = await readExportMarker(dir);
+  if (owner === void 0) {
+    try {
+      if ((await fsp.readdir(dir)).length === 0) {
+        return { state: "free" };
+      }
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return { state: "free" };
+      }
+    }
+    owner = null;
+  }
+  return owner === flowPath ? { state: "mine" } : { state: "foreign", owner };
+}
+function occupiedBy(owner) {
+  return owner === null ? "already holds files from an unknown source" : `already holds artifacts from ${owner}`;
+}
+async function takeExportDir(dir, flowPath) {
+  try {
+    await fsp.mkdir(dir, { recursive: true });
+    await fsp.writeFile(path13.join(dir, EXPORT_SOURCE_MARKER), `${flowPath}
+`, { flag: "wx" });
+    return null;
+  } catch (err) {
+    if (err.code !== "EEXIST") {
+      return `could not be claimed (${err instanceof Error ? err.message : String(err)})`;
+    }
+  }
+  const owner = await readExportMarker(dir);
+  return owner === flowPath ? null : occupiedBy(owner ?? null);
+}
+async function claimExportDirName(outputDir, flowPath, stem) {
+  const hash = createHash5("sha256").update(flowPath).digest("hex");
+  const candidates = [stem];
+  for (let len = 8; len <= hash.length; len += 8) {
+    candidates.push(`${stem}-${hash.slice(0, len)}`);
+  }
+  const avoided = [];
+  for (const name of candidates) {
+    const dir = path13.join(outputDir, name);
+    const claim = await classifyExportDir(dir, flowPath);
+    const reason = claim.state === "foreign" ? occupiedBy(claim.owner) : await takeExportDir(dir, flowPath);
+    if (reason !== null) {
+      avoided.push({ dir, reason });
+      continue;
+    }
+    for (const entry of avoided) {
+      console.error(
+        `warning: ${entry.dir} ${entry.reason}; writing this flow's artifacts to ${dir} so neither set is overwritten`
+      );
+    }
+    return name;
+  }
+  console.error(
+    `warning: not exporting artifacts for ${flowPath}: no candidate directory from ${avoided[0].dir} through ${avoided[avoided.length - 1].dir} could be claimed without overwriting other files; leaving this run's artifact paths in place so nothing is overwritten`
+  );
+  return null;
+}
+async function exportFailureArtifacts(report, outputDir, flowPath, ctx) {
+  const stem = path13.basename(flowPath, ".yaml");
+  if (!SAFE_ARTIFACT_NAME.test(stem)) {
     console.error(
-      `warning: skipping artifact export for unsafe flow name ${JSON.stringify(report.flow)}`
+      `warning: skipping artifact export for unsafe flow filename ${JSON.stringify(stem)}`
     );
     return;
   }
+  let dir = null;
   for (const s of report.steps) {
     if (s.kind !== "snapshot" || s.status !== "fail" || !s.artifacts) continue;
     const key = s.snapshotKey ?? keyFromBaselinePath(s.artifacts);
     if (!key || !SAFE_ARTIFACT_NAME.test(key)) continue;
     const { result } = await materializeArtifacts(s.artifacts, ctx);
     s.artifacts = result;
-    const dir = path12.join(outputDir, report.flow);
     for (const [role, value] of Object.entries(s.artifacts)) {
       if (typeof value !== "string") continue;
-      const dest = path12.join(dir, `${key}-${role}.png`);
-      const rel = path12.relative(outputDir, dest);
-      if (rel.startsWith("..") || path12.isAbsolute(rel)) continue;
+      if (dir === null) {
+        const dirName = await claimExportDirName(outputDir, flowPath, stem);
+        if (dirName === null) return;
+        dir = path13.join(outputDir, dirName);
+      }
+      const dest = path13.join(dir, `${key}-${role}.png`);
+      const rel = path13.relative(outputDir, dest);
+      if (rel.startsWith("..") || path13.isAbsolute(rel)) continue;
       try {
-        await fsp.mkdir(dir, { recursive: true });
         await fsp.copyFile(value, dest);
         s.artifacts[role] = dest;
       } catch (err) {
@@ -9023,7 +9837,7 @@ async function exportFailureArtifacts(report, outputDir, ctx) {
 function keyFromBaselinePath(artifacts) {
   const baseline = artifacts.baseline;
   if (typeof baseline !== "string") return null;
-  return path12.basename(baseline).replace(/\.png$/, "");
+  return path13.basename(baseline).replace(/\.png$/, "");
 }
 function resolveArtifactDisplayPaths(report) {
   for (const s of report.steps) {
@@ -9035,12 +9849,12 @@ function resolveArtifactDisplayPaths(report) {
 }
 function exitAfterFlush(code, streams = [process.stdout, process.stderr]) {
   return Promise.all(
-    streams.map((s) => new Promise((resolve9) => s.write("", () => resolve9())))
+    streams.map((s) => new Promise((resolve10) => s.write("", () => resolve10())))
   ).then(() => process.exit(code));
 }
 function renderReport(report) {
   const lines = [];
-  lines.push(`Flow "${report.flow}" on ${report.device}`);
+  lines.push(`Flow "${report.flow}"${report.device ? ` on ${report.device}` : ""}`);
   if (report.executionPrerequisite) {
     lines.push(`  assumes: ${report.executionPrerequisite}`);
   }
@@ -9064,20 +9878,188 @@ function renderReport(report) {
 ${renderSummary(report)}`);
   return lines.join("\n");
 }
+async function isRunnableFlowFile(filePath) {
+  try {
+    const stat5 = await fsp.stat(filePath);
+    if (!stat5.isFile()) return false;
+    await fsp.access(filePath, fsConstants2.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function collectRunnableFlowPaths(dir, relDir = "") {
+  const found = [];
+  const entries = await fsp.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const rel = relDir ? path13.join(relDir, entry.name) : entry.name;
+    if (entry.isDirectory()) {
+      if (entry.name === "__baselines__") continue;
+      found.push(
+        ...await collectRunnableFlowPaths(path13.join(dir, entry.name), rel).catch(() => [])
+      );
+      continue;
+    }
+    if (!entry.name.endsWith(".yaml")) continue;
+    if (!SAFE_FLOW_NAME.test(path13.basename(entry.name, ".yaml"))) continue;
+    if (await isRunnableFlowFile(path13.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: path13.join(FLOWS_DIR, `${ref}.yaml`), fromName: true };
+}
+async function savedFlowHint(projectRoot, missingPath) {
+  const dir = path13.resolve(projectRoot, FLOWS_DIR);
+  const within = path13.relative(dir, missingPath);
+  if (!within.startsWith("..") && !path13.isAbsolute(within)) return "";
+  const wanted = `${path13.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 = path13.basename(actual, ".yaml");
+  if (!SAFE_FLOW_NAME.test(name)) return "";
+  if (!await isRunnableFlowFile(path13.join(dir, actual))) return "";
+  return `
+A flow named "${name}" is saved under ${FLOWS_DIR} \u2014 did you mean: argent flow run ${name}`;
+}
+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 ? path13.join(rel, entry.name) : entry.name;
+      if (entry.isDirectory()) {
+        if (recursive && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+          await walk(path13.join(current, entry.name), entryRel).catch(() => {
+          });
+        }
+        continue;
+      }
+      if (!entry.name.endsWith(".yaml")) continue;
+      if (!SAFE_FLOW_NAME.test(path13.basename(entry.name, ".yaml"))) continue;
+      if (await isRunnableFlowFile(path13.join(current, entry.name))) found.push(entryRel);
+    }
+  };
+  await walk(dir, "");
+  return found.sort();
+}
+async function requireLocalToolServer() {
+  const routing = await getResolvedToolsUrl();
+  if (routing.source === "none") return true;
+  const recovery = routing.source === "env" ? routing.shadowedLink ? `Unset ARGENT_TOOLS_URL and run \`argent unlink\`, then try again \u2014 a link to ${routing.shadowedLink.url} is also configured and takes over once the env var is unset.` : "Unset ARGENT_TOOLS_URL and try again." : "Run `argent unlink` and try again.";
+  console.error(
+    `argent flow run requires the auto-started local tool server; ${routing.source} routing is configured.
+${recovery}`
+  );
+  return false;
+}
+function buildRunPayload(flowPath, projectRoot, args) {
+  const payload = {
+    flow_path: flowPath,
+    project_root: projectRoot,
+    // Headless runs never block on the LLM prerequisite handshake.
+    prerequisiteAcknowledged: true
+  };
+  if (args.device) payload.device = args.device;
+  if (args.platform) payload.platform = args.platform;
+  if (args.updateBaselines) payload.updateBaselines = true;
+  return payload;
+}
+async function exportAndResolveArtifacts(report, outputDir, flowPath, baseUrl) {
+  if (outputDir) {
+    const { url, token } = await baseUrl();
+    await exportFailureArtifacts(report, outputDir, flowPath, { toolsUrl: url, authToken: token });
+  }
+  resolveArtifactDisplayPaths(report);
+}
+async function runFlowDirectory(dir, args, projectRoot, options) {
+  let flows;
+  try {
+    flows = await collectFlowFiles(dir, args.recursive);
+  } catch {
+    console.error(`Could not read flow directory: ${dir}`);
+    return exitAfterFlush(2);
+  }
+  if (flows.length === 0) {
+    console.error(`No flows found in ${dir}`);
+    if (!args.recursive) console.error("Pass -r/--recursive to include subdirectories.");
+    return exitAfterFlush(2);
+  }
+  if (!await requireLocalToolServer()) return exitAfterFlush(2);
+  const { callTool, baseUrl } = createToolsClient({ paths: options.paths });
+  const outputBase = args.output ? path13.resolve(args.output) : void 0;
+  const results = [];
+  let stopped = false;
+  for (const [i2, rel] of flows.entries()) {
+    if (!args.json) console.log(`[${i2 + 1}/${flows.length}] ${rel}`);
+    if (stopped) {
+      results.push({ path: rel, status: "skip" });
+      if (!args.json) console.log(`  ${STATUS_GLYPH.skip} not run (batch stopped)`);
+      continue;
+    }
+    let report;
+    try {
+      const resp = await callTool(
+        "flow-execute",
+        buildRunPayload(path13.join(dir, rel), projectRoot, args)
+      );
+      const data = resp.data;
+      if (data && typeof data === "object" && "steps" in data) report = data;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(message);
+      results.push({ path: rel, status: "fail", error: message });
+      const rejectedThisFlowOnly = err instanceof ToolInvocationError && err.errorKind === "validation";
+      if (!rejectedThisFlowOnly) stopped = true;
+      continue;
+    }
+    if (!report) {
+      const message = `"${rel}" did not produce a run report.`;
+      console.error(message);
+      results.push({ path: rel, status: "fail", error: message });
+      stopped = true;
+      continue;
+    }
+    await exportAndResolveArtifacts(
+      report,
+      outputBase ? path13.join(outputBase, path13.dirname(rel)) : void 0,
+      path13.join(dir, rel),
+      baseUrl
+    );
+    results.push({ path: rel, status: report.ok ? "pass" : "fail", report });
+    if (!args.json) {
+      for (const line of renderFailedSteps(report)) console.log(line);
+      console.log(`  ${renderSummary(report, { withDevice: true })}`);
+    }
+  }
+  const counts = {
+    total: results.length,
+    passed: results.filter((r2) => r2.status === "pass").length,
+    failed: results.filter((r2) => r2.status === "fail").length,
+    skipped: results.filter((r2) => r2.status === "skip").length
+  };
+  if (args.json) {
+    console.log(JSON.stringify({ ok: counts.failed === 0, ...counts, flows: results }, null, 2));
+  } else {
+    console.log(`
+${renderBatchSummary(counts)}`);
+  }
+  return exitAfterFlush(counts.failed === 0 ? 0 : 1);
+}
 async function flow(argv, options) {
   const [sub, ...rest] = argv;
   if (!sub || sub === "--help" || sub === "-h") {
     printHelp();
     return;
   }
-  const { callTool, baseUrl } = createToolsClient({ paths: options.paths });
   if (sub === "list") {
-    const dir = path12.join(process.cwd(), ".argent", "flows");
+    const dir = path13.join(process.cwd(), FLOWS_DIR);
     try {
-      const entries = await fsp.readdir(dir);
-      const names = entries.filter((f) => f.endsWith(".yaml")).map((f) => f.replace(/\.yaml$/, ""));
-      if (names.length === 0) console.log("No flows found in .argent/flows");
-      else console.log(names.join("\n"));
+      const paths = (await collectRunnableFlowPaths(dir)).sort().map((rel) => path13.join(FLOWS_DIR, rel));
+      if (paths.length === 0) console.log("No flows found in .argent/flows");
+      else console.log(paths.join("\n"));
     } catch {
       console.log("No .argent/flows directory in the current working directory.");
     }
@@ -9103,21 +10085,121 @@ async function flow(argv, options) {
     }
     throw err;
   }
-  if (!args.name) {
-    console.error("argent flow run <name> requires a flow name.");
+  if (!args.flowRef) {
+    console.error(
+      "argent flow run <flow|flow.yaml|dir> requires a flow name, a YAML file path, or a directory path."
+    );
     printHelp();
     return exitAfterFlush(2);
   }
-  const flowName = args.name;
-  const payload = {
-    name: flowName,
-    project_root: process.cwd(),
-    // Headless runs never block on the LLM prerequisite handshake.
-    prerequisiteAcknowledged: true
-  };
-  if (args.device) payload.device = args.device;
-  if (args.platform) payload.platform = args.platform;
-  if (args.updateBaselines) payload.updateBaselines = true;
+  const projectRoot = process.cwd();
+  const { suppliedPath, fromName } = resolveFlowRef(args.flowRef);
+  if (suppliedPath.split(/[\\/]+/).includes("..")) {
+    let recovery = "Pass the fully resolved path to the flow's YAML.";
+    const suppliedBase2 = path13.basename(suppliedPath);
+    if (suppliedBase2 !== ".." && suppliedBase2 !== ".") {
+      try {
+        const resolved = path13.join(await fsp.realpath(path13.dirname(suppliedPath)), suppliedBase2);
+        await fsp.stat(resolved);
+        recovery = `Did you mean: argent flow run ${shellQuoteArg(resolved)}`;
+      } catch {
+      }
+    }
+    console.error(
+      `Flow path must not contain ".." segments \u2014 they are collapsed without following symlinks, so the path can name a different file than the one your shell opens: ${suppliedPath}
+` + recovery
+    );
+    return exitAfterFlush(2);
+  }
+  const resolvedPath = path13.resolve(projectRoot, suppliedPath);
+  let isDirectory = false;
+  try {
+    isDirectory = (await fsp.stat(resolvedPath)).isDirectory();
+  } catch {
+    if (args.recursive && !fromName) {
+      console.error(`Flow directory not found: ${resolvedPath}`);
+      return exitAfterFlush(2);
+    }
+  }
+  if (isDirectory) {
+    return runFlowDirectory(resolvedPath, args, projectRoot, options);
+  }
+  if (args.recursive) {
+    console.error(
+      fromName ? `flow run --recursive requires a directory path; "${args.flowRef}" is a saved-flow name, which always addresses the single file ${suppliedPath}.` : `flow run --recursive requires a directory path: ${suppliedPath}`
+    );
+    return exitAfterFlush(2);
+  }
+  const separatorTrimmedPath = suppliedPath.replace(/[\\/]+$/, "");
+  if (separatorTrimmedPath !== suppliedPath && separatorTrimmedPath !== "") {
+    const hint = SAFE_FLOW_NAME.test(separatorTrimmedPath) ? `.${path13.sep}${separatorTrimmedPath}` : separatorTrimmedPath;
+    console.error(
+      `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)}`
+    );
+    return exitAfterFlush(2);
+  }
+  if (path13.extname(suppliedPath) !== ".yaml") {
+    const looksLikeName = !suppliedPath.includes("/") && !suppliedPath.includes("\\") && path13.extname(suppliedPath) === "";
+    if (path13.basename(suppliedPath).toLowerCase() === ".yaml") {
+      console.error(
+        `Flow filename must have a non-empty name containing only letters, numbers, "_", or "-": ${suppliedPath}`
+      );
+    } else if (looksLikeName) {
+      console.error(
+        `Flow name must contain only letters, numbers, "_", or "-": ${suppliedPath}
+Names run \`${FLOWS_DIR}/<name>.yaml\`; pass a path ending in .yaml to run a flow file kept elsewhere.`
+      );
+    } else if (path13.extname(suppliedPath).toLowerCase() === ".yaml") {
+      console.error(
+        `Flow extension must be lowercase .yaml, not ${path13.extname(suppliedPath)}: ${suppliedPath}`
+      );
+    } else {
+      console.error(`Flow path must end in .yaml: ${suppliedPath}`);
+    }
+    return exitAfterFlush(2);
+  }
+  const flowName = path13.basename(suppliedPath, ".yaml");
+  if (!SAFE_FLOW_NAME.test(flowName)) {
+    console.error(
+      `Flow filename must have a non-empty name containing only letters, numbers, "_", or "-": ${suppliedPath}`
+    );
+    return exitAfterFlush(2);
+  }
+  const flowPath = resolvedPath;
+  try {
+    const stat5 = await fsp.stat(flowPath);
+    if (!stat5.isFile()) {
+      console.error(`Flow path is not a file: ${flowPath}`);
+      return exitAfterFlush(2);
+    }
+    await fsp.access(flowPath, fsConstants2.R_OK);
+  } catch (err) {
+    const code = err.code;
+    const detail = code === "ENOENT" ? "Flow file not found" : "Could not read flow file";
+    let recovery = "";
+    if (code === "ENOENT") {
+      recovery = fromName ? `
+No flow named "${args.flowRef}" is saved there \u2014 run \`argent flow list\` to see the saved flows.` : await savedFlowHint(projectRoot, flowPath);
+    }
+    console.error(`${detail}: ${flowPath}${recovery}`);
+    return exitAfterFlush(2);
+  }
+  const suppliedBase = path13.basename(flowPath);
+  const siblings = await fsp.readdir(path13.dirname(flowPath)).catch(() => null);
+  if (siblings !== null && !siblings.includes(suppliedBase)) {
+    const actual = siblings.find((name) => name.toLowerCase() === suppliedBase.toLowerCase());
+    const actualRunnable = actual !== void 0 && path13.extname(actual) === ".yaml" && SAFE_FLOW_NAME.test(path13.basename(actual, ".yaml"));
+    const recovery = actualRunnable ? fromName ? `Did you mean: argent flow run ${path13.basename(actual, ".yaml")}` : `Did you mean: argent flow run ${shellQuoteArg(path13.join(path13.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.";
+    console.error(
+      `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}`
+    );
+    return exitAfterFlush(2);
+  }
+  if (!await requireLocalToolServer()) return exitAfterFlush(2);
+  const { callTool, baseUrl } = createToolsClient({ paths: options.paths });
+  const payload = buildRunPayload(flowPath, projectRoot, args);
   let liveSteps = 0;
   let liveIndex = 0;
   const onStepReport = (event) => {
@@ -9149,14 +10231,12 @@ async function flow(argv, options) {
     console.error(`"${flowName}" did not produce a run report.`);
     return exitAfterFlush(2);
   }
-  if (args.output) {
-    const { url, token } = await baseUrl();
-    await exportFailureArtifacts(report, path12.resolve(args.output), {
-      toolsUrl: url,
-      authToken: token
-    });
-  }
-  resolveArtifactDisplayPaths(report);
+  await exportAndResolveArtifacts(
+    report,
+    args.output ? path13.resolve(args.output) : void 0,
+    flowPath,
+    baseUrl
+  );
   if (args.json) {
     console.log(JSON.stringify(report, null, 2));
   } else if (liveSteps > 0) {
@@ -9216,10 +10296,27 @@ ${sorted.length} tools. Run \`argent tools describe <name>\` for details.`);
     console.log(formatSchemaUsage(meta.inputSchema));
     if (meta.outputHint) console.log(`
 Output hint: ${meta.outputHint}`);
+  }
+  function printUsage4() {
+    console.log(`Usage:
+  argent tools                       List available tools
+  argent tools describe <name>       Show one tool's flags and description
+
+Options:
+  --json                             Print machine-readable JSON
+  --help, -h                         Show this help
+
+Listing tools contacts the argent tool-server, starting one if none is running.
+`);
   }
   const json = argv.includes("--json");
-  const positional = argv.filter((a2) => !a2.startsWith("--"));
+  const isHelpFlag = (a2) => a2 === "--help" || a2 === "-h";
+  const positional = argv.filter((a2) => !a2.startsWith("--") || isHelpFlag(a2));
   const sub = positional[0];
+  if (sub !== void 0 && isHelpFlag(sub)) {
+    printUsage4();
+    return;
+  }
   if (!sub) {
     await listTools(json);
     return;
@@ -9233,27 +10330,17 @@ Output hint: ${meta.outputHint}`);
     await describeTool(name, json);
     return;
   }
-  if (sub === "--help" || sub === "-h") {
-    console.log(`Usage:
-  argent tools                       List available tools
-  argent tools describe <name>       Show one tool's flags and description
-
-Options:
-  --json                             Print machine-readable JSON
-`);
-    return;
-  }
   console.error(`Unknown subcommand: tools ${sub}`);
   process.exit(1);
 }
 
 // ../argent-cli/src/server.ts
-import * as fs9 from "node:fs";
-import * as path13 from "node:path";
+import * as fs10 from "node:fs";
+import * as path14 from "node:path";
 import { homedir as homedir5, networkInterfaces } from "node:os";
 import { spawn as spawn3 } from "node:child_process";
-var STATE_DIR2 = path13.join(homedir5(), ".argent");
-var LOG_FILE2 = path13.join(STATE_DIR2, "tool-server.log");
+var STATE_DIR2 = path14.join(homedir5(), ".argent");
+var LOG_FILE2 = path14.join(STATE_DIR2, "tool-server.log");
 async function describeForeignServers(ownBundlePath) {
   const others = (await readAllToolsServerStates()).filter(
     ({ state: state2 }) => state2.bundlePath !== ownBundlePath && isToolsServerProcessAlive(state2.pid)
@@ -9312,12 +10399,12 @@ Stop one with: kill <pid>`);
   console.log(`tool-server stopped (pid ${state2.pid}).`);
 }
 function logsCmd(follow) {
-  if (!fs9.existsSync(LOG_FILE2)) {
+  if (!fs10.existsSync(LOG_FILE2)) {
     console.log(`No log file at ${LOG_FILE2}`);
     return;
   }
   if (!follow) {
-    process.stdout.write(fs9.readFileSync(LOG_FILE2, "utf8"));
+    process.stdout.write(fs10.readFileSync(LOG_FILE2, "utf8"));
     return;
   }
   const child = spawn3("tail", ["-f", LOG_FILE2], { stdio: "inherit" });
@@ -9660,9 +10747,9 @@ async function server(argv, options) {
 }
 
 // ../argent-cli/src/lens.ts
-import * as fs10 from "node:fs";
+import * as fs11 from "node:fs";
 import * as os2 from "node:os";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 
 // ../argent-cli/src/lens-terminal.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
@@ -9880,15 +10967,15 @@ 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 dirname8, join as join14 } from "node:path";
+import { dirname as dirname9, join as join15 } from "node:path";
 var nodeRequire = createRequire(import.meta.url);
 function ensureSpawnHelperExecutable(req = nodeRequire) {
   if (process.platform !== "darwin") return;
   try {
-    const prebuilds = join14(dirname8(req.resolve("node-pty/package.json")), "prebuilds");
+    const prebuilds = join15(dirname9(req.resolve("node-pty/package.json")), "prebuilds");
     for (const entry of readdirSync2(prebuilds)) {
       try {
-        chmodSync2(join14(prebuilds, entry, "spawn-helper"), 493);
+        chmodSync2(join15(prebuilds, entry, "spawn-helper"), 493);
       } catch {
       }
     }
@@ -9920,7 +11007,7 @@ function ptyInjectBeats(text2) {
   ];
 }
 function sleep(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 var DEFAULT_COLS = 80;
 var DEFAULT_ROWS = 24;
@@ -10030,10 +11117,10 @@ function parseSseBuffer(buffer) {
   const events = [];
   let rest = normalised;
   for (; ; ) {
-    const sep5 = rest.indexOf("\n\n");
-    if (sep5 === -1) break;
-    const rawFrame = rest.slice(0, sep5);
-    rest = rest.slice(sep5 + 2);
+    const sep6 = rest.indexOf("\n\n");
+    if (sep6 === -1) break;
+    const rawFrame = rest.slice(0, sep6);
+    rest = rest.slice(sep6 + 2);
     let event = "message";
     const dataLines = [];
     for (const line of rawFrame.split("\n")) {
@@ -10141,7 +11228,7 @@ var SPAWN_GRACE_MS = 8e3;
 var DEATH_CONFIRMATIONS = 3;
 var SSE_RECONNECT_MS = 1e3;
 function sleep2(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 var TRUST_PROMPT_RE = /trust this folder|do you trust|yes,? i trust|trust the files in this/i;
 async function dismissTrustPrompt(session) {
@@ -10297,8 +11384,15 @@ function parseArgs(argv) {
   for (let i2 = 0; i2 < argv.length; i2++) {
     const tok = argv[i2];
     if (tok === "--help" || tok === "-h") help = true;
-    else if (tok === "--forget") forget = true;
-    else if (tok === "--terminal" || tok === "-t") {
+    else if (tok === "--forget") {
+      forget = true;
+      const next = argv[i2 + 1]?.trim().toLowerCase();
+      if (next === "true" || next === "false") {
+        process.stderr.write(`lens: --forget does not take a value; omit it to keep the state
+`);
+        process.exit(2);
+      }
+    } else if (tok === "--terminal" || tok === "-t") {
       const v = argv[++i2];
       if (v === "iterm" || v === "terminal") terminal = v;
       else {
@@ -10414,12 +11508,12 @@ async function lens(argv, options) {
     await endSession(baseUrl);
     process.exit(1);
   }
-  const seedFile = path14.join(os2.tmpdir(), `argent-lens-seed-${process.pid}-${Date.now()}.txt`);
-  fs10.writeFileSync(seedFile, buildSeedPrompt(), "utf8");
+  const seedFile = path15.join(os2.tmpdir(), `argent-lens-seed-${process.pid}-${Date.now()}.txt`);
+  fs11.writeFileSync(seedFile, buildSeedPrompt(), "utf8");
   const launchCmd = agent.launch(shellQuote(process.cwd()), shellQuote(seedFile));
   const removeSeedFile = () => {
     try {
-      fs10.rmSync(seedFile, { force: true });
+      fs11.rmSync(seedFile, { force: true });
     } catch {
     }
   };
@@ -10809,7 +11903,7 @@ Options:
 
 // ../argent-cli/src/config.ts
 var import_picocolors2 = __toESM(require_picocolors(), 1);
-import * as path15 from "node:path";
+import * as path16 from "node:path";
 function config(argv) {
   if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
     printUsage();
@@ -10859,6 +11953,7 @@ the raw value stored at each scope.`);
 }
 function scopeDetail(e) {
   const parts = [`scopes: ${e.scopes.join(", ")}`];
+  if (e.expected) parts.push(`value: ${e.expected}${e.example ? `, e.g. ${e.example}` : ""}`);
   if (e.project !== void 0) parts.push(`project=${formatValuePlain(e.project)}`);
   if (e.global !== void 0) parts.push(`global=${formatValuePlain(e.global)}`);
   return parts.join("  \xB7  ");
@@ -10923,7 +12018,7 @@ parsed (e.g. \`true\`, \`42\`, \`["a","b"]\`); anything else is stored as a stri
     if (warning) console.error(import_picocolors2.default.yellow(warning));
     console.log(`Set ${import_picocolors2.default.bold(key)} = ${formatValuePlain(stored)} (${scopeLabel(targetScope)}).`);
   } catch (err) {
-    reportError(err);
+    reportError(err, () => suggestCorrectedSet(err, key, rawValue, scope));
   }
 }
 function cmdUnset(argv) {
@@ -10992,16 +12087,16 @@ function wantsHelp(argv) {
 }
 function scopeLabel(scope) {
   if (scope === "global") return "global";
-  return `project: ${path15.dirname(configDir("project"))}`;
+  return `project: ${path16.dirname(configDir("project"))}`;
 }
 function degenerateProjectScopeWarning(scope) {
   if (scope !== "project") return null;
   const projDir = configDir("project");
-  if (path15.resolve(projDir) === path15.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 (${path15.join(projDir, "config.json")}).`;
+  if (path16.resolve(projDir) === path16.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 (${path16.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 ${path15.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 ${path16.join(projDir, "config.json")}.`;
   }
   return null;
 }
@@ -11016,7 +12111,20 @@ function formatValue(value) {
   }
   return formatValuePlain(value);
 }
-function reportError(err) {
+function quoteForShell(value) {
+  if (/^[A-Za-z0-9._/@:+-]+$/.test(value)) return value;
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function suggestCorrectedSet(err, key, rawValue, scope) {
+  if (!(err instanceof ConfigValidationError)) return null;
+  const def = getConfigDefinition(key);
+  if (!def) return null;
+  const wrapped = def.parse([rawValue]);
+  if (wrapped === void 0) return null;
+  const scopeFlag = scope ? ` --scope ${scope}` : "";
+  return `argent config set ${key} ${quoteForShell(JSON.stringify([rawValue]))}${scopeFlag}`;
+}
+function reportError(err, suggest) {
   if (err instanceof ConfigManagedElsewhereError) {
     console.error(`Error: ${err.message} Use \`${err.command}\` instead.`);
   } else if (err instanceof UnknownConfigKeyError || err instanceof ConfigScopeError || err instanceof ConfigValidationError) {
@@ -11024,6 +12132,15 @@ function reportError(err) {
     if (err instanceof UnknownConfigKeyError) {
       console.error(`Run \`argent config list\` to see available keys.`);
     }
+    if (err instanceof ConfigValidationError) {
+      const corrected = suggest?.() ?? null;
+      if (corrected) {
+        console.error(`Did you mean: ${corrected}`);
+      } else if (err.example) {
+        console.error(`Example: argent config set ${err.key} ${quoteForShell(err.example)}`);
+      }
+      console.error(`Run \`argent config list\` to see each key's expected value.`);
+    }
   } else {
     console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -11055,6 +12172,99 @@ ${keyLines.join("\n")}
 Run \`argent config <command> --help\` for command-specific help.`);
 }
 
+// ../argent-cli/src/secrets.ts
+var import_picocolors3 = __toESM(require_picocolors(), 1);
+async function secrets(argv) {
+  const [sub, ...rest] = argv;
+  if (sub === void 0 || sub === "list") return cmdList2(rest);
+  if (sub === "--help" || sub === "-h") return printUsage2();
+  if (sub === "--json") return cmdList2([sub, ...rest]);
+  console.error(`Error: unknown subcommand "secrets ${sub}". Try \`argent secrets --help\`.`);
+  process.exit(2);
+}
+function printUsage2() {
+  console.log(`Usage: argent secrets [list] [--json]
+
+List the secrets a \`{{secret:<NAME>}}\` placeholder can resolve, and the sources
+they come from. Names only \u2014 a value is never printed.
+
+A name is resolved by the machine running the tool-server, taking the first
+source that defines it:
+
+  1. ${SECRET_ENV_PREFIX}<NAME> in the environment    prefixed variables only
+  2. <project>/.argent/secrets.env             every key (gitignore this file)
+  3. <project>/.env.local, then <project>/.env  only ${SECRET_ENV_PREFIX}-prefixed keys
+  4. ~/.argent/secrets.env                     every key, any project
+
+A secrets file applies to the next tool call \u2014 no restart. An environment
+variable only reaches a tool-server started after it was exported.
+
+Examples:
+  echo 'APP_PASSWORD=\u2026' >> ~/.argent/secrets.env   # available in every project
+  argent secrets                                   # check it is picked up`);
+}
+async function cmdList2(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) return printUsage2();
+  const json = argv.includes("--json");
+  const sources = secretSources();
+  const all = secretNames(sources);
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          secrets: all,
+          sources: sources.map((s) => ({
+            source: s.label,
+            present: s.present,
+            names: s.names,
+            ...s.needsPrefix ? { needsPrefix: true } : {}
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log(`Secrets available to \`{{secret:<NAME>}}\` on this machine:
+`);
+  const claimed = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    console.log(`  ${source.label}`);
+    if (!source.present) {
+      console.log(`    ${import_picocolors3.default.dim("not found")}`);
+    } else if (source.needsPrefix) {
+      console.log(
+        `    ${import_picocolors3.default.dim(`no ${SECRET_ENV_PREFIX}* keys \u2014 only prefixed keys are exposed from a file the app shares`)}`
+      );
+    } else if (source.names.length === 0) {
+      console.log(`    ${import_picocolors3.default.dim("no secrets")}`);
+    } else {
+      const rendered = source.names.map(
+        (name) => claimed.has(name) ? import_picocolors3.default.dim(`${name} (shadowed above)`) : name
+      );
+      for (const name of source.names) claimed.add(name);
+      console.log(`    ${rendered.join(", ")}`);
+    }
+  }
+  console.log(
+    `
+${all.length === 0 ? "No secrets are defined." : `${all.length} name${all.length === 1 ? "" : "s"} in effect: ${all.join(", ")}`}`
+  );
+  console.log(
+    import_picocolors3.default.dim("Values are never printed. Run `argent secrets --help` to see where to add one.")
+  );
+  const routed = await getResolvedToolsUrl().catch(() => ({ url: null }));
+  if (routed.url) {
+    console.log(
+      import_picocolors3.default.yellow(
+        `
+Note: a remote tool-server is linked (${routed.url}). Placeholders resolve there, against that machine's environment and secrets files \u2014 not the ones listed above.`
+      )
+    );
+  }
+}
+
 // ../../node_modules/@clack/core/dist/index.mjs
 import { styleText } from "node:util";
 import { stdout, stdin } from "node:process";
@@ -11775,7 +12985,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 dirname10, join as join17 } from "node:path";
+import { dirname as dirname11, join as join18 } from "node:path";
 function isUnicodeSupported() {
   if (process$1.platform !== "win32") {
     return process$1.env.TERM !== "linux";
@@ -12212,7 +13422,7 @@ ${r2}
 }).prompt();
 
 // ../argent-cli/src/link.ts
-var import_picocolors3 = __toESM(require_picocolors(), 1);
+var import_picocolors4 = __toESM(require_picocolors(), 1);
 var WILDCARD_HOSTS = /* @__PURE__ */ new Set(["0.0.0.0", "::", "::0", ""]);
 function isLoopback2(host) {
   return host === "127.0.0.1" || host === "localhost" || host === "::1";
@@ -12470,7 +13680,7 @@ async function preflightHealth(url, token) {
 }
 function printRestartHint() {
   console.log(
-    import_picocolors3.default.dim("Restart your editor to apply the change to any running `argent mcp` session.")
+    import_picocolors4.default.dim("Restart your editor to apply the change to any running `argent mcp` session.")
   );
 }
 function printSecurityCaveat(host, token, url) {
@@ -12479,7 +13689,7 @@ function printSecurityCaveat(host, token, url) {
   if (tls) {
     if (!token) {
       process.stderr.write(
-        import_picocolors3.default.yellow(
+        import_picocolors4.default.yellow(
           `WARNING: ${host} is reached over HTTPS but with NO token \u2014 anyone who can reach the URL can drive the server. Pair with a token.
 `
         )
@@ -12489,7 +13699,7 @@ function printSecurityCaveat(host, token, url) {
   }
   if (token) {
     process.stderr.write(
-      import_picocolors3.default.dim(
+      import_picocolors4.default.dim(
         `Note: ${host} is reached over plain HTTP (bearer-token auth, no TLS). Keep this link to a trusted network or VPN, or front it with an https:// tunnel.
 `
       )
@@ -12497,7 +13707,7 @@ function printSecurityCaveat(host, token, url) {
     return;
   }
   process.stderr.write(
-    import_picocolors3.default.yellow(
+    import_picocolors4.default.yellow(
       `WARNING: linked target ${host} is non-loopback and has NO token \u2014 tool calls travel over plain HTTP with no auth. Treat this link as trusted-network-only, or pair with a token (start the server without --no-auth).
 `
     )
@@ -12530,9 +13740,9 @@ async function link(argv) {
   if (flags2.host !== null) {
     host = flags2.host;
   } else {
-    intro(import_picocolors3.default.bgCyan(import_picocolors3.default.black(" argent link ")));
+    intro(import_picocolors4.default.bgCyan(import_picocolors4.default.black(" argent link ")));
     if (existing) {
-      log.info(`Current link: ${import_picocolors3.default.cyan(existing.url)} (${existing.createdAt})`);
+      log.info(`Current link: ${import_picocolors4.default.cyan(existing.url)} (${existing.createdAt})`);
     }
     host = await promptHost(existing);
   }
@@ -12548,12 +13758,12 @@ async function link(argv) {
   let url = flags2.url ?? formatUrl(host, port);
   if (!flags2.yes && existing) {
     if (existing.url === url) {
-      log.info(`Already linked to ${import_picocolors3.default.cyan(url)}.`);
+      log.info(`Already linked to ${import_picocolors4.default.cyan(url)}.`);
       outro("No changes.");
       return;
     }
     const overwrite = await confirm({
-      message: `Replace existing link ${import_picocolors3.default.dim(existing.url)} with ${import_picocolors3.default.cyan(url)}?`,
+      message: `Replace existing link ${import_picocolors4.default.dim(existing.url)} with ${import_picocolors4.default.cyan(url)}?`,
       initialValue: true
     });
     if (isCancel(overwrite) || !overwrite) {
@@ -12571,10 +13781,10 @@ async function link(argv) {
       }
       const result = await preflightHealth(url, token);
       if (result.ok) {
-        if (spinner2) spinner2.stop(import_picocolors3.default.green("Tool-server reachable."));
+        if (spinner2) spinner2.stop(import_picocolors4.default.green("Tool-server reachable."));
         break;
       }
-      if (spinner2) spinner2.stop(import_picocolors3.default.red("Verification failed."));
+      if (spinner2) spinner2.stop(import_picocolors4.default.red("Verification failed."));
       const detail = result.error ? ` (${result.error})` : "";
       if (flags2.yes) {
         console.error(
@@ -12614,15 +13824,15 @@ async function link(argv) {
   };
   await writeLinkConfig(cfg);
   if (existing && existing.url !== url) {
-    console.log(`${import_picocolors3.default.green("\u2713")} Link updated: ${import_picocolors3.default.dim(existing.url)} \u2192 ${import_picocolors3.default.cyan(url)}`);
+    console.log(`${import_picocolors4.default.green("\u2713")} Link updated: ${import_picocolors4.default.dim(existing.url)} \u2192 ${import_picocolors4.default.cyan(url)}`);
   } else {
-    console.log(`${import_picocolors3.default.green("\u2713")} Linked: ${import_picocolors3.default.cyan(url)}`);
+    console.log(`${import_picocolors4.default.green("\u2713")} Linked: ${import_picocolors4.default.cyan(url)}`);
   }
-  if (token) console.log(import_picocolors3.default.dim("  auth: token stored in ~/.argent/link.json (0600)"));
+  if (token) console.log(import_picocolors4.default.dim("  auth: token stored in ~/.argent/link.json (0600)"));
   printSecurityCaveat(host, token, url);
   if (process.env.ARGENT_TOOLS_URL) {
     console.log(
-      import_picocolors3.default.yellow(
+      import_picocolors4.default.yellow(
         `Note: ARGENT_TOOLS_URL=${process.env.ARGENT_TOOLS_URL} is set in your environment and takes precedence over the link.`
       )
     );
@@ -12653,7 +13863,7 @@ async function unlink3(argv) {
   }
   if (!flags2.yes) {
     const confirmed = await confirm({
-      message: `Remove link to ${import_picocolors3.default.cyan(existing.url)}?`,
+      message: `Remove link to ${import_picocolors4.default.cyan(existing.url)}?`,
       initialValue: true
     });
     if (isCancel(confirmed) || !confirmed) {
@@ -12662,10 +13872,10 @@ async function unlink3(argv) {
     }
   }
   await clearLinkConfig();
-  console.log(`${import_picocolors3.default.green("\u2713")} Unlinked from ${import_picocolors3.default.dim(existing.url)}.`);
+  console.log(`${import_picocolors4.default.green("\u2713")} Unlinked from ${import_picocolors4.default.dim(existing.url)}.`);
   if (process.env.ARGENT_TOOLS_URL) {
     console.log(
-      import_picocolors3.default.yellow(
+      import_picocolors4.default.yellow(
         `The env var ARGENT_TOOLS_URL is also set in your shell (=${process.env.ARGENT_TOOLS_URL}) and takes precedence \u2014 unset it manually if you want fully local behaviour.`
       )
     );
@@ -12674,13 +13884,13 @@ async function unlink3(argv) {
 }
 
 // ../argent-cli/src/telemetry.ts
-var import_picocolors4 = __toESM(require_picocolors(), 1);
+var import_picocolors5 = __toESM(require_picocolors(), 1);
 async function telemetry(args) {
   const sub = args[0];
   init("cli");
   switch (sub) {
     case void 0:
-      printUsage2();
+      printUsage3();
       await shutdown();
       return;
     case "status":
@@ -12695,7 +13905,7 @@ async function telemetry(args) {
       return;
     case "--help":
     case "-h":
-      printUsage2();
+      printUsage3();
       await shutdown();
       return;
     default:
@@ -12704,7 +13914,7 @@ async function telemetry(args) {
       process.exit(1);
   }
 }
-function printUsage2() {
+function printUsage3() {
   console.log(`Usage:
   argent telemetry status    Show telemetry state and device id
   argent telemetry enable    Enable telemetry
@@ -12722,21 +13932,21 @@ async function cmdEnable() {
   const wasEnabled = isEnabled();
   markEnabled();
   if (wasEnabled) {
-    console.log(import_picocolors4.default.dim("Telemetry was already enabled."));
+    console.log(import_picocolors5.default.dim("Telemetry was already enabled."));
   } else {
-    console.log(import_picocolors4.default.green("Telemetry enabled."));
+    console.log(import_picocolors5.default.green("Telemetry enabled."));
   }
   await shutdown();
 }
 async function cmdDisable() {
   const wasEnabled = isEnabled();
   if (!wasEnabled) {
-    console.log(import_picocolors4.default.dim("Telemetry was already disabled."));
+    console.log(import_picocolors5.default.dim("Telemetry was already disabled."));
     await shutdown();
     return;
   }
   await markDisabled();
-  console.log(import_picocolors4.default.red("Telemetry disabled."));
+  console.log(import_picocolors5.default.red("Telemetry disabled."));
   await shutdown();
 }
 export {
@@ -12751,6 +13961,7 @@ export {
   lens,
   link,
   run,
+  secrets,
   server,
   telemetry,
   tools,