@swmansion/argent 0.31.2-next.1 → 0.31.2-next.11

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/ArgentRunnerSession+Gestures.swift

@@ -21,10 +21,10 @@ extension ArgentRunnerSession {
 
     /// Taps at the wire coordinates: one tap, the native double-tap when
     /// `numberOfTaps` is 2, or a loop of single taps above that. XCUICoordinate
-    /// has no N-tap API, and the loop is not one gesture on hardware: each tap
-    /// is its own synthesized event behind XCTest's idle wait and an XPC round
-    /// trip, hundreds of milliseconds apart, so the taps land separately and do
-    /// not trigger a multi-tap recognizer. That is documented, not refused.
+    /// has no N-tap API, and the loop is not one gesture: each tap is its own
+    /// synthesized event and XPC round trip, about 300 ms apart on a
+    /// simulator, which a double-tap recognizer can still pair. That is
+    /// documented, not refused.
     func performTap(_ request: CommandRequest, on app: XCUIApplication)
         -> Envelope
     {
@@ -39,15 +39,17 @@ extension ArgentRunnerSession {
 
         let coordinate = point(app, x, y, relativeTo: app.frame.origin)
 
-        switch taps {
-        case 1:
-            coordinate.tap()
-        case 2:
-            coordinate.doubleTap()
-        default:
-            // Separate taps, not one gesture (see the doc comment above).
-            for _ in 0..<taps {
+        skippingQuiescence(of: app) {
+            switch taps {
+            case 1:
                 coordinate.tap()
+            case 2:
+                coordinate.doubleTap()
+            default:
+                // Separate taps, not one gesture (see the doc comment above).
+                for _ in 0..<taps {
+                    coordinate.tap()
+                }
             }
         }
 
@@ -63,7 +65,11 @@ extension ArgentRunnerSession {
         }
 
         let seconds = max(0.05, (request.durationMs ?? 800) / 1000)
-        point(app, x, y, relativeTo: app.frame.origin).press(forDuration: seconds)
+        let coordinate = point(app, x, y, relativeTo: app.frame.origin)
+
+        skippingQuiescence(of: app) {
+            coordinate.press(forDuration: seconds)
+        }
 
         return .success(MessagePayload(message: "long-pressed"))
     }
@@ -112,12 +118,14 @@ extension ArgentRunnerSession {
             velocity = .default
         }
 
-        start.press(
-            forDuration: startHold,
-            thenDragTo: end,
-            withVelocity: velocity,
-            thenHoldForDuration: endHold
-        )
+        skippingQuiescence(of: app) {
+            start.press(
+                forDuration: startHold,
+                thenDragTo: end,
+                withVelocity: velocity,
+                thenHoldForDuration: endHold
+            )
+        }
 
         return .success(MessagePayload(message: "dragged"))
     }

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/ArgentRunnerSession+Quiescence.swift

@@ -0,0 +1,95 @@
+import XCTest
+
+/// XCTest waits up to 60s before and after every synthesized event for the
+/// app to report idle. A screen that never does, such as one holding a paused
+/// UIViewPropertyAnimator (expo-blur), stalls each gesture for two minutes,
+/// past its watchdog budget. The runner skips those waits and runs XCTest's
+/// idle check itself under a short cap. Every API here is XCTest SPI, probed
+/// before use: when any is missing, the event runs with XCTest's own waits.
+extension ArgentRunnerSession {
+    /// The longest a gesture waits for the app to go idle before its event.
+    /// Covers a navigation transition, so a gesture sent right after the one
+    /// that started it lands on the new screen instead of mid-transition.
+    static let preEventSettleTimeout: TimeInterval = 2
+
+    private static let performWithInteractionOptions = NSSelectorFromString(
+        "_performWithInteractionOptions:block:"
+    )
+    /// Bit 1 skips the pre-event wait, bit 2 the post-event one.
+    private static let skipQuiescenceOptions: UInt32 = 0b11
+
+    private static let applicationImpl = NSSelectorFromString("applicationImpl")
+    private static let currentProcess = NSSelectorFromString("currentProcess")
+    private static let initiateQuiescenceChecks = NSSelectorFromString(
+        "_initiateQuiescenceChecksIncludingAnimationsIdle:"
+    )
+    private static let makeQuiescenceExpectation = NSSelectorFromString(
+        "_makeQuiescenceExpectation"
+    )
+
+    /// Waits at most `preEventSettleTimeout` for `app` to go idle, then runs
+    /// `body`, which synthesizes events into it, without XCTest's waits.
+    func skippingQuiescence(of app: XCUIApplication, _ body: () -> Void) {
+        let selector = Self.performWithInteractionOptions
+
+        guard app.responds(to: selector),
+            awaitQuiescence(of: app, timeout: Self.preEventSettleTimeout)
+        else {
+            body()
+            return
+        }
+
+        typealias Perform = @convention(c) (
+            NSObject, Selector, UInt32, @convention(block) () -> Void
+        ) -> Void
+        let perform = unsafeBitCast(app.method(for: selector), to: Perform.self)
+
+        // XCTest restores the prior options only when the block returns, and
+        // every XCUIApplication for this bundle id shares them, so an
+        // exception must not unwind through it.
+        var exception: NSException?
+        withoutActuallyEscaping(body) { body in
+            perform(app, selector, Self.skipQuiescenceOptions) {
+                exception = ArgentExceptionGuard.exception(from: body)
+            }
+        }
+        exception?.raise()
+    }
+
+    /// XCTest's own idle check (event loop and animations), under `timeout`.
+    /// False when any SPI it needs is missing.
+    private func awaitQuiescence(of app: XCUIApplication, timeout: TimeInterval)
+        -> Bool
+    {
+        guard
+            let impl = Self.object(app, Self.applicationImpl),
+            let process = Self.object(impl, Self.currentProcess),
+            process.responds(to: Self.initiateQuiescenceChecks)
+        else {
+            return false
+        }
+
+        typealias Initiate = @convention(c) (NSObject, Selector, Bool) -> Void
+        let initiate = unsafeBitCast(
+            process.method(for: Self.initiateQuiescenceChecks),
+            to: Initiate.self
+        )
+        initiate(process, Self.initiateQuiescenceChecks, true)
+
+        guard
+            let expectation = Self.object(process, Self.makeQuiescenceExpectation)
+                as? XCTestExpectation
+        else {
+            return false
+        }
+
+        _ = XCTWaiter.wait(for: [expectation], timeout: timeout)
+        return true
+    }
+
+    /// The object a zero-argument getter returns, or nil when `target` lacks it.
+    private static func object(_ target: NSObject, _ getter: Selector) -> NSObject? {
+        guard target.responds(to: getter) else { return nil }
+        return target.perform(getter)?.takeUnretainedValue() as? NSObject
+    }
+}

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/ArgentRunnerSession+TextEntry.swift

@@ -77,7 +77,7 @@ extension ArgentRunnerSession {
                 app.keyboards.keys.matching(submitKey).firstMatch,
             ] where candidate.exists && candidate.isHittable {
                 let label = candidate.label
-                candidate.tap()
+                skippingQuiescence(of: app) { candidate.tap() }
 
                 return .success(
                     MessagePayload(message: "pressed keyboard \(label)")
@@ -131,7 +131,7 @@ extension ArgentRunnerSession {
         }
 
         let exceptionDescription = ArgentExceptionGuard.runCatching {
-            app.typeText(text)
+            self.skippingQuiescence(of: app) { app.typeText(text) }
         }
 
         if let exceptionDescription {

package/dist/ios-device-runner/ArgentRunner/ArgentRunnerUITests/RunnerProtocol.swift

@@ -70,10 +70,10 @@ extension CommandKind {
         switch self {
         // XCTest types long strings in real time, so typing needs extra room.
         case .type: return 55
-        // Gestures must outlast XCTest's ~60s pre-event idle wait. A screen that
-        // never reports quiescent stalls the wait until XCTest gives up and
-        // synthesizes the event anyway, and a shorter budget would abandon a
-        // command that still completes.
+        // tap, longPress and drag outlast XCTest's ~60s pre-event idle wait,
+        // which runs where the runner cannot skip it
+        // (ArgentRunnerSession+Quiescence.swift). touchPaths never waits for
+        // idle but shares the gesture budget.
         case .tap, .longPress, .drag, .touchPaths: return 75
         default: return 30
         }
@@ -117,7 +117,7 @@ struct CommandRequest: Codable {
     let y: Double?
     /// `tap`: number of taps. Defaults to 1; 2 is the native double-tap.
     /// Higher counts loop single taps on the device: there is no native N-tap
-    /// API, so they land as separate taps, not one multi-tap gesture.
+    /// API, so they are not one multi-tap gesture.
     let numberOfTaps: Int?
     /// `drag`: absolute start and end points.
     let fromX: Double?

package/dist/mcp-server.mjs

@@ -25593,6 +25593,36 @@ var TOOL_ID_ALIASES = Object.freeze({
 function canonicalToolId(id) {
   return Object.hasOwn(TOOL_ID_ALIASES, id) ? TOOL_ID_ALIASES[id] : id;
 }
+var TOOL_PARAM_ALIASES = Object.freeze({
+  "e2e-execute": Object.freeze({ flow_path: "e2e_test_path", flow_file: "e2e_test_file" }),
+  "e2e-read-prerequisite": Object.freeze({
+    flow_path: "e2e_test_path",
+    flow_file: "e2e_test_file"
+  })
+});
+var ToolParamAliasError = class extends Error {
+  constructor(former, current) {
+    super(`Pass ${current} or its former name ${former}, not both.`);
+    this.name = "ToolParamAliasError";
+  }
+};
+function toolParamAliases(tool) {
+  const id = canonicalToolId(tool);
+  return Object.hasOwn(TOOL_PARAM_ALIASES, id) ? TOOL_PARAM_ALIASES[id] : {};
+}
+function canonicalToolArgs(tool, args) {
+  if (typeof args !== "object" || args === null || Array.isArray(args)) return args;
+  const record2 = args;
+  let out;
+  for (const [former, current] of Object.entries(toolParamAliases(tool))) {
+    if (record2[former] === void 0) continue;
+    if (record2[current] !== void 0) throw new ToolParamAliasError(former, current);
+    out ??= { ...record2 };
+    out[current] = out[former];
+    delete out[former];
+  }
+  return out ?? args;
+}
 
 // ../registry/src/flow-file-refs.ts
 async function canonicalFlowPath(p) {
@@ -25662,7 +25692,13 @@ async function classifyOnDiskSpelling(dir, base, addressable = FLOW_FILE_NAME_PA
 }
 function nestedFlowTarget(args) {
   if (typeof args !== "object" || args === null || Array.isArray(args)) return void 0;
-  const { name, project_root: projectRoot, flow_path: flowPath } = args;
+  let canonical;
+  try {
+    canonical = canonicalToolArgs("e2e-execute", args);
+  } catch {
+    return void 0;
+  }
+  const { name, project_root: projectRoot, e2e_test_path: flowPath } = canonical;
   if (flowPath === void 0) {
     if (typeof name !== "string" || !FLOW_NAME_PATTERN.test(name)) return void 0;
     if (!isResolvedAbsolute(projectRoot)) return void 0;
@@ -25671,7 +25707,7 @@ function nestedFlowTarget(args) {
   }
   if (name !== void 0 || !isResolvedAbsolute(flowPath)) return void 0;
   if (!FLOW_FILE_NAME_PATTERN.test(path8.basename(flowPath))) return void 0;
-  return { kind: "flow_path", path: flowPath };
+  return { kind: "e2e_test_path", path: flowPath };
 }
 function isResolvedAbsolute(value) {
   return typeof value === "string" && path8.isAbsolute(value) && !value.split(/[\\/]+/).includes("..");
@@ -25703,6 +25739,8 @@ var FAILURE_CODES = {
   TOOL_CAPABILITY_UNSUPPORTED_OPERATION: "TOOL_CAPABILITY_UNSUPPORTED_OPERATION",
   TOOL_PLATFORM_NOT_IMPLEMENTED: "TOOL_PLATFORM_NOT_IMPLEMENTED",
   TOOL_DEPENDENCY_MISSING: "TOOL_DEPENDENCY_MISSING",
+  // Xcode's simctl or devicectl wrapper would start its component install and wait for a password.
+  TOOL_XCODE_FIRST_LAUNCH_PENDING: "TOOL_XCODE_FIRST_LAUNCH_PENDING",
   TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
   TOOLSERVER_UNHANDLED_REJECTION: "TOOLSERVER_UNHANDLED_REJECTION",
   TOOLSERVER_UNCAUGHT_EXCEPTION: "TOOLSERVER_UNCAUGHT_EXCEPTION",
@@ -25875,6 +25913,16 @@ var FAILURE_CODES = {
   JS_RUNTIME_CDP_DISCONNECTED: "JS_RUNTIME_CDP_DISCONNECTED",
   JS_RUNTIME_PAUSED: "JS_RUNTIME_PAUSED",
   NETWORK_INSPECTOR_CDP_DISCONNECTED: "NETWORK_INSPECTOR_CDP_DISCONNECTED",
+  ANDROID_NETWORK_INSPECTOR_FACTORY_OPTIONS_INVALID: "ANDROID_NETWORK_INSPECTOR_FACTORY_OPTIONS_INVALID",
+  ANDROID_NETWORK_INSPECTOR_WRONG_PLATFORM: "ANDROID_NETWORK_INSPECTOR_WRONG_PLATFORM",
+  ANDROID_NETWORK_INSPECTOR_UNKNOWN_PACKAGE: "ANDROID_NETWORK_INSPECTOR_UNKNOWN_PACKAGE",
+  ANDROID_NETWORK_INSPECTOR_RUN_AS_FAILED: "ANDROID_NETWORK_INSPECTOR_RUN_AS_FAILED",
+  ANDROID_NETWORK_INSPECTOR_DEVICE_IN_USE: "ANDROID_NETWORK_INSPECTOR_DEVICE_IN_USE",
+  ANDROID_NETWORK_INSPECTOR_NO_DEVICE_PORT: "ANDROID_NETWORK_INSPECTOR_NO_DEVICE_PORT",
+  NATIVE_NETWORK_LOGS_STOP_UNSUPPORTED: "NATIVE_NETWORK_LOGS_STOP_UNSUPPORTED",
+  NDJSON_CDP_REQUEST_TIMEOUT: "NDJSON_CDP_REQUEST_TIMEOUT",
+  NDJSON_CDP_REQUEST_FAILED: "NDJSON_CDP_REQUEST_FAILED",
+  NDJSON_CDP_CONNECTION_CLOSED: "NDJSON_CDP_CONNECTION_CLOSED",
   REACT_PROFILER_NO_ACTIVE_SESSION: "REACT_PROFILER_NO_ACTIVE_SESSION",
   REACT_PROFILER_CDP_CONNECTION_LOST: "REACT_PROFILER_CDP_CONNECTION_LOST",
   REACT_PROFILER_NO_CPU_PROFILE: "REACT_PROFILER_NO_CPU_PROFILE",
@@ -26611,12 +26659,18 @@ function isResolvedAbsolute2(value) {
   return typeof value === "string" && path11.isAbsolute(value) && !value.split(/[\\/]+/).includes("..");
 }
 function namesValidFlow(args) {
-  const { project_root, flow_path, name } = args;
+  let canonical;
+  try {
+    canonical = canonicalToolArgs("e2e-execute", args);
+  } catch {
+    return false;
+  }
+  const { project_root, e2e_test_path: testPath, name } = canonical;
   if (!isResolvedAbsolute2(project_root)) return false;
   if (name === void 0) {
-    return isResolvedAbsolute2(flow_path) && FLOW_FILE_NAME_PATTERN.test(path11.basename(flow_path));
+    return isResolvedAbsolute2(testPath) && FLOW_FILE_NAME_PATTERN.test(path11.basename(testPath));
   }
-  return flow_path === void 0 && typeof name === "string" && FLOW_NAME_PATTERN.test(name);
+  return testPath === void 0 && typeof name === "string" && FLOW_NAME_PATTERN.test(name);
 }
 function savedFlowProject(file) {
   if (!path11.isAbsolute(file)) return null;
@@ -26790,8 +26844,8 @@ function memberCollector(roots, opts) {
 `));
   const emit = (member, sent) => {
     members2.push(member);
-    const subject = member.role === "flow" ? member.canonical : member.key;
-    if (logging) log(printable(`[flow-files] ${member.role} ${subject}: ${sent}`));
+    const [label, subject] = member.role === "flow" ? ["e2e test", member.canonical] : [member.role, member.key];
+    if (logging) log(printable(`[e2e-files] ${label} ${subject}: ${sent}`));
   };
   async function flow(anchorDir, target, onlyPresent) {
     const key = flowMemberKey(anchorDir, target);
@@ -26957,7 +27011,7 @@ function recordedStep(args) {
   if (typeof text !== "string") return void 0;
   let parsed;
   try {
-    parsed = JSON.parse(text);
+    parsed = canonicalToolArgs(command, JSON.parse(text));
   } catch {
     return void 0;
   }
@@ -26980,7 +27034,7 @@ async function collectStepMembers(args, opts, recordingDirFor = e2eDirFor) {
     const self = await collector.flow(path11.dirname(recording), path11.basename(recording));
     let runArgs = step.args;
     const named = nestedFlowTarget(runArgs);
-    if (named?.kind === "flow_path") {
+    if (named?.kind === "e2e_test_path") {
       const stem = path11.basename(named.path, ".yaml");
       const base = path11.basename(named.path);
       const dir = path11.resolve(path11.dirname(named.path));
@@ -26989,7 +27043,7 @@ async function collectStepMembers(args, opts, recordingDirFor = e2eDirFor) {
       if (dirs.some((d) => path11.resolve(d) === dir)) {
         await collector.flow(path11.dirname(named.path), base);
         runArgs = { ...runArgs, name: stem };
-        delete runArgs.flow_path;
+        delete runArgs.e2e_test_path;
       }
     }
     const target = nestedFlowTarget(runArgs);
@@ -27017,7 +27071,21 @@ async function nameToE2ePathForOlderServer(tool, fileInputs, args) {
   const picked = await pickE2eFile(target.paths);
   if (!picked.exists || picked.legacy) return args;
   const { name: _name, ...rest } = args;
-  return { ...rest, flow_path: picked.path };
+  return { ...rest, e2e_test_path: picked.path };
+}
+function formerParamsForOlderServer(meta2, args) {
+  const listed = meta2.inputSchema.properties;
+  if (typeof args !== "object" || args === null || Array.isArray(args)) return args;
+  if (typeof listed !== "object" || listed === null) return args;
+  const record2 = args;
+  let out;
+  for (const [former, current] of Object.entries(toolParamAliases(meta2.name))) {
+    if (record2[current] === void 0 || current in listed || !(former in listed)) continue;
+    out ??= { ...record2 };
+    out[former] = out[current];
+    delete out[current];
+  }
+  return out ?? args;
 }
 async function stepForOlderServer(args, listedId) {
   if (typeof args !== "object" || args === null || Array.isArray(args)) return args;
@@ -27275,12 +27343,13 @@ function createToolsClient(options = {}) {
   async function callTool(name, args, opts) {
     opts?.signal?.throwIfAborted();
     const { url, token, remote } = await route();
-    let finalArgs = args;
+    let finalArgs = canonicalToolArgs(name, args);
     const tools = await fetchTools({ signal: opts?.signal });
     const meta2 = findTool(tools, name);
     const olderServer = meta2 !== null && !tools.some((t) => t.name === canonicalToolId(meta2.name));
     if (meta2) {
-      finalArgs = await nameToE2ePathForOlderServer(meta2.name, meta2.fileInputs, args);
+      finalArgs = await nameToE2ePathForOlderServer(meta2.name, meta2.fileInputs, finalArgs);
+      finalArgs = formerParamsForOlderServer(meta2, finalArgs);
     }
     if (olderServer && canonicalToolId(meta2.name) === "e2e-add-step") {
       finalArgs = await stepForOlderServer(finalArgs, (tool) => findTool(tools, tool)?.name);
@@ -27308,7 +27377,7 @@ function createToolsClient(options = {}) {
       if (filesLogEnabled()) {
         for (const file of applied.written) {
           if (baselineDirs.includes(path12.dirname(file))) {
-            diagnose(`[flow-files] baseline ${file}: written`);
+            diagnose(`[e2e-files] baseline ${file}: written`);
           }
         }
       }
@@ -28678,12 +28747,13 @@ function stepLabel(step) {
 }
 async function flowRunToMcpContent(result, ctx) {
   const blocks = [];
+  const name = result.e2eTest ?? result.flow;
   if (result.executionPrerequisite) {
     blocks.push({ type: "text", text: `Prerequisite: ${result.executionPrerequisite}` });
   }
   blocks.push({
     type: "text",
-    text: `Running e2e test "${result.flow}"${result.device ? ` on ${result.device}` : ""} (${result.steps.length} steps)`
+    text: `Running e2e test "${name}"${result.device ? ` on ${result.device}` : ""} (${result.steps.length} steps)`
   });
   if (typeof result.warning === "string")
     blocks.push({ type: "text", text: `\u26A0 ${result.warning}` });
@@ -28728,7 +28798,7 @@ async function flowRunToMcpContent(result, ctx) {
       text: `${result.ok ? "PASS" : "FAIL"} \u2014 ${result.passed ?? 0} passed, ${result.failed ?? 0} failed, ${result.errored ?? 0} errored, ${result.skipped ?? 0} skipped${note}${durationSuffix(result.durationMs)}`
     });
   } else {
-    blocks.push({ type: "text", text: `E2E test "${result.flow}" complete.` });
+    blocks.push({ type: "text", text: `E2E test "${name}" complete.` });
   }
   return blocks;
 }
@@ -29339,7 +29409,7 @@ ${desc}` }];
         deviceId: getDeviceIdFromArgs(params.arguments)
       };
       let content;
-      if (canonicalToolId(params.name) === "e2e-execute" && result && typeof result === "object" && "flow" in result && "steps" in result) {
+      if (canonicalToolId(params.name) === "e2e-execute" && result && typeof result === "object" && ("e2eTest" in result || "flow" in result) && "steps" in result) {
         content = await flowRunToMcpContent(result, ctx);
       } else if (params.name === "screenshot-diff" && isScreenshotDiffResult(result)) {
         content = await screenshotDiffToMcpContent(result, ctx);

package/dist/tool-args.generated.d.ts

@@ -223,14 +223,14 @@ export interface ArgentToolArgs {
         delayMs?: number;
     };
     "e2e-execute": {
-        /** Name of a saved e2e test to run from `.argent/e2e`, or `.argent/flows` when it is not there (e.g. "settings-explore"). Omit when flow_path is set. */
+        /** Name of a saved e2e test to run from `.argent/e2e`, or `.argent/flows` when it is not there (e.g. "settings-explore"). Omit when e2e_test_path is set. */
         name?: string;
-        /** Absolute path to the calling agent's project root: the cwd it is working in. With name, the saved e2e test is read from `.argent/e2e/<name>.yaml`, else `.argent/flows/<name>.yaml`, under this root; with flow_path, the e2e test, 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 e2e test is read from `.argent/e2e/<name>.yaml`, else `.argent/flows/<name>.yaml`, under this root; with e2e_test_path, the e2e test, 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. */
         project_root: string;
         /** Path to the e2e test .yaml as readable by the tool-server. Internal: the argent client derives it from project_root and name automatically; leave unset. */
-        flow_file?: string;
+        e2e_test_file?: string;
         /** Omit when name is set. Absolute path to an e2e test .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 e2e test 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 e2e test file. A tool: e2e-execute step that names an e2e test with name and an absolute project_root without a .. segment runs: the client also uploads that e2e test and its own files. Over a link, the uploaded e2e tests must not have: script: steps; tool: steps that run an e2e test another way or record an e2e test; 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. */
-        flow_path?: string;
+        e2e_test_path?: string;
         /** 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. */
         device?: string;
         /** 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 a standalone e2e test - 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: … }` 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 a standalone e2e test's 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. */
@@ -239,6 +239,10 @@ export interface ArgentToolArgs {
         updateBaselines?: boolean;
         /** Set to true to confirm the execution prerequisite has been met. Required (LLM path) when a fragment defines an executionPrerequisite. */
         prerequisiteAcknowledged?: boolean;
+        /** @deprecated Renamed to `e2e_test_path`. */
+        flow_path?: string;
+        /** @deprecated Renamed to `e2e_test_file`. */
+        flow_file?: string;
     };
     "e2e-finish-recording": {
         /** Name of the e2e test being recorded: the one passed to e2e-start-recording. */
@@ -247,14 +251,18 @@ export interface ArgentToolArgs {
         project_root: string;
     };
     "e2e-read-prerequisite": {
-        /** Name of a saved e2e test to inspect from `.argent/e2e`, or `.argent/flows` when it is not there (e.g. "settings-explore"). Omit when flow_path is set. */
+        /** Name of a saved e2e test to inspect from `.argent/e2e`, or `.argent/flows` when it is not there (e.g. "settings-explore"). Omit when e2e_test_path is set. */
         name?: string;
-        /** Absolute path to the calling agent's project root: the cwd it is working in. With name, the saved e2e test is read from `.argent/e2e/<name>.yaml`, else `.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 e2e test is read from `.argent/e2e/<name>.yaml`, else `.argent/flows/<name>.yaml`, under this root; with e2e_test_path, the prerequisite is read from that YAML instead, so pass the agent's cwd. */
         project_root: string;
         /** Path to the e2e test .yaml as readable by the tool-server. Internal: the argent client derives it from project_root and name automatically; leave unset. */
-        flow_file?: string;
+        e2e_test_file?: string;
         /** Omit when name is set. Absolute path to an e2e test .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 e2e test source here as to e2e-execute, so the prerequisite you read belongs to the e2e test that will run. */
+        e2e_test_path?: string;
+        /** @deprecated Renamed to `e2e_test_path`. */
         flow_path?: string;
+        /** @deprecated Renamed to `e2e_test_file`. */
+        flow_file?: string;
     };
     "e2e-start-recording": {
         /** Name for this e2e test (e.g. "settings-explore"): letters, digits, underscore and hyphen only. */
@@ -400,7 +408,7 @@ export interface ArgentToolArgs {
         x: number;
         /** Normalized vertical position 0.0–1.0 (top=0, bottom=1), not pixels */
         y: number;
-        /** Number of taps/clicks dispatched as ONE multi-tap gesture (2 = double-tap / double-click). The taps land inside the OS double-tap window; on Chromium each click carries an escalating CDP clickCount so dblclick actually fires; on physical iOS 2 is the native double-tap and higher counts land as separate taps. On HarmonyOS only 2 is one gesture; 3 or more are separate injections a device round trip apart, which the OS reads as single taps. Default 1. */
+        /** Number of taps/clicks dispatched as ONE multi-tap gesture (2 = double-tap / double-click). The taps land inside the OS double-tap window; on Chromium each click carries an escalating CDP clickCount so dblclick actually fires; on physical iOS 2 is the native double-tap and higher counts loop single taps, which a double-tap recognizer may pair. On HarmonyOS only 2 is one gesture; 3 or more are separate injections a device round trip apart, which the OS reads as single taps. Default 1. */
         clickCount?: number;
     };
     keyboard: {
@@ -477,14 +485,18 @@ export interface ArgentToolArgs {
         maxDepth?: number;
     };
     "native-network-logs": {
-        /** Simulator UDID */
+        /** Device ID from list-devices: an iOS simulator UDID or Android serial */
         udid: string;
-        /** Bundle ID of the app */
+        /** App bundle ID on iOS or package name on Android */
         bundleId: string;
-        /** Maximum number of events to return (most recent first) */
+        /** Android only: the app's Metro port, whose requests are left out of the listing. Omit it to use this device's port, 8081 by default. */
+        port?: number;
+        /** Maximum number of entries to return: the most recent ones, oldest first */
         limit?: number;
-        /** Clear the log after reading */
+        /** Clear the log after reading. On Android, the IDs of cleared requests still work in view-network-request-details */
         clear?: boolean;
+        /** Android only: turn native capture off for this app instead of listing. Other apps keep theirs. */
+        stop?: boolean;
     };
     "native-profiler-analyze": {
         /** Target device id from `list-devices` (iOS UDID or Android serial). */
@@ -890,9 +902,9 @@ export interface ArgentToolArgs {
     "view-network-request-details": {
         /** 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. */
         port?: number;
-        /** Device id from list-devices (iOS simulator UDID or Android serial), 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. An android- ID needs no debugger connection. */
         device_id: string;
-        /** The requestId from view-network-logs to get full details for */
+        /** The requestId from view-network-logs, or an android- ID from native-network-logs */
         requestId: string;
         /** Whether to include the response body (if captured). Defaults to true. */
         includeBody?: boolean;