@swmansion/argent 0.14.1-next.8 → 0.15.0

package/dist/cli-cmds.mjs

@@ -1,4 +1,4 @@
-import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import { createRequire as __createRequire } from 'node:module'; import { fileURLToPath as __fileURLToPath } from 'node:url'; import { dirname as __pathDirname } from 'node:path'; const require = __createRequire(import.meta.url); const __filename = __fileURLToPath(import.meta.url); const __dirname = __pathDirname(__filename);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -162,8 +162,8 @@ var require_src = __commonJS({
 });
 
 // ../argent-cli/src/run.ts
-import * as fs7 from "node:fs";
-import * as path9 from "node:path";
+import * as fs8 from "node:fs";
+import * as path10 from "node:path";
 
 // ../argent-tools-client/src/launcher.ts
 import * as net from "node:net";
@@ -172,8 +172,8 @@ import * as path from "node:path";
 import * as readline from "node:readline";
 import { homedir } from "node:os";
 import { spawn, execFileSync } from "node:child_process";
-import { randomBytes } from "node:crypto";
-import { mkdir, writeFile, readFile, unlink, rename, chmod } from "node:fs/promises";
+import { createHash, randomBytes } from "node:crypto";
+import { mkdir, writeFile, readFile, readdir, unlink, rename, chmod } from "node:fs/promises";
 var STATE_DIR = path.join(homedir(), ".argent");
 var STATE_FILE = path.join(STATE_DIR, "tool-server.json");
 var LOG_FILE = path.join(STATE_DIR, "tool-server.log");
@@ -193,6 +193,8 @@ function buildToolsServerEnv(paths, port, baseEnv = process.env, options = {}) {
     env.ARGENT_IDLE_TIMEOUT_MINUTES = String(options.idleTimeoutMinutes);
   }
   if (options.token) env[AUTH_TOKEN_ENV] = options.token;
+  if (paths.installKind) env.ARGENT_INSTALL_KIND = paths.installKind;
+  if (paths.installProjectRoot) env.ARGENT_PROJECT_ROOT = paths.installProjectRoot;
   return env;
 }
 function generateToken() {
@@ -202,7 +204,7 @@ function generateAuthToken() {
   return generateToken();
 }
 function findFreePort() {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const srv = net.createServer();
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
@@ -213,12 +215,55 @@ function findFreePort() {
       const port = addr.port;
       srv.close((err) => {
         if (err) reject(err);
-        else resolve3(port);
+        else resolve4(port);
       });
     });
     srv.on("error", reject);
   });
 }
+function isVersionNewer(a2, b) {
+  const parse = (v) => {
+    const [core = "", ...preParts] = v.split("+")[0].split("-");
+    const nums = core.split(".").map((n2) => Number.parseInt(n2, 10));
+    if (nums.length === 0 || nums.some((n2) => Number.isNaN(n2))) return null;
+    return { nums, pre: preParts.length > 0 ? preParts.join("-").split(".") : [] };
+  };
+  const pa = parse(a2);
+  const pb = parse(b);
+  if (!pa || !pb) return false;
+  for (let i2 = 0; i2 < 3; i2++) {
+    const x = pa.nums[i2] ?? 0;
+    const y = pb.nums[i2] ?? 0;
+    if (x !== y) return x > y;
+  }
+  if (pa.pre.length === 0 && pb.pre.length === 0) return false;
+  if (pa.pre.length === 0) return true;
+  if (pb.pre.length === 0) return false;
+  for (let i2 = 0; i2 < Math.max(pa.pre.length, pb.pre.length); i2++) {
+    const x = pa.pre[i2];
+    const y = pb.pre[i2];
+    if (x === void 0) return false;
+    if (y === void 0) return true;
+    if (x === y) continue;
+    const xn = /^\d+$/.test(x) ? Number.parseInt(x, 10) : null;
+    const yn = /^\d+$/.test(y) ? Number.parseInt(y, 10) : null;
+    if (xn !== null && yn !== null) return xn > yn;
+    if (xn !== null) return false;
+    if (yn !== null) return true;
+    return x > y;
+  }
+  return false;
+}
+function readBundlePackageVersion(bundlePath) {
+  try {
+    const pkg = JSON.parse(
+      fs.readFileSync(path.join(path.dirname(bundlePath), "..", "package.json"), "utf8")
+    );
+    return typeof pkg.version === "string" ? pkg.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -271,7 +316,7 @@ function killSpawnedChild(child, pid) {
   }
 }
 function spawnToolsServer(paths, port, options = {}) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let logFd;
     try {
       fs.mkdirSync(STATE_DIR, { recursive: true });
@@ -307,7 +352,8 @@ function spawnToolsServer(paths, port, options = {}) {
         const actualPort = parseInt(match[1], 10);
         rl.close();
         child.stdout?.resume();
-        settle(() => resolve3({ port: actualPort, pid }));
+        child.stdout?.unref?.();
+        settle(() => resolve4({ port: actualPort, pid }));
       }
     });
     child.on("error", (err) => {
@@ -325,24 +371,36 @@ function spawnToolsServer(paths, port, options = {}) {
     rl.on("close", () => clearTimeout(timer));
   });
 }
-async function readToolsServerState() {
+function stateFileForBundle(bundlePath) {
+  const key = createHash("sha256").update(bundlePath).digest("hex").slice(0, 12);
+  return path.join(STATE_DIR, `tool-server-${key}.json`);
+}
+async function readStateFile(file) {
   try {
-    const raw = await readFile(STATE_FILE, "utf8");
+    const raw = await readFile(file, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
+async function readToolsServerState(bundlePath) {
+  if (bundlePath === void 0) return readStateFile(STATE_FILE);
+  const own = await readStateFile(stateFileForBundle(bundlePath));
+  if (own) return own;
+  const legacy = await readStateFile(STATE_FILE);
+  return legacy && legacy.bundlePath === bundlePath ? legacy : null;
+}
 async function writeToolsServerState(state2) {
+  const target = stateFileForBundle(state2.bundlePath);
   await mkdir(STATE_DIR, { recursive: true });
-  const tmp = `${STATE_FILE}.${process.pid}.tmp`;
+  const tmp = `${target}.${process.pid}.tmp`;
   try {
     await writeFile(tmp, JSON.stringify(state2, null, 2) + "\n", {
       encoding: "utf8",
       mode: 384
     });
     await chmod(tmp, 384);
-    await rename(tmp, STATE_FILE);
+    await rename(tmp, target);
   } catch (err) {
     await unlink(tmp).catch(() => {
     });
@@ -350,22 +408,55 @@ async function writeToolsServerState(state2) {
   }
 }
 function writeToolsServerStateSync(state2) {
+  const target = stateFileForBundle(state2.bundlePath);
   fs.mkdirSync(STATE_DIR, { recursive: true });
-  fs.writeFileSync(STATE_FILE, JSON.stringify(state2, null, 2) + "\n", {
+  fs.writeFileSync(target, JSON.stringify(state2, null, 2) + "\n", {
     encoding: "utf8",
     mode: 384
   });
-  fs.chmodSync(STATE_FILE, 384);
+  fs.chmodSync(target, 384);
+}
+async function clearToolsServerState(bundlePath) {
+  const files = [STATE_FILE];
+  if (bundlePath !== void 0) {
+    files[0] = stateFileForBundle(bundlePath);
+    const legacy = await readStateFile(STATE_FILE);
+    if (legacy && legacy.bundlePath === bundlePath) files.push(STATE_FILE);
+  }
+  for (const file of files) {
+    try {
+      await unlink(file);
+    } catch {
+    }
+  }
 }
-async function clearToolsServerState() {
+var STATE_FILE_RE = /^tool-server(-[0-9a-f]{12})?\.json$/;
+async function readAllToolsServerStates() {
+  let names;
   try {
-    await unlink(STATE_FILE);
+    names = await readdir(STATE_DIR);
   } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (!STATE_FILE_RE.test(name)) continue;
+    const file = path.join(STATE_DIR, name);
+    const state2 = await readStateFile(file);
+    if (state2) out.push({ file, state: state2 });
+  }
+  return out;
+}
+async function sweepDeadStateFiles() {
+  for (const { file } of await readAllToolsServerStates()) {
+    if (file === STATE_FILE) continue;
+    const fresh = await readStateFile(file);
+    if (fresh && !isProcessAlive(fresh.pid)) await unlink(file).catch(() => {
+    });
   }
 }
 var readState = readToolsServerState;
 var writeState = writeToolsServerState;
-var clearState = clearToolsServerState;
 var SIGTERM_GRACE_MS = 6e3;
 var SIGKILL_GRACE_MS = 1e3;
 var KILL_POLL_MS = 100;
@@ -394,11 +485,11 @@ async function terminatePid(pid, stillOurs) {
   }
   await waitForExit(pid, SIGKILL_GRACE_MS);
 }
-async function killToolServer() {
-  const state2 = await readState();
+async function killToolServer(bundlePath) {
+  const state2 = await readState(bundlePath);
   if (!state2) return;
   await terminatePid(state2.pid);
-  await clearState();
+  await clearToolsServerState(bundlePath ?? state2.bundlePath);
 }
 function processCommandMatches(pid, marker) {
   if (!marker) return false;
@@ -409,8 +500,8 @@ function processCommandMatches(pid, marker) {
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     if (!cmd) return false;
-    const argv = cmd.split(/\s+/);
-    return argv.includes(marker) && argv.includes("start");
+    const escaped = marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?:^|\\s)${escaped} start(?:\\s|$)`).test(cmd);
   } catch {
     return false;
   }
@@ -474,25 +565,45 @@ async function acquireSpawnLock() {
     }
   }
 }
-async function reusableHandle(state2) {
+async function reusableHandle(state2, wantBundlePath, wantVersion) {
   if (!state2 || !isProcessAlive(state2.pid)) return null;
+  if (wantBundlePath !== void 0 && state2.bundlePath !== wantBundlePath) return null;
+  if (wantBundlePath !== void 0 && state2.version !== void 0) {
+    const diskVersion = readBundlePackageVersion(wantBundlePath);
+    if (diskVersion !== void 0) {
+      if (diskVersion !== state2.version) return null;
+    } else if (wantVersion !== void 0 && state2.version !== wantVersion && isVersionNewer(wantVersion, state2.version)) {
+      return null;
+    }
+  }
   const host = state2.host ?? "127.0.0.1";
   const healthy = await isToolsServerHealthy(state2.port, host, 2e3, state2.token);
   if (!healthy) return null;
   return { url: formatUrl(healthCheckHost(host), state2.port), token: state2.token ?? "" };
 }
 async function ensureToolsServer(paths) {
-  const fast = await reusableHandle(await readState());
+  const fast = await reusableHandle(
+    await readState(paths.bundlePath),
+    paths.bundlePath,
+    paths.version
+  );
   if (fast) return fast;
   const lock = await acquireSpawnLock();
   try {
-    const state2 = await readState();
-    const reuse = await reusableHandle(state2);
+    const state2 = await readState(paths.bundlePath);
+    const reuse = await reusableHandle(state2, paths.bundlePath, paths.version);
     if (reuse) return reuse;
-    if (state2 && state2.managed === "autospawn" && isProcessAlive(state2.pid) && processCommandMatches(state2.pid, state2.bundlePath)) {
+    if (state2 && state2.managed === "autospawn" && state2.bundlePath === paths.bundlePath && isProcessAlive(state2.pid) && processCommandMatches(state2.pid, state2.bundlePath)) {
       await terminatePid(state2.pid, () => processCommandMatches(state2.pid, state2.bundlePath));
     }
-    await clearState();
+    await clearToolsServerState(paths.bundlePath);
+    await sweepDeadStateFiles();
+    if (!fs.existsSync(paths.bundlePath)) {
+      throw new Error(
+        `The argent install serving this session is gone from disk (${paths.bundlePath}) \u2014 it was likely updated or removed. Restart the editor's MCP connection to reconnect.`
+      );
+    }
+    const diskVersion = readBundlePackageVersion(paths.bundlePath) ?? paths.version;
     const token = generateToken();
     const port = await findFreePort();
     const { port: actualPort, pid } = await spawnToolsServer(paths, port, {
@@ -504,6 +615,7 @@ async function ensureToolsServer(paths) {
       pid,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       bundlePath: paths.bundlePath,
+      version: diskVersion,
       host: "127.0.0.1",
       token,
       managed: "autospawn"
@@ -617,8 +729,8 @@ function parseLinkTarget(input) {
   const host = u3.hostname.startsWith("[") ? u3.hostname.slice(1, -1) : u3.hostname;
   if (!host) throw new Error(`URL "${input}" is missing a host.`);
   const port = u3.port ? Number(u3.port) : u3.protocol === "https:" ? 443 : 80;
-  const path12 = u3.pathname === "/" ? "" : u3.pathname.replace(/\/+$/, "");
-  const url = `${u3.protocol}//${u3.host}${path12}`;
+  const path13 = u3.pathname === "/" ? "" : u3.pathname.replace(/\/+$/, "");
+  const url = `${u3.protocol}//${u3.host}${path13}`;
   const token = u3.username ? decodeURIComponent(u3.username) : void 0;
   return { url, host, port, ...token ? { token } : {} };
 }
@@ -775,7 +887,7 @@ function createToolsClient(options = {}) {
 import { mkdir as mkdir4, readFile as readFile4, rm, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join as join3 } from "node:path";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
@@ -796,7 +908,7 @@ function sanitizeSegment(segment) {
 }
 function projectSlug() {
   const cwd = process.cwd();
-  const hash = createHash("sha1").update(cwd).digest("hex").slice(0, 6);
+  const hash = createHash2("sha1").update(cwd).digest("hex").slice(0, 6);
   const name = sanitizeSegment(basename(cwd)) || "root";
   return `${name}-${hash}`;
 }
@@ -904,7 +1016,7 @@ function getDeviceIdFromArgs(args) {
 }
 
 // ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname2, posix, sep } from "path";
+import { dirname as dirname3, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -912,7 +1024,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname2(process.argv[1]) : process.cwd(), isWindows = "\\" === sep) {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname3(process.argv[1]) : process.cwd(), isWindows = "\\" === sep) {
   const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
   return (filename) => {
     if (!filename) return;
@@ -930,8 +1042,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? dirname2(proce
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path12) {
-  return path12.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path13) {
+  return path13.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 
 // ../../node_modules/@posthog/core/dist/featureFlagUtils.mjs
@@ -3483,15 +3595,15 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path12, ranges, output) {
-  return new Promise((resolve3) => {
-    const stream = createReadStream(path12);
+function getContextLinesFromFile(path13, ranges, output) {
+  return new Promise((resolve4) => {
+    const stream = createReadStream(path13);
     const lineReaded = createInterface2({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve3();
+      resolve4();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -3500,7 +3612,7 @@ function getContextLinesFromFile(path12, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path12, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path13, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -3561,8 +3673,8 @@ function clearLineContext(frame) {
   delete frame.context_line;
   delete frame.post_context;
 }
-function shouldSkipContextLinesForFile(path12) {
-  return path12.startsWith("node:") || path12.endsWith(".min.js") || path12.endsWith(".min.cjs") || path12.endsWith(".min.mjs") || path12.startsWith("data:");
+function shouldSkipContextLinesForFile(path13) {
+  return path13.startsWith("node:") || path13.endsWith(".min.js") || path13.endsWith(".min.cjs") || path13.endsWith(".min.mjs") || path13.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame) {
   if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
@@ -3635,14 +3747,14 @@ function snipLine(line, colno) {
 }
 
 // ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/relative-path.node.mjs
-import { isAbsolute as isAbsolute2, relative, sep as sep2 } from "path";
+import { isAbsolute as isAbsolute3, relative as relative2, sep as sep2 } from "path";
 function createRelativePathModifier(basePath = process.cwd()) {
   const isWindows = "\\" === sep2;
   const toUnix = (p) => isWindows ? p.replace(/\\/g, "/") : p;
   const normalizedBase = toUnix(basePath);
   return async (frames) => {
     for (const frame of frames) if (!(!frame.filename || frame.filename.startsWith("node:") || frame.filename.startsWith("data:"))) {
-      if (isAbsolute2(frame.filename)) frame.filename = toUnix(relative(normalizedBase, toUnix(frame.filename)));
+      if (isAbsolute3(frame.filename)) frame.filename = toUnix(relative2(normalizedBase, toUnix(frame.filename)));
     }
     return frames;
   };
@@ -4788,9 +4900,9 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     if (!waitUntil) return;
     if (this.disabled || this.optedOut) return;
     if (!this._waitUntilCycle) {
-      let resolve3;
+      let resolve4;
       const promise = new Promise((r2) => {
-        resolve3 = r2;
+        resolve4 = r2;
       });
       try {
         waitUntil(promise);
@@ -4798,7 +4910,7 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
         return;
       }
       this._waitUntilCycle = {
-        resolve: resolve3,
+        resolve: resolve4,
         startedAt: Date.now(),
         timer: void 0
       };
@@ -4822,12 +4934,12 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     return cycle?.resolve;
   }
   async resolveWaitUntilFlush() {
-    const resolve3 = this._consumeWaitUntilCycle();
+    const resolve4 = this._consumeWaitUntilCycle();
     try {
       await super.flush();
     } catch {
     } finally {
-      resolve3?.();
+      resolve4?.();
     }
   }
   getPersistedProperty(key) {
@@ -4948,15 +5060,15 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
   async waitForLocalEvaluationReady(timeoutMs = THIRTY_SECONDS) {
     if (this.isLocalEvaluationReady()) return true;
     if (void 0 === this.featureFlagsPoller) return false;
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       const timeout = setTimeout(() => {
         cleanup();
-        resolve3(false);
+        resolve4(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count) => {
         clearTimeout(timeout);
         cleanup();
-        resolve3(count > 0);
+        resolve4(count > 0);
       });
     });
   }
@@ -5411,14 +5523,14 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     this.context?.enter(data, options);
   }
   async _shutdown(shutdownTimeoutMs) {
-    const resolve3 = this._consumeWaitUntilCycle();
+    const resolve4 = this._consumeWaitUntilCycle();
     await this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
     this.errorTracking.shutdown();
     try {
       return await super._shutdown(shutdownTimeoutMs);
     } finally {
       this.distinctIdHasSentFlagCalls = {};
-      resolve3?.();
+      resolve4?.();
     }
   }
   async _requestRemoteConfigPayload(flagKey) {
@@ -5824,6 +5936,9 @@ var FAILURE_CODES = {
   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",
@@ -5839,6 +5954,14 @@ var FAILURE_CODES = {
   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",
@@ -5851,6 +5974,7 @@ var FAILURE_CODES = {
   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",
@@ -5904,6 +6028,7 @@ var FAILURE_CODES = {
   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_PROJECT_ROOT_MISSING: "DEBUGGER_METRO_PROJECT_ROOT_MISSING",
   DEBUGGER_METRO_NO_TARGETS: "DEBUGGER_METRO_NO_TARGETS",
@@ -5948,8 +6073,19 @@ var FAILURE_CODES = {
   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",
   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",
@@ -5957,6 +6093,27 @@ var FAILURE_CODES = {
   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_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",
+  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",
@@ -5995,6 +6152,7 @@ var FAILURE_COMMANDS = [
   "ax_service",
   "simulator_server",
   "cdp",
+  "electron",
   "npm",
   "npx",
   "unknown"
@@ -6028,7 +6186,15 @@ var FAILURE_SPAWN_CODE_SET = new Set(FAILURE_SPAWN_CODES);
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // ../telemetry/src/events.ts
-var PLATFORMS = ["ios", "ios-remote", "android", "chromium", "vega"];
+var PLATFORMS = [
+  "ios",
+  "ios-remote",
+  "android",
+  "chromium",
+  "vega",
+  "tvos",
+  "android-tv"
+];
 
 // ../telemetry/src/ai-identity.ts
 var AI_CLIENTS = [
@@ -6094,6 +6260,7 @@ var FAILURE_SIGNAL_NAME = oneOf(FAILURE_SIGNAL_NAMES);
 var FAILURE_SPAWN_CODE = oneOf(FAILURE_SPAWN_CODES);
 var NETWORK_FAILURE = oneOf(NETWORK_FAILURES);
 var AI_CLIENT = oneOf(AI_CLIENTS);
+var INSTALL_MODE = oneOf(["global", "local"]);
 var AI_TELEMETRY = {
   ai_client: AI_CLIENT
 };
@@ -6117,10 +6284,21 @@ var ALLOWED = {
     duration_ms: DURATION_MS,
     is_success: bool,
     editors_configured_count: COUNT,
+    install_mode: INSTALL_MODE,
     ...FAILURE_SIGNAL
   },
   "installation:cli_init_cancel": {
-    step: oneOf(["global_install", "editors", "scope", "skills", "allowlist"])
+    step: oneOf([
+      "global_install",
+      "editors",
+      "scope",
+      "skills",
+      "allowlist",
+      "install_mode"
+    ])
+  },
+  "installation:install_mode_decision": {
+    install_mode: INSTALL_MODE
   },
   "installation:global_install_decision": {
     // `from_tar` is intentionally absent; the installer skips that dev path.
@@ -6134,11 +6312,16 @@ var ALLOWED = {
   "installation:editors_select": {
     editors: arrayOf(ADAPTER_NAME),
     detected_editor_count: COUNT,
-    scope: oneOf(["local", "global", "custom"])
+    scope: oneOf(["local", "global", "custom"]),
+    install_mode: INSTALL_MODE
   },
   "installation:allowlist_decision": {
     is_enabled: bool
   },
+  "installation:stale_config_cleanup": {
+    removed_count: COUNT,
+    warned_count: COUNT
+  },
   "installation:skill_install": {
     method: oneOf(["default", "interactive", "manual"]),
     is_online: bool,
@@ -6162,16 +6345,19 @@ var ALLOWED = {
   },
   "installation:cli_update_start": {},
   "installation:cli_update_complete": {
-    duration_ms: DURATION_MS
+    duration_ms: DURATION_MS,
+    install_mode: INSTALL_MODE
   },
   "installation:cli_update_fail": {
     duration_ms: DURATION_MS,
+    install_mode: INSTALL_MODE,
     ...FAILURE_SIGNAL
   },
   "installation:cli_uninstall_start": {},
   "installation:cli_uninstall_complete": {
     has_pruned_content: bool,
     has_uninstalled_package: bool,
+    install_mode: INSTALL_MODE,
     ...FAILURE_SIGNAL
   },
   "tool:invoke": {
@@ -6256,9 +6442,9 @@ function isReplitAgent(env) {
 }
 var DEVIN_MARKER_PATH = "/opt/.devin";
 var JULES_MARKER_PATH = "/opt/environment_summary.sh";
-function safeExists(fileExists, path12) {
+function safeExists(fileExists, path13) {
   try {
-    return fileExists(path12);
+    return fileExists(path13);
   } catch {
     return false;
   }
@@ -6679,7 +6865,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID2 = randomUUID3();
 function readCliVersion() {
   if (true) {
-    return "0.14.0";
+    return "0.15.0";
   }
   return "0.0.0";
 }
@@ -6958,17 +7144,141 @@ function debugLogPath() {
 }
 
 // ../telemetry/src/identity.ts
+var FINGERPRINT_PATTERN = /^[0-9a-f]{64}$/;
 var cached = null;
-function readOrCreateAnonId() {
+var fingerprintResolved = null;
+var upgradeInFlight = false;
+var upgradeAttempts = 0;
+var upgradeLastAttemptMs = 0;
+var UPGRADE_COOLDOWN_MS = 6e4;
+var UPGRADE_MAX_ATTEMPTS = 3;
+function readOrCreateAnonId(resolveFingerprint) {
+  const finalPath = identityFilePath();
+  if (cached && cached.path === finalPath && FINGERPRINT_PATTERN.test(cached.id)) {
+    return cached.id;
+  }
+  const stored = tryReadId(finalPath);
+  if (stored && FINGERPRINT_PATTERN.test(stored)) {
+    cached = { path: finalPath, id: stored };
+    return stored;
+  }
+  if (stored) {
+    cached = { path: finalPath, id: stored };
+    return stored;
+  }
+  const target = resolveFingerprintOnce(resolveFingerprint);
+  if (target) {
+    try {
+      writeIdFileAtomic(finalPath, target);
+    } catch {
+    }
+    cached = { path: finalPath, id: target };
+    return target;
+  }
+  return mintRandomId(finalPath);
+}
+function scheduleFingerprintUpgrade(resolveFingerprintAsync) {
+  if (!resolveFingerprintAsync) return;
+  if (upgradeInFlight) return;
   const finalPath = identityFilePath();
-  if (cached && cached.path === finalPath) return cached.id;
-  const existing = tryReadId(finalPath);
-  if (existing) {
-    cached = { path: finalPath, id: existing };
-    return existing;
+  if (servedFingerprintId(finalPath)) return;
+  if (upgradeAttempts >= UPGRADE_MAX_ATTEMPTS) return;
+  const now = Date.now();
+  if (upgradeAttempts > 0 && now - upgradeLastAttemptMs < UPGRADE_COOLDOWN_MS) return;
+  upgradeInFlight = true;
+  upgradeAttempts += 1;
+  upgradeLastAttemptMs = now;
+  void Promise.resolve().then(() => resolveFingerprintAsync()).then((raw) => {
+    const fp = normalizeFingerprint(raw);
+    if (fp) adoptFingerprint(fp);
+  }).catch(() => {
+  }).finally(() => {
+    upgradeInFlight = false;
+  });
+}
+function servedFingerprintId(finalPath) {
+  if (cached && cached.path === finalPath && FINGERPRINT_PATTERN.test(cached.id)) {
+    return cached.id;
+  }
+  const stored = tryReadId(finalPath);
+  if (stored && FINGERPRINT_PATTERN.test(stored)) {
+    cached = { path: finalPath, id: stored };
+    return stored;
   }
+  return null;
+}
+function normalizeFingerprint(raw) {
+  if (!raw) return null;
+  const normalized = raw.trim().toLowerCase();
+  return FINGERPRINT_PATTERN.test(normalized) ? normalized : null;
+}
+function adoptFingerprint(fp) {
+  const finalPath = identityFilePath();
+  const stored = tryReadId(finalPath);
+  if (stored !== fp) {
+    try {
+      writeIdFileAtomic(finalPath, fp);
+    } catch {
+    }
+  }
+  cached = { path: finalPath, id: fp };
+}
+function resolveFingerprintOnce(resolveFingerprint) {
+  if (!resolveFingerprint) return null;
+  if (fingerprintResolved) return fingerprintResolved.value;
+  let raw;
+  try {
+    raw = resolveFingerprint();
+  } catch {
+    raw = null;
+  }
+  const value = normalizeFingerprint(raw);
+  fingerprintResolved = { value };
+  return value;
+}
+function isCorruptIdFile(filePath) {
+  let isRegularFile;
+  try {
+    isRegularFile = fs4.lstatSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+  return isRegularFile && tryReadId(filePath) === null;
+}
+function writeIdFileAtomic(finalPath, id) {
   fs4.mkdirSync(argentHomeDir(), { recursive: true });
-  const uuid = crypto2.randomUUID();
+  let occupant;
+  try {
+    occupant = fs4.lstatSync(finalPath);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  if (occupant && !occupant.isFile()) {
+    throw new Error("telemetry: refusing to replace a non-regular file at the identity path");
+  }
+  const tmpPath = path8.join(
+    argentHomeDir(),
+    `.telemetry-id.tmp.${process.pid}.${crypto2.randomUUID()}`
+  );
+  const fd = fs4.openSync(tmpPath, "wx", 384);
+  try {
+    try {
+      fs4.writeSync(fd, id);
+      fs4.fsyncSync(fd);
+    } finally {
+      fs4.closeSync(fd);
+    }
+    fs4.renameSync(tmpPath, finalPath);
+  } finally {
+    try {
+      fs4.unlinkSync(tmpPath);
+    } catch {
+    }
+  }
+}
+function mintRandomId(finalPath) {
+  fs4.mkdirSync(argentHomeDir(), { recursive: true });
+  let value = crypto2.randomUUID();
   for (let attempt = 0; attempt < 3; attempt++) {
     const tmpPath = path8.join(
       argentHomeDir(),
@@ -6983,14 +7293,14 @@ function readOrCreateAnonId() {
     }
     try {
       try {
-        fs4.writeSync(fd, uuid);
+        fs4.writeSync(fd, value);
         fs4.fsyncSync(fd);
       } finally {
         fs4.closeSync(fd);
       }
       fs4.linkSync(tmpPath, finalPath);
-      cached = { path: finalPath, id: uuid };
-      return uuid;
+      cached = { path: finalPath, id: value };
+      return value;
     } catch (err) {
       if (err.code === "EEXIST") {
         const beatUs = tryReadId(finalPath);
@@ -6998,6 +7308,10 @@ function readOrCreateAnonId() {
           cached = { path: finalPath, id: beatUs };
           return beatUs;
         }
+        if (isCorruptIdFile(finalPath)) {
+          const adopted = claimCorruptOccupant(finalPath);
+          if (adopted) value = adopted;
+        }
         continue;
       }
       throw err;
@@ -7008,7 +7322,28 @@ function readOrCreateAnonId() {
       }
     }
   }
-  throw new Error("telemetry: failed to create anonymous identity after retries");
+  throw new Error("telemetry: failed to create identity after retries");
+}
+function claimCorruptOccupant(finalPath) {
+  const claimed = path8.join(
+    argentHomeDir(),
+    `.telemetry-id.corrupt.${process.pid}.${crypto2.randomUUID()}`
+  );
+  try {
+    fs4.renameSync(finalPath, claimed);
+  } catch {
+    return null;
+  }
+  let grabbed;
+  try {
+    grabbed = tryReadId(claimed);
+  } finally {
+    try {
+      fs4.unlinkSync(claimed);
+    } catch {
+    }
+  }
+  return grabbed;
 }
 function peekAnonId() {
   return tryReadId(identityFilePath());
@@ -7028,14 +7363,120 @@ function tryReadId(filePath) {
   return null;
 }
 
-// ../telemetry/src/consent.ts
+// ../telemetry/src/fingerprint.ts
+import { execFileSync as execFileSync2, spawn as spawn2 } from "node:child_process";
+
+// ../native-devtools-ios/src/index.ts
+import * as path9 from "node:path";
 import * as fs5 from "node:fs";
+var DYLIB_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_DIR ?? path9.join(__dirname, "..", "dylibs");
+var BIN_DIR = process.env.ARGENT_SIMULATOR_SERVER_DIR ?? path9.join(__dirname, "..", "bin");
+var DYLIB_TCP_DIR = process.env.ARGENT_NATIVE_DEVTOOLS_TCP_DIR ?? path9.join(DYLIB_DIR, "tcp");
+var DYLIB_TVOS_DIR = path9.join(DYLIB_DIR, "tvos");
+function hostPlatformKey() {
+  if (process.platform === "linux" && process.arch === "arm64") {
+    return "linux-arm64";
+  }
+  return process.platform;
+}
+function platformBinDir() {
+  return path9.join(BIN_DIR, hostPlatformKey());
+}
+function simulatorServerBinaryPath() {
+  const p = path9.join(platformBinDir(), "simulator-server");
+  if (!fs5.existsSync(p)) {
+    const flat = path9.join(BIN_DIR, "simulator-server");
+    const migrationHint = fs5.existsSync(flat) ? ` Found a binary at the old flat path ${flat}; move it to ${p} or update ARGENT_SIMULATOR_SERVER_DIR to point at the parent of the platform subdirectory.` : "";
+    throw new Error(
+      `simulator-server binary not found for platform "${hostPlatformKey()}" at ${p}. Supported hosts today: darwin, linux (x86_64 and arm64).${migrationHint}`
+    );
+  }
+  return p;
+}
+
+// ../telemetry/src/fingerprint.ts
+var FINGERPRINT_TIMEOUT_MS = 5e3;
+var FINGERPRINT_MAX_BUFFER = 4096;
+function resolveHostFingerprint() {
+  try {
+    const out = execFileSync2(simulatorServerBinaryPath(), ["fingerprint"], {
+      encoding: "utf8",
+      timeout: FINGERPRINT_TIMEOUT_MS,
+      // Reap with SIGKILL, not the default SIGTERM: a binary that ignores SIGTERM
+      // would otherwise block the (synchronous) event loop past the cap forever.
+      // SIGKILL can't be trapped, so the timeout is a genuine bound here.
+      killSignal: "SIGKILL",
+      // Cap captured stdout (same limit as the async variant): a binary streaming
+      // output is SIGKILL'd at this cap rather than filling Node's 1 MiB default.
+      maxBuffer: FINGERPRINT_MAX_BUFFER,
+      // Ignore stderr so a binary that logs diagnostics doesn't pollute the
+      // caller's stderr; stdout (index 1) is captured as the return value.
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out.length > 0 ? out : null;
+  } catch {
+    return null;
+  }
+}
+function resolveHostFingerprintAsync() {
+  return new Promise((resolve4) => {
+    let binary;
+    try {
+      binary = simulatorServerBinaryPath();
+    } catch {
+      resolve4(null);
+      return;
+    }
+    let settled = false;
+    let child;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(watchdog);
+      try {
+        child?.kill("SIGKILL");
+      } catch {
+      }
+      resolve4(value);
+    };
+    const watchdog = setTimeout(() => finish(null), FINGERPRINT_TIMEOUT_MS);
+    watchdog.unref?.();
+    try {
+      child = spawn2(binary, ["fingerprint"], { stdio: ["ignore", "pipe", "ignore"] });
+    } catch {
+      finish(null);
+      return;
+    }
+    let out = "";
+    let overflowed = false;
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      if (overflowed) return;
+      out += chunk;
+      if (out.length > FINGERPRINT_MAX_BUFFER) {
+        overflowed = true;
+        finish(null);
+      }
+    });
+    child.on("error", () => finish(null));
+    child.on("close", (code) => {
+      if (overflowed) return;
+      const trimmed = out.trim();
+      finish(code === 0 && trimmed.length > 0 ? trimmed : null);
+    });
+    child.unref?.();
+    child.stdout?.unref?.();
+  });
+}
+
+// ../telemetry/src/consent.ts
+import * as fs6 from "node:fs";
 var cache = { current: null };
 var sessionOverride = null;
 function readConfigOverride() {
   let stats;
   try {
-    stats = fs5.lstatSync(configFilePath());
+    stats = fs6.lstatSync(configFilePath());
   } catch (err) {
     if (err.code === "ENOENT") {
       cache.current = { mtimeMs: null, fingerprint: null, enabledOverride: null };
@@ -7055,7 +7496,7 @@ function readConfigOverride() {
   }
   let parsedEnabled = null;
   try {
-    const raw = fs5.readFileSync(configFilePath(), "utf8");
+    const raw = fs6.readFileSync(configFilePath(), "utf8");
     const json = JSON.parse(raw);
     if (json && typeof json === "object") {
       const t2 = json.telemetry;
@@ -7116,7 +7557,7 @@ function writeConsentFlag(enabled) {
 }
 
 // ../telemetry/src/debug.ts
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 function isDebugEnabled(env = process.env) {
   const v = env.ARGENT_TELEMETRY_DEBUG;
   if (!v) return false;
@@ -7143,8 +7584,8 @@ function emitDebugPayload(payload) {
   } catch {
   }
   try {
-    fs6.mkdirSync(argentHomeDir(), { recursive: true });
-    fs6.appendFileSync(debugLogPath(), line + "\n");
+    fs7.mkdirSync(argentHomeDir(), { recursive: true });
+    fs7.appendFileSync(debugLogPath(), line + "\n");
   } catch {
   }
 }
@@ -7162,8 +7603,8 @@ function emitDebugError(prefix, err) {
 var TELEMETRY_OPT_OUT_COMMAND = "argent telemetry disable";
 var TELEMETRY_DETAILS_URL = "https://swmansion.com/legal/argent/privacy-notice/";
 var FIRST_RUN_NOTICE_BODY_LINES = [
-  "Argent collects anonymous usage data to help us improve the tool. We never",
-  "collect your source code, file paths, tool inputs, or error contents."
+  "Argent collects usage data to help us improve the tool.",
+  "We never collect your source code, file paths, tool inputs, or error contents."
 ];
 var FIRST_RUN_NOTICE = [
   ...FIRST_RUN_NOTICE_BODY_LINES,
@@ -7187,11 +7628,12 @@ function activeRuntime() {
 function buildPayload(event, props) {
   let distinctId;
   try {
-    distinctId = readOrCreateAnonId();
+    distinctId = readOrCreateAnonId(resolveHostFingerprint);
   } catch (err) {
     emitDebugError("buildPayload: identity creation failed", err);
     return null;
   }
+  scheduleFingerprintUpgrade(resolveHostFingerprintAsync);
   const base = getBaseProps(activeRuntime());
   const sanitized = sanitize(event, props);
   const properties = { ...base, ...sanitized };
@@ -7234,7 +7676,7 @@ async function shutdown(timeoutMs = SHORT_FLUSH_TIMEOUT_MS) {
   try {
     await Promise.race([
       client2.shutdown(timeoutMs),
-      new Promise((resolve3) => setTimeout(resolve3, timeoutMs + 250).unref())
+      new Promise((resolve4) => setTimeout(resolve4, timeoutMs + 250).unref())
     ]);
   } catch (err) {
     emitDebugError("shutdown failed", err);
@@ -7254,7 +7696,7 @@ async function markDisabled() {
       try {
         await Promise.race([
           client2.shutdown(SHORT_FLUSH_TIMEOUT_MS),
-          new Promise((resolve3) => setTimeout(resolve3, SHORT_FLUSH_TIMEOUT_MS).unref())
+          new Promise((resolve4) => setTimeout(resolve4, SHORT_FLUSH_TIMEOUT_MS).unref())
         ]);
       } catch {
       }
@@ -7321,6 +7763,7 @@ function parseJsonOrThrow(raw, label) {
 }
 function parseFlags(argv, schema) {
   const properties = schema?.properties ?? {};
+  const argsHatchHint = properties.args === void 0 ? " or --args '<json>'" : "";
   const args = {};
   const positional = [];
   let helpRequested = false;
@@ -7356,7 +7799,7 @@ function parseFlags(argv, schema) {
     } else {
       flag = tok.slice(2);
     }
-    if (flag === "args") {
+    if (flag === "args" && properties.args === void 0) {
       const { value: value2, nextIndex: nextIndex2 } = inlineValue !== void 0 ? { value: inlineValue, nextIndex: i2 } : takeNext(i2, "args");
       rawArgs = value2;
       i2 = nextIndex2;
@@ -7367,7 +7810,7 @@ function parseFlags(argv, schema) {
       const { value: value2, nextIndex: nextIndex2 } = inlineValue !== void 0 ? { value: inlineValue, nextIndex: i2 } : takeNext(i2, flag);
       if (seenArrayFields.has(fieldName)) {
         throw new FlagParseException(
-          `--${fieldName} and --${flag} cannot be mixed for the same field; pass it entirely as --${flag} '<json>' or --args '<json>'`
+          `--${fieldName} and --${flag} cannot be mixed for the same field; pass it entirely as --${flag} '<json>'${argsHatchHint}`
         );
       }
       args[fieldName] = parseJsonOrThrow(value2, `--${flag}`);
@@ -7399,13 +7842,13 @@ function parseFlags(argv, schema) {
       const itemType = propSchema.items?.type;
       if (!isScalarType(itemType)) {
         throw new FlagParseException(
-          `--${flag} is an array of objects; pass it as --${flag}-json '<json>' or --args '<json>'`
+          `--${flag} is an array of objects; pass it as --${flag}-json '<json>'${argsHatchHint}`
         );
       }
       const { value: value2, nextIndex: nextIndex2 } = inlineValue !== void 0 ? { value: inlineValue, nextIndex: i2 } : takeNext(i2, flag);
       if (jsonFields.has(flag)) {
         throw new FlagParseException(
-          `--${flag} and --${flag}-json cannot be mixed for the same field; pass it entirely as --${flag}-json '<json>' or --args '<json>'`
+          `--${flag} and --${flag}-json cannot be mixed for the same field; pass it entirely as --${flag}-json '<json>'${argsHatchHint}`
         );
       }
       const coerced = coerceScalar(value2, itemType, flag);
@@ -7420,7 +7863,7 @@ function parseFlags(argv, schema) {
     }
     if (propSchema?.type === "object") {
       throw new FlagParseException(
-        `--${flag} is an object; pass it as --${flag}-json '<json>' or --args '<json>'`
+        `--${flag} is an object; pass it as --${flag}-json '<json>'${argsHatchHint}`
       );
     }
     const { value, nextIndex } = inlineValue !== void 0 ? { value: inlineValue, nextIndex: i2 } : takeNext(i2, flag);
@@ -7495,27 +7938,31 @@ function splitOptions(argv) {
   return { json, outPath, argvForFlags: rest };
 }
 async function readStdin() {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve3(data));
+    process.stdin.on("end", () => resolve4(data));
     process.stdin.on("error", reject);
   });
 }
 function printToolHelp(meta) {
   const description = meta.description?.trim() ?? "";
+  const schema = meta.inputSchema;
+  const hasOwnArgsField = schema?.properties?.args !== void 0;
   console.log(`argent run ${meta.name} [flags]`);
   if (description) console.log(`
 ${description}
 `);
   console.log("Flags:");
-  console.log(formatSchemaUsage(meta.inputSchema));
+  console.log(formatSchemaUsage(schema));
   console.log("\nGlobal flags:");
-  console.log("  --args <json>          Pass the entire payload as JSON (overrides flags)");
-  console.log("  --args -               Read the entire payload as JSON from stdin");
+  if (!hasOwnArgsField) {
+    console.log("  --args <json>          Pass the entire payload as JSON (overrides flags)");
+    console.log("  --args -               Read the entire payload as JSON from stdin");
+  }
   console.log("  --<field>-json <json>  Pass a single field as JSON (objects/nested arrays)");
   console.log("  --json                 Print the raw JSON result");
   console.log("  --out <path>           For image results, save to <path> instead of fetching URL");
@@ -7529,8 +7976,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());
-  fs7.mkdirSync(path9.dirname(path9.resolve(outPath)), { recursive: true });
-  fs7.writeFileSync(outPath, buf);
+  fs8.mkdirSync(path10.dirname(path10.resolve(outPath)), { recursive: true });
+  fs8.writeFileSync(outPath, buf);
 }
 function renderResult(result, outputHint, images, json) {
   if (json) return JSON.stringify(result, null, 2);
@@ -7669,8 +8116,8 @@ Examples:
   if (outPath && meta.outputHint === "image") {
     try {
       if (images.length > 0) {
-        fs7.mkdirSync(path9.dirname(path9.resolve(outPath)), { recursive: true });
-        fs7.writeFileSync(outPath, images[0].data);
+        fs8.mkdirSync(path10.dirname(path10.resolve(outPath)), { recursive: true });
+        fs8.writeFileSync(outPath, images[0].data);
       } else if (result && typeof result === "object") {
         await fetchImageToFile(result, outPath);
       }
@@ -7770,27 +8217,29 @@ Options:
 }
 
 // ../argent-cli/src/server.ts
-import * as fs8 from "node:fs";
-import * as path10 from "node:path";
+import * as fs9 from "node:fs";
+import * as path11 from "node:path";
 import { homedir as homedir5, networkInterfaces } from "node:os";
-import { spawn as spawn2 } from "node:child_process";
-var STATE_DIR2 = path10.join(homedir5(), ".argent");
-var STATE_FILE2 = path10.join(STATE_DIR2, "tool-server.json");
-var LOG_FILE2 = path10.join(STATE_DIR2, "tool-server.log");
-function readState2() {
-  try {
-    return JSON.parse(fs8.readFileSync(STATE_FILE2, "utf8"));
-  } catch {
-    return null;
-  }
+import { spawn as spawn3 } from "node:child_process";
+var STATE_DIR2 = path11.join(homedir5(), ".argent");
+var LOG_FILE2 = path11.join(STATE_DIR2, "tool-server.log");
+async function describeForeignServers(ownBundlePath) {
+  const others = (await readAllToolsServerStates()).filter(
+    ({ state: state2 }) => state2.bundlePath !== ownBundlePath && isToolsServerProcessAlive(state2.pid)
+  );
+  if (others.length === 0) return null;
+  const list = others.map(({ state: state2 }) => `pid ${state2.pid} (${state2.bundlePath})`).join(", ");
+  return `Note: ${others.length} tool-server(s) from other argent installs: ${list}`;
 }
-async function statusCmd(json) {
-  const state2 = readState2();
+async function statusCmd(json, paths) {
+  const state2 = await readToolsServerState(paths?.bundlePath);
   if (!state2) {
+    const foreign = await describeForeignServers(paths?.bundlePath);
     if (json) {
       console.log(JSON.stringify({ running: false }, null, 2));
     } else {
-      console.log("tool-server: not running (no state file)");
+      console.log("tool-server: not running (no state file for this install)");
+      if (foreign) console.log(foreign);
     }
     return;
   }
@@ -7819,25 +8268,28 @@ async function statusCmd(json) {
 State file is stale; next \`argent\` invocation will respawn the server.`);
   }
 }
-async function stopCmd() {
-  const state2 = readState2();
+async function stopCmd(paths) {
+  const state2 = await readToolsServerState(paths?.bundlePath);
   if (!state2) {
     console.log("tool-server: not running");
+    const foreign = await describeForeignServers(paths?.bundlePath);
+    if (foreign) console.log(`${foreign}
+Stop one with: kill <pid>`);
     return;
   }
-  await killToolServer();
+  await killToolServer(paths?.bundlePath);
   console.log(`tool-server stopped (pid ${state2.pid}).`);
 }
 function logsCmd(follow) {
-  if (!fs8.existsSync(LOG_FILE2)) {
+  if (!fs9.existsSync(LOG_FILE2)) {
     console.log(`No log file at ${LOG_FILE2}`);
     return;
   }
   if (!follow) {
-    process.stdout.write(fs8.readFileSync(LOG_FILE2, "utf8"));
+    process.stdout.write(fs9.readFileSync(LOG_FILE2, "utf8"));
     return;
   }
-  const child = spawn2("tail", ["-f", LOG_FILE2], { stdio: "inherit" });
+  const child = spawn3("tail", ["-f", LOG_FILE2], { stdio: "inherit" });
   child.on("exit", (code) => process.exit(code ?? 0));
 }
 var StartFlagError = class extends Error {
@@ -7981,11 +8433,11 @@ function printConnectionInfo(bindHost, port, token) {
     );
   }
 }
-async function ensureNoExistingServer(force) {
-  const state2 = await readToolsServerState();
+async function ensureNoExistingServer(force, paths) {
+  const state2 = await readToolsServerState(paths.bundlePath);
   if (!state2) return;
   const alive = isToolsServerProcessAlive(state2.pid);
-  const healthy = alive ? await isToolsServerHealthy(state2.port, state2.host ?? "127.0.0.1") : false;
+  const healthy = alive ? await isToolsServerHealthy(state2.port, state2.host ?? "127.0.0.1", 2e3, state2.token) : false;
   if (alive && healthy && !force) {
     const url = formatUrl(state2.host ?? "127.0.0.1", state2.port);
     throw new StartFlagError(
@@ -7994,9 +8446,9 @@ Use \`argent server stop\` first, or pass \`--force\` to replace it.`
     );
   }
   if (alive && force) {
-    await killToolServer();
+    await killToolServer(paths.bundlePath);
   } else {
-    await clearToolsServerState();
+    await clearToolsServerState(paths.bundlePath);
   }
 }
 async function resolvePort(requested) {
@@ -8026,7 +8478,7 @@ async function startCmd(argv, paths) {
     return;
   }
   try {
-    await ensureNoExistingServer(flags2.force);
+    await ensureNoExistingServer(flags2.force, paths);
   } catch (err) {
     if (err instanceof StartFlagError) {
       console.error(err.message);
@@ -8086,7 +8538,7 @@ async function runForeground(paths, port, host, idleTimeoutMinutes, token) {
     idleTimeoutMinutes,
     token
   });
-  const child = spawn2("node", [paths.bundlePath, "start"], {
+  const child = spawn3("node", [paths.bundlePath, "start"], {
     stdio: "inherit",
     env
   });
@@ -8124,7 +8576,7 @@ async function runForeground(paths, port, host, idleTimeoutMinutes, token) {
       process.removeListener("SIGINT", onInt);
       process.removeListener("SIGTERM", onTerm);
       if (stateWritten) {
-        clearToolsServerState().catch(() => {
+        clearToolsServerState(paths.bundlePath).catch(() => {
         });
       }
     };
@@ -8162,10 +8614,10 @@ async function server(argv, options) {
       await startCmd(argv.slice(1), options?.paths);
       return;
     case "status":
-      await statusCmd(json);
+      await statusCmd(json, options?.paths);
       return;
     case "stop":
-      await stopCmd();
+      await stopCmd(options?.paths);
       return;
     case "logs":
       logsCmd(follow);
@@ -8177,22 +8629,22 @@ async function server(argv, options) {
 }
 
 // ../argent-cli/src/lens.ts
-import * as fs9 from "node:fs";
+import * as fs10 from "node:fs";
 import * as os2 from "node:os";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 
 // ../argent-cli/src/lens-terminal.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync5 } from "node:fs";
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { existsSync as existsSync6 } from "node:fs";
 var ITERM_PATHS = ["/Applications/iTerm.app", `${process.env.HOME ?? ""}/Applications/iTerm.app`];
-function isITermInstalled(existsSync7 = defaultExists) {
-  return ITERM_PATHS.some((p) => p && existsSync7(p));
+function isITermInstalled(existsSync8 = defaultExists) {
+  return ITERM_PATHS.some((p) => p && existsSync8(p));
 }
 function defaultExists(p) {
-  return existsSync5(p);
+  return existsSync6(p);
 }
-function resolveTerminal(preferred = "iterm", existsSync7 = defaultExists) {
-  if (preferred === "iterm" && isITermInstalled(existsSync7)) return "iterm";
+function resolveTerminal(preferred = "iterm", existsSync8 = defaultExists) {
+  if (preferred === "iterm" && isITermInstalled(existsSync8)) return "iterm";
   return "terminal";
 }
 function escapeAppleScript(s) {
@@ -8341,7 +8793,7 @@ function parseAliveTtys(psOutput) {
 }
 function runOsascript(script) {
   try {
-    return execFileSync2("/usr/bin/osascript", ["-e", script], {
+    return execFileSync3("/usr/bin/osascript", ["-e", script], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -8383,7 +8835,7 @@ function pressEnter(session) {
 }
 function aliveTtys() {
   try {
-    const out = execFileSync2("/bin/ps", ["-A", "-o", "tty="], { encoding: "utf8" });
+    const out = execFileSync3("/bin/ps", ["-A", "-o", "tty="], { encoding: "utf8" });
     return parseAliveTtys(out);
   } catch {
     return /* @__PURE__ */ new Set();
@@ -8420,7 +8872,7 @@ function ptyInjectBeats(text2) {
   ];
 }
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 var DEFAULT_COLS = 80;
 var DEFAULT_ROWS = 24;
@@ -8578,7 +9030,7 @@ async function* lensEvents(baseUrl, signal) {
 }
 
 // ../argent-cli/src/lens-agents.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync as execFileSync4 } from "node:child_process";
 var AGENTS = [
   {
     id: "claude",
@@ -8620,7 +9072,7 @@ function agentIds() {
 }
 function defaultIsOnPath(bin) {
   try {
-    execFileSync3(process.platform === "win32" ? "where" : "which", [bin], {
+    execFileSync4(process.platform === "win32" ? "where" : "which", [bin], {
       stdio: ["ignore", "ignore", "ignore"]
     });
     return true;
@@ -8641,7 +9093,7 @@ var SPAWN_GRACE_MS = 8e3;
 var DEATH_CONFIRMATIONS = 3;
 var SSE_RECONNECT_MS = 1e3;
 function sleep2(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 var TRUST_PROMPT_RE = /trust this folder|do you trust|yes,? i trust|trust the files in this/i;
 async function dismissTrustPrompt(session) {
@@ -8793,11 +9245,11 @@ function parseArgs(argv) {
   let terminal;
   let agent;
   let help = false;
-  let forget2 = false;
+  let forget = false;
   for (let i2 = 0; i2 < argv.length; i2++) {
     const tok = argv[i2];
     if (tok === "--help" || tok === "-h") help = true;
-    else if (tok === "--forget") forget2 = true;
+    else if (tok === "--forget") forget = true;
     else if (tok === "--terminal" || tok === "-t") {
       const v = argv[++i2];
       if (v === "iterm" || v === "terminal") terminal = v;
@@ -8815,7 +9267,7 @@ function parseArgs(argv) {
       }
     }
   }
-  return { terminal, agent, help, forget: forget2 };
+  return { terminal, agent, help, forget };
 }
 function printHelp() {
   process.stdout.write(
@@ -8842,12 +9294,12 @@ Options:
   );
 }
 async function lens(argv, options) {
-  const { terminal: preferred, agent: agentId, help, forget: forget2 } = parseArgs(argv);
+  const { terminal: preferred, agent: agentId, help, forget } = parseArgs(argv);
   if (help) {
     printHelp();
     return;
   }
-  if (forget2) {
+  if (forget) {
     const had = getRememberedAgent();
     clearRememberedAgent();
     process.stdout.write(
@@ -8914,12 +9366,12 @@ async function lens(argv, options) {
     await endSession(baseUrl);
     process.exit(1);
   }
-  const seedFile = path11.join(os2.tmpdir(), `argent-lens-seed-${process.pid}-${Date.now()}.txt`);
-  fs9.writeFileSync(seedFile, buildSeedPrompt(), "utf8");
+  const seedFile = path12.join(os2.tmpdir(), `argent-lens-seed-${process.pid}-${Date.now()}.txt`);
+  fs10.writeFileSync(seedFile, buildSeedPrompt(), "utf8");
   const launchCmd = agent.launch(shellQuote(process.cwd()), shellQuote(seedFile));
   const removeSeedFile = () => {
     try {
-      fs9.rmSync(seedFile, { force: true });
+      fs10.rmSync(seedFile, { force: true });
     } catch {
     }
   };
@@ -10023,8 +10475,8 @@ var n = class extends V {
 import { styleText as styleText2, stripVTControlCharacters } from "node:util";
 import process$1 from "node:process";
 var import_sisteransi2 = __toESM(require_src(), 1);
-import { existsSync as existsSync6, lstatSync as lstatSync3, readdirSync as readdirSync2 } from "node:fs";
-import { dirname as dirname5, join as join11 } from "node:path";
+import { existsSync as existsSync7, lstatSync as lstatSync3, readdirSync as readdirSync2 } from "node:fs";
+import { dirname as dirname6, join as join12 } from "node:path";
 function isUnicodeSupported() {
   if (process$1.platform !== "win32") {
     return process$1.env.TERM !== "linux";
@@ -10955,17 +11407,17 @@ async function telemetry(args) {
 }
 function printUsage() {
   console.log(`Usage:
-  argent telemetry status    Show telemetry state and anonymous id
+  argent telemetry status    Show telemetry state and device id
   argent telemetry enable    Enable telemetry
   argent telemetry disable   Disable telemetry
 `);
 }
 function printStatus() {
   const s = status();
-  const anonLabel = s.anonIdPrefix ? `${s.anonIdPrefix}...` : s.hasAnonIdOnDisk ? "present" : "not created";
+  const idLabel = s.anonIdPrefix ? `${s.anonIdPrefix}...` : s.hasAnonIdOnDisk ? "present" : "not created";
   console.log("telemetry:");
-  console.log(`  state:   ${s.enabled ? "enabled" : "disabled"}`);
-  console.log(`  anon id: ${anonLabel}`);
+  console.log(`  state:     ${s.enabled ? "enabled" : "disabled"}`);
+  console.log(`  device id: ${idLabel}`);
 }
 async function cmdEnable() {
   const wasEnabled = isEnabled();