@swmansion/argent 0.28.1-next.2 → 0.28.1-next.21

package/dist/tool-server.cjs

@@ -13223,8 +13223,8 @@ function finalize(ctx, schema) {
   const root = ctx.seen.get(schema);
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
-  const flattenRef = (zodSchema80) => {
-    const seen = ctx.seen.get(zodSchema80);
+  const flattenRef = (zodSchema81) => {
+    const seen = ctx.seen.get(zodSchema81);
     if (seen.ref === null)
       return;
     const schema2 = seen.def ?? seen.schema;
@@ -13242,7 +13242,7 @@ function finalize(ctx, schema) {
         Object.assign(schema2, refSchema);
       }
       Object.assign(schema2, _cached);
-      const isParentRef = zodSchema80._zod.parent === ref;
+      const isParentRef = zodSchema81._zod.parent === ref;
       if (isParentRef) {
         for (const key2 in schema2) {
           if (key2 === "$ref" || key2 === "allOf")
@@ -13262,7 +13262,7 @@ function finalize(ctx, schema) {
         }
       }
     }
-    const parent = zodSchema80._zod.parent;
+    const parent = zodSchema81._zod.parent;
     if (parent && parent !== ref) {
       flattenRef(parent);
       const parentSeen = ctx.seen.get(parent);
@@ -13280,7 +13280,7 @@ function finalize(ctx, schema) {
       }
     }
     ctx.override({
-      zodSchema: zodSchema80,
+      zodSchema: zodSchema81,
       jsonSchema: schema2,
       path: seen.path ?? []
     });
@@ -16081,10 +16081,10 @@ function convertBaseSchema(schema, ctx) {
     }
     ctx.processing.add(refPath);
     const resolved = resolveRef(refPath, ctx);
-    const zodSchema81 = convertSchema(resolved, ctx);
-    ctx.refs.set(refPath, zodSchema81);
+    const zodSchema82 = convertSchema(resolved, ctx);
+    ctx.refs.set(refPath, zodSchema82);
     ctx.processing.delete(refPath);
-    return zodSchema81;
+    return zodSchema82;
   }
   if (schema.enum !== void 0) {
     const enumValues = schema.enum;
@@ -16126,7 +16126,7 @@ function convertBaseSchema(schema, ctx) {
   if (!type) {
     return z.any();
   }
-  let zodSchema80;
+  let zodSchema81;
   switch (type) {
     case "string": {
       let stringSchema = z.string();
@@ -16189,7 +16189,7 @@ function convertBaseSchema(schema, ctx) {
       if (schema.pattern) {
         stringSchema = stringSchema.regex(new RegExp(schema.pattern));
       }
-      zodSchema80 = stringSchema;
+      zodSchema81 = stringSchema;
       break;
     }
     case "number":
@@ -16214,15 +16214,15 @@ function convertBaseSchema(schema, ctx) {
       if (typeof schema.multipleOf === "number") {
         numberSchema = numberSchema.multipleOf(schema.multipleOf);
       }
-      zodSchema80 = numberSchema;
+      zodSchema81 = numberSchema;
       break;
     }
     case "boolean": {
-      zodSchema80 = z.boolean();
+      zodSchema81 = z.boolean();
       break;
     }
     case "null": {
-      zodSchema80 = z.null();
+      zodSchema81 = z.null();
       break;
     }
     case "object": {
@@ -16237,12 +16237,12 @@ function convertBaseSchema(schema, ctx) {
         const keySchema = convertSchema(schema.propertyNames, ctx);
         const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z.any();
         if (Object.keys(shape).length === 0) {
-          zodSchema80 = z.record(keySchema, valueSchema);
+          zodSchema81 = z.record(keySchema, valueSchema);
           break;
         }
         const objectSchema2 = z.object(shape).passthrough();
         const recordSchema = z.looseRecord(keySchema, valueSchema);
-        zodSchema80 = z.intersection(objectSchema2, recordSchema);
+        zodSchema81 = z.intersection(objectSchema2, recordSchema);
         break;
       }
       if (schema.patternProperties) {
@@ -16260,25 +16260,25 @@ function convertBaseSchema(schema, ctx) {
         }
         schemasToIntersect.push(...looseRecords);
         if (schemasToIntersect.length === 0) {
-          zodSchema80 = z.object({}).passthrough();
+          zodSchema81 = z.object({}).passthrough();
         } else if (schemasToIntersect.length === 1) {
-          zodSchema80 = schemasToIntersect[0];
+          zodSchema81 = schemasToIntersect[0];
         } else {
           let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
           for (let i = 2; i < schemasToIntersect.length; i++) {
             result = z.intersection(result, schemasToIntersect[i]);
           }
-          zodSchema80 = result;
+          zodSchema81 = result;
         }
         break;
       }
       const objectSchema = z.object(shape);
       if (schema.additionalProperties === false) {
-        zodSchema80 = objectSchema.strict();
+        zodSchema81 = objectSchema.strict();
       } else if (typeof schema.additionalProperties === "object") {
-        zodSchema80 = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
+        zodSchema81 = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
       } else {
-        zodSchema80 = objectSchema.passthrough();
+        zodSchema81 = objectSchema.passthrough();
       }
       break;
     }
@@ -16289,29 +16289,29 @@ function convertBaseSchema(schema, ctx) {
         const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
         const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
         if (rest) {
-          zodSchema80 = z.tuple(tupleItems).rest(rest);
+          zodSchema81 = z.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema80 = z.tuple(tupleItems);
+          zodSchema81 = z.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema80 = zodSchema80.check(z.minLength(schema.minItems));
+          zodSchema81 = zodSchema81.check(z.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema80 = zodSchema80.check(z.maxLength(schema.maxItems));
+          zodSchema81 = zodSchema81.check(z.maxLength(schema.maxItems));
         }
       } else if (Array.isArray(items)) {
         const tupleItems = items.map((item) => convertSchema(item, ctx));
         const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
         if (rest) {
-          zodSchema80 = z.tuple(tupleItems).rest(rest);
+          zodSchema81 = z.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema80 = z.tuple(tupleItems);
+          zodSchema81 = z.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema80 = zodSchema80.check(z.minLength(schema.minItems));
+          zodSchema81 = zodSchema81.check(z.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema80 = zodSchema80.check(z.maxLength(schema.maxItems));
+          zodSchema81 = zodSchema81.check(z.maxLength(schema.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
@@ -16322,16 +16322,16 @@ function convertBaseSchema(schema, ctx) {
         if (typeof schema.maxItems === "number") {
           arraySchema = arraySchema.max(schema.maxItems);
         }
-        zodSchema80 = arraySchema;
+        zodSchema81 = arraySchema;
       } else {
-        zodSchema80 = z.array(z.any());
+        zodSchema81 = z.array(z.any());
       }
       break;
     }
     default:
       throw new Error(`Unsupported type: ${type}`);
   }
-  return zodSchema80;
+  return zodSchema81;
 }
 function convertSchema(schema, ctx) {
   if (typeof schema === "boolean") {
@@ -73655,16 +73655,16 @@ function lookupExternalDeviceNow(id) {
   }
   return device;
 }
-async function assertExternalCapability(namespace, device, capability37) {
-  assertExternalCapabilitySync(namespace, device, capability37);
+async function assertExternalCapability(namespace, device, capability38) {
+  assertExternalCapabilitySync(namespace, device, capability38);
 }
-function assertExternalCapabilitySync(namespace, device, capability37) {
+function assertExternalCapabilitySync(namespace, device, capability38) {
   const id = typeof device === "string" ? device : device.id;
   const externalDevice = isExternalId(id) ? lookupExternalDeviceNow(id) : externalClaimForNativeId(id);
   if (!externalDevice) return;
-  if (externalDevice.capabilities.has(capability37)) return;
+  if (externalDevice.capabilities.has(capability38)) return;
   throw new FailureError(
-    `${namespace} is not available on '${externalDevice.name}': ${externalDevice.provider.name} did not grant the '${capability37}' capability for this device.`,
+    `${namespace} is not available on '${externalDevice.name}': ${externalDevice.provider.name} did not grant the '${capability38}' capability for this device.`,
     {
       error_code: FAILURE_CODES.EXTERNAL_DEVICE_CAPABILITY_DENIED,
       error_kind: "unsupported",
@@ -94920,7 +94920,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID = (0, import_node_crypto3.randomUUID)();
 function readCliVersion() {
   if (true) {
-    return "0.28.1-next.2";
+    return "0.28.1-next.21";
   }
   return "0.0.0";
 }
@@ -96694,8 +96694,8 @@ async function simctlArgsForUdid(udid, args, options) {
   return [...simctlPrefix(await deviceSetForUdid(udid)), ...nativeArgs(udid, args)];
 }
 function assertSimctlEntitlement(udid, options) {
-  const capability37 = options?.granted ?? "simctl";
-  assertExternalCapabilitySync(capability37, udid, capability37);
+  const capability38 = options?.granted ?? "simctl";
+  assertExternalCapabilitySync(capability38, udid, capability38);
 }
 async function simctlTargetForUdid(udid, options) {
   assertSimctlEntitlement(udid, options);
@@ -97760,6 +97760,9 @@ var axServiceBlueprint = {
           treeVersion: result.treeVersion
         };
       },
+      async foregroundApp() {
+        return await query("foreground_app");
+      },
       async livePanel() {
         const result = await query("live_panel", LIVE_PANEL_TIMEOUT_MS);
         if (result.error) {
@@ -97869,23 +97872,23 @@ var InvalidToolInputError = class extends Error {
     });
   }
 };
-function platformMatrix(platform, capability37) {
+function platformMatrix(platform, capability38) {
   switch (platform) {
     case "ios":
-      return capability37.apple;
+      return capability38.apple;
     case "ios-remote":
-      return capability37.appleRemote;
+      return capability38.appleRemote;
     case "android":
-      return capability37.android;
+      return capability38.android;
     case "chromium":
-      return capability37.chromium;
+      return capability38.chromium;
     case "vega":
-      return capability37.vega;
+      return capability38.vega;
   }
 }
-function assertSupported(toolId, capability37, device) {
-  if (!capability37) return;
-  const matrix = platformMatrix(device.platform, capability37);
+function assertSupported(toolId, capability38, device) {
+  if (!capability38) return;
+  const matrix = platformMatrix(device.platform, capability38);
   if (!matrix) {
     throw new UnsupportedOperationError(toolId, device, `no ${device.platform} support declared`);
   }
@@ -97893,7 +97896,7 @@ function assertSupported(toolId, capability37, device) {
   if (!supported) {
     throw new UnsupportedOperationError(toolId, device, `kind '${device.kind}' not supported`);
   }
-  if (capability37.supports && !capability37.supports(device)) {
+  if (capability38.supports && !capability38.supports(device)) {
     throw new UnsupportedOperationError(toolId, device, "supports() refiner rejected device");
   }
 }
@@ -113332,7 +113335,8 @@ function parseUiAutomatorDump(rawOutput, screenW, screenH, options = {}) {
   if (xmlEnd !== -1) xml = xml.slice(0, xmlEnd + "</hierarchy>".length);
   const root = parseUiAutomatorXml(xml);
   if (!root) {
-    throw new FailureError("Failed to parse uiautomator dump output", {
+    const got = rawOutput.trim() ? `${rawOutput.length} chars: ${JSON.stringify(rawOutput.slice(0, 200))}` : "empty";
+    throw new FailureError(`Failed to parse uiautomator dump output (${got})`, {
       error_code: FAILURE_CODES.ANDROID_UIAUTOMATOR_PARSE_FAILED,
       failure_stage: "android_uiautomator_parse_dump",
       failure_area: "tool_server",
@@ -116728,13 +116732,13 @@ function scheduleGroupSigkill(pid, graceMs, opts) {
   }, graceMs).unref();
 }
 async function pollPidsUntilGone(pids, opts) {
-  const isAlive = opts.isAlive ?? pidIsAlive;
+  const isAlive2 = opts.isAlive ?? pidIsAlive;
   const sleep14 = opts.sleep ?? ((ms) => new Promise((resolve14) => setTimeout(resolve14, ms)));
   const maxPolls = Math.max(1, Math.ceil(opts.timeoutMs / opts.pollIntervalMs));
-  let remaining = pids.filter((pid) => isAlive(pid));
+  let remaining = pids.filter((pid) => isAlive2(pid));
   for (let poll = 0; poll < maxPolls && remaining.length > 0; poll += 1) {
     await sleep14(opts.pollIntervalMs);
-    remaining = remaining.filter((pid) => isAlive(pid));
+    remaining = remaining.filter((pid) => isAlive2(pid));
   }
   return remaining;
 }
@@ -117834,9 +117838,11 @@ var fs29 = __toESM(require("node:fs"));
 var path26 = __toESM(require("node:path"));
 var os12 = __toESM(require("node:os"));
 var MAX_ENTRIES = 5e4;
+var STALE_LOG_MS = 24 * 60 * 60 * 1e3;
 var CLUSTER_KEY_LENGTH = 80;
 var SOURCE_EXT = /\.(tsx?|jsx?|mjs|cjs)$/;
 var LINE_RE = /^\[L:(\d+)\] (\S+) (\S+)\s+(\S+) \| (.*)$/;
+var liveLogFiles = /* @__PURE__ */ new Set();
 var LogFileWriter = class {
   filePath;
   fd = null;
@@ -117850,7 +117856,9 @@ var LogFileWriter = class {
     const timestamp = Date.now();
     const dir = path26.join(os12.homedir(), ".argent", "tmp");
     fs29.mkdirSync(dir, { recursive: true });
-    this.filePath = path26.join(dir, `argent-logs-${port}-${timestamp}.log`);
+    pruneStaleLogs(dir);
+    this.filePath = path26.join(dir, `argent-logs-${port}-${timestamp}-p${process.pid}.log`);
+    liveLogFiles.add(this.filePath);
     this.open();
   }
   open() {
@@ -117943,9 +117951,11 @@ var LogFileWriter = class {
     }
     return { entries: filtered, total };
   }
-  close() {
+  /** `keepFile` leaves the log to the sweep, 24h after the close. */
+  close({ keepFile = false } = {}) {
     if (this.closed) return;
     this.closed = true;
+    liveLogFiles.delete(this.filePath);
     if (this.fd !== null) {
       try {
         fs29.closeSync(this.fd);
@@ -117953,12 +117963,47 @@ var LogFileWriter = class {
       }
       this.fd = null;
     }
+    if (keepFile) {
+      try {
+        const now = /* @__PURE__ */ new Date();
+        fs29.utimesSync(this.filePath, now, now);
+      } catch {
+      }
+      return;
+    }
     try {
       fs29.unlinkSync(this.filePath);
     } catch {
     }
   }
 };
+function pruneStaleLogs(dir) {
+  const cutoff = Date.now() - STALE_LOG_MS;
+  let names;
+  try {
+    names = fs29.readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const pid = Number(/^argent-logs-.*-p(\d+)\.log$/.exec(name)?.[1]);
+    if (!pid) continue;
+    const file2 = path26.join(dir, name);
+    if (pid === process.pid ? liveLogFiles.has(file2) : isAlive(pid)) continue;
+    try {
+      if (fs29.statSync(file2).mtimeMs < cutoff) fs29.unlinkSync(file2);
+    } catch {
+    }
+  }
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
 function cleanSourceUrl(url2) {
   try {
     const { pathname } = new URL(url2);
@@ -117996,20 +118041,36 @@ var reaped = /* @__PURE__ */ new Map();
 function key(kind, deviceId) {
   return `${kind}:${deviceId.toLowerCase()}`;
 }
-function recordReapedSession(kind, deviceId, salvage) {
-  const entry = { kind, deviceId, atMs: Date.now() };
+function recordReapedSession(kind, deviceIds, salvage, connectionLost = false) {
+  const ids = [deviceIds].flat().filter((id) => id !== void 0);
+  const entry = { kind, deviceId: ids[0], ids, atMs: Date.now() };
   if (salvage) entry.salvage = salvage;
-  reaped.set(key(kind, deviceId), entry);
+  if (connectionLost) entry.connectionLost = true;
+  for (const id of ids) reaped.set(key(kind, id), entry);
 }
 function takeReapedSession(kind, deviceId) {
-  const k = key(kind, deviceId);
-  const entry = reaped.get(k);
-  if (entry) reaped.delete(k);
+  const entry = reaped.get(key(kind, deviceId));
+  for (const id of entry?.ids ?? []) {
+    if (reaped.get(key(kind, id)) === entry) reaped.delete(key(kind, id));
+  }
   return entry;
 }
+function takeReapedSessionAnyId(kind, ids) {
+  let first;
+  for (const id of new Set(ids)) {
+    if (id === void 0) continue;
+    const entry = takeReapedSession(kind, id);
+    first ??= entry;
+  }
+  return first;
+}
 function describeReapedSession(entry, what) {
   const secondsAgo = Math.max(0, Math.round((Date.now() - entry.atMs) / 1e3));
-  return `The ${what} for device ${entry.deviceId} was torn down ${secondsAgo}s ago \u2014 by a stop-all-simulator-servers, which reaps every service a device owns, or by another teardown that reaches the same services (a stop-simulator-server on Chromium, or a react-profiler-start reclaiming the session with force). One tool-server serves every agent using this argent install, so this may have been another agent rather than your own call. It was not a session that never started.` + (entry.salvage ? ` ${entry.salvage}` : "");
+  const salvage = entry.salvage ? ` ${entry.salvage}` : "";
+  if (entry.connectionLost) {
+    return `The ${what} for device ${entry.deviceId} lost its connection ${secondsAgo}s ago \u2014 the app crashed or quit, or its debugger endpoint went away.${salvage}`;
+  }
+  return `The ${what} for device ${entry.deviceId} was torn down ${secondsAgo}s ago \u2014 by a stop-all-simulator-servers, which reaps every service a device owns, or by another teardown that reaches the same services (a stop-simulator-server on Chromium, or a react-profiler-start reclaiming the session with force). One tool-server serves every agent using this argent install, so this may have been another agent rather than your own call. It was not a session that never started.${salvage}`;
 }
 
 // ../tool-server/src/blueprints/chromium-js-runtime-debugger.ts
@@ -118174,14 +118235,17 @@ var chromiumJsRuntimeDebuggerBlueprint = {
         cdp.events.off("disconnected", onDisconnected);
         await consoleServer.close();
         const captured = logWriter.getStats().totalEntries;
+        const keepFile = captured > 0 && !cdp.isConnected();
         if (captured > 0) {
+          const entries = `${captured} captured console ${captured === 1 ? "entry" : "entries"}`;
           recordReapedSession(
             "js-runtime-debugger",
             device.id,
-            `The ${captured} captured console ${captured === 1 ? "entry" : "entries"} went with it \u2014 the log file is deleted on teardown, so this registry starts empty rather than the app having logged nothing.`
+            keepFile ? `The log file with its ${entries} is kept at ${logWriter.getFilePath()}.` : `The ${entries} went with it \u2014 the log file is deleted on teardown, so this registry starts empty rather than the app having logged nothing.`,
+            keepFile
           );
         }
-        logWriter.close();
+        logWriter.close({ keepFile });
       },
       events
     };
@@ -119997,17 +120061,21 @@ var jsRuntimeDebuggerBlueprint = {
       api,
       dispose: async () => {
         const captured = logWriter.getStats().totalEntries;
+        const keepFile = captured > 0 && !cdp.isConnected();
         if (captured > 0) {
-          const salvage = `The ${captured} captured console ${captured === 1 ? "entry" : "entries"} went with it \u2014 the log file is deleted on teardown, so this registry starts empty rather than the app having logged nothing.`;
-          recordReapedSession("js-runtime-debugger", deviceId, salvage);
-          if (api.logicalDeviceId && api.logicalDeviceId !== deviceId) {
-            recordReapedSession("js-runtime-debugger", api.logicalDeviceId, salvage);
-          }
+          const entries = `${captured} captured console ${captured === 1 ? "entry" : "entries"}`;
+          const salvage = keepFile ? `The log file with its ${entries} is kept at ${logWriter.getFilePath()}.` : `The ${entries} went with it \u2014 the log file is deleted on teardown, so this registry starts empty rather than the app having logged nothing.`;
+          recordReapedSession(
+            "js-runtime-debugger",
+            [deviceId, api.logicalDeviceId],
+            salvage,
+            keepFile
+          );
         }
         forgetDeviceAlias(api.logicalDeviceId);
         forgetLogicalKeyedDevice(deviceId);
         await consoleServer.close();
-        logWriter.close();
+        logWriter.close({ keepFile });
         await cdp.disconnect();
       },
       events
@@ -122643,8 +122711,9 @@ async function resolveLauncherActivity(udid, bundleId, isTv = false) {
   }
   const launcher = await resolveFor();
   if (launcher) return launcher;
+  const pmPath = await adbShell(udid, `pm path ${shellQuote(bundleId)}; true`);
   throw new FailureError(
-    `Could not resolve a ${isTv ? "LEANBACK_LAUNCHER or LAUNCHER" : "LAUNCHER"} activity for ${bundleId}. Install the app first, or pass an explicit \`activity\`. (resolve-activity output: ${lastRaw.trim() || "empty"})`,
+    `Could not resolve a ${isTv ? "LEANBACK_LAUNCHER or LAUNCHER" : "LAUNCHER"} activity for ${bundleId}. ` + (pmPath.includes("package:") ? `It is installed but declares no such activity: pass an explicit \`activity\`. ` : `It is not installed on ${udid}: install it with \`reinstall-app\`. `) + `(resolve-activity output: ${lastRaw.trim() || "empty"})`,
     {
       error_code: FAILURE_CODES.ANDROID_LAUNCH_ACTIVITY_RESOLVE_FAILED,
       failure_stage: "android_launch_resolve_activity",
@@ -124825,7 +124894,6 @@ var gestureScrollTool = {
   description: `Scroll content in a Chromium app by dispatching mouse-wheel events at a point. Anchor x/y are normalized 0.0\u20131.0 (fractions of the window, not pixels), same coordinate space as gesture-tap and describe. Deltas are fractions of the window too: deltaY 0.5 scrolls down half a window; negative scrolls back up.
 Use when content is below/above the fold (describe shows off-screen elements with zero height) or a list needs scrolling. Chromium only \u2014 on iOS/Android use gesture-swipe.
 Returns { scrolled: true, timestampMs }. Fails if the Chromium CDP session is not reachable for the given device.`,
-  alwaysLoad: true,
   searchHint: "scroll wheel list page chromium mouse down up content fold",
   zodSchema: zodSchema19,
   capability: capability11,
@@ -124892,7 +124960,6 @@ var gestureDragTool = {
   description: `Press the left mouse button at a start point, move to an end point, and release \u2014 a desktop mouse drag in a Chromium app. All positions are normalized 0.0\u20131.0 (fractions of the window, not pixels), same coordinate space as gesture-tap and describe, except that a coordinate of exactly 1.0 lands one pixel inside the window edge (gesture-tap maps it to the edge itself). Interpolates mouse-move events at ~60fps over durationMs for a natural drag (a momentum-free drag samples more finely when durationMs is short, so its ease-out has a curve).
 Use for slider thumbs, drag-and-drop, text selection, or draggable UI elements. Dragging never scrolls content on desktop \u2014 use gesture-scroll for lists/pages. Chromium only \u2014 on iOS/Android use gesture-swipe.
 Pass momentum:false for a momentum-free drag that decelerates into the release, so apps that compute a fling from the pointer stream read ~0 velocity and the drag ends where it was aimed instead of flinging past it (a durationMs under ~100ms is too short for the deceleration to suppress the fling entirely). Returns { dragged: true, timestampMs }. Fails if the Chromium CDP session is not reachable for the given device.`,
-  alwaysLoad: true,
   searchHint: "drag drop slider mouse press move release chromium select",
   zodSchema: zodSchema20,
   capability: capability12,
@@ -126150,6 +126217,10 @@ On a TV target (runtimeKind 'tv') only \`text\` applies \u2014 focus a text fiel
 One call does one action: pass text OR key, never both. To type and then press a key, send two \`keyboard\` steps in one \`run-sequence\` \u2014 { text: "hello" } then { key: "enter" } \u2014 which also keeps it to a single round-trip.`,
     zodSchema: zodSchema25,
     capability: capability17,
+    alwaysLoad: true,
+    // Typing time grows with text length on several backends and can outlast the MCP
+    // fetch timeout, whose abort replays the call: the text would be typed twice.
+    longRunning: true,
     searchHint: "type text keyboard input named key enter escape arrow tv vega fire tv search field hid leanback",
     services: () => ({}),
     execute: async (services, params, options) => {
@@ -127146,7 +127217,6 @@ Single press: { button: "down" }. Repeat the same button: { button: "down", repe
 Multi-step navigation: pass a path as { button: ["up","right","right","select"] } \u2014 it runs in one tool call, far cheaper than separate presses.
 Read the screen with \`describe\` before and after to see where focus landed.
 Returns { pressed, count }.`,
-    alwaysLoad: true,
     // A path (≤64 buttons) × repeat (≤50) flattens to thousands of presses, sent
     // one round-trip at a time on the Apple/Android path — minutes of wall-clock.
     longRunning: true,
@@ -127197,9 +127267,9 @@ async function invokeSubTool(registry2, ctx, toolId, args, extra) {
 }
 function describeNestedParamError(registry2, err, toolId, dispatchedArgs, authoredArgs) {
   if (getFailureSignal(err)?.error_code !== FAILURE_CODES.TOOL_INPUT_INVALID) return void 0;
-  const zodSchema80 = registry2.getTool(toolId)?.zodSchema;
-  if (!zodSchema80) return void 0;
-  const parsed = zodSchema80.safeParse(dispatchedArgs ?? {});
+  const zodSchema81 = registry2.getTool(toolId)?.zodSchema;
+  if (!zodSchema81) return void 0;
+  const parsed = zodSchema81.safeParse(dispatchedArgs ?? {});
   if (parsed.success) return void 0;
   return `Invalid params for tool "${toolId}": ${describeParamIssues(parsed.error, authoredArgs)}`;
 }
@@ -133512,7 +133582,7 @@ var zodSchema29 = external_exports.object({
     `Max time to wait for the condition before giving up (default ${DEFAULT_TIMEOUT_MS3}).`
   ),
   pollIntervalMs: external_exports.number().int().min(50).max(5e3).optional().describe(`How often to re-check the tree (default ${DEFAULT_POLL_INTERVAL_MS}).`)
-}).refine((p) => p.condition !== "text" || p.expectedText !== void 0, {
+}).strict().refine((p) => p.condition !== "text" || p.expectedText !== void 0, {
   message: "condition `text` requires expectedText",
   path: ["expectedText"]
 });
@@ -133935,7 +134005,7 @@ var debuggerConnectTool = {
   },
   description: `Connect to a JS runtime CDP debugger.
 iOS / Android / Vega: connects to Metro's CDP endpoint on the given port. Chromium: re-uses the page CDP session opened by boot-device \u2014 port is ignored.
-Returns connection info including port, projectRoot (empty on Chromium and on legacy Metro, e.g. Vega), deviceName, appName, logicalDeviceId (absent on Vega), and isNewDebugger. If already connected, returns the existing connection.
+Returns connection info including port, projectRoot (empty on Chromium and on legacy Metro, e.g. Vega), deviceName, appName, logicalDeviceId (absent on Vega), and isNewDebugger, plus a note naming the kept log file when the previous session ended because the app crashed. If already connected, returns the existing connection.
 Use when starting a debug session or before calling other debugger-* tools. Fails if the runtime is unreachable (Metro down, or Chromium CDP terminated).`,
   zodSchema: zodSchema31,
   capability: DEBUGGER_TOOL_CAPABILITY,
@@ -133944,11 +134014,10 @@ Use when starting a debug session or before calling other debugger-* tools. Fail
   }),
   async execute(services, params) {
     const api = services.debugger;
-    for (const id of new Set(
-      [params.device_id, api.logicalDeviceId].filter((v) => v !== void 0)
-    )) {
-      takeReapedSession("js-runtime-debugger", id);
-    }
+    const reaped2 = takeReapedSessionAnyId("js-runtime-debugger", [
+      params.device_id,
+      api.logicalDeviceId
+    ]);
     return {
       port: api.port,
       projectRoot: api.projectRoot,
@@ -133956,7 +134025,8 @@ Use when starting a debug session or before calling other debugger-* tools. Fail
       appName: api.appName,
       logicalDeviceId: api.logicalDeviceId,
       isNewDebugger: api.isNewDebugger,
-      connected: api.cdp.isConnected()
+      connected: api.cdp.isConnected(),
+      ...reaped2?.connectionLost ? { note: describeReapedSession(reaped2, "previous JS-runtime debugger session") } : {}
     };
   }
 };
@@ -135803,8 +135873,8 @@ function createDebuggerLogRegistryTool(registry2) {
     },
     description: `Get a summary of all console logs captured from the app's JS runtime.
 Returns the log file path, entry counts by level, and message clusters (grouped by similarity). Works against Hermes (iOS / Android / Vega) and V8 (Chromium).
-Use when investigating warnings, errors, or unexpected output \u2014 call this first for an overview, then read the returned file for details. Returns empty stats if no log data has been captured yet \u2014 but check { note }, which is present only when the stats are empty BECAUSE a stop-all-simulator-servers tore the previous debugger session down and deleted its log file. Absent that note, empty really does mean the app has logged nothing.
-When the debugger cannot be reached, this tool does not fail: it returns { status: "not_connected", reason, detail, guidance } with NO log file \u2014 follow the guidance (do not retry in a loop, and do not try to read a log file from this state). A "connected" result's stats may come from a session whose socket has since died \u2014 use debugger-status, not this tool, to judge debugger health.`,
+Use when investigating warnings, errors, or unexpected output \u2014 call this first for an overview, then read the returned file for details. Returns empty stats if no log data has been captured yet \u2014 but check { note }, which is present only when the stats are empty BECAUSE the previous debugger session ended: torn down (e.g. by stop-all-simulator-servers) with its log file deleted, or cut off by the app crashing with its log file kept at the path the note names. Absent that note, empty really does mean the app has logged nothing.
+When the debugger cannot be reached, this tool does not fail: it returns { status: "not_connected", reason, detail, guidance } with NO log file \u2014 follow the guidance (do not retry in a loop). Read a log file in this state only when a { note } names one kept from before the app crashed. A "connected" result's stats may come from a session whose socket has since died \u2014 use debugger-status, not this tool, to judge debugger health.`,
     zodSchema: zodSchema37,
     capability: DEBUGGER_TOOL_CAPABILITY,
     // Resolved manually in execute so a not-connected precondition becomes a
@@ -135825,16 +135895,11 @@ When the debugger cannot be reached, this tool does not fail: it returns { statu
           logicalDeviceId: api.logicalDeviceId
         };
         if (stats.totalEntries === 0) {
-          const aliases = [
+          const reaped2 = takeReapedSessionAnyId("js-runtime-debugger", [
             canonicalDeviceId(params.device_id),
             params.device_id,
             api.logicalDeviceId
-          ].filter((id) => id !== void 0);
-          let reaped2;
-          for (const id of new Set(aliases)) {
-            const entry = takeReapedSession("js-runtime-debugger", id);
-            reaped2 ??= entry;
-          }
+          ]);
           if (reaped2) response.note = describeReapedSession(reaped2, "JS-runtime debugger session");
         }
         return response;
@@ -135842,7 +135907,17 @@ When the debugger cannot be reached, this tool does not fail: it returns { statu
         const reason = classifyNotConnected(err);
         if (!reason) throw err;
         trackDebuggerOutcome("debugger-log-registry", reason, params, ctx);
-        return buildNotConnected(reason, err, params);
+        const result = buildNotConnected(
+          reason,
+          err,
+          params
+        );
+        const reaped2 = takeReapedSessionAnyId("js-runtime-debugger", [
+          canonicalDeviceId(params.device_id),
+          params.device_id
+        ]);
+        if (reaped2) result.note = describeReapedSession(reaped2, "JS-runtime debugger session");
+        return result;
       }
     }
   };
@@ -136972,6 +137047,73 @@ Fails if the iOS ax-service predates the tree command; update argent.`,
   };
 }
 
+// ../tool-server/src/tools/foreground-app/index.ts
+init_zod();
+var zodSchema42 = external_exports.object({
+  udid: external_exports.string().min(1).describe("Target device id from `list-devices`.")
+});
+var capability27 = {
+  apple: { simulator: true },
+  appleRemote: { simulator: true },
+  android: { emulator: true, device: true, unknown: true }
+};
+async function readIosForegroundApp(registry2, device) {
+  const ref = axServiceRef(device);
+  const ax = await registry2.resolveService(ref.urn, ref.options);
+  const { bundleId, name, alertVisible } = await ax.foregroundApp();
+  return { bundleId, name, alertVisible };
+}
+async function readAndroidForegroundApp(registry2, device) {
+  const ref = androidDevtoolsRef(device);
+  const devtools = await registry2.resolveService(ref.urn, ref.options);
+  const [capture, size] = await Promise.all([
+    // The default settle, as ui-tree: free on a settled screen, and it keeps a
+    // mid-transition window list (right after home or a launch) from naming the old app.
+    devtools.getHierarchy({ maxDepth: 0, clearCache: true }),
+    devtools.getScreenSize()
+  ]);
+  const tree = adaptAndroidTree({ ...capture, truncated: false }, size);
+  return { bundleId: tree.foregroundApp, alertVisible: tree.alertVisible };
+}
+function createForegroundAppTool(registry2) {
+  return {
+    id: "foreground-app",
+    interaction: {
+      startedMsg: () => "Reading foreground app",
+      completedMsg: () => "Read foreground app",
+      failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to read foreground app: ${failureSignal2.error_code}`
+    },
+    description: `Read which app is in front, for SDK callers.
+Returns { bundleId, name, alertVisible }; under a system alert, bundleId is the app it covers.
+A field is unset when it is unknown.`,
+    hideFromMcp: true,
+    zodSchema: zodSchema42,
+    capability: capability27,
+    services: () => ({}),
+    execute: dispatchByPlatform({
+      toolId: "foreground-app",
+      capability: capability27,
+      ios: {
+        requires: iosRequires,
+        handler: async (_services, _params, device) => {
+          if (await isTvOsSimulator(device.id)) {
+            throw new UnsupportedOperationError("foreground-app", device, "tvOS");
+          }
+          return readIosForegroundApp(registry2, device);
+        }
+      },
+      iosRemote: {
+        requires: ["sim-remote"],
+        handler: async (_services, _params, device) => readIosForegroundApp(registry2, device)
+      },
+      android: {
+        requires: androidRequires,
+        handler: async (_services, _params, device) => readAndroidForegroundApp(registry2, device)
+      }
+    })
+  };
+}
+
 // ../tool-server/src/tools/await-screen-idle/index.ts
 init_zod();
 init_device_info();
@@ -136980,7 +137122,7 @@ var AWAIT_SCREEN_IDLE_TOOL_ID = "await-screen-idle";
 var DEFAULT_TIMEOUT_MS4 = 3e3;
 var DEFAULT_POLL_INTERVAL_MS2 = 200;
 var DEFAULT_MIN_STABLE_MS = 250;
-var zodSchema42 = external_exports.object({
+var zodSchema43 = external_exports.object({
   udid: external_exports.string().min(1).describe("Target device id from `list-devices` (iOS UDID, Android serial, or Chromium id)."),
   timeoutMs: external_exports.number().int().positive().max(12e4).optional().describe(
     `Max time to wait for the screen to settle before giving up (default ${DEFAULT_TIMEOUT_MS4}).`
@@ -136989,8 +137131,8 @@ var zodSchema42 = external_exports.object({
   minStableMs: external_exports.number().int().min(0).max(1e4).optional().describe(
     `The screen must hold the same content for at least this long to count as settled (default ${DEFAULT_MIN_STABLE_MS}).`
   )
-});
-var capability27 = {
+}).strict();
+var capability28 = {
   apple: { simulator: true, device: true },
   appleRemote: { simulator: true },
   android: { emulator: true, device: true, unknown: true },
@@ -137037,8 +137179,8 @@ ${DEFAULT_TIMEOUT_MS4}ms) is reached. Returns { settled, waitedMs, polls } \u201
 still before the timeout. Use after a launch/navigation to wait for the UI to render before screenshotting or tapping.`,
     searchHint: "wait until screen settles idle stable stops changing animation transition rendered ready before screenshot",
     longRunning: true,
-    zodSchema: zodSchema42,
-    capability: capability27,
+    zodSchema: zodSchema43,
+    capability: capability28,
     services: (params) => {
       const device = resolveDevice(params.udid);
       if (device.platform === "chromium") {
@@ -137048,7 +137190,7 @@ still before the timeout. Use after a launch/navigation to wait for the UI to re
     },
     async execute(services, params, ctx) {
       const device = resolveDevice(params.udid);
-      assertSupported(AWAIT_SCREEN_IDLE_TOOL_ID, capability27, device);
+      assertSupported(AWAIT_SCREEN_IDLE_TOOL_ID, capability28, device);
       if (device.platform === "ios") await ensureDeps(iosRequires);
       else if (device.platform === "ios-remote") await ensureDeps(["sim-remote"]);
       else if (device.platform === "android") await ensureDeps(androidRequires);
@@ -137135,7 +137277,7 @@ function bootstrapFailureMessage(bootstrap) {
 // ../tool-server/src/tools/profiler/react/react-profiler-start.ts
 var NO_DEVTOOLS_HOOK_ERROR = "React DevTools hook (__REACT_DEVTOOLS_GLOBAL_HOOK__) is not present in this app's JavaScript runtime. React profiling requires a development build with React DevTools enabled. Likely causes: (1) the app is a release/production build \u2014 DevTools is stripped to reduce bundle size; (2) you connected to the wrong JS runtime; (3) this isn't a React (Native) app. Fix: rebuild in debug/dev mode (e.g. `npx react-native run-ios` without --configuration Release; for Expo, run a dev client). Once the app is running with DevTools attached, call react-profiler-start again.";
 var NO_RENDERERS_ATTACHED_ERROR = "React DevTools hook is present but no React renderer has registered yet. The hook is loaded but no fiber renderer has attached \u2014 typically because the app has not committed its first render, or the DevTools backend has not been bootstrapped on a bridgeless React Native dev build. Fix: ensure the app has rendered (interact with it once, then retry); if it stays empty, call react-profiler-start first \u2014 it will attempt to attach the DevTools backend automatically.";
-var zodSchema43 = external_exports.object({
+var zodSchema44 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
     "Device id from list-devices \u2014 the SAME id you passed to debugger-connect (iOS simulator UDID or Android serial)."
@@ -137167,7 +137309,7 @@ Before calling this, ask the user if they also want native profiling (native-pro
 After starting, ask the user to perform the interaction to profile, then call react-profiler-stop.
 Returns { started_at, startedAtEpochMs, hermes_version, detected_architecture } on success, or the already_running payload described above.
 Fails if the Hermes runtime is not reachable or the Metro CDP connection cannot be established.`,
-    zodSchema: zodSchema43,
+    zodSchema: zodSchema44,
     capability: RN_ONLY_TOOL_CAPABILITY,
     services: () => ({}),
     async execute(_services, params) {
@@ -137438,7 +137580,7 @@ async function readCommitTree(path53) {
 }
 
 // ../tool-server/src/tools/profiler/react/react-profiler-stop.ts
-var zodSchema44 = external_exports.object({
+var zodSchema45 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
     "Device id from list-devices \u2014 the SAME id you passed to debugger-connect (iOS simulator UDID or Android serial)."
@@ -137527,7 +137669,7 @@ Call react-profiler-start first, then exercise the app, then call this.
 Returns { duration_ms, sample_count, fiber_renders_captured, total_react_commits, hot_commit_indices } summarizing the session.
 When any commit had fibers whose display name could not be resolved at stop time (typically transient components like modals/tooltips/animations that unmounted before stop), the response also includes { unattributed_ms, unattributed_fiber_count, unattributed_commit_count } \u2014 these quantify how much work is not accounted for in the per-component breakdown (the per-commit duration itself remains correct).
 Fails if no active profiling session exists or the CDP connection was lost during recording.`,
-    zodSchema: zodSchema44,
+    zodSchema: zodSchema45,
     capability: RN_ONLY_TOOL_CAPABILITY,
     services: () => ({}),
     async execute(_services, params) {
@@ -137752,7 +137894,7 @@ Fails if no active profiling session exists or the CDP connection was lost durin
 
 // ../tool-server/src/tools/profiler/react/react-profiler-status.ts
 init_zod();
-var zodSchema45 = external_exports.object({
+var zodSchema46 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
     "Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId)."
@@ -137767,7 +137909,7 @@ function createReactProfilerStatusTool(registry2) {
       failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to check React profiler: ${failureSignal2.error_code}`
     },
     description: `Check the state of the React profiler session without side effects. Use after an interruption (debugger disconnect, unexpected error, agent pause) to decide whether to continue with react-profiler-stop, start a new session, or reconnect the debugger. Ownership is verified server-side against this tool-server's in-memory session \u2014 no token-threading is required. Returns { session_status, is_running, current_owner, \u2026 }. If this tool-server process restarted after react-profiler-start, status will report 'taken_over'; use react-profiler-start { force: true } to reclaim.`,
-    zodSchema: zodSchema45,
+    zodSchema: zodSchema46,
     // RN-only: companion to react-profiler-start.
     capability: RN_ONLY_TOOL_CAPABILITY,
     services: () => ({}),
@@ -139381,7 +139523,7 @@ var annotationSchema = external_exports.object({
   ),
   label: external_exports.string().describe("Description of the action performed")
 });
-var zodSchema46 = external_exports.object({
+var zodSchema47 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
     "Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId)."
@@ -139414,7 +139556,7 @@ where tapTimestampMs is the timestampMs returned by the tap/swipe tool and start
 is returned by react-profiler-start.
 Use when the profiling session is complete and you need to interpret the collected data.
 Fails if react-profiler-stop has not been called or no profiling data is stored.`,
-  zodSchema: zodSchema46,
+  zodSchema: zodSchema47,
   // RN-only: reads commit data captured via the React DevTools backend, which
   // Chromium does not have.
   capability: RN_ONLY_TOOL_CAPABILITY,
@@ -139551,7 +139693,7 @@ Fails if react-profiler-stop has not been called or no profiling data is stored.
 // ../tool-server/src/tools/profiler/react/react-profiler-component-source.ts
 init_zod();
 var import_fs6 = require("fs");
-var zodSchema47 = external_exports.object({
+var zodSchema48 = external_exports.object({
   component_name: external_exports.string().describe("Name of the React component to look up"),
   project_root: external_exports.string().describe("Absolute path to the RN project root")
 });
@@ -139569,7 +139711,7 @@ var reactProfilerComponentSourceTool = {
 Call this per-finding after react-profiler-analyze to inspect source before proposing a fix.
 Returns found: false if the component is not found in user-owned code (e.g. lives in node_modules).
 When several files define a component with the same name (e.g. platform variants like List.tsx and List.web.tsx), returns the primary match and lists the rest under otherMatches[] (file/line/col) \u2014 check it before assuming the returned file is the one you meant.`,
-  zodSchema: zodSchema47,
+  zodSchema: zodSchema48,
   // Declared so the tool catalogue groups this with the other react-profiler-*
   // tools; the HTTP gate itself is a no-op here, as there is no device arg to
   // inspect.
@@ -139625,7 +139767,7 @@ When several files define a component with the same name (e.g. platform variants
 // ../tool-server/src/tools/profiler/react/react-profiler-cpu-summary.ts
 init_zod();
 init_src2();
-var zodSchema48 = external_exports.object({
+var zodSchema49 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
     "Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId)."
@@ -139707,7 +139849,7 @@ Use when you specifically need to investigate JS CPU hotspots that are NOT tied
 Call react-profiler-stop first. Reads directly from the stored cpuProfile.
 Returns a markdown table of the top hotspot functions with self-time, total-time, and location.
 Fails if react-profiler-stop has not been called or no CPU profile is stored.`,
-  zodSchema: zodSchema48,
+  zodSchema: zodSchema49,
   // RN-only: reads a Hermes CPU profile; Chromium's V8 sample format differs.
   capability: RN_ONLY_TOOL_CAPABILITY,
   services: () => ({}),
@@ -139803,7 +139945,7 @@ function renderMarkdownTable2(entries) {
   );
   return [header, sep5, ...rows].join("\n");
 }
-var zodSchema49 = external_exports.object({
+var zodSchema50 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
     "Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId)."
@@ -139821,7 +139963,7 @@ var reactProfilerRendersTool = {
 Returns a markdown table of the top re-rendering components. No profiling session required \u2014 works on a live connected app.
 Use when you want a quick snapshot of render counts without a full profiling session.
 Fails if the React DevTools hook is not present in the runtime or the app is not connected.`,
-  zodSchema: zodSchema49,
+  zodSchema: zodSchema50,
   // RN-only: queries the React DevTools backend hook on the live runtime.
   capability: RN_ONLY_TOOL_CAPABILITY,
   services: (params) => ({
@@ -139978,7 +140120,7 @@ function buildFiberTreeScript(maxDepth, filter) {
   }
 })()`;
 }
-var zodSchema50 = external_exports.object({
+var zodSchema51 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
     "Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId)."
@@ -139997,7 +140139,7 @@ var reactProfilerFiberTreeTool = {
 Use when tracing ancestry of a library component or checking for useMemoCache hook (confirms React Compiler is active on a component).
 Returns a nested JSON tree of fiber nodes with name, tag, actualDuration, selfBaseDuration, and children.
 Fails if the React DevTools hook is not present or no fiber roots have been committed yet.`,
-  zodSchema: zodSchema50,
+  zodSchema: zodSchema51,
   // RN-only: walks the fiber tree via the React DevTools backend hook.
   capability: RN_ONLY_TOOL_CAPABILITY,
   services: (params) => ({
@@ -143795,7 +143937,7 @@ function metroDeviceIdParam(description) {
 }
 
 // ../tool-server/src/tools/profiler/native-profiler/native-profiler-start.ts
-var zodSchema51 = external_exports.object({
+var zodSchema52 = external_exports.object({
   device_id: metroDeviceIdParam(
     "Target device id from `list-devices` (iOS UDID or Android serial)."
   ),
@@ -143809,7 +143951,7 @@ var zodSchema51 = external_exports.object({
     "iOS-only. When true, cold-launches the app under the profiler with Malloc Stack Logging enabled so memory leaks carry an allocation backtrace (responsible frame + library). Without it, leaks are still detected but unattributable \u2014 Instruments reports '<Call stack limit reached>'. Trade-offs: this RESTARTS the app (current state is lost), adds memory/CPU overhead, and makes the app noticeably slow to launch (every startup allocation records a backtrace), so leave it off for pure CPU/hang profiling. Requires a non-degraded Xcode: on Xcode 26.4 and later the cold-launch path is broken, so the call is rejected up front (re-run without the flag, or set ARGENT_IOS_CAPTURE=device to override if the device path works on your host). ARGENT_IOS_CAPTURE=all-processes \u2014 e.g. exported globally for the normal capture path \u2014 also rejects this flag up front, since that fallback cannot cold-launch; unset it (or set it to device) first. Ignored on Android."
   )
 });
-var capability28 = {
+var capability29 = {
   apple: { simulator: true },
   android: { emulator: true, device: true, unknown: true }
 };
@@ -143820,21 +143962,21 @@ var nativeProfilerStartTool = {
     completedMsg: () => "Started native profiler",
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to start native profiler: ${failureSignal2.error_code}`
   },
-  capability: capability28,
+  capability: capability29,
   description: `Start native profiling on a booted device. iOS: Instruments via xctrace (CPU, hangs, memory). Android: Perfetto (CPU, jank, RSS-growth weak signal).
 Auto-detects the running app process unless app_process is explicitly provided.
 After starting, let the user interact with the app, then call native-profiler-stop.
 Use when you want to capture native CPU, hang, and memory data for a running app.
 Returns { status, pid, traceFile } confirming the recording has started.
 Fails if no app is running on the device, or the profiler cannot attach to the process.`,
-  zodSchema: zodSchema51,
+  zodSchema: zodSchema52,
   services: (params) => ({
     session: nativeProfilerSessionRef(resolveDevice(params.device_id))
   }),
   async execute(services, params) {
     const api = services.session;
     const device = resolveDevice(params.device_id);
-    assertSupported("native-profiler-start", capability28, device);
+    assertSupported("native-profiler-start", capability29, device);
     if (api.platform === "ios") {
       await ensureDeps(["xcrun"]);
       return startNativeProfilerIos(api, params);
@@ -143847,12 +143989,12 @@ Fails if no app is running on the device, or the profiler cannot attach to the p
 // ../tool-server/src/tools/profiler/native-profiler/native-profiler-stop.ts
 init_zod();
 init_device_info();
-var zodSchema52 = external_exports.object({
+var zodSchema53 = external_exports.object({
   device_id: metroDeviceIdParam(
     "Target device id from `list-devices` (iOS UDID or Android serial)."
   )
 });
-var capability29 = {
+var capability30 = {
   apple: { simulator: true },
   android: { emulator: true, device: true, unknown: true }
 };
@@ -143880,7 +144022,7 @@ var nativeProfilerStopTool = {
     completedMsg: ({ result }) => `Saved native profile ${result.traceFile.filename}`,
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to stop native profiler: ${failureSignal2.error_code}`
   },
-  capability: capability29,
+  capability: capability30,
   // Packaging plus the export passes routinely exceed the 30s MCP fetch timeout.
   longRunning: true,
   description: `Stop native profiling and export trace data.
@@ -143890,14 +144032,14 @@ Call native-profiler-start first.
 Use when the user has finished the interaction to profile and you need to export the trace.
 Returns { traceFile, exportedFiles, exportDiagnostics? }; traceFile is the raw trace bundle and exportedFiles the exports, all downloadable artifacts materialized to local paths.
 Fails if no active native-profiler-start session exists for the given device_id.`,
-  zodSchema: zodSchema52,
+  zodSchema: zodSchema53,
   services: (params) => ({
     session: nativeProfilerSessionRef(resolveDevice(params.device_id))
   }),
   async execute(services, params, ctx) {
     const api = services.session;
     const device = resolveDevice(params.device_id);
-    assertSupported("native-profiler-stop", capability29, device);
+    assertSupported("native-profiler-stop", capability30, device);
     if (api.platform === "ios") {
       await ensureDeps(["xcrun"]);
       const ios = await stopNativeProfilerIos(api);
@@ -143925,12 +144067,12 @@ Fails if no active native-profiler-start session exists for the given device_id.
 // ../tool-server/src/tools/profiler/native-profiler/native-profiler-analyze.ts
 init_zod();
 init_device_info();
-var zodSchema53 = external_exports.object({
+var zodSchema54 = external_exports.object({
   device_id: metroDeviceIdParam(
     "Target device id from `list-devices` (iOS UDID or Android serial)."
   )
 });
-var capability30 = {
+var capability31 = {
   apple: { simulator: true },
   android: { emulator: true, device: true, unknown: true }
 };
@@ -143941,7 +144083,7 @@ var nativeProfilerAnalyzeTool = {
     completedMsg: () => "Analyzed native profile",
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to analyze native profile: ${failureSignal2.error_code}`
   },
-  capability: capability30,
+  capability: capability31,
   // Parsing a trace from a recording up to RECORDING_CAP_MS long routinely exceeds
   // the 30s MCP fetch timeout, and an aborted call is replayed, not cancelled.
   longRunning: true,
@@ -143954,14 +144096,14 @@ profiler-stack-query for hang stacks, CPU context, leak details) or implement fi
 Call native-profiler-stop first to export the trace data.
 Use when you need to interpret a completed native profiling recording.
 Fails if native-profiler-stop has not been called first to export trace data.`,
-  zodSchema: zodSchema53,
+  zodSchema: zodSchema54,
   services: (params) => ({
     session: nativeProfilerSessionRef(resolveDevice(params.device_id))
   }),
   async execute(services, params, ctx) {
     const api = services.session;
     const device = resolveDevice(params.device_id);
-    assertSupported("native-profiler-analyze", capability30, device);
+    assertSupported("native-profiler-analyze", capability31, device);
     let result;
     if (api.platform === "ios") {
       await ensureDeps(["xcrun"]);
@@ -145024,7 +145166,7 @@ var DEFAULT_TIME_LIMIT_SECONDS = 180;
 var MAX_TIME_LIMIT_SECONDS = 600;
 var POINTER_TRAIL_LENGTH = 8;
 var POINTER_REQUEST_TIMEOUT_MS = 2e3;
-var zodSchema54 = external_exports.object({
+var zodSchema55 = external_exports.object({
   udid: external_exports.string().describe("Target device id from `list-devices` (iOS Simulator UDID or Android serial)."),
   timeLimitSeconds: external_exports.number().int().min(1).max(MAX_TIME_LIMIT_SECONDS).optional().describe(
     `Auto-stop cap in seconds (default ${DEFAULT_TIME_LIMIT_SECONDS}, max ${MAX_TIME_LIMIT_SECONDS}). Set it to slightly more than the interaction you plan to capture.`
@@ -145036,7 +145178,7 @@ var zodSchema54 = external_exports.object({
     "Default true. Draw simulator-server's touch visualizer into the recording: a pulse marks each tap, a comet trail follows swipes and drags, and paired markers show two-finger pinch/rotate, so the video makes clear where every interaction landed. Set false to record the raw screen with no overlay."
   )
 });
-var capability31 = {
+var capability32 = {
   apple: { simulator: true },
   android: { emulator: true, device: true, unknown: true }
 };
@@ -145048,7 +145190,7 @@ function createScreenRecordingStartTool(registry2) {
       completedMsg: () => "Started screen recording",
       failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to start screen recording: ${failureSignal2.error_code}`
     },
-    capability: capability31,
+    capability: capability32,
     description: `Start recording the device screen to a video file (h264 mp4, 30fps at the device's native resolution).
 By default stretches where the screen does not change are trimmed out (see trimStatic), so a long session with only brief activity comes back as a short clip instead of minutes of dead air.
 By default every tap, swipe, drag, pinch and rotate is drawn into the video as an on-screen touch marker (see showTouches), so the recording shows where each interaction landed.
@@ -145057,7 +145199,7 @@ Use when the user wants a video of an interaction, animation, or app behavior \u
 Returns { status: "recording", timeLimitSeconds, outputFile } \u2014 the video is retrieved later by \`screen-recording-stop\`, not by reading outputFile directly.
 Fails if a recording is already running on the device, the device is not booted, ffmpeg is not installed, or the platform cannot be recorded (tvOS, Chromium, Vega and remote simulators are unsupported).`,
     searchHint: "record video screen capture movie mp4 start filming screencast",
-    zodSchema: zodSchema54,
+    zodSchema: zodSchema55,
     // Resolved inside execute, not declared eagerly: a tvOS udid classifies as
     // iOS by shape, so an eager service would spawn simulator-server for a
     // device it cannot drive and hang on its ready timeout (as in `screenshot`).
@@ -145067,7 +145209,7 @@ Fails if a recording is already running on the device, the device is not booted,
     async execute(services, params) {
       const api = services.session;
       const device = resolveDevice(params.udid);
-      assertSupported("screen-recording-start", capability31, device);
+      assertSupported("screen-recording-start", capability32, device);
       if (device.platform === "ios" && await isTvOsSimulator(params.udid)) {
         throw new FailureError(
           `Screen recording is not supported on tvOS simulators (device ${params.udid}).`,
@@ -145156,11 +145298,11 @@ function makePointerControl(simulator) {
 var import_node_path22 = require("node:path");
 init_zod();
 init_device_info();
-var zodSchema55 = external_exports.object({
+var zodSchema56 = external_exports.object({
   udid: external_exports.string().describe("Target device id from `list-devices` (iOS Simulator UDID or Android serial).")
 });
 var RECORDINGS_DIR = ".argent/recordings";
-var capability32 = {
+var capability33 = {
   apple: { simulator: true },
   android: { emulator: true, device: true, unknown: true }
 };
@@ -145171,21 +145313,21 @@ var screenRecordingStopTool = {
     completedMsg: ({ result }) => `Saved screen recording ${result.video.filename}`,
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to stop screen recording: ${failureSignal2.error_code}`
   },
-  capability: capability32,
+  capability: capability33,
   description: `Stop the screen recording started by \`screen-recording-start\` and retrieve the video: frame capture ends and ffmpeg finalizes the mp4.
 Also retrieves the video when the recording already ended on its own (time limit reached, capture process died) \u2014 call it even after the cap fired.
 Use when the interaction being captured is finished, or a tool-result note reminds you a recording is still running.
 Returns { video, durationMs, wallClockMs?, trimmedMs?, panelSwitches?, warning? }; video is a downloadable artifact materialized to a local path. When static-frame trimming removed dead air, durationMs is the trimmed video length and wallClockMs/trimmedMs report the real duration and how much was cut. On a foldable simulator, the recording follows the panel that shows the UI. panelSwitches gives the number of panel changes. The video keeps the size of the first panel. warning is set when argent could not find that panel during the recording.
 Fails if no recording (running or finished-but-unretrieved) exists for the given udid.`,
   searchHint: "stop end finish screen recording video capture save retrieve",
-  zodSchema: zodSchema55,
+  zodSchema: zodSchema56,
   services: (params) => ({
     session: screenRecordingSessionRef(resolveDevice(params.udid))
   }),
   async execute(services, params, ctx) {
     const api = services.session;
     const device = resolveDevice(params.udid);
-    assertSupported("screen-recording-stop", capability32, device);
+    assertSupported("screen-recording-stop", capability33, device);
     const stopped = await stopCapture(api);
     const artifacts = requireArtifacts(ctx);
     const video = await artifacts.register({
@@ -145217,7 +145359,7 @@ var timeWindowSchema = external_exports.object({
     "End of window in ms since profiling started \u2014 the same clock profiler-commit-query prints"
   )
 });
-var zodSchema56 = external_exports.object({
+var zodSchema57 = external_exports.object({
   port: metroPortField,
   device_id: metroDeviceIdParam(
     "Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId)."
@@ -145506,7 +145648,7 @@ Every table states how many samples it covers and how much of that was idle.
 Use when investigating JS CPU hotspots or correlating CPU cost with specific components.
 Returns a markdown table of CPU hotspots, call tree, or per-component CPU breakdown.
 Fails if no CPU profile is stored \u2014 run react-profiler-stop first.`,
-  zodSchema: zodSchema56,
+  zodSchema: zodSchema57,
   // RN-only: reads Hermes-format CPU profiles; Chromium's V8 sample format differs.
   capability: RN_ONLY_TOOL_CAPABILITY,
   services: () => ({}),
@@ -145592,7 +145734,7 @@ var timeRangeSchema = external_exports.object({
     "End of range in ms since profiling started \u2014 the same clock profiler-commit-query prints"
   )
 });
-var zodSchema57 = external_exports.object({
+var zodSchema58 = external_exports.object({
   port: metroPortField,
   device_id: metroDeviceIdParam(
     "Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId)."
@@ -145865,7 +146007,7 @@ Modes:
 Use when drilling into specific components or time windows after react-profiler-analyze.
 Returns a markdown table or tree of commit data matching the requested mode.
 Fails if react-profiler-stop has not been called or no commit data is stored.`,
-  zodSchema: zodSchema57,
+  zodSchema: zodSchema58,
   // Reads React commit data captured via the React DevTools backend.
   capability: RN_ONLY_TOOL_CAPABILITY,
   services: () => ({}),
@@ -145936,7 +146078,7 @@ Fails if react-profiler-stop has not been called or no commit data is stored.`,
 init_zod();
 init_src2();
 init_device_info();
-var zodSchema58 = external_exports.object({
+var zodSchema59 = external_exports.object({
   device_id: metroDeviceIdParam("iOS Simulator UDID or Android serial."),
   mode: external_exports.enum(["hang_stacks", "function_callers", "thread_breakdown", "leak_stacks"]).describe(
     "Query mode: hang_stacks (full CPU context during a hang), function_callers (who calls a native function), thread_breakdown (CPU split by thread), leak_stacks (leak details by object type)"
@@ -146254,7 +146396,7 @@ Modes:
 Use when drilling into native hang stacks, thread CPU breakdown, or memory leaks after native-profiler-analyze.
 Returns a markdown report with native call stacks, thread weights, or leak details for the selected mode.
 Fails if native-profiler-analyze has not been run or no parsed trace data is in memory.`,
-  zodSchema: zodSchema58,
+  zodSchema: zodSchema59,
   // No chromium entry: it has no native trace capture.
   capability: {
     apple: { simulator: true },
@@ -146324,7 +146466,7 @@ function buildPerfettoAnchor(wallClockStartMs) {
 }
 
 // ../tool-server/src/tools/profiler/combined/profiler-combined-report.ts
-var zodSchema59 = external_exports.object({
+var zodSchema60 = external_exports.object({
   port: metroPortField,
   device_id: metroDeviceIdParam("iOS Simulator/device UDID or Android serial")
 });
@@ -146341,7 +146483,7 @@ Requires both react-profiler-analyze and native-profiler-analyze to have been ca
 Call this tool when both profilers were run in parallel on the same session.
 Returns a markdown report correlating hangs with React commits, memory leaks, and investigation hints.
 Fails if either react-profiler-analyze or native-profiler-analyze has not been called first.`,
-  zodSchema: zodSchema59,
+  zodSchema: zodSchema60,
   // iOS reads xctrace output; Android re-queries the Perfetto .pftrace via
   // loadAndroidCombinedData. Chromium has no native trace capture.
   capability: {
@@ -146665,7 +146807,7 @@ function assertSafeSessionId(sessionId) {
     );
   }
 }
-var zodSchema60 = external_exports.object({
+var zodSchema61 = external_exports.object({
   mode: external_exports.enum(["list", "load_react", "load_native"]).describe(
     "list: show available sessions on disk. load_react: load a React profiler session into memory for query tools. load_native: re-parse native profiler XML files (xctrace on iOS) into memory for query tools."
   ),
@@ -147026,7 +147168,7 @@ Modes:
   For Android .pftrace restores, pass app_process for older sessions that do not have a metadata sidecar.
 Returns a summary of the loaded session or a session list for the list mode.
 Fails if the session_id is not found or required XML files are missing from disk.`,
-  zodSchema: zodSchema60,
+  zodSchema: zodSchema61,
   // The Hermes, xctrace and perfetto formats this loads have no Chromium
   // equivalent; the gate fails at the call site, not inside the trace parser.
   capability: RN_ONLY_TOOL_CAPABILITY,
@@ -147155,7 +147297,7 @@ function unnameableSessionUrns(urns) {
 }
 
 // ../tool-server/src/tools/simulator/stop-simulator-server.ts
-var zodSchema61 = external_exports.object({
+var zodSchema62 = external_exports.object({
   udid: external_exports.string().describe(
     "Target device id (iOS UDID, Android serial, or Chromium id) whose transport session to stop"
   )
@@ -147169,7 +147311,7 @@ function createStopSimulatorServerTool(registry2) {
       failedMsg: ({ params, failureSignal: failureSignal2 }) => `Failed to stop simulator server for ${params.udid}: ${failureSignal2.error_code}`
     },
     description: `Stop the transport session for a specific device (iOS simulator / Android: simulator-server process; physical iOS: the on-device runner; Chromium: CDP WebSocket) and free its resources; on a TV target it also reaps that device's TV-control daemons. Use when you are done interacting with one device but want to keep others running, or to restart a wedged transport. On iOS / Android / TV it deliberately leaves this device's native-devtools, accessibility, profiler and debugger services running - to drain those as well, use stop-all-simulator-servers with \`devices\`. On CHROMIUM that does not hold: the JS-runtime debugger declares the CDP session as a dependency, so stopping the transport cascades to it and its captured console history goes with it - reconnect with debugger-connect afterwards. Returns { stopped, udid }. Fails silently if no session is open for the given id.`,
-    zodSchema: zodSchema61,
+    zodSchema: zodSchema62,
     services: () => ({}),
     async execute(_services, params) {
       const udid = params.udid;
@@ -147200,7 +147342,7 @@ function createStopSimulatorServerTool(registry2) {
 init_zod();
 init_src2();
 init_external_devices();
-var zodSchema62 = external_exports.object({
+var zodSchema63 = external_exports.object({
   devices: external_exports.array(external_exports.string()).optional().describe(
     "Device ids (iOS UDID / Android serial / Chromium id) to scope the teardown to \u2014 pass the devices THIS session actually used. Omit only for a deliberate machine-wide cleanup: one tool-server serves every agent using this argent install, so an unscoped stop also kills devices another agent is mid-session on."
   )
@@ -147238,8 +147380,8 @@ function createStopAllSimulatorServersTool(registry2) {
     description: `Stop the services a device owns - simulator-server processes (iOS + Android), native devtools, the iOS accessibility service, TV-control daemons, Chromium CDP sessions, screen recordings, native profiler sessions, and JS-runtime debugger sessions along with the network inspectors and React profiler sessions that ride on them - freeing their spawned processes, sockets and ports. Call this when your session ends or the user says they are done.
 PASS \`devices\` with the device ids this session used \u2014 one tool-server serves every agent, subagent and CLI call using this argent install, and an unscoped call tears down THEIR devices too (a mid-recording devtools teardown degrades another agent's flow to brittle coordinate taps; that agent is warned, but its recorded steps are already the worse kind). Omit \`devices\` only when a machine-wide cleanup is what you actually want. Passing an EMPTY array scopes to nothing and stops nothing - it is not a way to ask for the machine-wide sweep.
 A JS-runtime debugger session is keyed by the id you called \`debugger-connect\` with. On a Metro serving two or more devices that id is not a udid or serial - connect refuses those and tells you to re-target with the \`logicalDeviceId\` it returns - so a scope built from \`list-devices\` ids cannot reach that session. Pass any such \`logicalDeviceId\` in \`devices\` ALONGSIDE the device id; { left_running } names the ones you missed.
-Returns { stopped } - the URNs of the services that were actually live and got shut down; an ERROR node is disposed too but never appears there, so an empty \`stopped\` only means nothing was still running. { unmatched } lists supplied ids that own no service here, so a mistyped id - or a device NAME passed where an id was expected - does not read as a clean machine. It is NOT proof the id is wrong: a Vega device is driven through CLI/adb shell-outs, so one you only booted and drove with the remote registers no service and always lands here \u2014 as does a real device of any platform this session never started anything on. Present ONLY when \`devices\` was supplied AND at least one id matched nothing - absent on an unscoped call and when every id matched. Stopping the same device twice does not report it unmatched: ownership counts regardless of service state. { left_running } lists live debugger sessions (and the network inspectors / React profiler sessions riding on them) whose id no device scope can name - re-call with that id to reap them. { aborted: true } means the caller cancelled the request part-way, so the rest of the machine was left untouched and neither of the other two fields was computed. Past the schema - which rejects an unknown key outright, so the \`udids\` slip is an error rather than a silent machine-wide sweep - the call always succeeds; reaping nothing is a result, not a failure.`,
-    zodSchema: zodSchema62,
+Returns { stopped } - the URNs of the services that were actually live and got shut down; an ERROR node is disposed too but never appears there, so an empty \`stopped\` only means nothing was still running. { unmatched } lists supplied ids that own no service here, so a mistyped id - or a device NAME passed where an id was expected - does not read as a clean machine. It is NOT proof the id is wrong: a Vega device is driven through CLI/adb shell-outs, so one you only booted and drove with the remote registers no service and always lands here \u2014 as does a real device of any platform this session never started anything on. Present ONLY when \`devices\` was supplied AND at least one id matched nothing - absent on an unscoped call and when every id matched. Stopping the same device twice does not report it unmatched: ownership counts regardless of service state. { left_running } lists the URNs of live debugger sessions (and the network inspectors / React profiler sessions riding on them) whose id no device scope can name - re-call with the id after each URN's \`<namespace>:<port>:\` prefix to reap them. { aborted: true } means the caller cancelled the request part-way, so the rest of the machine was left untouched and neither of the other two fields was computed. Past the schema - which rejects an unknown key outright, so the \`udids\` slip is an error rather than a silent machine-wide sweep - the call always succeeds; reaping nothing is a result, not a failure.`,
+    zodSchema: zodSchema63,
     services: () => ({}),
     async execute(_services, params, ctx) {
       const devices = params.devices;
@@ -147319,7 +147461,7 @@ function listeningPids(port) {
   if (!output) return [];
   return output.split("\n").map((s) => parseInt(s.trim(), 10)).filter((n) => !Number.isNaN(n));
 }
-var zodSchema63 = external_exports.object({
+var zodSchema64 = external_exports.object({
   port: external_exports.number().int().min(1).max(65535).default(8081).describe("TCP port Metro is listening on (default 8081)")
 });
 var stopMetroTool = {
@@ -147330,7 +147472,7 @@ var stopMetroTool = {
     failedMsg: ({ params, failureSignal: failureSignal2 }) => `Failed to stop Metro on port ${params.port}: ${failureSignal2.error_code}`
   },
   description: `Stop the Metro bundler process listening on a given port (default 8081). Use when ending a React Native session or when Metro must be restarted. Returns { stopped, port, pids }; stopped=false if no process is found on the port. Fails if the port lookup command times out or the process cannot be killed. This is DESTRUCTIVE \u2014 always ask the user for confirmation before calling this tool.`,
-  zodSchema: zodSchema63,
+  zodSchema: zodSchema64,
   services: () => ({}),
   async execute(_services, params) {
     const port = params.port;
@@ -149674,7 +149816,7 @@ async function appendStepToFlow(session, step) {
 }
 
 // ../tool-server/src/tools/flows/flow-start-recording.ts
-var zodSchema64 = external_exports.object({
+var zodSchema65 = external_exports.object({
   name: external_exports.string().describe(
     'Name for this flow (e.g. "settings-explore") \u2014 letters, digits, underscore and hyphen only.'
   ),
@@ -149731,7 +149873,7 @@ recording. Over a link, the next recorded step writes over your edit.
 Without a link, the recorder reads the file again before each step, but an
 edit that renumbers the steps drops the warnings that flow-finish-recording
 reports for those steps.`,
-  zodSchema: zodSchema64,
+  zodSchema: zodSchema65,
   fileInputs: fileInputs2,
   services: () => ({}),
   async execute(_services, params, ctx) {
@@ -152231,7 +152373,7 @@ function stepAnchor(step) {
 
 // ../tool-server/src/tools/flows/flow-add-step.ts
 init_device_info();
-var zodSchema65 = external_exports.object({
+var zodSchema66 = external_exports.object({
   name: external_exports.string().describe("Name of the flow being recorded \u2014 the one passed to flow-start-recording."),
   project_root: external_exports.string().describe(
     "Absolute path to the project root of the flow being recorded \u2014 the same value passed to flow-start-recording. Together with `name` it identifies which recording this step belongs to."
@@ -152690,7 +152832,7 @@ Returns { message, stepCount, recorded, savedTo }; \`recorded\`, not the status,
     // more times — and every retry re-runs the action and appends another step,
     // because an aborted request still appends its first.
     longRunning: true,
-    zodSchema: zodSchema65,
+    zodSchema: zodSchema66,
     fileInputs: fileInputs3,
     services: () => ({}),
     async execute(_services, params, ctx) {
@@ -152879,7 +153021,7 @@ Returns { message, stepCount, recorded, savedTo }; \`recorded\`, not the status,
 
 // ../tool-server/src/tools/flows/flow-insert-echo.ts
 init_zod();
-var zodSchema66 = external_exports.object({
+var zodSchema67 = external_exports.object({
   name: external_exports.string().describe("Name of the flow being recorded \u2014 the one passed to flow-start-recording."),
   project_root: external_exports.string().describe(
     "Absolute path to the project root of the flow being recorded \u2014 the same value passed to flow-start-recording. Together with `name` it identifies which recording this echo belongs to."
@@ -152897,7 +153039,7 @@ var flowInsertEchoTool = {
   description: `Record an echo step in the flow named by \`name\` + \`project_root\`. Echo steps print a message when the flow is replayed \u2014 useful as labels between tool calls.
 Use when you want to annotate a recorded flow with a human-readable label or checkpoint message.
 Returns { message, stepCount, savedTo }. Fails if that flow has no recording in progress.`,
-  zodSchema: zodSchema66,
+  zodSchema: zodSchema67,
   services: () => ({}),
   async execute(_services, params) {
     const session = await requireRecordingSession(params.project_root, params.name);
@@ -153317,7 +153459,7 @@ var FlowScriptExecutor = class {
         { notes, durationMs: Date.now() - startedAt }
       );
     }
-    const lifeline = child.stdio[4];
+    const lifeline = child.stdio?.[4];
     lifeline?.unref?.();
     let startedSeen = false;
     let terminal = null;
@@ -154200,7 +154342,7 @@ function errMsg3(err) {
 
 // ../tool-server/src/tools/flows/flow-add-script.ts
 var OUTPUT_RENDER_LIMIT_BYTES = 64 * 1024;
-var zodSchema67 = external_exports.object({
+var zodSchema68 = external_exports.object({
   name: external_exports.string().describe("Flow name passed to flow-start-recording."),
   project_root: external_exports.string().describe("Absolute project root passed to flow-start-recording."),
   path: external_exports.string().describe(
@@ -154257,7 +154399,7 @@ var flowAddScriptTool = {
   // The flag only skips the adapter's own abort timer; its retry loop is
   // untouched, so a call that fails some other way is still re-POSTed.
   longRunning: true,
-  zodSchema: zodSchema67,
+  zodSchema: zodSchema68,
   services: () => ({}),
   async execute(_services, params, ctx) {
     const session = await requireRecordingSession(params.project_root, params.name);
@@ -154347,7 +154489,7 @@ var flowAddScriptTool = {
 // ../tool-server/src/tools/flows/flow-finish-recording.ts
 init_zod();
 var fs60 = __toESM(require("node:fs/promises"));
-var zodSchema68 = external_exports.object({
+var zodSchema69 = external_exports.object({
   name: external_exports.string().describe("Name of the flow being recorded \u2014 the one passed to flow-start-recording."),
   project_root: external_exports.string().describe(
     "Absolute path to the project root of the flow being recorded \u2014 the same value passed to flow-start-recording. Together with `name` it identifies which recording to finish."
@@ -154406,7 +154548,7 @@ var flowFinishRecordingTool = {
   description: `Finish recording the flow named by \`name\` + \`project_root\`, leaving recordings under any other key untouched. Returns { message, path, executionPrerequisite, steps, summary, flowFile, savedTo } - a summary of all recorded steps plus the final YAML. Use when you have added all desired steps and want to finalize the flow file. Fails if that flow has no recording in progress.
 A warning flow-add-step raised on a recorded \`await-ui-element\` is repeated in \`summary\` as a \`warning:\` line of its own, right below the step it judges, and \`message\` counts them by kind. A warning is repeated only while the step it judges is still identifiable by its number: hand-editing the .yaml during the recording moves the steps, so those warnings are DROPPED rather than pinned on whichever step inherited the number, and \`message\` says how many were dropped. A step that carries a cross-tree warning was re-probed against the runner's tree: read it before converting that wait to \`await:\`/\`assert:\`, which is what the verdict is about and what this moment is for. A step that recorded a wait which did not pass was never probed at all, and its own warning names the CAUSE, because only one of them judges the condition: an unmet wait was read and found false, and it stops the run at replay; a wait whose tree source could not be read, or one that was cancelled, observed nothing and leaves the condition UNKNOWN rather than known-bad. Read those before replaying.
 You can still edit the .yaml file directly afterwards to remove or reorder steps.`,
-  zodSchema: zodSchema68,
+  zodSchema: zodSchema69,
   services: () => ({}),
   async execute(_services, params) {
     const { filePath, flowFile, savedTo, flow, summary, headline } = await withFlowFileLock(
@@ -155741,7 +155883,7 @@ function formatScreenshotDiffSummary(result) {
   const shownRegions = result.regions.slice(0, MAX_SUMMARY_REGIONS);
   const coordinateSpace = coordinateSpaceForSummary(result.imageSize);
   const lines = ["Screenshot diff summary", "", "Overall:"];
-  lines.push(`- status: ${status}`);
+  lines.push(statusLine(status));
   if (result.sizeNormalization) {
     const { baseline, current, comparedAt } = result.sizeNormalization;
     lines.push(
@@ -155802,6 +155944,12 @@ function formatScreenshotDiffSummary(result) {
   }
   return lines.join("\n");
 }
+function statusLine(status) {
+  return `- status: ${status}`;
+}
+function summaryReportsDimensionMismatch(summary) {
+  return summary.split("\n").includes(statusLine("dimension_mismatch"));
+}
 function screenshotDiffStatus(result) {
   if (result.dimensionMismatch) return "dimension_mismatch";
   if (!Number.isFinite(result.totalPixels) || !Number.isFinite(result.differentPixels) || !Number.isFinite(result.mismatchPercentage)) {
@@ -156878,7 +157026,7 @@ async function restoreStatusBar(device) {
 }
 
 // ../tool-server/src/tools/flows/flow-run.ts
-var zodSchema69 = external_exports.object({
+var zodSchema70 = external_exports.object({
   name: external_exports.string().optional().describe(
     'Name of a saved flow to run from `.argent/flows` (e.g. "settings-explore"). Omit when flow_path is set.'
   ),
@@ -157385,7 +157533,7 @@ one-off interaction use the gesture tools instead, and to author a flow use flow
 exactly one flow source: name (under project_root) or flow_path.
 Returns a per-step report: the first failure stops the run and the rest report as skipped.`,
     longRunning: true,
-    zodSchema: zodSchema69,
+    zodSchema: zodSchema70,
     fileInputs: fileInputs4,
     services: () => ({}),
     async execute(_services, params, ctx) {
@@ -158362,7 +158510,7 @@ async function resolveFlowSource(params, fileInput, flowPathInput) {
 // ../tool-server/src/tools/flows/flow-read-prerequisite.ts
 init_zod();
 var fs64 = __toESM(require("node:fs/promises"));
-var zodSchema70 = external_exports.object({
+var zodSchema71 = external_exports.object({
   name: external_exports.string().optional().describe(
     'Name of a saved flow to inspect from `.argent/flows` (e.g. "settings-explore"). Omit when flow_path is set.'
   ),
@@ -158418,7 +158566,7 @@ Touches no device: nothing is launched, tapped, dispatched or torn down, and no
 needs booting, so calling this costs nothing but a file read.
 Fails if the flow file does not exist.
 Address the flow exactly as you will address it in flow-execute: name or flow_path, one and only one; supplying both or neither is rejected. The name goes in \`name\`, which resolves <project_root>/.argent/flows/<name>.yaml.`,
-  zodSchema: zodSchema70,
+  zodSchema: zodSchema71,
   fileInputs: fileInputs5,
   services: () => ({}),
   async execute(_services, params, ctx) {
@@ -158734,7 +158882,7 @@ async function readWorkspaceSnapshot(workspacePath) {
 }
 
 // ../tool-server/src/tools/workspace/gather-workspace-data.ts
-var zodSchema71 = external_exports.object({
+var zodSchema72 = external_exports.object({
   workspacePath: external_exports.string().describe("Absolute path to the project root directory to inspect (e.g. /Users/dev/MyApp)")
 });
 var fileInputs6 = [
@@ -158765,7 +158913,7 @@ exploration of anything the snapshot surfaces.
 Use when you need to inspect project configuration without manually reading multiple files.
 Returns partial data if workspacePath does not exist or is not readable; missing items are represented as null or empty collections.
 Fails if the workspacePath is not an absolute path or the directory cannot be accessed.`,
-  zodSchema: zodSchema71,
+  zodSchema: zodSchema72,
   fileInputs: fileInputs6,
   services: () => ({}),
   async execute(_services, params) {
@@ -158839,7 +158987,7 @@ function targetFlagsFor(target) {
   if (target === "both") return ["--global", "--local"];
   return [`--${target}`];
 }
-var zodSchema72 = external_exports.object({
+var zodSchema73 = external_exports.object({
   target: external_exports.enum(["auto", "global", "local", "both"]).optional().describe(
     "Which install to update. 'auto' (default) updates the install serving this session \u2014 the global PATH install or this project's local devDependency, whichever this server runs from. Pass 'global' / 'local' to force one, or 'both' when the user has both and wants each updated."
   )
@@ -158853,7 +159001,7 @@ var updateArgentTool = {
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to update Argent: ${failureSignal2.error_code}`
   },
   description: "Apply a pending Argent update. Only call this tool when the user has explicitly consented to updating Argent in this conversation. Use when an update notification indicates a new version is available and the user agrees to update. By default updates the install serving this session; pass `target` to choose global/local/both. Returns { message } with the update status and version info. The tool server will restart automatically after the update. Fails if no update is available or an update is already in progress.",
-  zodSchema: zodSchema72,
+  zodSchema: zodSchema73,
   services: () => ({}),
   async execute(_services, params, _options) {
     const { updateAvailable, updateInstallable, currentVersion, installableVersion } = getUpdateState();
@@ -158938,7 +159086,7 @@ var updateArgentTool = {
 
 // ../tool-server/src/tools/system/dismiss-update.ts
 init_zod();
-var zodSchema73 = external_exports.object({
+var zodSchema74 = external_exports.object({
   hours: external_exports.number().min(0).describe("Number of hours to suppress the update notification")
 });
 var dismissUpdateTool = {
@@ -158949,7 +159097,7 @@ var dismissUpdateTool = {
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to dismiss Argent update: ${failureSignal2.error_code}`
   },
   description: "Clear the Argent update notification for the given number of hours. Use when the user asks to postpone or silence update reminders. Returns { message } confirming the suppression duration. Fails if the hours value is negative or the suppression state cannot be persisted.",
-  zodSchema: zodSchema73,
+  zodSchema: zodSchema74,
   services: () => ({}),
   async execute(_services, params, _options) {
     const durationMs = params.hours * 60 * 60 * 1e3;
@@ -158968,7 +159116,7 @@ var import_path8 = __toESM(require("path"));
 init_zod();
 init_src2();
 init_device_info();
-var zodSchema74 = external_exports.object({
+var zodSchema75 = external_exports.object({
   baselinePath: external_exports.string().min(1).optional().describe("Path to the baseline PNG file. Required unless captureBaseline is true."),
   currentPath: external_exports.string().min(1).optional().describe("Path to the current PNG file. Required unless captureCurrent is true."),
   udid: external_exports.string().min(1).describe("Target device id from `list-devices` (iOS UDID or Android serial)."),
@@ -158985,7 +159133,7 @@ var zodSchema74 = external_exports.object({
     "Directory where diff artifacts should be written. Optional \u2014 defaults to a temp directory; the diff images are returned in the result either way."
   )
 }).strict();
-var capability33 = {
+var capability34 = {
   apple: { simulator: true, device: true },
   android: { emulator: true, device: true, unknown: true }
 };
@@ -158998,7 +159146,7 @@ var screenshotDiffTool = {
   id: "screenshot-diff",
   interaction: {
     startedMsg: () => "Comparing screenshots",
-    completedMsg: () => "Compared screenshots",
+    completedMsg: ({ result }) => summaryReportsDimensionMismatch(result.summary) ? "Skipped comparison - screenshot dimensions differ" : "Compared screenshots",
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to compare screenshots: ${failureSignal2.error_code}`
   },
   description: `Compare two PNG screenshots and return a compact visual-diff summary.
@@ -159010,8 +159158,8 @@ Returns { summary, diffPath, contextDiffPath }. The summary uses normalized [0,1
 Ignores the fixed top status-bar band for both pixel and OCR text comparisons.
 Fails if the input sources are invalid, PNG files cannot be read, outputDir cannot be written, or the simulator-server / emulator backend is not reachable.`,
   searchHint: "compare screenshots png diff visual UI changes UI regression visual regression screenshot diff changed regions text ocr live capture",
-  zodSchema: zodSchema74,
-  capability: capability33,
+  zodSchema: zodSchema75,
+  capability: capability34,
   fileInputs: fileInputs7,
   services: (params) => {
     if (params.captureBaseline || params.captureCurrent) {
@@ -159324,7 +159472,7 @@ async function captureElementFrame(registry2, udid, match, opts = {}) {
 }
 
 // ../tool-server/src/tools/variants/propose-variant.ts
-var zodSchema75 = external_exports.object({
+var zodSchema76 = external_exports.object({
   element: external_exports.string().min(1).max(200).describe(
     'Human name of the on-screen element this variant targets, e.g. "Foo button" or "profile header". Repeated calls with the same element accumulate multiple variants on it. Used as the default screen matcher when `match` is omitted.'
   ),
@@ -159384,7 +159532,7 @@ arrives as a follow-up message (this is the case in an \`argent lens\` CLI sessi
 Returns { round, elementId, variantId, element, variantCount, totalElements } \u2014 confirmation only;
 it does not wait for the user.`,
     searchHint: "propose design variant alternative option for element non-blocking ab choice",
-    zodSchema: zodSchema75,
+    zodSchema: zodSchema76,
     services: () => ({}),
     async execute(_services, params) {
       let frame = params.variant.frame;
@@ -159408,7 +159556,7 @@ it does not wait for the user.`,
 
 // ../tool-server/src/tools/variants/await-user-selection.ts
 init_zod();
-var zodSchema76 = external_exports.object({
+var zodSchema77 = external_exports.object({
   timeoutSeconds: external_exports.number().int().min(5).max(86400).optional().describe(
     "Max seconds to block this call before returning a re-awaitable { status: 'pending' } result (default 1800). The user's proposals stay live across timeouts \u2014 on 'pending' just call await_user_selection again. Lower this if your MCP client enforces a short request timeout."
   )
@@ -159449,7 +159597,7 @@ This tool is long-running; it intentionally holds the request open. It honors cl
 disconnects (aborts cleanly).`,
   searchHint: "await wait user selection choice variant blocking confirm picks complete",
   longRunning: true,
-  zodSchema: zodSchema76,
+  zodSchema: zodSchema77,
   services: () => ({}),
   async execute(_services, params, options) {
     const timeoutMs = (params.timeoutSeconds ?? 1800) * 1e3;
@@ -159464,7 +159612,7 @@ disconnects (aborts cleanly).`,
 init_zod();
 init_src2();
 init_device_info();
-var zodSchema77 = external_exports.object({
+var zodSchema78 = external_exports.object({
   udid: external_exports.string().describe("Chromium device id from `list-devices` (e.g. `chromium-cdp-9222`)."),
   action: external_exports.enum(["list", "select", "new", "close"]).describe(
     "list: enumerate tabs/windows. select: make a tab active (every other tool then acts on it). new: open a tab. close: close a tab."
@@ -159497,7 +159645,7 @@ var tabAction = {
     failure: "close"
   }
 };
-var capability34 = {
+var capability35 = {
   chromium: { app: true }
 };
 var chromiumTabsTool = {
@@ -159515,8 +159663,8 @@ var chromiumTabsTool = {
 Use when an app exposes multiple windows or tabs and you need to inspect or drive one other than the current page, or to open/close a page during a flow. tabIds are stable for the session and never reused.
 Returns { tabs: [{ tabId, targetId, title, url, active, label? }] }. Fails if the device is not a Chromium (CDP) device, or the requested tabId/label no longer matches a live tab. Chromium-only.`,
   searchHint: "tab tabs window windows switch select close new open multi-tab chromium electron",
-  zodSchema: zodSchema77,
-  capability: capability34,
+  zodSchema: zodSchema78,
+  capability: capability35,
   services: (params) => {
     const device = resolveDevice(params.udid);
     if (device.platform === "chromium") {
@@ -159617,7 +159765,7 @@ async function clearStorage(cdp, type) {
 }
 
 // ../tool-server/src/tools/chromium-cookies/index.ts
-var zodSchema78 = external_exports.object({
+var zodSchema79 = external_exports.object({
   udid: external_exports.string().describe("Chromium device id from `list-devices` (e.g. `chromium-cdp-9222`)."),
   action: external_exports.enum(["get", "set", "delete", "clear"]).describe(
     "get: read cookies. set: create/update a cookie. delete: remove a named cookie. clear: remove all browser cookies."
@@ -159640,7 +159788,7 @@ var cookieAction = {
   delete: { started: "Deleting", completed: "Deleted", failure: "delete" },
   clear: { started: "Clearing", completed: "Cleared", failure: "clear" }
 };
-var capability35 = {
+var capability36 = {
   chromium: { app: true }
 };
 var chromiumCookiesTool = {
@@ -159658,8 +159806,8 @@ var chromiumCookiesTool = {
 Use when seeding an authenticated session before a flow (set the session cookie, then navigate) or asserting cookie state after one.
 Returns { cookies, count } for get, or a small status object ({ set } / { deleted } / { cleared }) otherwise. Fails if the device is not a Chromium (CDP) device, or set is missing name/value. Chromium-only.`,
   searchHint: "cookies cookie get set delete clear httponly samesite session auth chromium",
-  zodSchema: zodSchema78,
-  capability: capability35,
+  zodSchema: zodSchema79,
+  capability: capability36,
   services: (params) => {
     const device = resolveDevice(params.udid);
     if (device.platform === "chromium") {
@@ -159724,7 +159872,7 @@ Returns { cookies, count } for get, or a small status object ({ set } / { delete
 init_zod();
 init_src2();
 init_device_info();
-var zodSchema79 = external_exports.object({
+var zodSchema80 = external_exports.object({
   udid: external_exports.string().describe("Chromium device id from `list-devices` (e.g. `chromium-cdp-9222`)."),
   store: external_exports.enum(["local", "session"]).describe("Which Web Storage area: `local` (localStorage) or `session` (sessionStorage)."),
   action: external_exports.enum(["get", "set", "remove", "clear"]).describe(
@@ -159739,7 +159887,7 @@ var storageAction = {
   remove: { started: "Removing from", completed: "Removed from", failure: "remove from" },
   clear: { started: "Clearing", completed: "Cleared", failure: "clear" }
 };
-var capability36 = {
+var capability37 = {
   chromium: { app: true }
 };
 var chromiumStorageTool = {
@@ -159758,8 +159906,8 @@ Set \`store\` to "local" or "session". Storage is per-origin, so it reflects the
 Use when seeding feature flags / auth tokens before a flow or asserting persisted app state after one.
 Returns { value } for a single key, { entries, count } for all, or a status object ({ set } / { removed } / { cleared }) otherwise. Fails if the device is not a Chromium (CDP) device, or set is missing key/value. Chromium-only.`,
   searchHint: "storage localstorage sessionstorage local session get set remove clear key value chromium",
-  zodSchema: zodSchema79,
-  capability: capability36,
+  zodSchema: zodSchema80,
+  capability: capability37,
   services: (params) => {
     const device = resolveDevice(params.udid);
     if (device.platform === "chromium") {
@@ -159871,6 +160019,7 @@ function createRegistry() {
   registry2.registerTool(networkRequestTool);
   registry2.registerTool(createDescribeTool(registry2));
   registry2.registerTool(createUiTreeTool(registry2));
+  registry2.registerTool(createForegroundAppTool(registry2));
   registry2.registerTool(createAwaitUiElementTool(registry2));
   registry2.registerTool(createAwaitScreenIdleTool(registry2));
   registry2.registerTool(createReactProfilerStartTool(registry2));
@@ -160140,9 +160289,9 @@ function createPreviewWindowManager(opts = {}) {
     if (fs68.existsSync(bundled)) return bundled;
     return require.resolve("@argent/preview-window/dist/main.js");
   };
-  const isAlive = (c) => c !== null && c.exitCode === null && !c.killed;
+  const isAlive2 = (c) => c !== null && c.exitCode === null && !c.killed;
   const ensureOpen = (url2) => {
-    if (isAlive(child) && !closing) {
+    if (isAlive2(child) && !closing) {
       send({ cmd: "foreground", url: url2 });
       return;
     }
@@ -160187,12 +160336,12 @@ function createPreviewWindowManager(opts = {}) {
     closing = false;
   };
   const requestClose = () => {
-    if (!isAlive(child)) return;
+    if (!isAlive2(child)) return;
     closing = true;
     send({ cmd: "close" });
   };
   const dispose = () => {
-    if (isAlive(child)) child.kill();
+    if (isAlive2(child)) child.kill();
     child = null;
     closing = false;
   };