@swmansion/argent 0.28.1-next.22 → 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.22";
+    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");
   }
 }
@@ -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;
@@ -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)}`;
 }
@@ -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 },
@@ -137179,8 +137639,8 @@ ${DEFAULT_TIMEOUT_MS4}ms) is reached. Returns { settled, waitedMs, polls }; sett
 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,7 +137737,7 @@ function bootstrapFailureMessage(bootstrap) {
 // ../tool-server/src/tools/profiler/react/react-profiler-start.ts
 var NO_DEVTOOLS_HOOK_ERROR = "React DevTools hook (__REACT_DEVTOOLS_GLOBAL_HOOK__) is not present in this app's JavaScript runtime. React profiling requires a development build with React DevTools enabled. Likely causes: (1) the app is a release/production build \u2014 DevTools is stripped to reduce bundle size; (2) you connected to the wrong JS runtime; (3) this isn't a React (Native) app. Fix: rebuild in debug/dev mode (e.g. `npx react-native run-ios` without --configuration Release; for Expo, run a dev client). Once the app is running with DevTools attached, call react-profiler-start again.";
 var NO_RENDERERS_ATTACHED_ERROR = "React DevTools hook is present but no React renderer has registered yet. The hook is loaded but no fiber renderer has attached \u2014 typically because the app has not committed its first render, or the DevTools backend has not been bootstrapped on a bridgeless React Native dev build. Fix: ensure the app has rendered (interact with it once, then retry); if it stays empty, call react-profiler-start first \u2014 it will attempt to attach the DevTools backend automatically.";
-var zodSchema44 = external_exports.object({
+var zodSchema45 = external_exports.object({
   port: metroPortField,
   device_id: external_exports.string().describe(
     "Device id from list-devices: the SAME id you passed to debugger-connect (iOS simulator UDID or Android serial)."
@@ -137309,7 +137769,7 @@ Before calling this, ask the user if they also want native profiling (native-pro
 After starting, ask the user to perform the interaction to profile, then call react-profiler-stop.
 Returns { started_at, startedAtEpochMs, hermes_version, detected_architecture } on success, or the already_running payload described above.
 Fails if the Hermes runtime is not reachable or the Metro CDP connection cannot be established.`,
-    zodSchema: zodSchema44,
+    zodSchema: zodSchema45,
     capability: RN_ONLY_TOOL_CAPABILITY,
     services: () => ({}),
     async execute(_services, params) {
@@ -137580,7 +138040,7 @@ 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: the SAME id you passed to debugger-connect (iOS simulator UDID or Android serial)."
@@ -137669,7 +138129,7 @@ Call react-profiler-start first, then exercise the app, then call this.
 Returns { duration_ms, sample_count, fiber_renders_captured, total_react_commits, hot_commit_indices } summarizing the session.
 When any commit had fibers whose display name could not be resolved at stop time (typically transient components like modals/tooltips/animations that unmounted before stop), the response also includes { unattributed_ms, unattributed_fiber_count, unattributed_commit_count }. 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)."
@@ -137909,7 +138369,7 @@ function createReactProfilerStatusTool(registry2) {
       failedMsg: ({ failureSignal: failureSignal2 }) => `Failed to check React profiler: ${failureSignal2.error_code}`
     },
     description: `Check the state of the React profiler session without side effects. Use after an interruption (debugger disconnect, unexpected error, agent pause) to decide whether to continue with react-profiler-stop, start a new session, or reconnect the debugger. Ownership is verified server-side against this tool-server's in-memory session, 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: zodSchema46,
+    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")
 });
@@ -139711,7 +140171,7 @@ var reactProfilerComponentSourceTool = {
 Call this per-finding after react-profiler-analyze to inspect source before proposing a fix.
 Returns found: false if the component is not found in user-owned code (e.g. lives in node_modules).
 When several files define a component with the same name (e.g. platform variants like List.tsx and List.web.tsx), returns the primary match and lists the rest under otherMatches[] (file/line/col). Check it before assuming the returned file is the one you meant.`,
-  zodSchema: zodSchema48,
+  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)."
@@ -139849,7 +140309,7 @@ Use when you specifically need to investigate JS CPU hotspots that are NOT tied
 Call react-profiler-stop first. Reads directly from the stored cpuProfile.
 Returns a markdown table of the top hotspot functions with self-time, total-time, and location.
 Fails if react-profiler-stop has not been called or no CPU profile is stored.`,
-  zodSchema: 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)."
@@ -139963,7 +140423,7 @@ var reactProfilerRendersTool = {
 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)."
   ),
@@ -143951,7 +144411,7 @@ var zodSchema52 = external_exports.object({
     "iOS-only. When true, cold-launches the app under the profiler with Malloc Stack Logging enabled so memory leaks carry an allocation backtrace (responsible frame + library). Without it, leaks are still detected but unattributable: 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,7 +145650,7 @@ 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.
@@ -145199,7 +145659,7 @@ Use when the user wants a video of an interaction, animation, or app behavior; f
 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); 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({
@@ -145359,7 +145819,7 @@ var timeWindowSchema = external_exports.object({
     "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)."
@@ -145648,7 +146108,7 @@ Every table states how many samples it covers and how much of that was idle.
 Use when investigating JS CPU hotspots or correlating CPU cost with specific components.
 Returns a markdown table of CPU hotspots, call tree, or per-component CPU breakdown.
 Fails if no CPU profile is stored; run react-profiler-stop first.`,
-  zodSchema: zodSchema57,
+  zodSchema: zodSchema58,
   // RN-only: reads Hermes-format CPU profiles; Chromium's V8 sample format differs.
   capability: RN_ONLY_TOOL_CAPABILITY,
   services: () => ({}),
@@ -145734,7 +146194,7 @@ var timeRangeSchema = external_exports.object({
     "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)."
@@ -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,7 +147802,7 @@ 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. 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."
   )
@@ -147381,7 +147841,7 @@ function createStopAllSimulatorServersTool(registry2) {
 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, 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,
+    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 = {
@@ -147472,7 +147932,7 @@ var stopMetroTool = {
     failedMsg: ({ params, failureSignal: failureSignal2 }) => `Failed to stop Metro on port ${params.port}: ${failureSignal2.error_code}`
   },
   description: `Stop the Metro bundler process listening on a given port (default 8081). Use when ending a React Native session or when Metro must be restarted. Returns { stopped, port, pids }; stopped=false if no process is found on the port. Fails if the port lookup command times out or the process cannot be killed. This is DESTRUCTIVE: always ask the user for confirmation before calling this tool.`,
-  zodSchema: zodSchema64,
+  zodSchema: zodSchema65,
   services: () => ({}),
   async execute(_services, params) {
     const port = params.port;
@@ -149816,7 +150276,7 @@ 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"): letters, digits, underscore and hyphen only.'
   ),
@@ -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,7 +152833,7 @@ function stepAnchor(step) {
 
 // ../tool-server/src/tools/flows/flow-add-step.ts
 init_device_info();
-var zodSchema66 = external_exports.object({
+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: the same value passed to flow-start-recording. Together with `name` it identifies which recording this step belongs to."
@@ -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,7 +153481,7 @@ 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({
+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: the same value passed to flow-start-recording. Together with `name` it identifies which recording this echo belongs to."
@@ -153039,7 +153499,7 @@ var flowInsertEchoTool = {
   description: `Record an echo step in the flow named by \`name\` + \`project_root\`. Echo steps print a message when the flow is replayed, 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,7 +154949,7 @@ 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({
+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: the same value passed to flow-start-recording. Together with `name` it identifies which recording to finish."
@@ -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,7 +157486,7 @@ 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.'
   ),
@@ -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,7 +158970,7 @@ async function resolveFlowSource(params, fileInput, flowPathInput) {
 // ../tool-server/src/tools/flows/flow-read-prerequisite.ts
 init_zod();
 var fs64 = __toESM(require("node:fs/promises"));
-var 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.'
   ),
@@ -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,7 +159447,7 @@ 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: 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."
   )
@@ -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)."),
@@ -159133,7 +159593,7 @@ var zodSchema75 = external_exports.object({
     "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,7 +159932,7 @@ 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.'
   ),
@@ -159532,7 +159992,7 @@ arrives as a follow-up message (this is the case in an \`argent lens\` CLI sessi
 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,7 +160016,7 @@ 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; on 'pending' just call await_user_selection again. Lower this if your MCP client enforces a short request timeout."
   )
@@ -159597,7 +160057,7 @@ This tool is long-running; it intentionally holds the request open. It honors cl
 disconnects (aborts cleanly).`,
   searchHint: "await wait user selection choice variant blocking confirm picks complete",
   longRunning: true,
-  zodSchema: 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));