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

package/dist/tool-server.cjs

@@ -1517,6 +1517,9 @@ var init_failure_codes = __esm({
       KEYBOARD_CHARACTER_UNSUPPORTED: "KEYBOARD_CHARACTER_UNSUPPORTED",
       KEYBOARD_TEXT_AND_KEY_COMBINED: "KEYBOARD_TEXT_AND_KEY_COMBINED",
       KEYBOARD_INPUT_NOT_FOCUSED: "KEYBOARD_INPUT_NOT_FOCUSED",
+      FILL_NO_FOCUSED_FIELD: "FILL_NO_FOCUSED_FIELD",
+      FILL_NOT_VERIFIED: "FILL_NOT_VERIFIED",
+      FILL_UNSUPPORTED_FIELD: "FILL_UNSUPPORTED_FIELD",
       SECRET_PLACEHOLDER_UNKNOWN: "SECRET_PLACEHOLDER_UNKNOWN",
       SCREENSHOT_DIFF_INPUT_INVALID: "SCREENSHOT_DIFF_INPUT_INVALID",
       BOOT_DEVICE_TARGET_SELECTION_INVALID: "BOOT_DEVICE_TARGET_SELECTION_INVALID",
@@ -13223,8 +13226,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 = (zodSchema81) => {
-    const seen = ctx.seen.get(zodSchema81);
+  const flattenRef = (zodSchema82) => {
+    const seen = ctx.seen.get(zodSchema82);
     if (seen.ref === null)
       return;
     const schema2 = seen.def ?? seen.schema;
@@ -13242,7 +13245,7 @@ function finalize(ctx, schema) {
         Object.assign(schema2, refSchema);
       }
       Object.assign(schema2, _cached);
-      const isParentRef = zodSchema81._zod.parent === ref;
+      const isParentRef = zodSchema82._zod.parent === ref;
       if (isParentRef) {
         for (const key2 in schema2) {
           if (key2 === "$ref" || key2 === "allOf")
@@ -13262,7 +13265,7 @@ function finalize(ctx, schema) {
         }
       }
     }
-    const parent = zodSchema81._zod.parent;
+    const parent = zodSchema82._zod.parent;
     if (parent && parent !== ref) {
       flattenRef(parent);
       const parentSeen = ctx.seen.get(parent);
@@ -13280,7 +13283,7 @@ function finalize(ctx, schema) {
       }
     }
     ctx.override({
-      zodSchema: zodSchema81,
+      zodSchema: zodSchema82,
       jsonSchema: schema2,
       path: seen.path ?? []
     });
@@ -16081,10 +16084,10 @@ function convertBaseSchema(schema, ctx) {
     }
     ctx.processing.add(refPath);
     const resolved = resolveRef(refPath, ctx);
-    const zodSchema82 = convertSchema(resolved, ctx);
-    ctx.refs.set(refPath, zodSchema82);
+    const zodSchema83 = convertSchema(resolved, ctx);
+    ctx.refs.set(refPath, zodSchema83);
     ctx.processing.delete(refPath);
-    return zodSchema82;
+    return zodSchema83;
   }
   if (schema.enum !== void 0) {
     const enumValues = schema.enum;
@@ -16126,7 +16129,7 @@ function convertBaseSchema(schema, ctx) {
   if (!type) {
     return z.any();
   }
-  let zodSchema81;
+  let zodSchema82;
   switch (type) {
     case "string": {
       let stringSchema = z.string();
@@ -16189,7 +16192,7 @@ function convertBaseSchema(schema, ctx) {
       if (schema.pattern) {
         stringSchema = stringSchema.regex(new RegExp(schema.pattern));
       }
-      zodSchema81 = stringSchema;
+      zodSchema82 = stringSchema;
       break;
     }
     case "number":
@@ -16214,15 +16217,15 @@ function convertBaseSchema(schema, ctx) {
       if (typeof schema.multipleOf === "number") {
         numberSchema = numberSchema.multipleOf(schema.multipleOf);
       }
-      zodSchema81 = numberSchema;
+      zodSchema82 = numberSchema;
       break;
     }
     case "boolean": {
-      zodSchema81 = z.boolean();
+      zodSchema82 = z.boolean();
       break;
     }
     case "null": {
-      zodSchema81 = z.null();
+      zodSchema82 = z.null();
       break;
     }
     case "object": {
@@ -16237,12 +16240,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) {
-          zodSchema81 = z.record(keySchema, valueSchema);
+          zodSchema82 = z.record(keySchema, valueSchema);
           break;
         }
         const objectSchema2 = z.object(shape).passthrough();
         const recordSchema = z.looseRecord(keySchema, valueSchema);
-        zodSchema81 = z.intersection(objectSchema2, recordSchema);
+        zodSchema82 = z.intersection(objectSchema2, recordSchema);
         break;
       }
       if (schema.patternProperties) {
@@ -16260,25 +16263,25 @@ function convertBaseSchema(schema, ctx) {
         }
         schemasToIntersect.push(...looseRecords);
         if (schemasToIntersect.length === 0) {
-          zodSchema81 = z.object({}).passthrough();
+          zodSchema82 = z.object({}).passthrough();
         } else if (schemasToIntersect.length === 1) {
-          zodSchema81 = schemasToIntersect[0];
+          zodSchema82 = 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]);
           }
-          zodSchema81 = result;
+          zodSchema82 = result;
         }
         break;
       }
       const objectSchema = z.object(shape);
       if (schema.additionalProperties === false) {
-        zodSchema81 = objectSchema.strict();
+        zodSchema82 = objectSchema.strict();
       } else if (typeof schema.additionalProperties === "object") {
-        zodSchema81 = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
+        zodSchema82 = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
       } else {
-        zodSchema81 = objectSchema.passthrough();
+        zodSchema82 = objectSchema.passthrough();
       }
       break;
     }
@@ -16289,29 +16292,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) {
-          zodSchema81 = z.tuple(tupleItems).rest(rest);
+          zodSchema82 = z.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema81 = z.tuple(tupleItems);
+          zodSchema82 = z.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema81 = zodSchema81.check(z.minLength(schema.minItems));
+          zodSchema82 = zodSchema82.check(z.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema81 = zodSchema81.check(z.maxLength(schema.maxItems));
+          zodSchema82 = zodSchema82.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) {
-          zodSchema81 = z.tuple(tupleItems).rest(rest);
+          zodSchema82 = z.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema81 = z.tuple(tupleItems);
+          zodSchema82 = z.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema81 = zodSchema81.check(z.minLength(schema.minItems));
+          zodSchema82 = zodSchema82.check(z.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema81 = zodSchema81.check(z.maxLength(schema.maxItems));
+          zodSchema82 = zodSchema82.check(z.maxLength(schema.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
@@ -16322,16 +16325,16 @@ function convertBaseSchema(schema, ctx) {
         if (typeof schema.maxItems === "number") {
           arraySchema = arraySchema.max(schema.maxItems);
         }
-        zodSchema81 = arraySchema;
+        zodSchema82 = arraySchema;
       } else {
-        zodSchema81 = z.array(z.any());
+        zodSchema82 = z.array(z.any());
       }
       break;
     }
     default:
       throw new Error(`Unsupported type: ${type}`);
   }
-  return zodSchema81;
+  return zodSchema82;
 }
 function convertSchema(schema, ctx) {
   if (typeof schema === "boolean") {
@@ -73655,16 +73658,16 @@ function lookupExternalDeviceNow(id) {
   }
   return device;
 }
-async function assertExternalCapability(namespace, device, capability38) {
-  assertExternalCapabilitySync(namespace, device, capability38);
+async function assertExternalCapability(namespace, device, capability39) {
+  assertExternalCapabilitySync(namespace, device, capability39);
 }
-function assertExternalCapabilitySync(namespace, device, capability38) {
+function assertExternalCapabilitySync(namespace, device, capability39) {
   const id = typeof device === "string" ? device : device.id;
   const externalDevice = isExternalId(id) ? lookupExternalDeviceNow(id) : externalClaimForNativeId(id);
   if (!externalDevice) return;
-  if (externalDevice.capabilities.has(capability38)) return;
+  if (externalDevice.capabilities.has(capability39)) return;
   throw new FailureError(
-    `${namespace} is not available on '${externalDevice.name}': ${externalDevice.provider.name} did not grant the '${capability38}' capability for this device.`,
+    `${namespace} is not available on '${externalDevice.name}': ${externalDevice.provider.name} did not grant the '${capability39}' capability for this device.`,
     {
       error_code: FAILURE_CODES.EXTERNAL_DEVICE_CAPABILITY_DENIED,
       error_kind: "unsupported",
@@ -94920,7 +94923,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.21";
+    return "0.28.1-next.23";
   }
   return "0.0.0";
 }
@@ -96694,8 +96697,8 @@ async function simctlArgsForUdid(udid, args, options) {
   return [...simctlPrefix(await deviceSetForUdid(udid)), ...nativeArgs(udid, args)];
 }
 function assertSimctlEntitlement(udid, options) {
-  const capability38 = options?.granted ?? "simctl";
-  assertExternalCapabilitySync(capability38, udid, capability38);
+  const capability39 = options?.granted ?? "simctl";
+  assertExternalCapabilitySync(capability39, udid, capability39);
 }
 async function simctlTargetForUdid(udid, options) {
   assertSimctlEntitlement(udid, options);
@@ -97439,6 +97442,7 @@ function axServiceRef(device, { transport = "unix" } = {}) {
   };
 }
 var LIVE_PANEL_TIMEOUT_MS = 2e3;
+var FILL_TIMEOUT_MS = 6e3;
 function getSocketPath(udid) {
   return `/tmp/ax-${udid.slice(0, 8)}.sock`;
 }
@@ -97689,7 +97693,7 @@ var axServiceBlueprint = {
       }
       throw err;
     }
-    function query(command, timeoutMs = 5e3) {
+    function query(command, timeoutMs = 5e3, params) {
       return new Promise((resolve14, reject) => {
         if (!daemonSocket || daemonSocket.destroyed) {
           reject(
@@ -97717,7 +97721,9 @@ var axServiceBlueprint = {
           }
         }, timeoutMs);
         pendingRpc.set(id, { resolve: resolve14, reject, timer });
-        daemonSocket.write(JSON.stringify({ id, command }) + "\n");
+        daemonSocket.write(
+          JSON.stringify(params === void 0 ? { id, command } : { id, command, params }) + "\n"
+        );
       });
     }
     const api = {
@@ -97775,6 +97781,47 @@ var axServiceBlueprint = {
         }
         return typeof result.displayId === "number" && result.displayId > 0 ? result.displayId : null;
       },
+      async fill(text, options2 = {}) {
+        let result;
+        try {
+          result = await query("fill", FILL_TIMEOUT_MS, {
+            text,
+            ...options2.check ? { check: true } : {},
+            ...options2.typeable === false ? { typeable: false } : {}
+          });
+        } catch (err) {
+          const code = err instanceof Error ? err.message : "";
+          if (code === "unknown_command") {
+            throw new FailureError("ax-service predates `fill`; update argent", {
+              error_code: FAILURE_CODES.AX_QUERY_FAILED,
+              failure_stage: "ax_service_fill",
+              failure_area: "tool_server",
+              error_kind: "unknown"
+            });
+          }
+          if (code === "no_focused_field" || code === "not_editable") {
+            return { focused: false, verified: false };
+          }
+          if (code === "unsupported_field") {
+            return { focused: true, verified: false, unsupported: true };
+          }
+          if (code === "single_line") return { focused: true, verified: false, singleLine: true };
+          if (code === "select_failed") return { focused: true, verified: false, untouched: true };
+          if (code === "fill_failed") return { focused: true, verified: false };
+          if (code === "fill_timeout" || code === "fill_busy" || getFailureSignal(err)?.error_code === FAILURE_CODES.AX_QUERY_TIMEOUT) {
+            return { focused: true, verified: false, timedOut: true };
+          }
+          throw err;
+        }
+        return {
+          focused: true,
+          verified: result.verified === true,
+          ...result.needsBackspace === true ? { needsBackspace: true } : {},
+          ...result.secure === true ? { secure: true } : {},
+          ...typeof result.cleared === "boolean" ? { cleared: result.cleared } : {},
+          ...result.untouched === true ? { untouched: true } : {}
+        };
+      },
       async alertCheck() {
         const result = await query("alert_check");
         return result.alertVisible ?? false;
@@ -97872,23 +97919,23 @@ var InvalidToolInputError = class extends Error {
     });
   }
 };
-function platformMatrix(platform, capability38) {
+function platformMatrix(platform, capability39) {
   switch (platform) {
     case "ios":
-      return capability38.apple;
+      return capability39.apple;
     case "ios-remote":
-      return capability38.appleRemote;
+      return capability39.appleRemote;
     case "android":
-      return capability38.android;
+      return capability39.android;
     case "chromium":
-      return capability38.chromium;
+      return capability39.chromium;
     case "vega":
-      return capability38.vega;
+      return capability39.vega;
   }
 }
-function assertSupported(toolId, capability38, device) {
-  if (!capability38) return;
-  const matrix = platformMatrix(device.platform, capability38);
+function assertSupported(toolId, capability39, device) {
+  if (!capability39) return;
+  const matrix = platformMatrix(device.platform, capability39);
   if (!matrix) {
     throw new UnsupportedOperationError(toolId, device, `no ${device.platform} support declared`);
   }
@@ -97896,7 +97943,7 @@ function assertSupported(toolId, capability38, device) {
   if (!supported) {
     throw new UnsupportedOperationError(toolId, device, `kind '${device.kind}' not supported`);
   }
-  if (capability38.supports && !capability38.supports(device)) {
+  if (capability39.supports && !capability39.supports(device)) {
     throw new UnsupportedOperationError(toolId, device, "supports() refiner rejected device");
   }
 }
@@ -111341,13 +111388,13 @@ var listDevicesTool = {
   description: `List iOS simulators, Android emulators, connected physical Android devices, running Chromium apps, and Vega (Fire TV) devices in one place.
 Use at the start of a session to pick a target id ('udid' for iOS entries, 'serial' for Android/Vega entries, 'id' for Chromium) to pass to interaction tools, and to see which targets are already running.
 Returns { devices, avds } where each device carries a 'platform' discriminator ('ios', 'android', 'chromium', or 'vega'); 'avds' lists Android AVDs bootable via boot-device. A Vega VVD is listed under 'devices' whether running or stopped (state 'running'/'stopped'); start a stopped one with boot-device using its 'vvdImage'.
-Android entries also carry a 'kind' ('emulator' for a local AVD, 'device' for a physical phone connected over USB / wireless adb) \u2014 physical phones are detected from \`adb devices\` (any serial that is not an \`emulator-*\` one) and are driven through the same interaction tools as emulators; they do not need boot-device (just connect the phone with USB debugging authorised).
+Android entries also carry a 'kind' ('emulator' for a local AVD, 'device' for a physical phone connected over USB / wireless adb). Physical phones are detected from \`adb devices\` (any serial that is not an \`emulator-*\` one) and are driven through the same interaction tools as emulators; they do not need boot-device (just connect the phone with USB debugging authorised).
 Physical iPhones appear as iOS entries with kind 'device' (no iPads); no boot-device. State 'connected' = cabled and usable; 'paired' = not reachable over USB, never auto-bound.
-TV targets are tagged with runtimeKind 'tv' (Apple TV simulators on iOS, Android TV / leanback devices on Android) \u2014 these are focus-driven, not touch-driven: use \`describe\` to read focus, \`tv-remote\` for remote presses (up/down/left/right/select/back/menu/home), and \`keyboard\` to type, rather than the coordinate/gesture tools.
-iOS simulators from an additional CoreSimulator device set (the 'ios.additionalDeviceSets' configuration \u2014 e.g. devices created by Radon IDE) are listed alongside default-set ones, tagged with their owning 'deviceSet' path; they are driven through the same tools by udid, but run headless (no Simulator.app window attaches to them).
+TV targets are tagged with runtimeKind 'tv' (Apple TV simulators on iOS, Android TV / leanback devices on Android). These are focus-driven, not touch-driven: use \`describe\` to read focus, \`tv-remote\` for remote presses (up/down/left/right/select/back/menu/home), and \`keyboard\` to type, rather than the coordinate/gesture tools.
+iOS simulators from an additional CoreSimulator device set (the 'ios.additionalDeviceSets' configuration, e.g. devices created by Radon IDE) are listed alongside default-set ones, tagged with their owning 'deviceSet' path; they are driven through the same tools by udid, but run headless (no Simulator.app window attaches to them).
 A foldable iOS simulator (the iPhone Duo) has 'foldable: true'. Use the \`fold\` tool to fold or unfold it.
-Chromium apps are discovered by probing CDP debugging ports (default 9222; extend via the ARGENT_CHROMIUM_PORTS=<comma-separated-ports> env var). They must already be running with --remote-debugging-port=<port> \u2014 use boot-device with electronAppPath to launch one.
-Booted/ready devices are listed first. Platforms whose CLI is unavailable are silently omitted \u2014 an empty result usually means xcode-select, Android platform-tools, or the Vega SDK is not installed.`,
+Chromium apps are discovered by probing CDP debugging ports (default 9222; extend via the ARGENT_CHROMIUM_PORTS=<comma-separated-ports> env var). They must already be running with --remote-debugging-port=<port>; use boot-device with electronAppPath to launch one.
+Booted/ready devices are listed first. Platforms whose CLI is unavailable are silently omitted; an empty result usually means xcode-select, Android platform-tools, or the Vega SDK is not installed.`,
   alwaysLoad: true,
   searchHint: "list devices simulators emulators avd serial udid ios android chromium vega app fire tv session start",
   zodSchema,
@@ -111921,7 +111968,7 @@ var NATIVE_DEVTOOLS_NAMESPACE = "NativeDevtools";
 function isInjectableBundleId(bundleId) {
   return !bundleId.toLowerCase().startsWith("com.apple.");
 }
-var NON_INJECTABLE_NATIVE_WARNING = "Do not fall back to the native-devtools feature tools (native-describe-screen, native-find-views, native-full-hierarchy, native-network-logs, native-view-at-point, native-user-interactable-view-at-point) \u2014 they run the same injection precheck and fail with the same non-injectable error.";
+var NON_INJECTABLE_NATIVE_WARNING = "Do not fall back to the native-devtools feature tools (native-describe-screen, native-find-views, native-full-hierarchy, native-network-logs, native-view-at-point, native-user-interactable-view-at-point): they run the same injection precheck and fail with the same non-injectable error.";
 var NON_INJECTABLE_RECOVERY = "Use the standard `describe` tool (its accessibility path reads the screen without injection) or `screenshot` (then interact by coordinate). " + NON_INJECTABLE_NATIVE_WARNING;
 var MAX_NATIVE_DEVTOOLS_INIT_ATTEMPTS = 3;
 var NATIVE_DEVTOOLS_AGE_SLOP_MS = 3e3;
@@ -113762,6 +113809,7 @@ var net3 = __toESM(require("node:net"));
 init_src2();
 var DEFAULT_RPC_TIMEOUT_MS = 5e3;
 var LONG_RPC_TIMEOUT_MS = 15e3;
+var SET_TEXT_RPC_TIMEOUT_MS = 14e3;
 function connectAndroidDevtoolsClient(localPort, onTerminated) {
   return new Promise((resolve14, reject) => {
     const socket = net3.createConnection({ host: "127.0.0.1", port: localPort });
@@ -113832,7 +113880,7 @@ function connectAndroidDevtoolsClient(localPort, onTerminated) {
               );
             }
             const id = nextId++;
-            const timeoutMs = method === "getHierarchy" ? LONG_RPC_TIMEOUT_MS : DEFAULT_RPC_TIMEOUT_MS;
+            const timeoutMs = method === "getHierarchy" ? LONG_RPC_TIMEOUT_MS : method === "setText" ? SET_TEXT_RPC_TIMEOUT_MS : DEFAULT_RPC_TIMEOUT_MS;
             return new Promise((resolveReq, rejectReq) => {
               const timer = setTimeout(() => {
                 pending.delete(id);
@@ -114201,6 +114249,35 @@ var androidDevtoolsBlueprint = {
       },
       ping() {
         return client2.request("ping");
+      },
+      async setText(text, setOpts = {}) {
+        let result;
+        try {
+          result = await client2.request("setText", {
+            text,
+            ...setOpts.check ? { check: true } : {}
+          });
+        } catch (err) {
+          if (err instanceof Error && err.message.includes("Unknown method: setText")) {
+            throw new FailureError("The devtools helper predates `setText`; update argent", {
+              error_code: FAILURE_CODES.ANDROID_DEVTOOLS_RPC_ERROR,
+              failure_stage: "android_devtools_set_text",
+              failure_area: "tool_server",
+              error_kind: "unknown"
+            });
+          }
+          if (getFailureSignal(err)?.error_code === FAILURE_CODES.ANDROID_DEVTOOLS_RPC_TIMEOUT || err instanceof Error && err.message.includes("Helper worker timed out")) {
+            return { focused: true, verified: false, timedOut: true };
+          }
+          throw err;
+        }
+        return {
+          focused: result.focused === true,
+          verified: result.verified === true,
+          ...typeof result.performed === "boolean" ? { performed: result.performed } : {},
+          ...typeof result.password === "boolean" ? { password: result.password } : {},
+          ...result.singleLine === true ? { singleLine: true } : {}
+        };
       }
     };
     const instance = {
@@ -116733,11 +116810,11 @@ function scheduleGroupSigkill(pid, graceMs, opts) {
 }
 async function pollPidsUntilGone(pids, opts) {
   const isAlive2 = opts.isAlive ?? pidIsAlive;
-  const sleep14 = opts.sleep ?? ((ms) => new Promise((resolve14) => setTimeout(resolve14, ms)));
+  const sleep15 = 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) => isAlive2(pid));
   for (let poll = 0; poll < maxPolls && remaining.length > 0; poll += 1) {
-    await sleep14(opts.pollIntervalMs);
+    await sleep15(opts.pollIntervalMs);
     remaining = remaining.filter((pid) => isAlive2(pid));
   }
   return remaining;
@@ -118909,19 +118986,19 @@ Returns { envSetup, appRunning, connected, requiresRestart, state, message, next
 - envSetup: DYLD_INSERT_LIBRARIES is configured in the simulator's launchd environment
 - appRunning: the target bundle currently has a running UIKit process on the simulator
 - connected: the dylib is active in the current running process for this bundleId
-- requiresRestart: the app is already running and a fresh process would reach this simulator's devtools endpoint where the current one does not \u2014 it carries no argent injection, was pointed at an earlier tool-server's listener, or could not be inspected to tell. Always false for a non-injectable app, and false when state is unregistered or connecting, where a relaunch cannot help.
-- state: why devtools are or aren't live, measured from the running process. "connected"; "not_running"; "stale_process" (the process cannot reach this simulator's devtools endpoint \u2014 launched either before argent's instrumentation was in place or against an earlier tool-server's listener \u2014 so restart-app fixes it); "unregistered" (the process IS injected and pointed at this simulator's devtools endpoint yet the service never registered it, so restarting the app cannot help); "connecting" (the process IS injected but launched moments ago and is still connecting, so waiting is what helps); "indeterminate" (the process could not be inspected). Omitted when injectable is false, which is terminal on its own.
-- message: the remedy for that state, in full, including for a state not listed above. Omitted when connected or non-injectable. Prefer it over inferring one from the booleans \u2014 it is the only field that can tell you to stop restarting the app.
+- requiresRestart: the app is already running and a fresh process would reach this simulator's devtools endpoint where the current one does not: it carries no argent injection, was pointed at an earlier tool-server's listener, or could not be inspected to tell. Always false for a non-injectable app, and false when state is unregistered or connecting, where a relaunch cannot help.
+- state: why devtools are or aren't live, measured from the running process. "connected"; "not_running"; "stale_process" (the process cannot reach this simulator's devtools endpoint, launched either before argent's instrumentation was in place or against an earlier tool-server's listener, so restart-app fixes it); "unregistered" (the process IS injected and pointed at this simulator's devtools endpoint yet the service never registered it, so restarting the app cannot help); "connecting" (the process IS injected but launched moments ago and is still connecting, so waiting is what helps); "indeterminate" (the process could not be inspected). Omitted when injectable is false, which is terminal on its own.
+- message: the remedy for that state, in full, including for a state not listed above. Omitted when connected or non-injectable. Prefer it over inferring one from the booleans: it is the only field that can tell you to stop restarting the app.
 - nextLaunchWillBeInjected: if you launch this bundle now, native devtools env setup is already in place (always false for a non-injectable app)
 - injectable: whether this app is a supported target for Argent native devtools. Apple system apps (bundle ids under com.apple.) are not: they are never the app under test, so the native tools refuse to read one.
 
 Call this before using app-scoped native hierarchy tools or native-network-logs.
-If injectable is false: treat this as TERMINAL \u2014 the app is not a supported native-devtools target, and no relaunch changes that. Do NOT restart/retry. Use the standard \`describe\` tool (its accessibility path reads the screen without injection) or \`screenshot\` (then interact by coordinate). Do not fall back to the native-devtools feature tools (native-describe-screen, native-find-views, native-full-hierarchy, native-network-logs, native-view-at-point, native-user-interactable-view-at-point) \u2014 they run the same injection precheck and fail with the same non-injectable error.
+If injectable is false: treat this as TERMINAL. The app is not a supported native-devtools target, and no relaunch changes that. Do NOT restart/retry. Use the standard \`describe\` tool (its accessibility path reads the screen without injection) or \`screenshot\` (then interact by coordinate). Do not fall back to the native-devtools feature tools (native-describe-screen, native-find-views, native-full-hierarchy, native-network-logs, native-view-at-point, native-user-interactable-view-at-point): they run the same injection precheck and fail with the same non-injectable error.
 If appRunning is false and nextLaunchWillBeInjected is true: use launch-app normally.
-If requiresRestart is true: call restart-app once, then proceed with the native feature. Read state before acting on a second such reading \u2014 indeterminate reaches this rule too, and its line below bounds it at that one restart.
-If state is unregistered: do NOT restart the app again \u2014 it already launched under the terms a restart would recreate. Restart the tool-server (\`argent server stop && argent server start --detach\`), then retry. If it reads unregistered again after that restart, stop: the process loads argent's dylib but never dials, and no further restart on either side changes it \u2014 treat native devtools as unavailable, then use \`describe\` or \`screenshot\` and drive by coordinate.
-If state is connecting: do NOT restart the app \u2014 launching it is what starts the connection, so a relaunch discards the one in progress and returns this same state. Wait a few seconds and repeat this call.
-If state is indeterminate: the process could not be inspected, so restart-app is worth one attempt. If this call still reports it after that restart, do NOT restart the app again \u2014 the service is stale rather than the app uninjected, so restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. Remote simulators can never inspect the process, so this is the only unconnected state a running app reaches there.
+If requiresRestart is true: call restart-app once, then proceed with the native feature. Read state before acting on a second such reading. Indeterminate reaches this rule too, and its line below bounds it at that one restart.
+If state is unregistered: do NOT restart the app again: it already launched under the terms a restart would recreate. Restart the tool-server (\`argent server stop && argent server start --detach\`), then retry. If it reads unregistered again after that restart, stop: the process loads argent's dylib but never dials, and no further restart on either side changes it. Treat native devtools as unavailable, then use \`describe\` or \`screenshot\` and drive by coordinate.
+If state is connecting: do NOT restart the app. Launching it is what starts the connection, so a relaunch discards the one in progress and returns this same state. Wait a few seconds and repeat this call.
+If state is indeterminate: the process could not be inspected, so restart-app is worth one attempt. If this call still reports it after that restart, do NOT restart the app again: the service is stale rather than the app uninjected, so restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. Remote simulators can never inspect the process, so this is the only unconnected state a running app reaches there.
 Returns { status: "init_failed", message, attempts } instead when the simulator's native-devtools environment failed to initialize.
 Fails if the simulator server is not running for the given UDID.`,
   zodSchema: zodSchema2,
@@ -119016,8 +119093,8 @@ var nativeNetworkLogsTool = {
 Unlike the JS-level network inspector (view-network-logs), this captures ALL network traffic from the app including native modules, Swift/Objective-C networking, and background transfers that bypass JS fetch. 
 Use when you need to inspect native-level HTTP traffic that is invisible to JS fetch interception. 
 Returns { status, count, events } where each event contains URL, method, status code, headers, and timing.
-If status is restart_required: follow the message (usually restart-app), then retry. If status is service_stale: the app is already injected, so restarting it cannot help \u2014 restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. If the same status comes back after that restart, stop restarting: follow the message, which names the terminal fallback. If status is connect_pending: the app is injected and still connecting \u2014 do not restart it, wait a few seconds and retry. If status is init_failed: the simulator's native-devtools environment could not be initialised \u2014 follow the message (re-boot the simulator) rather than retrying this tool.
-A not-running app comes back as one of those statuses rather than a failure. An app that is not connected does too, except on a device whose devtools agent argent attached to rather than armed itself \u2014 there it fails with \`NATIVE_DEVTOOLS_NOT_CONNECTED\`, since no restart of ours can complete a handshake we do not own. Failures are separate: an Apple system app is rejected outright (terminal \u2014 never retry it), while a missing host dependency or a udid that is not an Apple device is not.`,
+If status is restart_required: follow the message (usually restart-app), then retry. If status is service_stale: the app is already injected, so restarting it cannot help. Restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. If the same status comes back after that restart, stop restarting: follow the message, which names the terminal fallback. If status is connect_pending: the app is injected and still connecting. Do not restart it, wait a few seconds and retry. If status is init_failed: the simulator's native-devtools environment could not be initialised. Follow the message (re-boot the simulator) rather than retrying this tool.
+A not-running app comes back as one of those statuses rather than a failure. An app that is not connected does too, except on a device whose devtools agent argent attached to rather than armed itself: there it fails with \`NATIVE_DEVTOOLS_NOT_CONNECTED\`, since no restart of ours can complete a handshake we do not own. Failures are separate: an Apple system app is rejected outright (terminal: never retry it), while a missing host dependency or a udid that is not an Apple device is not.`,
   zodSchema: zodSchema3,
   services: (params) => ({
     nativeDevtools: nativeDevtoolsRef(resolveDevice(params.udid))
@@ -119079,8 +119156,8 @@ var nativeFindViewsTool = {
 Use when you need to locate a specific view by its properties without dumping the entire hierarchy.
 Returns { status: "ok", matches } with matching views including their frames, properties, optional ancestors, and optional children. Much more targeted than native-full-hierarchy.
 At least one of className, identifier, label, tag, or nativeID must be provided.
-If status is restart_required: follow the message (usually restart-app), then retry. If status is service_stale: the app is already injected, so restarting it cannot help \u2014 restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. If the same status comes back after that restart, stop restarting: follow the message, which names the terminal fallback. If status is connect_pending: the app is injected and still connecting \u2014 do not restart it, wait a few seconds and retry. If status is init_failed: the simulator's native-devtools environment could not be initialised \u2014 follow the message (re-boot the simulator) rather than retrying this tool.
-A not-connected or not-running app comes back as one of those statuses rather than a failure. Failures are separate: an Apple system app is rejected outright (terminal \u2014 never retry it), and the hierarchy query itself can error or time out.`,
+If status is restart_required: follow the message (usually restart-app), then retry. If status is service_stale: the app is already injected, so restarting it cannot help. Restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. If the same status comes back after that restart, stop restarting: follow the message, which names the terminal fallback. If status is connect_pending: the app is injected and still connecting. Do not restart it, wait a few seconds and retry. If status is init_failed: the simulator's native-devtools environment could not be initialised. Follow the message (re-boot the simulator) rather than retrying this tool.
+A not-connected or not-running app comes back as one of those statuses rather than a failure. Failures are separate: an Apple system app is rejected outright (terminal: never retry it), and the hierarchy query itself can error or time out.`,
   zodSchema: zodSchema4,
   services: (params) => ({
     nativeDevtools: nativeDevtoolsRef(resolveDevice(params.udid))
@@ -119130,7 +119207,7 @@ var zodSchema5 = external_exports.object({
     'Exact UIView class names whose entire subtree should be pruned (e.g. ["UIImageView"] to drop image leaf nodes)'
   ),
   skipClassPrefixes: external_exports.array(external_exports.string()).optional().describe(
-    'Class name prefixes to prune entire subtrees. For SwiftUI apps use ["_TtGC7SwiftUI"] to drop mangled SwiftUI generic type subtrees while keeping _UIHostingView and UIKit bridges. Avoid broad prefixes like "_UI" \u2014 they prune useful system views.'
+    'Class name prefixes to prune entire subtrees. For SwiftUI apps use ["_TtGC7SwiftUI"] to drop mangled SwiftUI generic type subtrees while keeping _UIHostingView and UIKit bridges. Avoid broad prefixes like "_UI": they prune useful system views.'
   ),
   maxDepth: external_exports.number().int().positive().optional().describe(
     "Maximum recursion depth (default 8). Increase for deeper inspection, decrease to reduce output size."
@@ -119149,8 +119226,8 @@ WARNING: Output can be extremely large (100KB\u2013500KB+) for complex apps, esp
 Use skipClasses / skipClassPrefixes to prune SwiftUI internal subtrees and reduce output size. Use the fields param to request only the properties you need.
 Use when you need deep layout debugging, finding views with no accessibility labels, or verifying view structure not exposed through the accessibility tree.
 Returns { status: "ok", windows, screen } with the full view hierarchy. screen gives the screen size in points on its portrait axes, and the interfaceOrientation of the UI (portrait, portraitUpsideDown, landscapeLeft, landscapeRight). Each screenFrame uses the portrait axes of the screen. Each windowFrame uses the axes of its window, which turn with the UI.
-If status is restart_required: follow the message (usually restart-app), then retry. If status is service_stale: the app is already injected, so restarting it cannot help \u2014 restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. If the same status comes back after that restart, stop restarting: follow the message, which names the terminal fallback. If status is connect_pending: the app is injected and still connecting \u2014 do not restart it, wait a few seconds and retry. If status is init_failed: the simulator's native-devtools environment could not be initialised \u2014 follow the message (re-boot the simulator) rather than retrying this tool.
-A not-connected or not-running app comes back as one of those statuses rather than a failure. Failures are separate: an Apple system app is rejected outright (terminal \u2014 never retry it), and the hierarchy query itself can error or time out.`,
+If status is restart_required: follow the message (usually restart-app), then retry. If status is service_stale: the app is already injected, so restarting it cannot help. Restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. If the same status comes back after that restart, stop restarting: follow the message, which names the terminal fallback. If status is connect_pending: the app is injected and still connecting. Do not restart it, wait a few seconds and retry. If status is init_failed: the simulator's native-devtools environment could not be initialised. Follow the message (re-boot the simulator) rather than retrying this tool.
+A not-connected or not-running app comes back as one of those statuses rather than a failure. Failures are separate: an Apple system app is rejected outright (terminal: never retry it), and the hierarchy query itself can error or time out.`,
   zodSchema: zodSchema5,
   services: (params) => ({
     nativeDevtools: nativeDevtoolsRef(resolveDevice(params.udid))
@@ -119218,8 +119295,8 @@ Use when you are evaluating or debugging the lower-level native data behind the
 describe tool, or when you need its raw point-space geometry rather than describe's
 normalized contract.
 
-If status is restart_required: follow the message (usually restart-app), then retry. If status is service_stale: the app is already injected, so restarting it cannot help \u2014 restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. If the same status comes back after that restart, stop restarting: follow the message, which names the terminal fallback. If status is connect_pending: the app is injected and still connecting \u2014 do not restart it, wait a few seconds and retry. If status is init_failed: the simulator's native-devtools environment could not be initialised \u2014 follow the message (re-boot the simulator) rather than retrying this tool.
-A not-connected or not-running app comes back as one of those statuses rather than a failure. Failures are separate: an Apple system app is rejected outright (terminal \u2014 never retry it), and the screen query itself can error or time out.`,
+If status is restart_required: follow the message (usually restart-app), then retry. If status is service_stale: the app is already injected, so restarting it cannot help. Restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. If the same status comes back after that restart, stop restarting: follow the message, which names the terminal fallback. If status is connect_pending: the app is injected and still connecting. Do not restart it, wait a few seconds and retry. If status is init_failed: the simulator's native-devtools environment could not be initialised. Follow the message (re-boot the simulator) rather than retrying this tool.
+A not-connected or not-running app comes back as one of those statuses rather than a failure. Failures are separate: an Apple system app is rejected outright (terminal: never retry it), and the screen query itself can error or time out.`,
   zodSchema: zodSchema6,
   services: (params) => ({
     nativeDevtools: nativeDevtoolsRef(resolveDevice(params.udid))
@@ -119287,8 +119364,8 @@ var nativeViewAtPointTool = {
 Unlike native-user-interactable-view-at-point, this ignores userInteractionEnabled,
 so it answers "what is visually here?" rather than "what would receive the touch?".
 
-Use when a screenshot shows something the accessibility tree does not name \u2014 an
-unlabeled icon, a decorative overlay, a custom-drawn cell \u2014 and you need the class,
+Use when a screenshot shows something the accessibility tree does not name (an
+unlabeled icon, a decorative overlay, a custom-drawn cell) and you need the class,
 identifier or nativeID of whatever draws it.
 
 Returns { status: "ok", view }: the matched view with its class name, frames,
@@ -119300,8 +119377,8 @@ normalized [0,1] simulator tap coordinates. To get them from a describe frame,
 multiply the normalized values by the screen size in points. Do this also when
 the UI is landscape.
 
-If status is restart_required: follow the message (usually restart-app), then retry. If status is service_stale: the app is already injected, so restarting it cannot help \u2014 restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. If the same status comes back after that restart, stop restarting: follow the message, which names the terminal fallback. If status is connect_pending: the app is injected and still connecting \u2014 do not restart it, wait a few seconds and retry. If status is init_failed: the simulator's native-devtools environment could not be initialised \u2014 follow the message (re-boot the simulator) rather than retrying this tool.
-A not-connected or not-running app comes back as one of those statuses rather than a failure. Failures are separate: an Apple system app is rejected outright (terminal \u2014 never retry it), and the point query itself can error or time out.`,
+If status is restart_required: follow the message (usually restart-app), then retry. If status is service_stale: the app is already injected, so restarting it cannot help. Restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. If the same status comes back after that restart, stop restarting: follow the message, which names the terminal fallback. If status is connect_pending: the app is injected and still connecting. Do not restart it, wait a few seconds and retry. If status is init_failed: the simulator's native-devtools environment could not be initialised. Follow the message (re-boot the simulator) rather than retrying this tool.
+A not-connected or not-running app comes back as one of those statuses rather than a failure. Failures are separate: an Apple system app is rejected outright (terminal: never retry it), and the point query itself can error or time out.`,
   zodSchema: zodSchema7,
   services: (params) => ({
     nativeDevtools: nativeDevtoolsRef(resolveDevice(params.udid))
@@ -119376,7 +119453,7 @@ Unlike native-view-at-point, this respects userInteractionEnabled and is closer
 UIKit hit-testing semantics.
 
 Use when a tap lands somewhere unexpected or does nothing, to see which control
-UIKit would hand the touch to \u2014 a transparent overlay swallowing it, a parent
+UIKit would hand the touch to: a transparent overlay swallowing it, a parent
 recognizer, a disabled button.
 
 Returns { status: "ok", view }: the hit-test winner with its class name, frames,
@@ -119388,8 +119465,8 @@ normalized [0,1] simulator tap coordinates. To get them from a describe frame,
 multiply the normalized values by the screen size in points. Do this also when
 the UI is landscape.
 
-If status is restart_required: follow the message (usually restart-app), then retry. If status is service_stale: the app is already injected, so restarting it cannot help \u2014 restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. If the same status comes back after that restart, stop restarting: follow the message, which names the terminal fallback. If status is connect_pending: the app is injected and still connecting \u2014 do not restart it, wait a few seconds and retry. If status is init_failed: the simulator's native-devtools environment could not be initialised \u2014 follow the message (re-boot the simulator) rather than retrying this tool.
-A not-connected or not-running app comes back as one of those statuses rather than a failure. Failures are separate: an Apple system app is rejected outright (terminal \u2014 never retry it), and the point query itself can error or time out.`,
+If status is restart_required: follow the message (usually restart-app), then retry. If status is service_stale: the app is already injected, so restarting it cannot help. Restart the tool-server (\`argent server stop && argent server start --detach\`) and retry. If the same status comes back after that restart, stop restarting: follow the message, which names the terminal fallback. If status is connect_pending: the app is injected and still connecting. Do not restart it, wait a few seconds and retry. If status is init_failed: the simulator's native-devtools environment could not be initialised. Follow the message (re-boot the simulator) rather than retrying this tool.
+A not-connected or not-running app comes back as one of those statuses rather than a failure. Failures are separate: an Apple system app is rejected outright (terminal: never retry it), and the point query itself can error or time out.`,
   zodSchema: zodSchema8,
   services: (params) => ({
     nativeDevtools: nativeDevtoolsRef(resolveDevice(params.udid))
@@ -119505,7 +119582,7 @@ init_zod();
 init_external_devices();
 var DEFAULT_METRO_PORT = 8081;
 var metroPortField = external_exports.coerce.number().int().min(1).max(65535).optional().describe(
-  "Metro server port. Optional \u2014 omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id."
+  "Metro server port. Optional: omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id."
 );
 function metroPort(params) {
   if (params.port !== void 0) return params.port;
@@ -121560,14 +121637,14 @@ var zodSchema9 = external_exports.object({
     "Android: AVD name to launch a new emulator from (from `list-devices` \u2192 `avds[].name`). Provide exactly one of `udid`, `avdName`, `vvdImage`, or `electronAppPath`."
   ),
   vvdImage: external_exports.string().optional().describe(
-    "Vega (Fire TV): VVD image to boot \u2014 the `vvdImage` of a Vega device from `list-devices` (e.g. `tv`). Starts the single SDK-managed Vega Virtual Device. Provide exactly one of `udid`, `avdName`, `vvdImage`, or `electronAppPath`."
+    "Vega (Fire TV): VVD image to boot: the `vvdImage` of a Vega device from `list-devices` (e.g. `tv`). Starts the single SDK-managed Vega Virtual Device. Provide exactly one of `udid`, `avdName`, `vvdImage`, or `electronAppPath`."
   ),
   bootTimeoutMs: external_exports.number().int().min(3e4).max(9e5).optional().describe(
     "Android/Vega: overall budget for the boot sequence. Default 480000 (8 min) on Android, 120000 (2 min) on Vega. Clamped to [30s, 15min]. Ignored on iOS."
   ),
   force: external_exports.boolean().optional().describe("Shut down and re-boot the device even if already running."),
   sound: external_exports.boolean().optional().describe(
-    "Android only: boot the emulator with audio output enabled. Defaults to false \u2014 argent boots emulators MUTED so several agent-driven devices don't all play sound on the host machine; pass `true` when the task involves playing, hearing, or testing audio. Takes effect at boot: if the emulator is already running muted, add `force: true` to reboot it with sound. A boot snapshot saved in the other audio mode can't be reused, so the first boot after toggling is a slower cold boot. The `boot-sound` argent flag flips this default to true. Ignored on iOS/Vega/Electron, which argent never mutes."
+    "Android only: boot the emulator with audio output enabled. Defaults to false: argent boots emulators MUTED so several agent-driven devices don't all play sound on the host machine; pass `true` when the task involves playing, hearing, or testing audio. Takes effect at boot: if the emulator is already running muted, add `force: true` to reboot it with sound. A boot snapshot saved in the other audio mode can't be reused, so the first boot after toggling is a slower cold boot. The `boot-sound` argent flag flips this default to true. Ignored on iOS/Vega/Electron, which argent never mutes."
   ),
   headless: external_exports.boolean().optional().describe(
     "iOS only: boot the simulator core WITHOUT opening its GUI window (Simulator.app, or Device Hub on Xcode 27+). The device still streams via simulator-server; used by Argent Lens. Set the `ARGENT_SIMULATOR_NO_WINDOW` env var (1/true/yes) to force this host-wide without passing the flag per call (the iOS analog of `ARGENT_EMULATOR_NO_WINDOW`). Ignored on Android/Vega/Electron, which have no equivalent GUI step."
@@ -122801,7 +122878,7 @@ function createLaunchAppTool(registry2) {
       failedMsg: ({ params, failureSignal: failureSignal2 }) => `Failed to launch ${params.bundleId}: ${failureSignal2.error_code}`
     },
     description: `Open an app by its bundle id (iOS) or package name (Android), or confirm the running renderer (Chromium).
-Use when starting any app \u2014 prefer this over tapping home-screen / launcher icons. Also prepares the native-devtools injection before the app starts (the iOS slice on iOS, the tvOS slice on Apple TV); on tvOS, interaction is focus-driven \u2014 use the tv-* tools rather than coordinate taps.
+Use when starting any app; prefer this over tapping home-screen / launcher icons. Also prepares the native-devtools injection before the app starts (the iOS slice on iOS, the tvOS slice on Apple TV); on tvOS, interaction is focus-driven; use the tv-* tools rather than coordinate taps.
 Returns { launched, bundleId, note? }. Fails if the app is not installed on the target device (iOS / Android). On a physical iPhone this registers the app every other tool acts on; com.apple.springboard and com.apple.Spotlight register without launching. note warns when runner signing is not ready.
 For Chromium, the app is already running behind a CDP port; this call simply refreshes the cached viewport and acknowledges the bundleId tag. To change the visible route, use \`open-url\`.
 On Vega (Fire TV), pass the interactive component app id from manifest.toml (e.g. com.example.app.main) as bundleId.
@@ -123020,7 +123097,7 @@ function createRestartAppTool(registry2) {
       failedMsg: ({ params, failureSignal: failureSignal2 }) => `Failed to restart ${params.bundleId}: ${failureSignal2.error_code}`
     },
     description: `Terminate then relaunch an app by bundle id / package name.
-Use when you need a clean in-memory state without a full reinstall. Also refreshes the native-devtools injection before the relaunch (the iOS slice on iOS, the tvOS slice on Apple TV); on tvOS, interaction is focus-driven \u2014 use the tv-* tools rather than coordinate taps.
+Use when you need a clean in-memory state without a full reinstall. Also refreshes the native-devtools injection before the relaunch (the iOS slice on iOS, the tvOS slice on Apple TV); on tvOS, interaction is focus-driven; use the tv-* tools rather than coordinate taps.
 Returns { restarted, bundleId }. Fails if the app is not installed.`,
     alwaysLoad: true,
     searchHint: "terminate relaunch restart reset app bundle id package simulator emulator vega tvos fire tv",
@@ -123589,7 +123666,7 @@ var zodSchema14 = external_exports.object({
     "The permission to change. `notifications` is Android-only (iOS has no simctl service for it); `reminders` is iOS-only; `camera` works on Android and on iOS only when the target simulator's runtime models the service (varies by simruntime, not by the installed Xcode)."
   ),
   bundleId: external_exports.string().regex(BUNDLE_ID_PATTERN, BUNDLE_ID_MESSAGE).describe(
-    "App to change the permission for \u2014 required for every action. iOS: bundle id (e.g. com.example.app). Android: package name. `reset` is per-app too: simctl's device-wide reset (no bundleId) silently leaves existing per-app grants untouched on recent iOS, so the permission is always reset for this one app."
+    "App to change the permission for, required for every action. iOS: bundle id (e.g. com.example.app). Android: package name. `reset` is per-app too: simctl's device-wide reset (no bundleId) silently leaves existing per-app grants untouched on recent iOS, so the permission is always reset for this one app."
   )
 });
 var permissionAction = {
@@ -123615,9 +123692,9 @@ var settingsPermissionsTool = {
   },
   description: `Grant, deny, or reset a runtime permission for an app without navigating the system Settings UI. Use during test setup to pre-authorize (or explicitly deny) a service before the app asks, or \`reset\` so the permission dialog appears again on next use. Always per-app: bundleId is required.
 Permissions: camera, microphone, photos, contacts, notifications, calendar, location, location-always, media-library, motion, reminders.
-iOS simulator: edits the simulator's TCC store, always per-app. \`notifications\` is not supported (no iOS equivalent). \`reset\` is per-app \u2014 a device-wide reset is a no-op for existing grants on recent iOS, so it is not offered. \`grant location\`/\`location-always\` needs the app already installed (location auth isn't stored in TCC and isn't applied to a bundle id until the app exists) \u2014 enforced on local simulators; a remote simulator can't be probed for install state, so ensure the app is installed there first. Other services can be granted before install.
+iOS simulator: edits the simulator's TCC store, always per-app. \`notifications\` is not supported (no iOS equivalent). \`reset\` is per-app: a device-wide reset is a no-op for existing grants on recent iOS, so it is not offered. \`grant location\`/\`location-always\` needs the app already installed (location auth isn't stored in TCC and isn't applied to a bundle id until the app exists). This is enforced on local simulators; a remote simulator can't be probed for install state, so ensure the app is installed there first. Other services can be granted before install.
 Android: changes the mapped \`android.permission.*\` runtime permissions (reset also best-effort clears the user-set permission flags). The app must be installed and declare them in its manifest; \`reminders\` has no Android equivalent.
-Some permission changes terminate the app if it is running (system behavior on both platforms) \u2014 set permissions before launching, or relaunch after.
+Some permission changes terminate the app if it is running (system behavior on both platforms), so set permissions before launching, or relaunch after.
 Returns { action, permission, bundleId, applied, skipped? }: \`applied\` lists the platform-level services/permissions actually changed; \`skipped\` (Android) lists mapped permissions the package manager rejected, e.g. ones the manifest doesn't declare. Fails if nothing could be applied.`,
   searchHint: "grant deny reset revoke app permissions privacy camera microphone location settings",
   zodSchema: zodSchema14,
@@ -123785,7 +123862,7 @@ var openUrlTool = {
   description: `Open a URL or URL scheme on the device.
 Use to navigate to a web page or deep-link into an app. On Chromium, this navigates the primary renderer to the given URL.
 Cross-platform schemes: https://, tel:, mailto:. iOS also: messages://, settings://, maps://. Android also: geo:, plus any app-specific deep link.
-Deep-linking caveat: an https:// link opens the native app only when an installed app is verified for the link's domain (iOS Universal Links / Android App Links) \u2014 otherwise it opens in the browser, and on iOS simulators it may open in Safari even when the owning app is installed. To reliably open an installed app, use its custom scheme (scheme://path) or launch-app with its bundle id.
+Deep-linking caveat: an https:// link opens the native app only when an installed app is verified for the link's domain (iOS Universal Links / Android App Links); otherwise it opens in the browser, and on iOS simulators it may open in Safari even when the owning app is installed. To reliably open an installed app, use its custom scheme (scheme://path) or launch-app with its bundle id.
 On a physical iPhone, http(s) URLs default to Safari and any other scheme needs bundleId; the receiving app becomes the app under automation.
 Returns { opened, url, note? }. note carries the deep-linking caveat when a web URL was opened on a native device. Fails if no app is registered to handle the URI (iOS/Android) or the renderer rejects the navigation (Chromium).`,
   zodSchema: zodSchema15,
@@ -124394,7 +124471,7 @@ var zodSchema16 = external_exports.object({
     "Scale factor (0.01-1.0). Defaults to ARGENT_SCREENSHOT_SCALE env var, or 0.25 if unset for iOS/Android. On Chromium the default is 1.0 (no downscale); pass <1 to opt in. Downscaling on Chromium requires the optional `sharp` dependency."
   ),
   includeImageInContext: external_exports.boolean().optional().default(true).describe(
-    "Default true. Set false only when capturing a full-resolution PNG (scale: 1.0) to save as a baseline/current for screenshot-diff \u2014 the file is still written, but the image bytes are not attached to the agent context."
+    "Default true. Set false only when capturing a full-resolution PNG (scale: 1.0) to save as a baseline/current for screenshot-diff. The file is still written, but the image bytes are not attached to the agent context."
   ),
   downscaler: external_exports.enum(["lanczos3", "box", "bilinear", "nearest"]).optional().describe(
     "Downscaling algorithm when scale<1 on Chromium. Defaults to lanczos3 (highest quality). Mirrors sim-server's wire enum. Ignored on physical iPhones."
@@ -124637,11 +124714,11 @@ var gestureTapTool = {
   },
   description: `Press the device screen (iOS simulator or physical device, Android emulator, or Chromium app) at normalized coordinates: x and y are fractions of screen width and height in 0.0\u20131.0 (not pixels).
 Sends a Down event followed by an Up event at the same point. For Chromium, this dispatches a CDP mouse-press/release on the renderer.
-Set clickCount: 2 for a double-tap / double-click \u2014 the taps are dispatched as one gesture with proper click counting, which two separate tap calls cannot guarantee.
+Set clickCount: 2 for a double-tap / double-click: the taps are dispatched as one gesture with proper click counting, which two separate tap calls cannot guarantee.
 Use when you need to tap a button, link, or any tappable element on the screen.
 Returns { tapped: true, timestampMs }. On physical iOS, reactivated: true = app was re-fronted; re-describe. Fails if the simulator-server / emulator backend / Chromium CDP is not reachable for the given device.
 On a physical iPhone use \`describe\`; \`native-describe-screen\` is simulator-only.
-Before tapping, determine the correct coordinates by using discovery tools \u2014 pick by platform: iOS / Android use \`describe\`, \`native-describe-screen\`, or \`debugger-component-tree\`; Chromium uses \`describe\` (the DOM walker), since the native and RN-specific discovery tools don't apply. More information in \`argent-device-interact\` skill`,
+Before tapping, determine the correct coordinates by using discovery tools. Pick by platform: iOS / Android use \`describe\`, \`native-describe-screen\`, or \`debugger-component-tree\`; Chromium uses \`describe\` (the DOM walker), since the native and RN-specific discovery tools don't apply. More information in \`argent-device-interact\` skill`,
   alwaysLoad: true,
   searchHint: "tap press button element device simulator emulator chromium touch down up click",
   zodSchema: zodSchema17,
@@ -124756,7 +124833,7 @@ var gestureSwipeTool = {
   description: `Execute a smooth swipe / drag touch gesture between two points on the device (iOS simulator or physical device, or Android emulator). All from/to positions are normalized 0.0\u20131.0 (fractions of screen width/height, not pixels), same as gesture-tap.
 Generates interpolated Move events for a natural feel (~60fps).
 Swipe up (fromY > toY) to scroll content down.
-Use when you need to scroll a list, dismiss a modal, drag an element, or navigate between pages. Not supported on Chromium \u2014 use gesture-scroll there instead.
+Use when you need to scroll a list, dismiss a modal, drag an element, or navigate between pages. Not supported on Chromium; use gesture-scroll there instead.
 Physical iOS: an edge gesture (back-swipe) needs fromX 0 exactly; durationMs sets drag speed, not time; momentum:false only rests 300ms at the end and does not damp.
 Pass momentum:false for a momentum-free swipe that lands where the finger lifts (little to no fling at the 300 default), when you need a deterministic scroll distance; it needs durationMs >= 150 and is rejected below that, a shorter ease-out leaving the OS too little wall clock to read the deceleration as a stop. At 150 it lands short of the lift point instead, and 2 of 47 runs still flung backwards. A plain swipe takes any duration up to 10000ms and is delivered as close to the speed it was authored as a 16ms frame allows: below ~32ms the whole travel lands in one or two frames, which the OS flings as hard as it flings anything. Returns { swiped: true, timestampMs }. On physical iOS, reactivated: true = app was re-fronted; re-describe. Fails if the simulator-server / emulator backend is not reachable for the given device.`,
   alwaysLoad: true,
@@ -124859,7 +124936,7 @@ var sleep4 = (ms) => new Promise((r) => setTimeout(r, ms));
 var zodSchema19 = external_exports.object({
   udid: external_exports.string().describe("Target Chromium device id from `list-devices` (chromium-cdp-<port>)."),
   x: external_exports.number().describe(
-    "Anchor x: normalized 0.0\u20131.0 (fraction of window width, not pixels). The wheel events land here \u2014 put it over the element you want to scroll."
+    "Anchor x: normalized 0.0\u20131.0 (fraction of window width, not pixels). The wheel events land here; put it over the element you want to scroll."
   ),
   y: external_exports.number().describe("Anchor y: normalized 0.0\u20131.0 (fraction of window height, not pixels)."),
   deltaX: external_exports.number().optional().describe(
@@ -124892,7 +124969,7 @@ var gestureScrollTool = {
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to scroll: ${failureSignal2.error_code}`
   },
   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.
+Use when content is below/above the fold (describe shows off-screen elements with zero height) or a list needs scrolling. Chromium only: on iOS/Android use gesture-swipe.
 Returns { scrolled: true, timestampMs }. Fails if the Chromium CDP session is not reachable for the given device.`,
   searchHint: "scroll wheel list page chromium mouse down up content fold",
   zodSchema: zodSchema19,
@@ -124937,7 +125014,7 @@ var zodSchema20 = external_exports.object({
     `Total drag duration in milliseconds (default 300, at most ${MAX_DURATION_MS2} - the button stays down for exactly this long), interpolated at ~60fps.`
   ),
   momentum: external_exports.boolean().optional().describe(
-    "Whether the drag releases with momentum; default true (a constant-speed drag). Pass false to decelerate into the release point (ease-out) so an app deriving fling from pointer release velocity (carousels, drag libraries) reads ~0 and applies little to no momentum \u2014 use it when the drag must stop where it was aimed rather than fling past. Deceleration needs wall clock: under ~100ms the whole drag fits inside the velocity window a page averages over (tens of ms), so some fling survives, and under ~70ms its extra frames cannot dispatch fast enough to fit durationMs. Keep durationMs at its default when the fling must be fully suppressed."
+    "Whether the drag releases with momentum; default true (a constant-speed drag). Pass false to decelerate into the release point (ease-out) so an app deriving fling from pointer release velocity (carousels, drag libraries) reads ~0 and applies little to no momentum. Use it when the drag must stop where it was aimed rather than fling past. Deceleration needs wall clock: under ~100ms the whole drag fits inside the velocity window a page averages over (tens of ms), so some fling survives, and under ~70ms its extra frames cannot dispatch fast enough to fit durationMs. Keep durationMs at its default when the fling must be fully suppressed."
   ),
   // `momentum`'s earlier spelling, with the opposite polarity. Declared so this
   // non-strict object refuses it instead of stripping it and running the default.
@@ -124957,8 +125034,8 @@ var gestureDragTool = {
     completedMsg: ({ params }) => `Dragged from (${Math.round(params.fromX * 100)}%, ${Math.round(params.fromY * 100)}%) to (${Math.round(params.toX * 100)}%, ${Math.round(params.toY * 100)}%)`,
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to drag: ${failureSignal2.error_code}`
   },
-  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.
+  description: `Press the left mouse button at a start point, move to an end point, and release: 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; use gesture-scroll for lists/pages. Chromium only: 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.`,
   searchHint: "drag drop slider mouse press move release chromium select",
   zodSchema: zodSchema20,
@@ -125271,7 +125348,7 @@ var gesturePinchTool = {
     completedMsg: ({ params }) => `Pinched ${params.endDistance > params.startDistance ? "out" : "in"} at (${Math.round(params.centerX * 100)}%, ${Math.round(params.centerY * 100)}%)`,
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to pinch: ${failureSignal2.error_code}`
   },
-  description: `Execute a pinch-to-zoom gesture by moving two fingers toward or away from a center point to change the scale of on-screen content. All positions and distances are normalized 0.0\u20131.0 (fractions of screen width/height, not pixels)\u2014same coordinate space as gesture-tap and gesture-swipe.
+  description: `Execute a pinch-to-zoom gesture by moving two fingers toward or away from a center point to change the scale of on-screen content. All positions and distances are normalized 0.0\u20131.0 (fractions of screen width/height, not pixels), same coordinate space as gesture-tap and gesture-swipe.
 startDistance > endDistance = pinch in (zoom out). startDistance < endDistance = pinch out (zoom in).
 Typical values: startDistance 0.2, endDistance 0.6 for a zoom-in pinch at screen center.
 Auto-generates interpolated frames at ~60fps. The angle parameter controls the axis (0 = horizontal, 90 = vertical). Optional endCenterX/endCenterY drift the centroid linearly over the gesture (omitted = fixed center).
@@ -125325,13 +125402,13 @@ var zodSchema23 = external_exports.object({
     "Center of rotation, vertical: normalized 0.0\u20131.0 (fraction of screen height, not pixels)"
   ),
   radius: external_exports.number().optional().describe(
-    "Distance from center to each finger: normalized 0.0\u20131.0 (fraction of screen, not pixels). E.g. 0.15 = fingers placed 15% of screen away from center. One value for both axes, so on a non-square screen the orbit is a physical ellipse \u2014 pass radiusX+radiusY instead for a true circle. Required unless radiusX and radiusY are given."
+    "Distance from center to each finger: normalized 0.0\u20131.0 (fraction of screen, not pixels). E.g. 0.15 = fingers placed 15% of screen away from center. One value for both axes, so on a non-square screen the orbit is a physical ellipse; pass radiusX+radiusY instead for a true circle. Required unless radiusX and radiusY are given."
   ),
   radiusX: external_exports.number().optional().describe(
-    "Per-axis finger distance, horizontal: normalized 0.0\u20131.0 fraction of screen WIDTH. Give both radiusX and radiusY (they override radius) with radiusX\xB7screenWidth = radiusY\xB7screenHeight for a physically circular orbit \u2014 constant finger separation, no pinch coupled into the turn."
+    "Per-axis finger distance, horizontal: normalized 0.0\u20131.0 fraction of screen WIDTH. Give both radiusX and radiusY (they override radius) with radiusX\xB7screenWidth = radiusY\xB7screenHeight for a physically circular orbit: constant finger separation, no pinch coupled into the turn."
   ),
   radiusY: external_exports.number().optional().describe(
-    "Per-axis finger distance, vertical: normalized 0.0\u20131.0 fraction of screen HEIGHT. Always paired with radiusX \u2014 see radiusX."
+    "Per-axis finger distance, vertical: normalized 0.0\u20131.0 fraction of screen HEIGHT. Always paired with radiusX; see radiusX."
   ),
   startAngle: external_exports.number().describe("Starting angle in degrees (0 = right, 90 = down)"),
   endAngle: external_exports.number().describe("Ending angle in degrees. endAngle > startAngle = clockwise."),
@@ -125361,7 +125438,7 @@ var gestureRotateTool = {
     },
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to rotate gesture: ${failureSignal2.error_code}`
   },
-  description: `Send a two-finger circular arc gesture to rotate on-screen content by a specified angle. Two fingers are placed opposite each other at a fixed radius from the center, then swept from startAngle to endAngle degrees. All positions and radii are normalized 0.0\u20131.0 (fractions of screen width/height, not pixels)\u2014same coordinate space as gesture-tap and gesture-swipe.
+  description: `Send a two-finger circular arc gesture to rotate on-screen content by a specified angle. Two fingers are placed opposite each other at a fixed radius from the center, then swept from startAngle to endAngle degrees. All positions and radii are normalized 0.0\u20131.0 (fractions of screen width/height, not pixels), same coordinate space as gesture-tap and gesture-swipe.
 endAngle > startAngle = clockwise rotation. Typical values: radius 0.15, startAngle 0, endAngle 90 for a 90\xB0 clockwise turn. A single radius applies to both axes, so on a non-square screen it traces a physical ellipse (finger separation varies through the turn); pass radiusX+radiusY (fractions of width/height with radiusX\xB7width = radiusY\xB7height) for a physically circular orbit instead.
 Auto-generates interpolated frames at ~60fps.
 Unlike gesture-pinch which moves fingers linearly to zoom, this orbits fingers in an arc to change orientation.
@@ -126162,7 +126239,7 @@ var zodSchema25 = external_exports.object({
     "Target device id from `list-devices` (iOS UDID, Android serial, Vega serial, or Chromium id)."
   ),
   text: external_exports.string().optional().describe(
-    'Text to type character by character. Cannot be combined with `key` in one call \u2014 one call per action; to type and then press a key, put two `keyboard` steps in one `run-sequence`. Handles uppercase and common punctuation. To type a credential without its plaintext ever entering your context, use a secret placeholder: `{{secret:<NAME>}}` \u2014 e.g. text: "{{secret:APP_PASSWORD}}". The value is resolved on the machine running the tool-server, from the first source that defines the name: the `ARGENT_SECRET_<NAME>` environment variable, `.argent/secrets.env` in the project, the project\'s `.env.local` / `.env` (only their `ARGENT_SECRET_`-prefixed keys), then `~/.argent/secrets.env`. Nothing else on the host is reachable. Placeholders can be embedded in longer text and are never echoed back resolved. If the secret you need is not set, the failure lists the available names and every source it looked in \u2014 ask the user to add it to one of them (a secrets file applies immediately; an env var needs a restart), NEVER ask the user to paste the secret value into the conversation.'
+    'Text to type character by character. Cannot be combined with `key` in one call (one call per action); to type and then press a key, put two `keyboard` steps in one `run-sequence`. Handles uppercase and common punctuation. To type a credential without its plaintext ever entering your context, use a secret placeholder: `{{secret:<NAME>}}`, e.g. text: "{{secret:APP_PASSWORD}}". The value is resolved on the machine running the tool-server, from the first source that defines the name: the `ARGENT_SECRET_<NAME>` environment variable, `.argent/secrets.env` in the project, the project\'s `.env.local` / `.env` (only their `ARGENT_SECRET_`-prefixed keys), then `~/.argent/secrets.env`. Nothing else on the host is reachable. Placeholders can be embedded in longer text and are never echoed back resolved. If the secret you need is not set, the failure lists the available names and every source it looked in; ask the user to add it to one of them (a secrets file applies immediately; an env var needs a restart), NEVER ask the user to paste the secret value into the conversation.'
   ),
   key: external_exports.string().optional().describe(
     "Named key to press: enter, escape, backspace, tab, space, arrow-up, arrow-down, arrow-left, arrow-right, f1-f12. Cannot be combined with `text` in one call: one call per action; to type and then press a key, put two `keyboard` steps in one `run-sequence`. Not supported on TV targets; move focus with `tv-remote` (up/down/left/right) instead. Physical iOS: only `enter` and `backspace`."
@@ -126210,11 +126287,11 @@ function createKeyboardTool(registry2) {
     description: `Type text or press special keys on the device (iOS simulator, Android emulator or device, Chromium app, Vega Virtual Device, or Apple TV / Android TV) using keyboard events.
 Use when you need to enter text or trigger a named key such as enter, escape, or arrow keys. On Vega and Apple TV / Android TV, prefer the remote tools for D-pad navigation; use keyboard to type into a focused text field (e.g. a search or login box).
 Returns { typed: string, keys: number }. On physical iOS, reactivated: true = app was re-fronted; re-describe. Fails if text and key are both given in one call (rejected before anything is typed), if an unsupported key name is provided, or if the device's input backend is not reachable.
-A failure is not rolled back. An unsupported key name is always rejected before anything is sent. Un-typeable text is not: the iOS simulator and Chromium reject it mid-string and leave the characters before it in the field (Android, Vega and TV targets check the whole string up front). A transport failure partway also leaves the text already sent. On a retry, read the field's actual contents \u2014 do not assume it is unchanged.
-- text: types a string (supports uppercase, digits, common punctuation). To type a credential, use \`{{secret:<NAME>}}\` \u2014 resolved server-side from the \`ARGENT_SECRET_<NAME>\` env var or an argent secrets file (\`.argent/secrets.env\` in the project, \`~/.argent/secrets.env\`, or an \`ARGENT_SECRET_\`-prefixed key in the project's \`.env\`/\`.env.local\`), so the plaintext never enters agent context; the result echoes the placeholder, not the value, and the after-typing auto-screenshot is skipped. To submit after typing a secret, put both steps in ONE \`run-sequence\` \u2014 that keeps the skip covering the Enter, which a second bare \`keyboard\` call would not.
+A failure is not rolled back. An unsupported key name is always rejected before anything is sent. Un-typeable text is not: the iOS simulator and Chromium reject it mid-string and leave the characters before it in the field (Android, Vega and TV targets check the whole string up front). A transport failure partway also leaves the text already sent. On a retry, read the field's actual contents; do not assume it is unchanged.
+- text: types a string (supports uppercase, digits, common punctuation). To type a credential, use \`{{secret:<NAME>}}\`, resolved server-side from the \`ARGENT_SECRET_<NAME>\` env var or an argent secrets file (\`.argent/secrets.env\` in the project, \`~/.argent/secrets.env\`, or an \`ARGENT_SECRET_\`-prefixed key in the project's \`.env\`/\`.env.local\`), so the plaintext never enters agent context; the result echoes the placeholder, not the value, and the after-typing auto-screenshot is skipped. To submit after typing a secret, put both steps in ONE \`run-sequence\`: that keeps the skip covering the Enter, which a second bare \`keyboard\` call would not.
 - key: presses a single named key (enter, escape, backspace, tab, arrow-up/down/left/right, f1-f12). NOT supported on TV targets; move focus with \`tv-remote\` instead. Physical iOS: only \`enter\` and \`backspace\`.
-On a TV target (runtimeKind 'tv') only \`text\` applies \u2014 focus a text field first (with \`tv-remote\`), then type into it (injected HID keyboard on Apple TV, \`adb input text\` on Android TV).
-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.`,
+On a TV target (runtimeKind 'tv') only \`text\` applies. Focus a text field first (with \`tv-remote\`), then type into it (injected HID keyboard on Apple TV, \`adb input text\` on Android TV).
+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\` ({ text: "hello" } then { key: "enter" }), which also keeps it to a single round-trip.`,
     zodSchema: zodSchema25,
     capability: capability17,
     alwaysLoad: true,
@@ -126279,7 +126356,7 @@ var pasteZodSchema = external_exports.object({
     "Target device id from `list-devices` (iOS simulator UDID or Android emulator serial)."
   ),
   text: external_exports.string().min(1).describe(
-    "Text to put on the device clipboard and paste into the focused field. Supports `{{secret:<NAME>}}` placeholders, resolved on the tool-server from the `ARGENT_SECRET_<NAME>` environment variable or an argent secrets file \u2014 the same sources as `keyboard` \u2014 so a credential never enters your context. If the secret is not set, the failure lists the available names and every source it looked in; ask the user to add it there, NEVER ask for the value in the conversation."
+    "Text to put on the device clipboard and paste into the focused field. Supports `{{secret:<NAME>}}` placeholders, resolved on the tool-server from the `ARGENT_SECRET_<NAME>` environment variable or an argent secrets file (the same sources as `keyboard`), so a credential never enters your context. If the secret is not set, the failure lists the available names and every source it looked in; ask the user to add it there, NEVER ask for the value in the conversation."
   )
 });
 
@@ -126425,7 +126502,7 @@ function createPasteTool(registry2) {
       failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to paste text: ${failureSignal2.error_code}`
     },
     description: `Paste text into the focused field: puts \`text\` on the DEVICE clipboard, then triggers the platform's paste shortcut (iOS simulator, Android emulator).
-Do NOT use this in place of \`keyboard\`. \`keyboard\` types as a user would and is the default for all text entry; use \`paste\` only where a real user would paste \u2014 a 2FA/OTP code copied from another app, a long link or token, or when testing the app's own paste handling.
+Do NOT use this in place of \`keyboard\`. \`keyboard\` types as a user would and is the default for all text entry; use \`paste\` only where a real user would paste: a 2FA/OTP code copied from another app, a long link or token, or when testing the app's own paste handling.
 Tap the field first so it has focus. Returns { pasted: true }, plus via: "keyboard" when a secret was typed instead of pasted. Fails on a TV target, when the device clipboard cannot be set, when a secret that has to be typed holds a character that cannot be typed, or when the simulator-server build lacks clipboard support.
 Supports \`{{secret:<NAME>}}\` placeholders like \`keyboard\`; the value is never echoed back.`,
     searchHint: "paste clipboard pasteboard otp 2fa code fill field",
@@ -126466,7 +126543,7 @@ var rotateTool = {
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to rotate device: ${failureSignal2.error_code}`
   },
   description: `Set the device orientation to Portrait, LandscapeLeft, LandscapeRight, or PortraitUpsideDown.
-Use to test layout in a different orientation. Re-run \`describe\` afterwards \u2014 frame coordinates change with the orientation.
+Use to test layout in a different orientation. Re-run \`describe\` afterwards: frame coordinates change with the orientation.
 On an unfolded foldable iOS simulator (the iPhone Duo), the value sets the orientation of the device, not of the UI: \`Portrait\` gives a landscape UI and \`LandscapeLeft\` gives a portrait UI. To fold or unfold the device, use \`fold\`.
 Returns { orientation }. Fails if the target device is not booted.`,
   zodSchema: zodSchema26,
@@ -126931,7 +127008,7 @@ var shakeTool = {
   },
   description: `Shake the device (iOS simulator or Android emulator).
 Use to trigger anything bound to the shake gesture: iOS's "Undo Typing" / "Redo Typing" prompt in a text field, React Native's developer menu in a debug build, or an app's own shake-to-report handler.
-iOS delivers one discrete shake per gesture (the same motion event a physical device raises). Android has no OS-level shake event \u2014 the accelerometer is driven through a burst of hard direction changes so app-side detectors fire, and the resting orientation is restored afterwards.
+iOS delivers one discrete shake per gesture (the same motion event a physical device raises). Android has no OS-level shake event: the accelerometer is driven through a burst of hard direction changes so app-side detectors fire, and the resting orientation is restored afterwards.
 Set \`count\` above 1 when a detector needs sustained motion before it triggers.
 Returns { shaken: true, count }.
 Works on local and remote (sim-remote) iOS simulators.
@@ -127189,7 +127266,7 @@ var buttonSchema = external_exports.preprocess(
   },
   external_exports.union([external_exports.enum(BUTTONS), external_exports.array(external_exports.enum(BUTTONS)).min(1).max(64)])
 ).describe(
-  'A single TV-remote button, or a path of them run in one call. Buttons: up/down/left/right (D-pad), select (OK), back, home, menu, playPause, rewind, fastForward, next, previous, volumeUp, volumeDown, mute. The media-transport and volume keys work on Android TV and Vega; on the Apple TV simulator they are rejected (its HID stack ignores them) \u2014 the D-pad/select/back/menu/home/playPause core works on all three. For multi-step navigation pass an array, e.g. ["up","right","right","select"] \u2014 strongly prefer this over multiple `tv-remote` calls: the whole path runs in a single call.'
+  'A single TV-remote button, or a path of them run in one call. Buttons: up/down/left/right (D-pad), select (OK), back, home, menu, playPause, rewind, fastForward, next, previous, volumeUp, volumeDown, mute. The media-transport and volume keys work on Android TV and Vega; on the Apple TV simulator they are rejected (its HID stack ignores them). The D-pad/select/back/menu/home/playPause core works on all three. For multi-step navigation pass an array, e.g. ["up","right","right","select"]; strongly prefer this over multiple `tv-remote` calls: the whole path runs in a single call.'
 );
 var zodSchema28 = external_exports.object({
   udid: external_exports.string().describe("Target TV device id from `list-devices` (Apple TV, Android TV, or Vega)."),
@@ -127211,10 +127288,10 @@ function createTvRemoteTool(registry2) {
       completedMsg: ({ params }) => `Pressed ${params.button} on TV remote${(params.repeat ?? 1) > 1 ? ` ${params.repeat} times` : ""}`,
       failedMsg: ({ params, failureSignal: failureSignal2 }) => `Failed to press ${params.button} on TV remote: ${failureSignal2.error_code}`
     },
-    description: `Press a TV remote / D-pad button (or a whole path of them) on a TV device \u2014 Apple TV (tvOS), Android TV (leanback), or Vega (Fire TV).
-A TV is navigated with a directional remote, not touch \u2014 use this instead of gesture-tap/swipe (which do not apply on a TV). Move focus with up/down/left/right, confirm with select, go back with back/menu, exit with home, and use playPause/rewind/fastForward/next/previous/volumeUp/volumeDown/mute for the corresponding remote keys. (On the Apple TV simulator the media-transport and volume keys are rejected \u2014 its HID stack ignores them; they work on Android TV and Vega.)
+    description: `Press a TV remote / D-pad button (or a whole path of them) on a TV device: Apple TV (tvOS), Android TV (leanback), or Vega (Fire TV).
+A TV is navigated with a directional remote, not touch. Use this instead of gesture-tap/swipe (which do not apply on a TV). Move focus with up/down/left/right, confirm with select, go back with back/menu, exit with home, and use playPause/rewind/fastForward/next/previous/volumeUp/volumeDown/mute for the corresponding remote keys. (On the Apple TV simulator the media-transport and volume keys are rejected (its HID stack ignores them); they work on Android TV and Vega.)
 Single press: { button: "down" }. Repeat the same button: { button: "down", repeat: 3 }.
-Multi-step navigation: pass a path as { button: ["up","right","right","select"] } \u2014 it runs in one tool call, far cheaper than separate presses.
+Multi-step navigation: pass a path as { button: ["up","right","right","select"] }. 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 }.`,
     // A path (≤64 buttons) × repeat (≤50) flattens to thousands of presses, sent
@@ -127267,9 +127344,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 zodSchema81 = registry2.getTool(toolId)?.zodSchema;
-  if (!zodSchema81) return void 0;
-  const parsed = zodSchema81.safeParse(dispatchedArgs ?? {});
+  const zodSchema82 = registry2.getTool(toolId)?.zodSchema;
+  if (!zodSchema82) return void 0;
+  const parsed = zodSchema82.safeParse(dispatchedArgs ?? {});
   if (parsed.success) return void 0;
   return `Invalid params for tool "${toolId}": ${describeParamIssues(parsed.error, authoredArgs)}`;
 }
@@ -133566,11 +133643,11 @@ var DEFAULT_POLL_INTERVAL_MS = 400;
 var zodSchema29 = external_exports.object({
   udid: external_exports.string().min(1).describe("Target device id from `list-devices` (iOS UDID, Android serial, or Chromium id)."),
   condition: external_exports.enum(["exists", "visible", "hidden", "text"]).describe(
-    "What to wait for. `exists`: selector is anywhere in the tree. `visible`: selector is present with a non-zero on-screen frame. `hidden`: selector is absent or zero-area. `text`: the first visible match in reading order (topmost), falling back to the first match overall if none is visible, contains (or, with textMatch `equals`, exactly matches) expectedText \u2014 if a loose selector hits several elements, only that one is checked, so narrow it to target the intended element."
+    "What to wait for. `exists`: selector is anywhere in the tree. `visible`: selector is present with a non-zero on-screen frame. `hidden`: selector is absent or zero-area. `text`: the first visible match in reading order (topmost), falling back to the first match overall if none is visible, contains (or, with textMatch `equals`, exactly matches) expectedText. If a loose selector hits several elements, only that one is checked, so narrow it to target the intended element."
   ),
   selector: selectorSchema.describe("Element to match (text / identifier / role)."),
   expectedText: external_exports.string().min(1).optional().describe(
-    "For condition `text`: the string the first visible matched element (topmost in reading order; the first match overall if none is visible) must contain (default) or equal \u2014 see `textMatch`. Case-insensitive."
+    "For condition `text`: the string the first visible matched element (topmost in reading order; the first match overall if none is visible) must contain (default) or equal (see `textMatch`). Case-insensitive."
   ),
   textMatch: external_exports.enum(["contains", "equals"]).optional().describe(
     "For condition `text`: how expectedText is compared. `contains` (default) is a case-insensitive substring; `equals` is a case-insensitive full-string match."
@@ -133680,13 +133757,13 @@ function createAwaitUiElementTool(registry2) {
     description: `Block until a UI element reaches an expected state or a timeout elapses, so you don't have to poll screenshot/describe yourself.
 
 Conditions:
-  exists   \u2014 the selector matches an element anywhere in the tree.
-  visible  \u2014 the selector matches an element with a non-zero on-screen frame.
-  hidden   \u2014 the selector matches nothing, or only a zero-area element (e.g. a spinner that disappeared).
-  text     \u2014 the first VISIBLE match in reading order (topmost, then leftmost; falling back to the first match
+  exists:    the selector matches an element anywhere in the tree.
+  visible:   the selector matches an element with a non-zero on-screen frame.
+  hidden:    the selector matches nothing, or only a zero-area element (e.g. a spinner that disappeared).
+  text:      the first VISIBLE match in reading order (topmost, then leftmost; falling back to the first match
              overall if none is visible) contains expectedText (case-insensitive substring), or exactly matches
              it when textMatch is \`equals\`. A loose selector can match several elements; only that one is
-             inspected, so if a different match is the one holding the text the wait still reports failure \u2014
+             inspected, so if a different match is the one holding the text the wait still reports failure;
              narrow the selector to target it.
 
 The selector is { text?, identifier?, role? }; every provided field must match. text and role match as
@@ -133697,10 +133774,10 @@ It polls the same accessibility / DOM tree as \`describe\`
 Vega automation toolkit) every pollIntervalMs
 (default ${DEFAULT_POLL_INTERVAL_MS}ms) until timeoutMs (default ${DEFAULT_TIMEOUT_MS3}ms).
 
-Returns { success: boolean, elapsed: number, note?, cause? } \u2014 success=false means the wait ended without the
-condition holding, which is not always a verdict on the condition: \`cause\` says which it was \u2014 \`unmet\` (the tree
+Returns { success: boolean, elapsed: number, note?, cause? }. success=false means the wait ended without the
+condition holding, which is not always a verdict on the condition: \`cause\` says which it was: \`unmet\` (the tree
 was read and the condition was false there), \`unreadable\` (no trustworthy read, so nothing was judged) or
-\`cancelled\` \u2014 and \`note\` describes what was seen. Only \`unmet\` licenses rewriting the check. Use this after a
+\`cancelled\`. \`note\` describes what was seen. Only \`unmet\` licenses rewriting the check. Use this after a
 tap/navigation to wait for the next screen, or before tapping an element that appears asynchronously.`,
     alwaysLoad: true,
     searchHint: "wait await poll until visible hidden exists text appears disappears timeout element condition settle",
@@ -133796,12 +133873,12 @@ var ALLOWED_TOOLS = /* @__PURE__ */ new Set([
 ]);
 var zodSchema30 = external_exports.object({
   udid: external_exports.string().describe(
-    "Target device id from `list-devices` (iOS UDID, Android serial, Vega serial, or Chromium id) \u2014 shared across all steps."
+    "Target device id from `list-devices` (iOS UDID, Android serial, Vega serial, or Chromium id), shared across all steps."
   ),
   steps: external_exports.array(
     external_exports.object({
       tool: external_exports.string().describe(
-        "Tool name \u2014 one of: gesture-tap, gesture-swipe, gesture-scroll, gesture-drag, gesture-custom, gesture-pinch, gesture-rotate, button, keyboard, paste, rotate, shake, fold, tv-remote, await-ui-element. On a TV target (Apple TV / Android TV / Vega) use tv-remote (remote presses) and keyboard (text)."
+        "Tool name, one of: gesture-tap, gesture-swipe, gesture-scroll, gesture-drag, gesture-custom, gesture-pinch, gesture-rotate, button, keyboard, paste, rotate, shake, fold, tv-remote, await-ui-element. On a TV target (Apple TV / Android TV / Vega) use tv-remote (remote presses) and keyboard (text)."
       ),
       args: external_exports.record(external_exports.string(), external_exports.unknown()).describe("Tool arguments (excluding udid, which is injected automatically)"),
       delayMs: external_exports.number().optional().describe(
@@ -133834,7 +133911,7 @@ On a physical iOS device only gesture-tap, gesture-swipe, gesture-custom, button
 Use when you need sequential actions and do NOT need to observe the screen between them
 (e.g. scrolling multiple times, typing then pressing enter, rotating back and forth).
 Returns { completed, total, steps } with per-step results. Fails if an unrecognised tool name is used in a step (error returned at that step, execution stops).
-One screenshot is captured automatically after the whole sequence (not per step) \u2014 call screenshot separately only for a baseline BEFORE it, or to observe an intermediate step.
+One screenshot is captured automatically after the whole sequence (not per step). Call screenshot separately only for a baseline BEFORE it, or to observe an intermediate step.
 That single capture is also why a secret belongs in this call rather than in two bare ones: the skip is decided from the whole request, so a \`{{secret:...}}\` in any step suppresses the capture that would otherwise follow the submit.
 
 ONLY use this when every step is known in advance. If any step depends on the
@@ -133852,41 +133929,41 @@ Allowed tools and their args (udid is auto-injected, do NOT include it in args):
   gesture-rotate: { centerX: number, centerY: number, radius?: number, radiusX?: number, radiusY?: number, startAngle: number, endAngle: number, durationMs?: number }  [ios/android]
   button:         { button: "home"|"back"|"power"|"volumeUp"|"volumeDown"|"appSwitch"|"actionButton" }                  [ios/android]
   keyboard:       { text?: string, key?: string, delayMs?: number }  (text OR key per step, never both; TV: text only)  [ios/android/chromium/vega/tv]
-                  text supports {{secret:<NAME>}} placeholders, resolved server-side from ARGENT_SECRET_<NAME> env vars or an argent secrets file \u2014 credentials never enter agent context
-  paste:          { text: string }  (device clipboard + paste shortcut; only where a user would paste, e.g. an OTP \u2014 keyboard otherwise)   [ios sim/android emu]
+                  text supports {{secret:<NAME>}} placeholders, resolved server-side from ARGENT_SECRET_<NAME> env vars or an argent secrets file; credentials never enter agent context
+  paste:          { text: string }  (device clipboard + paste shortcut; only where a user would paste, e.g. an OTP; keyboard otherwise)   [ios sim/android emu]
   rotate:         { orientation: "Portrait"|"LandscapeLeft"|"LandscapeRight"|"PortraitUpsideDown" }                     [ios/android]
   shake:          { count?: number }                                                                                    [ios sim/android emu]
   fold:           { posture?: "closed"|"half-open"|"open", angle?: 0-180 }  (one of posture/angle; the next step lands on the new panel, whose coordinates are different)  [foldable ios sim]
   tv-remote:      { button: <remote button | array of them>, repeat?: number }                                          [apple tv/android tv/vega]
-                  buttons: up/down/left/right/select/back/home/menu/playPause (+ rewind/fastForward/next/previous/volumeUp/volumeDown/mute \u2014 work on Android TV and Vega; rejected on the Apple TV simulator)
+                  buttons: up/down/left/right/select/back/home/menu/playPause (+ rewind/fastForward/next/previous/volumeUp/volumeDown/mute work on Android TV and Vega; rejected on the Apple TV simulator)
   await-ui-element: { condition: "exists"|"visible"|"hidden"|"text", selector: {text?,identifier?,role?}, expectedText?, timeoutMs?, pollIntervalMs? }  [ios/android/chromium]
 
-Example \u2014 scroll down three times (use gesture-scroll with positive deltaY on Chromium):
+Example: scroll down three times (use gesture-scroll with positive deltaY on Chromium):
   { "udid": "<UDID>", "steps": [
     { "tool": "gesture-swipe", "args": { "fromX": 0.5, "fromY": 0.7, "toX": 0.5, "toY": 0.3 } },
     { "tool": "gesture-swipe", "args": { "fromX": 0.5, "fromY": 0.7, "toX": 0.5, "toY": 0.3 } },
     { "tool": "gesture-swipe", "args": { "fromX": 0.5, "fromY": 0.7, "toX": 0.5, "toY": 0.3 } }
   ]}
 
-Example \u2014 type text and submit (two keyboard steps; one call cannot carry both):
+Example: type text and submit (two keyboard steps; one call cannot carry both):
   { "udid": "<UDID>", "steps": [
     { "tool": "keyboard", "args": { "text": "hello world" } },
     { "tool": "keyboard", "args": { "key": "enter" } }
   ]}
 
-Example \u2014 TV: move focus right twice then activate (one tv-remote step with a path is cheaper):
+Example (TV): move focus right twice then activate (one tv-remote step with a path is cheaper):
   { "udid": "<TV-TARGET-ID>", "steps": [
     { "tool": "tv-remote", "args": { "button": ["right", "right", "select"] } }
   ]}
 
-Example \u2014 tap, wait for the next screen's element, then tap it:
+Example: tap, wait for the next screen's element, then tap it:
   { "udid": "<UDID>", "steps": [
     { "tool": "gesture-tap", "args": { "x": 0.5, "y": 0.9 } },
     { "tool": "await-ui-element", "args": { "condition": "visible", "selector": { "text": "Continue" } } },
     { "tool": "gesture-tap", "args": { "x": 0.5, "y": 0.5 } }
   ]}
 If the await-ui-element condition is not met before its timeout, the sequence stops there and the
-following steps do NOT run \u2014 so the tap above only fires once "Continue" is actually on screen.
+following steps do NOT run, so the tap above only fires once "Continue" is actually on screen.
 
 Stops on the first error (or unmet await-ui-element condition) and returns partial results.`,
     alwaysLoad: true,
@@ -133993,7 +134070,7 @@ function debuggerServiceRef(params) {
 var zodSchema31 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
-    "Device id from list-devices: iOS simulator UDID, Android serial, Vega serial (amazon-...), or Chromium device id (chromium-cdp-<port>). Pass this SAME id as device_id to every subsequent debugger-* call to pin them to this device. The returned logicalDeviceId is informational (Metro's own per-connection handle, absent on Vega); you do not switch to it \u2014 forwarding it still resolves here, but the list-devices id is the stable one."
+    "Device id from list-devices: iOS simulator UDID, Android serial, Vega serial (amazon-...), or Chromium device id (chromium-cdp-<port>). Pass this SAME id as device_id to every subsequent debugger-* call to pin them to this device. The returned logicalDeviceId is informational (Metro's own per-connection handle, absent on Vega); you do not switch to it. Forwarding it still resolves here, but the list-devices id is the stable one."
   )
 });
 var debuggerConnectTool = {
@@ -134004,7 +134081,7 @@ var debuggerConnectTool = {
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to connect JavaScript debugger: ${failureSignal2.error_code}`
   },
   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.
+iOS / Android / Vega: connects to Metro's CDP endpoint on the given port. Chromium: re-uses the page CDP session opened by boot-device; 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, 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,
@@ -134116,7 +134193,7 @@ function isDebuggerNotConnectedResult(toolId, result) {
 var zodSchema32 = 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, Android serial, Vega serial, or Chromium device id). The logicalDeviceId debugger-connect returns also resolves here, but prefer the stable list-devices id."
+    "Device id from list-devices: the SAME id you passed to debugger-connect (iOS simulator UDID, Android serial, Vega serial, or Chromium device id). The logicalDeviceId debugger-connect returns also resolves here, but prefer the stable list-devices id."
   )
 });
 function createDebuggerStatusTool(registry2) {
@@ -134128,9 +134205,9 @@ function createDebuggerStatusTool(registry2) {
       failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to check JavaScript debugger: ${failureSignal2.error_code}`
     },
     description: `Get JS runtime debugger connection status and diagnostic info.
-Use when you need to verify connectivity before using other debugger tools. Never fails when the runtime is simply unreachable \u2014 it returns a discriminated result instead:
-- { status: "connected", ... } with port, projectRoot (empty on Chromium and on legacy Metro, e.g. Vega), deviceName, appName, logicalDeviceId (absent on Vega), isNewDebugger (false on the legacy inspector), connected flag, loadedScripts count, and sourceMapReady (always true \u2014 waits for pending source maps before returning; no-op on Chromium).
-- { status: "not_connected", connected: false, reason, detail, guidance } (port omitted on Chromium) when Metro is not running (reason "metro_not_running"), no app is attached ("no_app_connected"), the device_id matches no target ("device_mismatch"), the CDP endpoint is unreachable or answered malformed ("cdp_unreachable"), the runtime accepted the connection but never answered ("runtime_unresponsive"), the cached connection went stale ("stale_connection"), or a reconnect is in flight ("reconnecting"). Follow the guidance field \u2014 do not retry in a loop.`,
+Use when you need to verify connectivity before using other debugger tools. Never fails when the runtime is simply unreachable: it returns a discriminated result instead:
+- { status: "connected", ... } with port, projectRoot (empty on Chromium and on legacy Metro, e.g. Vega), deviceName, appName, logicalDeviceId (absent on Vega), isNewDebugger (false on the legacy inspector), connected flag, loadedScripts count, and sourceMapReady (always true: waits for pending source maps before returning; no-op on Chromium).
+- { status: "not_connected", connected: false, reason, detail, guidance } (port omitted on Chromium) when Metro is not running (reason "metro_not_running"), no app is attached ("no_app_connected"), the device_id matches no target ("device_mismatch"), the CDP endpoint is unreachable or answered malformed ("cdp_unreachable"), the runtime accepted the connection but never answered ("runtime_unresponsive"), the cached connection went stale ("stale_connection"), or a reconnect is in flight ("reconnecting"). Follow the guidance field; do not retry in a loop.`,
     zodSchema: zodSchema32,
     capability: DEBUGGER_TOOL_CAPABILITY,
     // Resolved manually in execute so a not-connected precondition becomes a
@@ -134191,7 +134268,7 @@ init_src2();
 var zodSchema33 = 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, Android serial, Vega serial, or Chromium device id). The logicalDeviceId debugger-connect returns also resolves here, but prefer the stable list-devices id."
+    "Device id from list-devices: the SAME id you passed to debugger-connect (iOS simulator UDID, Android serial, Vega serial, or Chromium device id). The logicalDeviceId debugger-connect returns also resolves here, but prefer the stable list-devices id."
   ),
   expression: external_exports.string().describe("JavaScript expression to evaluate in the app runtime")
 });
@@ -134202,8 +134279,8 @@ var debuggerEvaluateTool = {
     completedMsg: () => "Ran JavaScript in the app",
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to run JavaScript in the app: ${failureSignal2.error_code}`
   },
-  description: `Execute arbitrary JavaScript in the app's JS runtime via CDP \u2014 Hermes on iOS / Android / Vega, V8 on Chromium.
-Returns the evaluation result as a JSON-serializable value, along with deviceName, appName, and logicalDeviceId for context. Use when you need to read app state, call app functions, or test logic at runtime. The result is serialized by value, so cyclic objects (many RN runtime values \u2014 fiber nodes, navigation refs, global \u2014 are cyclic) fail with a serialization error rather than returning silently. Fails if the expression throws or the runtime is not connected.`,
+  description: `Execute arbitrary JavaScript in the app's JS runtime via CDP: Hermes on iOS / Android / Vega, V8 on Chromium.
+Returns the evaluation result as a JSON-serializable value, along with deviceName, appName, and logicalDeviceId for context. Use when you need to read app state, call app functions, or test logic at runtime. The result is serialized by value, so cyclic objects (many RN runtime values, such as fiber nodes, navigation refs and global, are cyclic) fail with a serialization error rather than returning silently. Fails if the expression throws or the runtime is not connected.`,
   zodSchema: zodSchema33,
   capability: DEBUGGER_TOOL_CAPABILITY,
   services: (params) => ({
@@ -134244,7 +134321,7 @@ init_src2();
 var zodSchema34 = 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)."
+    "Device id from list-devices: the SAME id you passed to debugger-connect (iOS simulator UDID or Android serial)."
   )
 });
 var debuggerReloadMetroTool = {
@@ -135196,7 +135273,7 @@ async function readTapAxes(registry2, app) {
 var zodSchema35 = 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)."
+    "Device id from list-devices: the SAME id you passed to debugger-connect (iOS simulator UDID or Android serial)."
   ),
   udid: external_exports.string().optional().describe(
     "iOS simulator UDID from list-devices. Pass it when device_id is a logicalDeviceId (two or more devices share one Metro), so that the tap coordinates of a landscape UI are on the screen's axes. Give the UDID of the simulator that shows the app."
@@ -135220,11 +135297,11 @@ function createDebuggerComponentTreeTool(registry2) {
       failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to read React component tree: ${failureSignal2.error_code}`
     },
     description: `Fetch the current screen of a running React Native app as a compact component text tree.
-Only shows on-screen components with unique positions \u2014 off-screen (scrolled) content,
+Only shows on-screen components with unique positions. Off-screen (scrolled) content,
 full-screen transparent wrappers, and implementation-detail components are pruned.
 
 Each visible component is listed with its name, text content, and normalized
-tap coordinates in [0,1] space (fractions of the screen, not pixels \u2014 same space as tap/swipe/gesture).
+tap coordinates in [0,1] space (fractions of the screen, not pixels; same space as tap/swipe/gesture).
 On an iOS simulator with a landscape UI (a rotated device, or an unfolded foldable), the tap
 coordinates are on the screen's axes, which the gesture tools use. When two or more devices share
 one Metro, pass the simulator's udid too. If the result says that the orientation could not be
@@ -135723,7 +135800,7 @@ function filterInspectItems(items, includeSkipped = false) {
 var zodSchema36 = 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)."
+    "Device id from list-devices: the SAME id you passed to debugger-connect (iOS simulator UDID or Android serial)."
   ),
   x: external_exports.coerce.number().describe("Logical X coordinate on device screen"),
   y: external_exports.coerce.number().describe("Logical Y coordinate on device screen"),
@@ -135732,7 +135809,7 @@ var zodSchema36 = external_exports.object({
     "When true, resolves bundled frame locations to original source files via Metro symbolication and includes a code fragment. When false, returns the raw bundled frame info (file, line, column) without symbolication or source reading."
   ),
   maxItems: external_exports.coerce.number().default(35).describe(
-    "Maximum number of hierarchy items to return, counted from the bottom (most specific component first). The hierarchy walks from the tapped element up to the root \u2014 the first items are the most relevant for editing. Increase to 70+ if you need to understand the broader navigation/screen structure."
+    "Maximum number of hierarchy items to return, counted from the bottom (most specific component first). The hierarchy walks from the tapped element up to the root, so the first items are the most relevant for editing. Increase to 70+ if you need to understand the broader navigation/screen structure."
   ),
   includeSkipped: external_exports.boolean().default(false).describe(
     "When true, items that would normally be filtered are kept in the response with skipped=true and a skipReason. Useful for understanding what was pruned."
@@ -135749,7 +135826,7 @@ var debuggerInspectElementTool = {
 Returns components from the tapped element upward through its parent hierarchy,
 each with its source file:line and a code fragment.
 
-The first items (lowest indices) are the most specific \u2014 the exact component under
+The first items (lowest indices) are the most specific: the exact component under
 the tap point and its direct parents. Higher indices are broader context (page, navigator).
 Default shows 35 items which covers all app-specific code; use maxItems=70+ to also
 see the navigation/screen structure.
@@ -135860,7 +135937,7 @@ init_zod();
 var zodSchema37 = 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, Android serial, Vega serial, or Chromium device id). The logicalDeviceId debugger-connect returns also resolves here, but prefer the stable list-devices id."
+    "Device id from list-devices: the SAME id you passed to debugger-connect (iOS simulator UDID, Android serial, Vega serial, or Chromium device id). The logicalDeviceId debugger-connect returns also resolves here, but prefer the stable list-devices id."
   )
 });
 function createDebuggerLogRegistryTool(registry2) {
@@ -135873,8 +135950,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 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.`,
+Use when investigating warnings, errors, or unexpected output. Call this first for an overview, then read the returned file for details. Returns empty stats if no log data has been captured yet, 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. 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. 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
@@ -135986,7 +136063,7 @@ ${lines.join("\n")}`;
 var zodSchema38 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
-    "Device id from list-devices (iOS simulator UDID or Android serial) \u2014 the same id used with debugger-connect."
+    "Device id from list-devices (iOS simulator UDID or Android serial), the same id used with debugger-connect."
   ),
   pageIndex: external_exports.union([external_exports.coerce.number().int().nonnegative(), external_exports.literal("latest")]).default("latest").describe(
     'Page index (0-based) or "latest" for the most recent page. Each page contains up to 50 entries.'
@@ -136002,7 +136079,7 @@ var networkLogsTool = {
   description: `Retrieve captured network (HTTP) requests from the running app.
 Returns a paginated list of requests with method, URL, status, resource type, size, and duration.
 Each entry includes a requestId that can be passed to view-network-request-details for full details.
-On React Native (iOS / Android / Vega) interception is injected into the JS runtime \u2014 it captures fetch() calls. On Chromium it reads the browser's native CDP Network domain (the active tab; all request types).
+On React Native (iOS / Android / Vega) interception is injected into the JS runtime: it captures fetch() calls. On Chromium it reads the browser's native CDP Network domain (the active tab; all request types).
 Use when inspecting outbound HTTP traffic or debugging API calls in the running app.
 Fails if the app is not connected (RN) or the device is not reachable (Chromium).`,
   zodSchema: zodSchema38,
@@ -136080,7 +136157,7 @@ var MAX_BODY_SIZE = 1e3;
 var zodSchema39 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
-    "Device id from list-devices (iOS simulator UDID or Android serial) \u2014 the same id used with debugger-connect."
+    "Device id from list-devices (iOS simulator UDID or Android serial), the same id used with debugger-connect."
   ),
   requestId: external_exports.string().describe("The requestId from view-network-logs to get full details for"),
   includeBody: external_exports.coerce.boolean().default(true).describe("Whether to include the response body (if captured). Defaults to true.")
@@ -136095,7 +136172,7 @@ var networkRequestTool = {
   description: `Get full details of a specific network request by its requestId (from view-network-logs).
 Returns request/response headers (sensitive headers redacted), status, timing, and optionally the response body.
 Large response bodies are truncated. Use when you need headers, body, or timing for a specific request after listing logs.
-Returns an error message string if the requestId is not found \u2014 use view-network-logs to get valid requestId values.`,
+Returns an error message string if the requestId is not found; use view-network-logs to get valid requestId values.`,
   zodSchema: zodSchema39,
   capability: DEBUGGER_TOOL_CAPABILITY,
   services: (params) => {
@@ -136484,10 +136561,10 @@ function createDescribeTool(registry2) {
       failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to read screen: ${failureSignal2.error_code}`
     },
     description: `Get the accessibility / DOM element tree for the current screen.
-On iOS, uses the AXRuntime accessibility service to inspect whatever is currently visible \u2014 including
+On iOS, uses the AXRuntime accessibility service to inspect whatever is currently visible, including
 system dialogs, permission prompts, and any foreground app content. On a physical iOS device the tree
 covers only the app registered by launch-app. On Android, runs \`uiautomator dump\`.
-On Chromium, walks the renderer's DOM via Chrome DevTools Protocol \u2014 every visible element with its ARIA
+On Chromium, walks the renderer's DOM via Chrome DevTools Protocol: every visible element with its ARIA
 role, accessible name, and bounding rect (normalized to 0\u20131).
 On Vega (Fire TV), reads the on-device automation toolkit (\`getPageSource\`); each element carries
 \`[focused]\`/\`[selected]\` so you can see where the D-pad cursor is, then move it with the \`tv-remote\` tool
@@ -136498,9 +136575,9 @@ When a system dialog is visible, describe returns the dialog's interactive eleme
 with tap coordinates. When no dialog is present, it returns the foreground app's accessible elements.
 On a physical iOS device, launch-app \`com.apple.springboard\` first to read system dialogs.
 
-Returns \`{ description, source }\` where \`description\` is a text rendering of the UI tree \u2014 one
+Returns \`{ description, source }\` where \`description\` is a text rendering of the UI tree, one
 line per element with its role, label/value/id, interactivity flags, and frame. Frame coordinates
-are normalized [0,1] fractions of the screen / window width/height (not pixels) \u2014 the same space as
+are normalized [0,1] fractions of the screen / window width/height (not pixels), the same space as
 gesture-tap / gesture-swipe / gesture-pinch.
 
 To tap an element use the centre of its frame: \`tap_x = frame.x + frame.width / 2\`,
@@ -136513,7 +136590,7 @@ For app-scoped inspection with full UIKit properties (accessibilityIdentifier, v
 use native-describe-screen with an explicit bundleId instead (iOS simulator only).
 For React Native apps, debugger-component-tree returns React component names with tap coordinates.
 
-On a TV target (Apple TV / Android TV \u2014 a \`list-devices\` entry with runtimeKind 'tv') this returns
+On a TV target (Apple TV / Android TV: a \`list-devices\` entry with runtimeKind 'tv') this returns
 the focus-driven view instead: the currently FOCUSED element and the list of FOCUSABLE elements,
 since a TV UI has no tap coordinates. Move the highlight with \`tv-remote\` (up/down/left/right/select/
 back/menu/home), then call describe again to confirm where focus landed.`,
@@ -137114,6 +137191,389 @@ A field is unset when it is unknown.`,
   };
 }
 
+// ../tool-server/src/tools/fill/index.ts
+init_zod();
+init_adb();
+
+// ../tool-server/src/tools/fill/errors.ts
+init_src2();
+function noFocusedFieldError(stage) {
+  return new InvalidToolInputError(
+    "Nothing that takes text has keyboard focus, so nothing was changed. Tap the text field first, then call fill again.",
+    {
+      error_code: FAILURE_CODES.FILL_NO_FOCUSED_FIELD,
+      failure_stage: stage,
+      error_kind: "validation"
+    }
+  );
+}
+function notVerifiedError(stage) {
+  return new FailureError(
+    "fill wrote to the focused field, but reading it back did not show the requested text. The field may hold other or partial text: read it before retrying.",
+    {
+      error_code: FAILURE_CODES.FILL_NOT_VERIFIED,
+      failure_stage: stage,
+      failure_area: "tool_server",
+      error_kind: "unknown"
+    }
+  );
+}
+function notChangedError(stage) {
+  return new FailureError(
+    "fill could not select the text of the focused field, so nothing was changed. Tap the field and retry.",
+    {
+      error_code: FAILURE_CODES.FILL_NOT_VERIFIED,
+      failure_stage: stage,
+      failure_area: "tool_server",
+      error_kind: "unknown"
+    }
+  );
+}
+function notAnsweredError(stage) {
+  return new FailureError(
+    "The device did not finish the fill in time. The field may have changed: read it before retrying.",
+    {
+      error_code: FAILURE_CODES.FILL_NOT_VERIFIED,
+      failure_stage: stage,
+      failure_area: "tool_server",
+      error_kind: "timeout"
+    }
+  );
+}
+function unsupportedFieldError(detail, stage) {
+  return new InvalidToolInputError(
+    `fill cannot set this field's text: ${detail}. Nothing was changed.`,
+    {
+      error_code: FAILURE_CODES.FILL_UNSUPPORTED_FIELD,
+      failure_stage: stage,
+      error_kind: "unsupported"
+    }
+  );
+}
+
+// ../tool-server/src/tools/fill/keys.ts
+init_src2();
+init_src2();
+var MAX_CLEAR_KEYS = 100;
+var XCTEST_DELETE = "\b";
+var KEY_TIMING = { holdMs: 20, settleMs: 300, typeDelayMs: 30 };
+var sleep14 = (ms) => new Promise((r) => setTimeout(r, ms));
+function typeableOnSimulator(text) {
+  for (const char of text) if (!charToKeyPress(char)) return false;
+  return true;
+}
+async function withoutTextInErrors(stage, run2) {
+  try {
+    return await run2();
+  } catch (err) {
+    const signal = getFailureSignal(err);
+    throw new FailureError(
+      "fill failed partway through typing: the focused field may hold part of the text. Read it before retrying.",
+      signal ?? {
+        error_code: FAILURE_CODES.FILL_NOT_VERIFIED,
+        failure_stage: stage,
+        failure_area: "tool_server",
+        error_kind: "unknown"
+      }
+    );
+  }
+}
+async function pressSimulatorBackspace(registry2, device) {
+  const ref = simulatorServerRef(device);
+  const api = await registry2.resolveService(ref.urn, ref.options);
+  await api.pressKey("Down", NAMED_KEYS.backspace);
+  await sleep14(KEY_TIMING.holdMs);
+  await api.pressKey("Up", NAMED_KEYS.backspace);
+  await sleep14(KEY_TIMING.settleMs);
+}
+async function typeOnSimulator(registry2, device, text) {
+  if (!text) return;
+  await withoutTextInErrors(
+    "fill_keys_ios",
+    () => typeSimulatorServer(registry2, device, {
+      udid: device.id,
+      text,
+      delayMs: KEY_TIMING.typeDelayMs
+    })
+  );
+}
+async function fillByDeviceKeys(registry2, device, text) {
+  const bundleId = requireCurrentIosDeviceApp(device.id);
+  const ref = iosDeviceRunnerRef(device);
+  const api = await registry2.resolveService(ref.urn, ref.options);
+  const type = async (chars) => {
+    try {
+      await typeText(api, bundleId, chars);
+    } catch (err) {
+      if (err instanceof RunnerCommandError && err.code === "TEXT_INPUT_NOT_FOCUSED") {
+        throw noFocusedFieldError("fill_keys_ios_device_focus");
+      }
+      throw err;
+    }
+  };
+  await type(XCTEST_DELETE.repeat(MAX_CLEAR_KEYS));
+  if (text) await withoutTextInErrors("fill_keys_ios_device", () => type(text));
+}
+
+// ../tool-server/src/tools/fill/ios.ts
+var NEWLINE = /[\r\n]/;
+async function fillIos(registry2, device, text) {
+  const ref = axServiceRef(device);
+  const ax = await registry2.resolveService(ref.urn, ref.options);
+  const typeable = typeableOnSimulator(text) && !NEWLINE.test(text);
+  const first = await ax.fill(text, { typeable });
+  if (!first.focused) throw noFocusedFieldError("fill_ios_no_focus");
+  if (first.unsupported) {
+    throw unsupportedFieldError(
+      "the focused element is not a text input (a date or time input, or a picker)",
+      "fill_ios_unsupported_field"
+    );
+  }
+  if (first.singleLine) {
+    throw unsupportedFieldError(
+      "a single-line text field cannot hold a newline",
+      "fill_ios_single_line"
+    );
+  }
+  if (first.timedOut) throw notAnsweredError("fill_ios_timeout");
+  if (first.untouched) throw notChangedError("fill_ios_select_failed");
+  if (first.verified) return { verified: true };
+  if (first.secure) {
+    if (!typeable) {
+      throw unsupportedFieldError(
+        "a secure text field takes only text the keyboard can type on one line, and this text has a character it cannot",
+        "fill_ios_secure_untypeable"
+      );
+    }
+    if (!first.cleared) throw notVerifiedError("fill_ios_secure_not_cleared");
+    await typeOnSimulator(registry2, device, text);
+    const check3 = await ax.fill(text, { check: true });
+    if (check3.verified) return { verified: true };
+    throw notVerifiedError("fill_ios_not_verified");
+  }
+  if (first.needsBackspace) {
+    await pressSimulatorBackspace(registry2, device);
+    const check3 = await ax.fill(text, { check: true });
+    if (check3.verified) return { verified: true };
+  }
+  throw notVerifiedError("fill_ios_not_verified");
+}
+
+// ../tool-server/src/tools/fill/android.ts
+async function fillAndroid(registry2, device, text) {
+  const ref = androidDevtoolsRef(device);
+  const helper = await registry2.resolveService(ref.urn, ref.options);
+  const answer = await helper.setText(text);
+  if (!answer.focused) throw noFocusedFieldError("fill_android_no_focus");
+  if (answer.singleLine) {
+    throw unsupportedFieldError(
+      "a single-line text field cannot hold a newline",
+      "fill_android_single_line"
+    );
+  }
+  if (answer.timedOut) throw notAnsweredError("fill_android_timeout");
+  if (answer.verified) return { verified: true };
+  throw notVerifiedError("fill_android_not_verified");
+}
+
+// ../tool-server/src/tools/fill/chromium.ts
+init_src2();
+function buildChromiumFillScript(text) {
+  return `(async () => {
+  const text = ${JSON.stringify(text)};
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  try {
+    const deepActive = (doc) => {
+      let el = doc.activeElement;
+      while (el && el.shadowRoot && el.shadowRoot.activeElement) el = el.shadowRoot.activeElement;
+      return el;
+    };
+    let el = deepActive(document);
+    while (el && String(el.tagName).toLowerCase() === "iframe") {
+      let inner = null;
+      try { inner = el.contentDocument; } catch (e) { inner = null; }
+      if (!inner) return { status: "no_focus" };
+      el = deepActive(inner);
+    }
+    if (!el || el.tagName === undefined) return { status: "no_focus" };
+    const doc = el.ownerDocument || document;
+    const win = doc.defaultView || window;
+    const tag = String(el.tagName).toLowerCase();
+    const type = tag === "input" ? String(el.type || "text").toLowerCase() : null;
+    if (type !== null && /^(date|time|month|week|datetime-local)$/.test(type)) {
+      return { status: "unsupported", detail: "a " + type + " input holds a structured value" };
+    }
+    const control =
+      tag === "textarea" ||
+      (tag === "input" && !/^(button|checkbox|radio|file|submit|reset|image|range|color|hidden)$/.test(type));
+    if (!control && el.isContentEditable !== true) return { status: "no_focus" };
+    if (control && el.disabled === true) return { status: "unsupported", detail: "it is disabled" };
+    if (control && el.readOnly === true) return { status: "unsupported", detail: "it is read-only" };
+    // An <input> holds one line and drops a newline.
+    if (tag === "input" && /[\\r\\n]/.test(text)) {
+      return { status: "unsupported", detail: "a single-line input cannot hold a newline" };
+    }
+    if (!control) {
+      // designMode or <body contenteditable>: the whole document is the field.
+      let host = el;
+      while (host.parentElement && host.parentElement.isContentEditable === true) host = host.parentElement;
+      if (host === doc.body || host === doc.documentElement) {
+        return { status: "unsupported", detail: "the whole document is editable" };
+      }
+    }
+    const trimEnd = (s) => s.replace(/[\\u200b\\ufeff]/g, "").replace(/\\n+$/, "");
+    const read = () =>
+      control ? String(el.value == null ? "" : el.value) : trimEnd(String(el.innerText == null ? el.textContent || "" : el.innerText));
+    const matches = () => (control ? read() === text : read() === trimEnd(text));
+    const settle = async () => {
+      for (let i = 0; i < 10; i++) {
+        await sleep(i === 0 ? 0 : 50);
+        if (matches()) return true;
+      }
+      return false;
+    };
+
+    if (control) {
+      try { el.select(); } catch (e) { /* no selection API */ }
+    } else {
+      const sel = doc.getSelection();
+      const range = doc.createRange();
+      range.selectNodeContents(el);
+      sel.removeAllRanges();
+      sel.addRange(range);
+    }
+    if (text === "") {
+      if (read() !== "") doc.execCommand("delete");
+    } else {
+      doc.execCommand("insertText", false, text);
+    }
+    let verified = await settle();
+    if (!verified && control) {
+      const proto = tag === "textarea" ? win.HTMLTextAreaElement.prototype : win.HTMLInputElement.prototype;
+      const setter = Object.getOwnPropertyDescriptor(proto, "value").set;
+      setter.call(el, text);
+      el.dispatchEvent(new win.Event("input", { bubbles: true }));
+      el.dispatchEvent(new win.Event("change", { bubbles: true }));
+      verified = await settle();
+    }
+    return { status: "ok", verified: verified };
+  } catch (e) {
+    return { status: "error" };
+  }
+})()`;
+}
+async function fillChromium(registry2, device, text) {
+  const ref = chromiumCdpRef(device);
+  const api = await registry2.resolveService(ref.urn, ref.options);
+  const out = await api.cdp.send(
+    "Runtime.evaluate",
+    { expression: buildChromiumFillScript(text), awaitPromise: true, returnByValue: true },
+    1e4
+  );
+  const answer = out.result?.value;
+  switch (answer?.status) {
+    case "ok":
+      if (answer.verified === true) {
+        return { verified: true };
+      }
+      throw notVerifiedError("fill_chromium_not_verified");
+    case "no_focus":
+      throw noFocusedFieldError("fill_chromium_no_focus");
+    case "unsupported":
+      throw unsupportedFieldError(answer.detail ?? "unsupported field", "fill_chromium_field");
+    default:
+      throw new FailureError("fill could not run in the page; nothing is known about the field.", {
+        error_code: FAILURE_CODES.FILL_NOT_VERIFIED,
+        failure_stage: "fill_chromium_script",
+        failure_area: "tool_server",
+        error_kind: "unknown",
+        failure_command: "cdp"
+      });
+  }
+}
+
+// ../tool-server/src/tools/fill/index.ts
+var zodSchema43 = external_exports.object({
+  udid: external_exports.string().min(1).describe("Target device id from `list-devices`."),
+  text: external_exports.string().describe(
+    'The text the focused field must hold afterwards; "" clears it. Supports `{{secret:<NAME>}}` placeholders like `keyboard`.'
+  )
+});
+var capability28 = {
+  apple: { simulator: true, device: true },
+  appleRemote: { simulator: true },
+  android: { emulator: true, device: true, unknown: true },
+  chromium: { app: true }
+};
+function createFillTool(registry2) {
+  const dispatch = dispatchByPlatform({
+    toolId: "fill",
+    capability: capability28,
+    ios: {
+      requires: iosRequires,
+      handler: async (_services, params, device) => {
+        if (await isTvOsSimulator(device.id)) {
+          throw new UnsupportedOperationError("fill", device, "tvOS");
+        }
+        return fillIos(registry2, device, params.text);
+      }
+    },
+    iosRemote: {
+      requires: ["sim-remote"],
+      handler: async (_services, params, device) => {
+        if (await isRemoteTvOsSimulator(device.id)) {
+          throw new UnsupportedOperationError("fill", device, "tvOS");
+        }
+        return fillIos(registry2, device, params.text);
+      }
+    },
+    iosDevice: {
+      requires: ["xcrun"],
+      handler: async (_services, params, device) => {
+        await fillByDeviceKeys(registry2, device, params.text);
+        return { verified: false };
+      }
+    },
+    android: {
+      requires: androidRequires,
+      handler: async (_services, params, device) => {
+        if (await isAndroidTv(device.id)) {
+          throw new UnsupportedOperationError("fill", device, "Android TV");
+        }
+        return fillAndroid(registry2, device, params.text);
+      }
+    },
+    chromium: {
+      handler: async (_services, params, device) => fillChromium(registry2, device, params.text)
+    }
+  });
+  return {
+    id: "fill",
+    interaction: {
+      // Never quote `text`: it may be a credential, and these messages reach
+      // the event log.
+      startedMsg: () => "Filling the focused field",
+      completedMsg: () => "Filled the focused field",
+      failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to fill the field: ${failureSignal2.error_code}`
+    },
+    description: `Set the text of the focused text field to exactly \`text\`, replacing what it holds; "" clears it. Tap the field first.
+Returns { verified }, never the text: true when the field was read back holding the text, false on a physical iPhone, where nothing can read it back.
+Fails with FILL_NO_FOCUSED_FIELD when nothing editable has focus, FILL_NOT_VERIFIED when the field does not read back the text, FILL_UNSUPPORTED_FIELD for a field that cannot take the text (a date or time input, a newline in a single-line field; nothing is changed). Fails if the device's ax-service or devtools helper predates fill; update argent. Not supported on TV targets or Vega.`,
+    hideFromMcp: true,
+    zodSchema: zodSchema43,
+    capability: capability28,
+    services: () => ({}),
+    execute: async (services, params, options) => {
+      const { text, secrets } = resolveSecretPlaceholders(params.text);
+      try {
+        return await dispatch(services, { udid: params.udid, text }, options);
+      } catch (err) {
+        throw redactSecretsFromError(err, secrets);
+      }
+    }
+  };
+}
+
 // ../tool-server/src/tools/await-screen-idle/index.ts
 init_zod();
 init_device_info();
@@ -137122,7 +137582,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 zodSchema43 = external_exports.object({
+var zodSchema44 = 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}).`
@@ -137132,7 +137592,7 @@ var zodSchema43 = external_exports.object({
     `The screen must hold the same content for at least this long to count as settled (default ${DEFAULT_MIN_STABLE_MS}).`
   )
 }).strict();
-var capability28 = {
+var capability29 = {
   apple: { simulator: true, device: true },
   appleRemote: { simulator: true },
   android: { emulator: true, device: true, unknown: true },
@@ -137175,12 +137635,12 @@ function createAwaitScreenIdleTool(registry2) {
 
 Polls the same accessibility / DOM tree as \`describe\` every pollIntervalMs (default ${DEFAULT_POLL_INTERVAL_MS2}ms) until it
 has content and that content holds identical for minStableMs (default ${DEFAULT_MIN_STABLE_MS}ms), or timeoutMs (default
-${DEFAULT_TIMEOUT_MS4}ms) is reached. Returns { settled, waitedMs, polls } \u2014 settled=false means the screen never went
+${DEFAULT_TIMEOUT_MS4}ms) is reached. Returns { settled, waitedMs, polls }; settled=false means the screen never went
 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: zodSchema43,
-    capability: capability28,
+    zodSchema: zodSchema44,
+    capability: capability29,
     services: (params) => {
       const device = resolveDevice(params.udid);
       if (device.platform === "chromium") {
@@ -137190,7 +137650,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, capability28, device);
+      assertSupported(AWAIT_SCREEN_IDLE_TOOL_ID, capability29, 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);
@@ -137277,10 +137737,10 @@ 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 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)."
+    "Device id from list-devices: the SAME id you passed to debugger-connect (iOS simulator UDID or Android serial)."
   ),
   sample_interval_us: external_exports.coerce.number().int().positive().default(100).describe("CPU sampling interval in microseconds (default 100)"),
   force: external_exports.boolean().default(false).describe(
@@ -137305,11 +137765,11 @@ function createReactProfilerStartTool(registry2) {
     description: `Start CPU profiling + React commit capture on the connected Hermes runtime.
 Delegates React commit capture to the in-app React DevTools backend (ri.startProfiling).
 If another tool-server already owns the session, returns { already_running: true, owner, stale, how_to_reclaim } without clobbering their data. Pass { force: true } to reclaim a fresh owner's session, but BEFORE OVERTAKING - ask the user for approval first, see relevant skill for guidance.
-Before calling this, ask the user if they also want native profiling (native-profiler-start) \u2014 recommend running both in parallel for a complete picture.
+Before calling this, ask the user if they also want native profiling (native-profiler-start), and recommend running both in parallel for a complete picture.
 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: zodSchema44,
+    zodSchema: zodSchema45,
     capability: RN_ONLY_TOOL_CAPABILITY,
     services: () => ({}),
     async execute(_services, params) {
@@ -137580,10 +138040,10 @@ async function readCommitTree(path53) {
 }
 
 // ../tool-server/src/tools/profiler/react/react-profiler-stop.ts
-var zodSchema45 = external_exports.object({
+var zodSchema46 = 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)."
+    "Device id from list-devices: the SAME id you passed to debugger-connect (iOS simulator UDID or Android serial)."
   )
 });
 function normalizeChangeDescription(raw) {
@@ -137667,9 +138127,9 @@ Reads commit data from the in-app React DevTools backend.
 Stores results in the ReactProfilerSession for later use by react-profiler-analyze or react-profiler-cpu-summary.
 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).
+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 }. 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: zodSchema45,
+    zodSchema: zodSchema46,
     capability: RN_ONLY_TOOL_CAPABILITY,
     services: () => ({}),
     async execute(_services, params) {
@@ -137894,7 +138354,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 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)."
@@ -137908,8 +138368,8 @@ function createReactProfilerStatusTool(registry2) {
       completedMsg: ({ result }) => result.is_running ? "React profiler is running" : "React profiler is stopped",
       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: zodSchema46,
+    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, so 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: zodSchema47,
     // RN-only: companion to react-profiler-start.
     capability: RN_ONLY_TOOL_CAPABILITY,
     services: () => ({}),
@@ -139523,7 +139983,7 @@ var annotationSchema = external_exports.object({
   ),
   label: external_exports.string().describe("Description of the action performed")
 });
-var zodSchema47 = external_exports.object({
+var zodSchema48 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
     "Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId)."
@@ -139556,7 +140016,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: zodSchema47,
+  zodSchema: zodSchema48,
   // RN-only: reads commit data captured via the React DevTools backend, which
   // Chromium does not have.
   capability: RN_ONLY_TOOL_CAPABILITY,
@@ -139693,7 +140153,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 zodSchema48 = external_exports.object({
+var zodSchema49 = 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")
 });
@@ -139710,8 +140170,8 @@ var reactProfilerComponentSourceTool = {
   description: `Find a React component's source via tree-sitter AST lookup: returns file path, line number, memoization status (isMemoized, hasUseCallback, hasUseMemo), and 50 lines of source for a named React component.
 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: zodSchema48,
+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). Check it before assuming the returned file is the one you meant.`,
+  zodSchema: zodSchema49,
   // 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.
@@ -139767,7 +140227,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 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)."
@@ -139843,13 +140303,13 @@ var reactProfilerCpuSummaryTool = {
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to summarize React CPU profile: ${failureSignal2.error_code}`
   },
   description: `Return a raw Hermes CPU flamegraph summary (top hotspot functions by self-time).
-FOR DEDICATED CPU INVESTIGATION ONLY \u2014 do NOT call this as part of a normal profiling session.
+FOR DEDICATED CPU INVESTIGATION ONLY: do NOT call this as part of a normal profiling session.
 Use react-profiler-analyze instead; it covers all React rendering performance analysis.
 Use when you specifically need to investigate JS CPU hotspots that are NOT tied to React rendering (e.g. regex slowness, cryptography, heavy computations).
 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: zodSchema49,
+  zodSchema: zodSchema50,
   // RN-only: reads a Hermes CPU profile; Chromium's V8 sample format differs.
   capability: RN_ONLY_TOOL_CAPABILITY,
   services: () => ({}),
@@ -139945,7 +140405,7 @@ function renderMarkdownTable2(entries) {
   );
   return [header, sep5, ...rows].join("\n");
 }
-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)."
@@ -139960,10 +140420,10 @@ var reactProfilerRendersTool = {
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to read React render activity: ${failureSignal2.error_code}`
   },
   description: `Scan the live React fiber tree to collect component render counts and durations.
-Returns a markdown table of the top re-rendering components. No profiling session required \u2014 works on a live connected app.
+Returns a markdown table of the top re-rendering components. No profiling session required; 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: zodSchema50,
+  zodSchema: zodSchema51,
   // RN-only: queries the React DevTools backend hook on the live runtime.
   capability: RN_ONLY_TOOL_CAPABILITY,
   services: (params) => ({
@@ -140120,7 +140580,7 @@ function buildFiberTreeScript(maxDepth, filter) {
   }
 })()`;
 }
-var zodSchema51 = external_exports.object({
+var zodSchema52 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
     "Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId)."
@@ -140139,7 +140599,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: zodSchema51,
+  zodSchema: zodSchema52,
   // RN-only: walks the fiber tree via the React DevTools backend hook.
   capability: RN_ONLY_TOOL_CAPABILITY,
   services: (params) => ({
@@ -143937,7 +144397,7 @@ function metroDeviceIdParam(description) {
 }
 
 // ../tool-server/src/tools/profiler/native-profiler/native-profiler-start.ts
-var zodSchema52 = external_exports.object({
+var zodSchema53 = external_exports.object({
   device_id: metroDeviceIdParam(
     "Target device id from `list-devices` (iOS UDID or Android serial)."
   ),
@@ -143948,10 +144408,10 @@ var zodSchema52 = external_exports.object({
     "iOS-only: path to an Instruments .tracetemplate file (defaults to bundled Argent template). Ignored on Android."
   ),
   malloc_stack_logging: external_exports.boolean().optional().describe(
-    "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."
+    "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: 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 (e.g. exported globally for the normal capture path) also rejects this flag up front, since that fallback cannot cold-launch; unset it (or set it to device) first. Ignored on Android."
   )
 });
-var capability29 = {
+var capability30 = {
   apple: { simulator: true },
   android: { emulator: true, device: true, unknown: true }
 };
@@ -143962,21 +144422,21 @@ var nativeProfilerStartTool = {
     completedMsg: () => "Started native profiler",
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to start native profiler: ${failureSignal2.error_code}`
   },
-  capability: capability29,
+  capability: capability30,
   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: zodSchema52,
+  zodSchema: zodSchema53,
   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", capability29, device);
+    assertSupported("native-profiler-start", capability30, device);
     if (api.platform === "ios") {
       await ensureDeps(["xcrun"]);
       return startNativeProfilerIos(api, params);
@@ -143989,12 +144449,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 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 }
 };
@@ -144022,7 +144482,7 @@ var nativeProfilerStopTool = {
     completedMsg: ({ result }) => `Saved native profile ${result.traceFile.filename}`,
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to stop native profiler: ${failureSignal2.error_code}`
   },
-  capability: capability30,
+  capability: capability31,
   // Packaging plus the export passes routinely exceed the 30s MCP fetch timeout.
   longRunning: true,
   description: `Stop native profiling and export trace data.
@@ -144032,14 +144492,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: 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-stop", capability30, device);
+    assertSupported("native-profiler-stop", capability31, device);
     if (api.platform === "ios") {
       await ensureDeps(["xcrun"]);
       const ios = await stopNativeProfilerIos(api);
@@ -144067,12 +144527,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 zodSchema54 = external_exports.object({
+var zodSchema55 = external_exports.object({
   device_id: metroDeviceIdParam(
     "Target device id from `list-devices` (iOS UDID or Android serial)."
   )
 });
-var capability31 = {
+var capability32 = {
   apple: { simulator: true },
   android: { emulator: true, device: true, unknown: true }
 };
@@ -144083,7 +144543,7 @@ var nativeProfilerAnalyzeTool = {
     completedMsg: () => "Analyzed native profile",
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to analyze native profile: ${failureSignal2.error_code}`
   },
-  capability: capability31,
+  capability: capability32,
   // 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,
@@ -144096,14 +144556,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: zodSchema54,
+  zodSchema: zodSchema55,
   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", capability31, device);
+    assertSupported("native-profiler-analyze", capability32, device);
     let result;
     if (api.platform === "ios") {
       await ensureDeps(["xcrun"]);
@@ -145166,7 +145626,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 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)."),
   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.`
@@ -145178,7 +145638,7 @@ var zodSchema55 = 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 capability32 = {
+var capability33 = {
   apple: { simulator: true },
   android: { emulator: true, device: true, unknown: true }
 };
@@ -145190,16 +145650,16 @@ function createScreenRecordingStartTool(registry2) {
       completedMsg: () => "Started screen recording",
       failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to start screen recording: ${failureSignal2.error_code}`
     },
-    capability: capability32,
+    capability: capability33,
     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.
-The recording keeps running across other tool calls (every result carries a reminder) until \`screen-recording-stop\` is called or timeLimitSeconds elapses \u2014 immediately after starting, set yourself a reminder/wakeup for the expected end of the recording so it is never left running.
-Use when the user wants a video of an interaction, animation, or app behavior \u2014 for a single still frame use \`screenshot\` instead.
-Returns { status: "recording", timeLimitSeconds, outputFile } \u2014 the video is retrieved later by \`screen-recording-stop\`, not by reading outputFile directly.
+The recording keeps running across other tool calls (every result carries a reminder) until \`screen-recording-stop\` is called or timeLimitSeconds elapses. Immediately after starting, set yourself a reminder/wakeup for the expected end of the recording so it is never left running.
+Use when the user wants a video of an interaction, animation, or app behavior; for a single still frame use \`screenshot\` instead.
+Returns { status: "recording", timeLimitSeconds, outputFile }. 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: zodSchema55,
+    zodSchema: zodSchema56,
     // 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`).
@@ -145209,7 +145669,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", capability32, device);
+      assertSupported("screen-recording-start", capability33, device);
       if (device.platform === "ios" && await isTvOsSimulator(params.udid)) {
         throw new FailureError(
           `Screen recording is not supported on tvOS simulators (device ${params.udid}).`,
@@ -145298,11 +145758,11 @@ function makePointerControl(simulator) {
 var import_node_path22 = require("node:path");
 init_zod();
 init_device_info();
-var zodSchema56 = external_exports.object({
+var zodSchema57 = 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 capability33 = {
+var capability34 = {
   apple: { simulator: true },
   android: { emulator: true, device: true, unknown: true }
 };
@@ -145313,21 +145773,21 @@ var screenRecordingStopTool = {
     completedMsg: ({ result }) => `Saved screen recording ${result.video.filename}`,
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to stop screen recording: ${failureSignal2.error_code}`
   },
-  capability: capability33,
+  capability: capability34,
   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.
+Also retrieves the video when the recording already ended on its own (time limit reached, capture process died); 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: zodSchema56,
+  zodSchema: zodSchema57,
   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", capability33, device);
+    assertSupported("screen-recording-stop", capability34, device);
     const stopped = await stopCapture(api);
     const artifacts = requireArtifacts(ctx);
     const video = await artifacts.register({
@@ -145353,13 +145813,13 @@ init_src2();
 var import_fs18 = require("fs");
 var timeWindowSchema = external_exports.object({
   start: external_exports.coerce.number().describe(
-    "Start of window in ms since profiling started \u2014 the same clock profiler-commit-query prints"
+    "Start of window in ms since profiling started, the same clock profiler-commit-query prints"
   ),
   end: external_exports.coerce.number().describe(
-    "End of window in ms since profiling started \u2014 the same clock profiler-commit-query prints"
+    "End of window in ms since profiling started, 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)."
@@ -145368,7 +145828,7 @@ var zodSchema57 = external_exports.object({
     "Query mode: top_functions (global hotspots), time_window (CPU in a time range), call_tree (callers/callees of a function), component_cpu (CPU during a component's commits)"
   ),
   time_window_ms: timeWindowSchema.optional().describe(
-    "Time window filter for time_window mode (ms since profiling started \u2014 the same clock profiler-commit-query prints)"
+    "Time window filter for time_window mode (ms since profiling started, the same clock profiler-commit-query prints)"
   ),
   component_name: external_exports.string().optional().describe("Component name for component_cpu mode"),
   function_name: external_exports.string().optional().describe("Function name for call_tree mode"),
@@ -145647,8 +146107,8 @@ Every table states how many samples it covers and how much of that was idle.
 - component_cpu: For a given component_name, aggregate CPU activity across all its commits.
 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: zodSchema57,
+Fails if no CPU profile is stored; run react-profiler-stop first.`,
+  zodSchema: zodSchema58,
   // RN-only: reads Hermes-format CPU profiles; Chromium's V8 sample format differs.
   capability: RN_ONLY_TOOL_CAPABILITY,
   services: () => ({}),
@@ -145728,13 +146188,13 @@ init_zod();
 init_src2();
 var timeRangeSchema = external_exports.object({
   start: external_exports.coerce.number().describe(
-    "Start of range in ms since profiling started \u2014 the same clock profiler-commit-query prints"
+    "Start of range in ms since profiling started, the same clock profiler-commit-query prints"
   ),
   end: external_exports.coerce.number().describe(
-    "End of range in ms since profiling started \u2014 the same clock profiler-commit-query prints"
+    "End of range in ms since profiling started, the same clock profiler-commit-query prints"
   )
 });
-var zodSchema58 = external_exports.object({
+var zodSchema59 = external_exports.object({
   port: metroPortField,
   device_id: metroDeviceIdParam(
     "Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId)."
@@ -145746,7 +146206,7 @@ var zodSchema58 = external_exports.object({
   time_range_ms: timeRangeSchema.optional().describe("Time range filter for by_time_range mode"),
   commit_index: external_exports.coerce.number().int().optional().describe("Commit index for by_index and cascade_tree modes"),
   top_n: external_exports.coerce.number().int().positive().optional().describe(
-    "Max results to return. Defaults to 20 for by_component / by_time_range, which count commits. by_index counts individual fibers and returns all of them unless this is set, because one commit's fibers collapse to far fewer distinct components \u2014 a small cap there can show less than the analyze report it is meant to expand on."
+    "Max results to return. Defaults to 20 for by_component / by_time_range, which count commits. by_index counts individual fibers and returns all of them unless this is set, because one commit's fibers collapse to far fewer distinct components, and a small cap there can show less than the analyze report it is meant to expand on."
   )
 });
 async function getCommitTree(port, deviceId) {
@@ -146007,7 +146467,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: zodSchema58,
+  zodSchema: zodSchema59,
   // Reads React commit data captured via the React DevTools backend.
   capability: RN_ONLY_TOOL_CAPABILITY,
   services: () => ({}),
@@ -146078,7 +146538,7 @@ Fails if react-profiler-stop has not been called or no commit data is stored.`,
 init_zod();
 init_src2();
 init_device_info();
-var zodSchema59 = external_exports.object({
+var zodSchema60 = 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)"
@@ -146396,7 +146856,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: zodSchema59,
+  zodSchema: zodSchema60,
   // No chromium entry: it has no native trace capture.
   capability: {
     apple: { simulator: true },
@@ -146466,7 +146926,7 @@ function buildPerfettoAnchor(wallClockStartMs) {
 }
 
 // ../tool-server/src/tools/profiler/combined/profiler-combined-report.ts
-var zodSchema60 = external_exports.object({
+var zodSchema61 = external_exports.object({
   port: metroPortField,
   device_id: metroDeviceIdParam("iOS Simulator/device UDID or Android serial")
 });
@@ -146483,7 +146943,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: zodSchema60,
+  zodSchema: zodSchema61,
   // iOS reads xctrace output; Android re-queries the Perfetto .pftrace via
   // loadAndroidCombinedData. Chromium has no native trace capture.
   capability: {
@@ -146807,7 +147267,7 @@ function assertSafeSessionId(sessionId) {
     );
   }
 }
-var zodSchema61 = external_exports.object({
+var zodSchema62 = 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."
   ),
@@ -147168,7 +147628,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: zodSchema61,
+  zodSchema: zodSchema62,
   // 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,
@@ -147297,7 +147757,7 @@ function unnameableSessionUrns(urns) {
 }
 
 // ../tool-server/src/tools/simulator/stop-simulator-server.ts
-var zodSchema62 = external_exports.object({
+var zodSchema63 = external_exports.object({
   udid: external_exports.string().describe(
     "Target device id (iOS UDID, Android serial, or Chromium id) whose transport session to stop"
   )
@@ -147311,7 +147771,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: zodSchema62,
+    zodSchema: zodSchema63,
     services: () => ({}),
     async execute(_services, params) {
       const udid = params.udid;
@@ -147342,9 +147802,9 @@ function createStopSimulatorServerTool(registry2) {
 init_zod();
 init_src2();
 init_external_devices();
-var zodSchema63 = external_exports.object({
+var zodSchema64 = 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."
+    "Device ids (iOS UDID / Android serial / Chromium id) to scope the teardown to. 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."
   )
 }).strict();
 function createStopAllSimulatorServersTool(registry2) {
@@ -147378,10 +147838,10 @@ function createStopAllSimulatorServersTool(registry2) {
       failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to stop simulator servers: ${failureSignal2.error_code}`
     },
     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.
+PASS \`devices\` with the device ids this session used: 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 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,
+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, 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: zodSchema64,
     services: () => ({}),
     async execute(_services, params, ctx) {
       const devices = params.devices;
@@ -147461,7 +147921,7 @@ function listeningPids(port) {
   if (!output) return [];
   return output.split("\n").map((s) => parseInt(s.trim(), 10)).filter((n) => !Number.isNaN(n));
 }
-var zodSchema64 = external_exports.object({
+var zodSchema65 = 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 = {
@@ -147471,8 +147931,8 @@ var stopMetroTool = {
     completedMsg: ({ params }) => `Stopped Metro on port ${params.port}`,
     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: zodSchema64,
+  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: always ask the user for confirmation before calling this tool.`,
+  zodSchema: zodSchema65,
   services: () => ({}),
   async execute(_services, params) {
     const port = params.port;
@@ -149816,15 +150276,15 @@ async function appendStepToFlow(session, step) {
 }
 
 // ../tool-server/src/tools/flows/flow-start-recording.ts
-var zodSchema65 = external_exports.object({
+var zodSchema66 = external_exports.object({
   name: external_exports.string().describe(
-    'Name for this flow (e.g. "settings-explore") \u2014 letters, digits, underscore and hyphen only.'
+    'Name for this flow (e.g. "settings-explore"): letters, digits, underscore and hyphen only.'
   ),
   project_root: external_exports.string().describe(
     "Absolute path to the project root directory (the directory that contains or should contain `.argent/flows/`). The flow file is created at `<project_root>/.argent/flows/<name>.yaml`."
   ),
   executionPrerequisite: external_exports.string().optional().describe(
-    'Fragments only: the app/device state assumed on entry (e.g. "Settings app open on General page"). For a self-contained e2e flow, omit this and record a `restart-app` as the first step instead \u2014 it is captured as the flow\'s `launch` step. restart-app has no chromium support, so a chromium flow records as a fragment; add the `launch: { chromium: <app path> }` line to the YAML afterward, deleting the executionPrerequisite line if you passed one \u2014 a flow that starts with a launch must not declare it.'
+    'Fragments only: the app/device state assumed on entry (e.g. "Settings app open on General page"). For a self-contained e2e flow, omit this and record a `restart-app` as the first step instead; it is captured as the flow\'s `launch` step. restart-app has no chromium support, so a chromium flow records as a fragment; add the `launch: { chromium: <app path> }` line to the YAML afterward, deleting the executionPrerequisite line if you passed one, since a flow that starts with a launch must not declare it.'
   )
 });
 var fileInputs2 = [
@@ -149848,19 +150308,19 @@ Use when you want to capture a reusable sequence of device interactions for late
 Returns { message, flowFile, savedTo } and optionally { restarted, discardedSteps } if a live recording of the same flow was discarded.
 Without a link, it creates that file and fails if the .argent/flows/ directory cannot be created or the file cannot be written. Over a link (argent link or ARGENT_TOOLS_URL, also to 127.0.0.1), your client writes the file, and \`savedTo\` is its path on your computer, or null when that write failed.
 
-Several flows can be recorded at once \u2014 each keyed by the \`name\` + \`project_root\`
-that every subsequent recording tool repeats \u2014 and one recording's steps never
+Several flows can be recorded at once, each keyed by the \`name\` + \`project_root\`
+that every subsequent recording tool repeats, and one recording's steps never
 land in another's file. Steps still run LIVE, so give each concurrent recording
 its own device and pick a name unique to your task.
 
-After starting, use flow-add-step to append tool calls \u2014 each step is executed
+After starting, use flow-add-step to append tool calls. Each step is executed
 LIVE so you can verify it works before it gets recorded. Read each step's
 \`message\`: an await-ui-element whose condition never held is still recorded (it
 returns success:false rather than failing), and a check that passes live can
 still fail once polished into an \`await:\`/\`assert:\` directive, which resolves
 against a different tree. flow-add-step warns about both when you record the
 wait DIRECTLY. A wait nested inside a recorded run-sequence gets neither warning
-\u2014 that tool reports its own shape \u2014 so for those, read \`toolResult\`. For a self-contained
+(that tool reports its own shape), so for those, read \`toolResult\`. For a self-contained
 e2e flow, record a restart-app of the app under test as the FIRST step (captured
 as the flow's \`launch\` step); for a reusable fragment, skip that and pass
 executionPrerequisite instead. Use flow-add-echo to add labels, and
@@ -149873,7 +150333,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: zodSchema65,
+  zodSchema: zodSchema66,
   fileInputs: fileInputs2,
   services: () => ({}),
   async execute(_services, params, ctx) {
@@ -152373,10 +152833,10 @@ function stepAnchor(step) {
 
 // ../tool-server/src/tools/flows/flow-add-step.ts
 init_device_info();
-var zodSchema66 = external_exports.object({
-  name: external_exports.string().describe("Name of the flow being recorded \u2014 the one passed to flow-start-recording."),
+var zodSchema67 = external_exports.object({
+  name: external_exports.string().describe("Name of the flow being recorded: 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."
+    "Absolute path to the project root of the flow being recorded: the same value passed to flow-start-recording. Together with `name` it identifies which recording this step belongs to."
   ),
   command: external_exports.string().describe(
     'MCP tool to execute and record, for example "gesture-tap". Do not pass a flow directive or a recording tool. Call flow-add-script directly for a requested script step.'
@@ -152832,7 +153292,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: zodSchema66,
+    zodSchema: zodSchema67,
     fileInputs: fileInputs3,
     services: () => ({}),
     async execute(_services, params, ctx) {
@@ -153021,10 +153481,10 @@ Returns { message, stepCount, recorded, savedTo }; \`recorded\`, not the status,
 
 // ../tool-server/src/tools/flows/flow-insert-echo.ts
 init_zod();
-var zodSchema67 = external_exports.object({
-  name: external_exports.string().describe("Name of the flow being recorded \u2014 the one passed to flow-start-recording."),
+var zodSchema68 = external_exports.object({
+  name: external_exports.string().describe("Name of the flow being recorded: 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."
+    "Absolute path to the project root of the flow being recorded: the same value passed to flow-start-recording. Together with `name` it identifies which recording this echo belongs to."
   ),
   message: external_exports.string().describe("Message to echo when the flow is replayed")
 });
@@ -153036,10 +153496,10 @@ var flowInsertEchoTool = {
     completedMsg: ({ params }) => `Added note to flow ${params.name}`,
     failedMsg: ({ params, failureSignal: failureSignal2 }) => `Failed to add note to flow ${params.name}: ${failureSignal2.error_code}`
   },
-  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.
+  description: `Record an echo step in the flow named by \`name\` + \`project_root\`. Echo steps print a message when the flow is replayed, 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: zodSchema67,
+  zodSchema: zodSchema68,
   services: () => ({}),
   async execute(_services, params) {
     const session = await requireRecordingSession(params.project_root, params.name);
@@ -154342,7 +154802,7 @@ function errMsg3(err) {
 
 // ../tool-server/src/tools/flows/flow-add-script.ts
 var OUTPUT_RENDER_LIMIT_BYTES = 64 * 1024;
-var zodSchema68 = external_exports.object({
+var zodSchema69 = 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(
@@ -154399,7 +154859,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: zodSchema68,
+  zodSchema: zodSchema69,
   services: () => ({}),
   async execute(_services, params, ctx) {
     const session = await requireRecordingSession(params.project_root, params.name);
@@ -154489,10 +154949,10 @@ var flowAddScriptTool = {
 // ../tool-server/src/tools/flows/flow-finish-recording.ts
 init_zod();
 var fs60 = __toESM(require("node:fs/promises"));
-var zodSchema69 = external_exports.object({
-  name: external_exports.string().describe("Name of the flow being recorded \u2014 the one passed to flow-start-recording."),
+var zodSchema70 = external_exports.object({
+  name: external_exports.string().describe("Name of the flow being recorded: 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."
+    "Absolute path to the project root of the flow being recorded: the same value passed to flow-start-recording. Together with `name` it identifies which recording to finish."
   )
 });
 function attachStepWarnings(summary, warnings) {
@@ -154548,7 +155008,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: zodSchema69,
+  zodSchema: zodSchema70,
   services: () => ({}),
   async execute(_services, params) {
     const { filePath, flowFile, savedTo, flow, summary, headline } = await withFlowFileLock(
@@ -157026,24 +157486,24 @@ async function restoreStatusBar(device) {
 }
 
 // ../tool-server/src/tools/flows/flow-run.ts
-var zodSchema70 = external_exports.object({
+var zodSchema71 = 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.'
   ),
   project_root: external_exports.string().describe(
-    "Absolute path to the calling agent's project root \u2014 the cwd it is working in. With name, the saved flow is read from `.argent/flows/<name>.yaml` under this root; with flow_path, the flow, its run: siblings, its script: paths and baselines all resolve beside the YAML instead, so pass the agent's cwd. A script still RUNS in this root whichever source was used."
+    "Absolute path to the calling agent's project root: the cwd it is working in. With name, the saved flow is read from `.argent/flows/<name>.yaml` under this root; with flow_path, the flow, its run: siblings, its script: paths and baselines all resolve beside the YAML instead, so pass the agent's cwd. A script still RUNS in this root whichever source was used."
   ),
   flow_file: external_exports.string().optional().describe(
-    "Path to the flow .yaml as readable by the tool-server. Internal \u2014 the argent client derives it from project_root and name automatically; leave unset."
+    "Path to the flow .yaml as readable by the tool-server. Internal: the argent client derives it from project_root and name automatically; leave unset."
   ),
   flow_path: external_exports.string().optional().describe(
     "Omit when name is set. Absolute path to a flow .yaml on the client. Over a link (argent link or ARGENT_TOOLS_URL), the argent client uploads the file, its run: fragments and the snapshot baselines of each run, and the tool-server runs those copies. Keep run: fragments under project_root or beside the flow file. With updateBaselines, the client writes the new baselines when the run ends. The client also uploads each absolute .png or .yaml path that a tool: step takes as a file argument, when the file is under project_root or beside the flow file. A tool: flow-execute step that names a flow with name and an absolute project_root without a .. segment runs: the client also uploads that flow and its own files. Over a link, the uploaded flows must not have: script: steps; tool: steps that run a flow another way or record a flow; tool: steps that take a directory, an app or an output directory; tool: steps whose tool builds a file path from several arguments; tool: steps that name a relative path or a file other than .png or .yaml. Without a link, the tool-server reads the files in place and all step kinds run."
   ),
   device: external_exports.string().optional().describe(
-    "Device id to run against (iOS UDID, Android/Vega serial, Chromium id) \u2014 the id list-devices reports. Auto-detected when omitted, but only when exactly one booted device matches (optionally narrowed by `platform`); with several booted the run fails and lists them, so pass this explicitly whenever more than one device is up."
+    "Device id to run against (iOS UDID, Android/Vega serial, Chromium id), as list-devices reports it. Auto-detected when omitted, but only when exactly one booted device matches (optionally narrowed by `platform`); with several booted the run fails and lists them, so pass this explicitly whenever more than one device is up."
   ),
   platform: external_exports.enum(SELECTABLE_PLATFORMS).optional().describe(
-    "Restrict auto-detection to this platform when several devices are booted. `ios` selects local simulators only \u2014 pass `ios-remote` to select a remote one. `chromium` does more than filter: with no `device` it SELECTS the self-boot branch for an e2e flow - the runner boots an Electron instance from the `launch` step's chromium value and tears it down after the run (a single-key `launch: { chromium: \u2026 }` map selects it on its own, without this parameter). When it selects that branch it never falls back to device auto-detection (a fragment, or an e2e launch map with no `chromium` key, still does), and the launch value must be a real Electron app path on the tool-server host: a bare-string `launch:` - what the recorder writes - holds an installed-app bundle id, so passing `chromium` for one fails the whole run with `Electron boot: path does not exist`. Edit the launch to `{ chromium: <app path> }` first."
+    "Restrict auto-detection to this platform when several devices are booted. `ios` selects local simulators only; pass `ios-remote` to select a remote one. `chromium` does more than filter: with no `device` it SELECTS the self-boot branch for an e2e flow - the runner boots an Electron instance from the `launch` step's chromium value and tears it down after the run (a single-key `launch: { chromium: \u2026 }` map selects it on its own, without this parameter). When it selects that branch it never falls back to device auto-detection (a fragment, or an e2e launch map with no `chromium` key, still does), and the launch value must be a real Electron app path on the tool-server host: a bare-string `launch:` - what the recorder writes - holds an installed-app bundle id, so passing `chromium` for one fails the whole run with `Electron boot: path does not exist`. Edit the launch to `{ chromium: <app path> }` first."
   ),
   updateBaselines: external_exports.boolean().optional().describe(
     "Write/refresh screenshot baselines for `snapshot` steps instead of diffing against them, also in the flows that tool: flow-execute steps run, unless such a step sets updateBaselines itself."
@@ -157533,7 +157993,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: zodSchema70,
+    zodSchema: zodSchema71,
     fileInputs: fileInputs4,
     services: () => ({}),
     async execute(_services, params, ctx) {
@@ -158510,15 +158970,15 @@ 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 zodSchema71 = external_exports.object({
+var zodSchema72 = 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.'
   ),
   project_root: external_exports.string().describe(
-    "Absolute path to the calling agent's project root \u2014 the cwd it is working in. With name, the saved flow is read from `.argent/flows/<name>.yaml` under this root; with flow_path, the prerequisite is read from that YAML instead, so pass the agent's cwd."
+    "Absolute path to the calling agent's project root: the cwd it is working in. With name, the saved flow is read from `.argent/flows/<name>.yaml` under this root; with flow_path, the prerequisite is read from that YAML instead, so pass the agent's cwd."
   ),
   flow_file: external_exports.string().optional().describe(
-    "Path to the flow .yaml as readable by the tool-server. Internal \u2014 the argent client derives it from project_root and name automatically; leave unset."
+    "Path to the flow .yaml as readable by the tool-server. Internal: the argent client derives it from project_root and name automatically; leave unset."
   ),
   flow_path: external_exports.string().optional().describe(
     "Omit when name is set. Absolute path to a flow .yaml on the client. Over a link (argent link or ARGENT_TOOLS_URL), the argent client uploads the file and the tool-server reads the uploaded copy; without a link, the tool-server reads the file in place. Pass the path through the argent client; a raw path that the file-input boundary did not verify is rejected. Pass the same flow source here as to flow-execute, so the prerequisite you read belongs to the flow that will run."
@@ -158556,7 +159016,7 @@ var flowReadPrerequisiteTool = {
     completedMsg: () => "Read flow prerequisite",
     failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to read flow prerequisite: ${failureSignal2.error_code}`
   },
-  description: `Read the execution prerequisite of a flow without running it \u2014 a saved flow from the .argent/flows/ directory, or an explicit boundary-managed flow_path.
+  description: `Read the execution prerequisite of a flow without running it: a saved flow from the .argent/flows/ directory, or an explicit boundary-managed flow_path.
 Returns { flow, executionPrerequisite }: the logical name, plus the precondition its author recorded
 verbatim. Empty when none was declared, which is always so for a self-contained scenario: one opening
 on a launch may declare no prerequisite, because it builds its own start state.
@@ -158566,7 +159026,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: zodSchema71,
+  zodSchema: zodSchema72,
   fileInputs: fileInputs5,
   services: () => ({}),
   async execute(_services, params, ctx) {
@@ -158882,7 +159342,7 @@ async function readWorkspaceSnapshot(workspacePath) {
 }
 
 // ../tool-server/src/tools/workspace/gather-workspace-data.ts
-var zodSchema72 = external_exports.object({
+var zodSchema73 = external_exports.object({
   workspacePath: external_exports.string().describe("Absolute path to the project root directory to inspect (e.g. /Users/dev/MyApp)")
 });
 var fileInputs6 = [
@@ -158913,7 +159373,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: zodSchema72,
+  zodSchema: zodSchema73,
   fileInputs: fileInputs6,
   services: () => ({}),
   async execute(_services, params) {
@@ -158987,9 +159447,9 @@ function targetFlagsFor(target) {
   if (target === "both") return ["--global", "--local"];
   return [`--${target}`];
 }
-var zodSchema73 = external_exports.object({
+var zodSchema74 = 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."
+    "Which install to update. 'auto' (default) updates the install serving this session: 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."
   )
 });
 var updateScheduled = false;
@@ -159001,7 +159461,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: zodSchema73,
+  zodSchema: zodSchema74,
   services: () => ({}),
   async execute(_services, params, _options) {
     const { updateAvailable, updateInstallable, currentVersion, installableVersion } = getUpdateState();
@@ -159086,7 +159546,7 @@ var updateArgentTool = {
 
 // ../tool-server/src/tools/system/dismiss-update.ts
 init_zod();
-var zodSchema74 = external_exports.object({
+var zodSchema75 = external_exports.object({
   hours: external_exports.number().min(0).describe("Number of hours to suppress the update notification")
 });
 var dismissUpdateTool = {
@@ -159097,7 +159557,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: zodSchema74,
+  zodSchema: zodSchema75,
   services: () => ({}),
   async execute(_services, params, _options) {
     const durationMs = params.hours * 60 * 60 * 1e3;
@@ -159116,7 +159576,7 @@ var import_path8 = __toESM(require("path"));
 init_zod();
 init_src2();
 init_device_info();
-var zodSchema75 = external_exports.object({
+var zodSchema76 = 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)."),
@@ -159130,10 +159590,10 @@ var zodSchema75 = external_exports.object({
     "Orientation override for live baseline/current captures. Ignored on physical iPhones."
   ),
   outputDir: external_exports.string().min(1).optional().describe(
-    "Directory where diff artifacts should be written. Optional \u2014 defaults to a temp directory; the diff images are returned in the result either way."
+    "Directory where diff artifacts should be written. Optional: defaults to a temp directory; the diff images are returned in the result either way."
   )
 }).strict();
-var capability34 = {
+var capability35 = {
   apple: { simulator: true, device: true },
   android: { emulator: true, device: true, unknown: true }
 };
@@ -159158,8 +159618,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: zodSchema75,
-  capability: capability34,
+  zodSchema: zodSchema76,
+  capability: capability35,
   fileInputs: fileInputs7,
   services: (params) => {
     if (params.captureBaseline || params.captureCurrent) {
@@ -159472,12 +159932,12 @@ async function captureElementFrame(registry2, udid, match, opts = {}) {
 }
 
 // ../tool-server/src/tools/variants/propose-variant.ts
-var zodSchema76 = external_exports.object({
+var zodSchema77 = 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.'
   ),
   udid: external_exports.string().min(1).max(200).optional().describe(
-    "Device id (iOS udid / Android serial) the variants were captured on. The preview window streams THIS device directly \u2014 pass the same udid you screenshotted/described with, so the human never has to pick a simulator. Set it on the first propose_variant of a round; later calls may omit it (the last non-empty value wins)."
+    "Device id (iOS udid / Android serial) the variants were captured on. The preview window streams THIS device directly; pass the same udid you screenshotted/described with, so the human never has to pick a simulator. Set it on the first propose_variant of a round; later calls may omit it (the last non-empty value wins)."
   ),
   match: external_exports.object({
     by: external_exports.enum(["text", "label", "identifier", "role"]).describe(
@@ -159501,7 +159961,7 @@ var zodSchema76 = external_exports.object({
       width: external_exports.number(),
       height: external_exports.number()
     }).optional().describe(
-      "Normalized [0..1] bounds (fractions of screen width/height) of the target element AS IT APPEARS IN THIS VARIANT \u2014 read the matched node's `frame` from `describe` AFTER applying this variant. The preview window crops the screenshot to these bounds, so each variant shows its own re-laid-out element instead of every variant sharing one stale frame. The element moves/resizes between variants, so capture it per variant. Omit if unknown."
+      "Normalized [0..1] bounds (fractions of screen width/height) of the target element AS IT APPEARS IN THIS VARIANT. Read the matched node's `frame` from `describe` AFTER applying this variant. The preview window crops the screenshot to these bounds, so each variant shows its own re-laid-out element instead of every variant sharing one stale frame. The element moves/resizes between variants, so capture it per variant. Omit if unknown."
     )
   }).describe("The variant being proposed for `element`.")
 });
@@ -159519,20 +159979,20 @@ function createProposeVariantTool(registry2) {
 Use when you have produced multiple alternative designs for an element and want the human to pick.
 Call this once per variant: e.g. propose_variant("Foo", v1), propose_variant("Foo", v2),
 propose_variant("Bar", v1)\u2026  Variants accumulate per element and across elements. The agent is NOT
-blocked \u2014 keep proposing and keep working. Each element appears live in the Argent Lens window (a
+blocked: keep proposing and keep working. Each element appears live in the Argent Lens window (a
 native window that opens automatically) as a floating card beside the streamed simulator, with a thin
 line connecting it to the matched on-screen element; you don't open or display anything yourself. Pass
 variant.previewImage (e.g. a screenshot path) to show how each variant looks.
 
-When you have proposed every variant for every element, you are done staging \u2014 the human reviews them
+When you have proposed every variant for every element, you are done staging. The human reviews them
 in the Argent Lens window and sends back their picks and comments. If an \`await_user_selection\` tool
 is available, call it once to block until they submit; otherwise just end your turn and their feedback
 arrives as a follow-up message (this is the case in an \`argent lens\` CLI session).
 
-Returns { round, elementId, variantId, element, variantCount, totalElements } \u2014 confirmation only;
+Returns { round, elementId, variantId, element, variantCount, totalElements }: confirmation only;
 it does not wait for the user.`,
     searchHint: "propose design variant alternative option for element non-blocking ab choice",
-    zodSchema: zodSchema76,
+    zodSchema: zodSchema77,
     services: () => ({}),
     async execute(_services, params) {
       let frame = params.variant.frame;
@@ -159556,9 +160016,9 @@ it does not wait for the user.`,
 
 // ../tool-server/src/tools/variants/await-user-selection.ts
 init_zod();
-var zodSchema77 = external_exports.object({
+var zodSchema78 = 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."
+    "Max seconds to block this call before returning a re-awaitable { status: 'pending' } result (default 1800). The user's proposals stay live across timeouts; on 'pending' just call await_user_selection again. Lower this if your MCP client enforces a short request timeout."
   )
 });
 var awaitUserSelectionTool = {
@@ -159583,21 +160043,21 @@ that opens automatically on the user's screen), then returns their choices and a
 Returns one of:
   \u2022 { status: "completed", round, selections: [{ element, chosenVariant, comment? }], unselected,
       annotations: [{ target, match, comment }], globalComment, morePending? }
-        \u2014 the user finished this round; apply chosenVariant for each element (skip ones in
+        The user finished this round; apply chosenVariant for each element (skip ones in
         \`unselected\`). \`annotations\` are free-form comments the user pinned to specific on-screen
-        elements via the inspector \u2014 treat each as a change request for that element.
+        elements via the inspector; treat each as a change request for that element.
         If \`morePending\` is true, another already-decided round or a freshly-staged round is
-        still waiting \u2014 call await_user_selection AGAIN (repeat until you get a completed result
+        still waiting. Call await_user_selection AGAIN (repeat until you get a completed result
         without \`morePending\`, a \`pending\`, or \`no_proposals\`); do not stop on this result alone.
-  \u2022 { status: "pending", message, proposedElements } \u2014 timeoutSeconds elapsed with no submission.
+  \u2022 { status: "pending", message, proposedElements }: timeoutSeconds elapsed with no submission.
         Expected, not an error: the proposals are still live; call await_user_selection AGAIN.
-  \u2022 { status: "no_proposals" } \u2014 you called this before propose_variant.
+  \u2022 { status: "no_proposals" }: you called this before propose_variant.
 
 This tool is long-running; it intentionally holds the request open. It honors client
 disconnects (aborts cleanly).`,
   searchHint: "await wait user selection choice variant blocking confirm picks complete",
   longRunning: true,
-  zodSchema: zodSchema77,
+  zodSchema: zodSchema78,
   services: () => ({}),
   async execute(_services, params, options) {
     const timeoutMs = (params.timeoutSeconds ?? 1800) * 1e3;
@@ -159612,7 +160072,7 @@ disconnects (aborts cleanly).`,
 init_zod();
 init_src2();
 init_device_info();
-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(["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."
@@ -159645,7 +160105,7 @@ var tabAction = {
     failure: "close"
   }
 };
-var capability35 = {
+var capability36 = {
   chromium: { app: true }
 };
 var chromiumTabsTool = {
@@ -159663,8 +160123,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: zodSchema78,
-  capability: capability35,
+  zodSchema: zodSchema79,
+  capability: capability36,
   services: (params) => {
     const device = resolveDevice(params.udid);
     if (device.platform === "chromium") {
@@ -159765,7 +160225,7 @@ async function clearStorage(cdp, type) {
 }
 
 // ../tool-server/src/tools/chromium-cookies/index.ts
-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`)."),
   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."
@@ -159788,7 +160248,7 @@ var cookieAction = {
   delete: { started: "Deleting", completed: "Deleted", failure: "delete" },
   clear: { started: "Clearing", completed: "Cleared", failure: "clear" }
 };
-var capability36 = {
+var capability37 = {
   chromium: { app: true }
 };
 var chromiumCookiesTool = {
@@ -159806,8 +160266,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: zodSchema79,
-  capability: capability36,
+  zodSchema: zodSchema80,
+  capability: capability37,
   services: (params) => {
     const device = resolveDevice(params.udid);
     if (device.platform === "chromium") {
@@ -159872,7 +160332,7 @@ Returns { cookies, count } for get, or a small status object ({ set } / { delete
 init_zod();
 init_src2();
 init_device_info();
-var zodSchema80 = external_exports.object({
+var zodSchema81 = 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(
@@ -159887,7 +160347,7 @@ var storageAction = {
   remove: { started: "Removing from", completed: "Removed from", failure: "remove from" },
   clear: { started: "Clearing", completed: "Cleared", failure: "clear" }
 };
-var capability37 = {
+var capability38 = {
   chromium: { app: true }
 };
 var chromiumStorageTool = {
@@ -159906,8 +160366,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: zodSchema80,
-  capability: capability37,
+  zodSchema: zodSchema81,
+  capability: capability38,
   services: (params) => {
     const device = resolveDevice(params.udid);
     if (device.platform === "chromium") {
@@ -160020,6 +160480,7 @@ function createRegistry() {
   registry2.registerTool(createDescribeTool(registry2));
   registry2.registerTool(createUiTreeTool(registry2));
   registry2.registerTool(createForegroundAppTool(registry2));
+  registry2.registerTool(createFillTool(registry2));
   registry2.registerTool(createAwaitUiElementTool(registry2));
   registry2.registerTool(createAwaitScreenIdleTool(registry2));
   registry2.registerTool(createReactProfilerStartTool(registry2));