@swmansion/argent 0.29.1-next.14 → 0.29.1-next.15

package/dist/cli-cmds.mjs

@@ -9608,6 +9608,11 @@ var FAILURE_CODES = {
   // a device that is not foldable, no hinge route, a remote simulator.
   IOS_FOLD_FAILED: "IOS_FOLD_FAILED",
   IOS_FOLD_UNSUPPORTED: "IOS_FOLD_UNSUPPORTED",
+  // The hinge of a foldable Android emulator: the console refused the move or
+  // the guest never committed the state vs. nothing to fold — a phone profile,
+  // a physical device.
+  ANDROID_FOLD_FAILED: "ANDROID_FOLD_FAILED",
+  ANDROID_FOLD_UNSUPPORTED: "ANDROID_FOLD_UNSUPPORTED",
   PASTE_CLIPBOARD_SET_FAILED: "PASTE_CLIPBOARD_SET_FAILED",
   PASTE_CLIPBOARD_UNSUPPORTED: "PASTE_CLIPBOARD_UNSUPPORTED",
   SETTINGS_PERMISSION_UNSUPPORTED: "SETTINGS_PERMISSION_UNSUPPORTED",
@@ -35301,7 +35306,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID2 = randomUUID5();
 function readCliVersion() {
   if (true) {
-    return "0.29.1-next.14";
+    return "0.29.1-next.15";
   }
   return "0.0.0";
 }

package/dist/client.js

@@ -8811,6 +8811,11 @@ var FAILURE_CODES = {
   // a device that is not foldable, no hinge route, a remote simulator.
   IOS_FOLD_FAILED: "IOS_FOLD_FAILED",
   IOS_FOLD_UNSUPPORTED: "IOS_FOLD_UNSUPPORTED",
+  // The hinge of a foldable Android emulator: the console refused the move or
+  // the guest never committed the state vs. nothing to fold — a phone profile,
+  // a physical device.
+  ANDROID_FOLD_FAILED: "ANDROID_FOLD_FAILED",
+  ANDROID_FOLD_UNSUPPORTED: "ANDROID_FOLD_UNSUPPORTED",
   PASTE_CLIPBOARD_SET_FAILED: "PASTE_CLIPBOARD_SET_FAILED",
   PASTE_CLIPBOARD_UNSUPPORTED: "PASTE_CLIPBOARD_UNSUPPORTED",
   SETTINGS_PERMISSION_UNSUPPORTED: "SETTINGS_PERMISSION_UNSUPPORTED",

package/dist/installer.mjs

@@ -15773,6 +15773,11 @@ var FAILURE_CODES = {
   // a device that is not foldable, no hinge route, a remote simulator.
   IOS_FOLD_FAILED: "IOS_FOLD_FAILED",
   IOS_FOLD_UNSUPPORTED: "IOS_FOLD_UNSUPPORTED",
+  // The hinge of a foldable Android emulator: the console refused the move or
+  // the guest never committed the state vs. nothing to fold — a phone profile,
+  // a physical device.
+  ANDROID_FOLD_FAILED: "ANDROID_FOLD_FAILED",
+  ANDROID_FOLD_UNSUPPORTED: "ANDROID_FOLD_UNSUPPORTED",
   PASTE_CLIPBOARD_SET_FAILED: "PASTE_CLIPBOARD_SET_FAILED",
   PASTE_CLIPBOARD_UNSUPPORTED: "PASTE_CLIPBOARD_UNSUPPORTED",
   SETTINGS_PERMISSION_UNSUPPORTED: "SETTINGS_PERMISSION_UNSUPPORTED",
@@ -16774,7 +16779,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID = randomUUID4();
 function readCliVersion() {
   if (true) {
-    return "0.29.1-next.14";
+    return "0.29.1-next.15";
   }
   return "0.0.0";
 }

package/dist/mcp-server.mjs

@@ -25070,6 +25070,11 @@ var FAILURE_CODES = {
   // a device that is not foldable, no hinge route, a remote simulator.
   IOS_FOLD_FAILED: "IOS_FOLD_FAILED",
   IOS_FOLD_UNSUPPORTED: "IOS_FOLD_UNSUPPORTED",
+  // The hinge of a foldable Android emulator: the console refused the move or
+  // the guest never committed the state vs. nothing to fold — a phone profile,
+  // a physical device.
+  ANDROID_FOLD_FAILED: "ANDROID_FOLD_FAILED",
+  ANDROID_FOLD_UNSUPPORTED: "ANDROID_FOLD_UNSUPPORTED",
   PASTE_CLIPBOARD_SET_FAILED: "PASTE_CLIPBOARD_SET_FAILED",
   PASTE_CLIPBOARD_UNSUPPORTED: "PASTE_CLIPBOARD_UNSUPPORTED",
   SETTINGS_PERMISSION_UNSUPPORTED: "SETTINGS_PERMISSION_UNSUPPORTED",

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

@@ -267,9 +267,9 @@ export interface ArgentToolArgs {
         executionPrerequisite?: string;
     };
     fold: {
-        /** Target device id from `list-devices` (a foldable iOS simulator UDID). */
+        /** Target device id from `list-devices` (a foldable iOS simulator UDID or Android emulator serial). */
         udid: string;
-        /** Where to move the hinge: `closed` (0°, the cover panel), `half-open` (120°) or `open` (180°, the inner panel). Exactly one of `posture` and `angle`. */
+        /** Where to move the hinge: `closed` (the cover panel), `half-open` or `open` (the inner panel). Exactly one of `posture` and `angle`. */
         posture?: "closed" | "half-open" | "open";
         /** The hinge angle in degrees, 0 (closed) to 180 (open). Exactly one of `posture` and `angle`. */
         angle?: number;

package/dist/tool-server.cjs

@@ -1325,6 +1325,11 @@ var init_failure_codes = __esm({
       // a device that is not foldable, no hinge route, a remote simulator.
       IOS_FOLD_FAILED: "IOS_FOLD_FAILED",
       IOS_FOLD_UNSUPPORTED: "IOS_FOLD_UNSUPPORTED",
+      // The hinge of a foldable Android emulator: the console refused the move or
+      // the guest never committed the state vs. nothing to fold — a phone profile,
+      // a physical device.
+      ANDROID_FOLD_FAILED: "ANDROID_FOLD_FAILED",
+      ANDROID_FOLD_UNSUPPORTED: "ANDROID_FOLD_UNSUPPORTED",
       PASTE_CLIPBOARD_SET_FAILED: "PASTE_CLIPBOARD_SET_FAILED",
       PASTE_CLIPBOARD_UNSUPPORTED: "PASTE_CLIPBOARD_UNSUPPORTED",
       SETTINGS_PERMISSION_UNSUPPORTED: "SETTINGS_PERMISSION_UNSUPPORTED",
@@ -82959,6 +82964,7 @@ __export(adb_exports, {
   getCachedAndroidRuntimeKind: () => getCachedAndroidRuntimeKind,
   hasDefaultBootSnapshot: () => hasDefaultBootSnapshot,
   isAndroidTv: () => isAndroidTv,
+  isFoldableAvd: () => isFoldableAvd,
   isTerminalAdbError: () => isTerminalAdbError,
   listAndroidDevices: () => listAndroidDevices,
   listAvds: () => listAvds,
@@ -83310,6 +83316,17 @@ async function resolveAvdPath(avdName) {
   }
   return null;
 }
+async function isFoldableAvd(avdName) {
+  const { readFile: readFile19 } = await import("node:fs/promises");
+  const avdPath = await resolveAvdPath(avdName);
+  if (!avdPath) return false;
+  try {
+    const hinge = (0, import_ini.parse)(await readFile19(`${avdPath}/config.ini`, "utf-8"))["hw.sensor.hinge"];
+    return hinge === true || hinge === "yes" || hinge === "true";
+  } catch {
+    return false;
+  }
+}
 async function hasDefaultBootSnapshot(avdName) {
   const { stat: stat7 } = await import("node:fs/promises");
   const avdPath = await resolveAvdPath(avdName);
@@ -90386,16 +90403,16 @@ var require_foldFlowLines = __commonJS({
         onFold();
       let res = text.slice(0, folds[0]);
       for (let i2 = 0; i2 < folds.length; ++i2) {
-        const fold = folds[i2];
+        const fold2 = folds[i2];
         const end2 = folds[i2 + 1] || text.length;
-        if (fold === 0)
+        if (fold2 === 0)
           res = `
 ${indent}${text.slice(0, end2)}`;
         else {
-          if (mode === FOLD_QUOTED && escapedFolds[fold])
-            res += `${text[fold]}\\`;
+          if (mode === FOLD_QUOTED && escapedFolds[fold2])
+            res += `${text[fold2]}\\`;
           res += `
-${indent}${text.slice(fold + 1, end2)}`;
+${indent}${text.slice(fold2 + 1, end2)}`;
         }
       }
       return res;
@@ -94034,8 +94051,8 @@ var require_resolve_flow_scalar = __commonJS({
         if (ch === "\r" && source[i + 1] === "\n")
           continue;
         if (ch === "\n") {
-          const { fold, offset } = foldNewline(source, i);
-          res += fold;
+          const { fold: fold2, offset } = foldNewline(source, i);
+          res += fold2;
           i = offset;
         } else if (ch === "\\") {
           let next = source[++i];
@@ -94075,19 +94092,19 @@ var require_resolve_flow_scalar = __commonJS({
       return res;
     }
     function foldNewline(source, offset) {
-      let fold = "";
+      let fold2 = "";
       let ch = source[offset + 1];
       while (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
         if (ch === "\r" && source[offset + 2] !== "\n")
           break;
         if (ch === "\n")
-          fold += "\n";
+          fold2 += "\n";
         offset += 1;
         ch = source[offset + 1];
       }
-      if (!fold)
-        fold = " ";
-      return { fold, offset };
+      if (!fold2)
+        fold2 = " ";
+      return { fold: fold2, offset };
     }
     var escapeCodes = {
       "0": "\0",
@@ -100213,7 +100230,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID = (0, import_node_crypto3.randomUUID)();
 function readCliVersion() {
   if (true) {
-    return "0.29.1-next.14";
+    return "0.29.1-next.15";
   }
   return "0.0.0";
 }
@@ -124990,7 +125007,7 @@ Android entries also carry a 'kind' ('emulator' for a local AVD, 'device' for a
 Physical iPhones appear as iOS entries with kind 'device' (no iPads); no boot-device. State 'connected' = cabled and usable; 'paired' = not reachable over USB, never auto-bound.
 TV targets are tagged with runtimeKind 'tv' (Apple TV simulators on iOS, Android TV / leanback devices on Android). These are focus-driven, not touch-driven: use \`describe\` to read focus, \`tv-remote\` for remote presses (up/down/left/right/select/back/menu/home), and \`keyboard\` to type, rather than the coordinate/gesture tools.
 iOS simulators from an additional CoreSimulator device set (the 'ios.additionalDeviceSets' configuration, e.g. devices created by Radon IDE) are listed alongside default-set ones, tagged with their owning 'deviceSet' path; they are driven through the same tools by udid, but run headless (no Simulator.app window attaches to them).
-A foldable iOS simulator (the iPhone Duo) has 'foldable: true'. Use the \`fold\` tool to fold or unfold it.
+A foldable iOS simulator (the iPhone Duo) or Android emulator (and its AVD) has 'foldable: true'. Use the \`fold\` tool to fold or unfold it.
 Chromium apps are discovered by probing CDP debugging ports (default 9222; extend via the ARGENT_CHROMIUM_PORTS=<comma-separated-ports> env var). They must already be running with --remote-debugging-port=<port>; use boot-device with electronAppPath to launch one.
 Booted/ready devices are listed first. Platforms whose CLI is unavailable are silently omitted; an empty result usually means xcode-select, Android platform-tools, or the Vega SDK is not installed.`,
   alwaysLoad: true,
@@ -125054,6 +125071,11 @@ Booted/ready devices are listed first. Platforms whose CLI is unavailable are si
       tunnelState: d.tunnelState
     }));
     iosRemote.sort(sortIosRemote);
+    const foldableAvds = new Set(
+      (await Promise.all(
+        [.../* @__PURE__ */ new Set([...avds.map((a) => a.name), ...android.map((d) => d.avdName)])].filter((name) => name !== null).map(async (name) => await isFoldableAvd(name) ? name : null)
+      )).filter((name) => name !== null)
+    );
     const androidTagged = android.map((d) => ({
       platform: "android",
       serial: d.serial,
@@ -125063,7 +125085,8 @@ Booted/ready devices are listed first. Platforms whose CLI is unavailable are si
       model: d.model,
       avdName: d.avdName,
       sdkLevel: d.sdkLevel,
-      runtimeKind: d.runtimeKind
+      runtimeKind: d.runtimeKind,
+      ...d.avdName !== null && foldableAvds.has(d.avdName) ? { foldable: true } : {}
     }));
     const vvdShadowSerials = await resolveVvdShadowAdbSerials(androidTagged, vega);
     const shadowSerials = /* @__PURE__ */ new Set([...vvdShadowSerials, ...externalShadows]);
@@ -125079,7 +125102,14 @@ Booted/ready devices are listed first. Platforms whose CLI is unavailable are si
       ...external.map(toListedExternal)
     ];
     devices.sort((a, b) => readinessRank(a) - readinessRank(b));
-    return { devices, avds, ...external.length > 0 ? { hint: EXTERNAL_DEVICES_HINT } : {} };
+    const avdsTagged = avds.map(
+      (a) => foldableAvds.has(a.name) ? { ...a, foldable: true } : a
+    );
+    return {
+      devices,
+      avds: avdsTagged,
+      ...external.length > 0 ? { hint: EXTERNAL_DEVICES_HINT } : {}
+    };
   }
 };
 
@@ -130408,11 +130438,11 @@ function scheduleGroupSigkill(pid, graceMs, opts) {
 }
 async function pollPidsUntilGone(pids, opts) {
   const isAlive2 = opts.isAlive ?? pidIsAlive;
-  const sleep15 = opts.sleep ?? ((ms) => new Promise((resolve15) => setTimeout(resolve15, ms)));
+  const sleep16 = opts.sleep ?? ((ms) => new Promise((resolve15) => setTimeout(resolve15, 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 sleep15(opts.pollIntervalMs);
+    await sleep16(opts.pollIntervalMs);
     remaining = remaining.filter((pid) => isAlive2(pid));
   }
   return remaining;
@@ -131038,7 +131068,7 @@ function transportFailureSignal(kind) {
     failure_stage: "ios_device_runner_transport",
     failure_area: "tool_server"
   };
-  const failed2 = {
+  const failed3 = {
     ...notReady,
     error_code: FAILURE_CODES.IOS_DEVICE_RUNNER_TRANSPORT_FAILED
   };
@@ -131048,11 +131078,11 @@ function transportFailureSignal(kind) {
     case "runner-not-listening":
       return { ...notReady, error_kind: "network", network_failure: "connection_refused" };
     case "timeout":
-      return { ...failed2, error_kind: "timeout" };
+      return { ...failed3, error_kind: "timeout" };
     case "protocol":
-      return { ...failed2, error_kind: "network", network_failure: "invalid_response" };
+      return { ...failed3, error_kind: "network", network_failure: "invalid_response" };
     case "http":
-      return { ...failed2, error_kind: "network", network_failure: "other" };
+      return { ...failed3, error_kind: "network", network_failure: "other" };
   }
 }
 function createRunnerClient(options) {
@@ -131808,7 +131838,7 @@ function createConsoleLogServer(consoleEvents, logWriter) {
   });
 }
 function makeStubSourceResolver() {
-  const unsupported = () => {
+  const unsupported2 = () => {
     throw new Error(
       "SourceResolver is not implemented on Chromium debugger sessions \u2014 Metro symbolicate is the only backing implementation."
     );
@@ -131816,7 +131846,7 @@ function makeStubSourceResolver() {
   return {
     resolveDebugStack: async () => null,
     symbolicate: async () => null,
-    readSourceFragment: unsupported
+    readSourceFragment: unsupported2
   };
 }
 var chromiumJsRuntimeDebuggerBlueprint = {
@@ -137095,8 +137125,8 @@ var vegaImpl3 = {
     const output2 = `${stdout}
 ${stderr}`;
     const succeeded = /\.\.\.\s*success\b/i.test(output2);
-    const failed2 = /\.\.\.\s*failed\b/i.test(output2);
-    if (!succeeded || failed2) {
+    const failed3 = /\.\.\.\s*failed\b/i.test(output2);
+    if (!succeeded || failed3) {
       throw new FailureError(`vega install-app failed: ${output2.trim()}`, {
         error_code: FAILURE_CODES.VEGA_CLI_COMMAND_FAILED,
         failure_stage: "vega_reinstall_install_app",
@@ -137780,10 +137810,10 @@ async function readAndroidSurfaceRotation(serial, peek) {
     } catch {
     }
   }
-  for (const shell of [adbServerShell, adbShell]) {
+  for (const shell2 of [adbServerShell, adbShell]) {
     for (const { cmd, pattern } of ROTATION_PROBES) {
       try {
-        const out = await shell(serial, cmd, { timeoutMs: 5e3 });
+        const out = await shell2(serial, cmd, { timeoutMs: 5e3 });
         const value = Number(pattern.exec(out)?.[1]);
         if (Number.isInteger(value) && isSurfaceRotation(value)) return value;
       } catch {
@@ -140662,6 +140692,20 @@ var iosRemoteImpl6 = {
 // ../tool-server/src/tools/shake/platforms/android.ts
 init_src2();
 init_adb();
+
+// ../tool-server/src/utils/emulator-console.ts
+init_adb();
+async function runEmuConsole(serial, args) {
+  const { stdout } = await runAdb(["-s", serial, "emu", ...args], { timeoutMs: 1e4 });
+  const lines = stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+  const verdict = lines[lines.length - 1];
+  if (verdict?.startsWith("KO:")) {
+    throw new Error(`emulator console rejected \`${args.join(" ")}\` \u2014 ${verdict}`);
+  }
+  return stdout;
+}
+
+// ../tool-server/src/tools/shake/platforms/android.ts
 var SHAKE_AMPLITUDE = 30;
 var SWINGS_PER_SHAKE = 8;
 var SWING_INTERVAL_MS = 50;
@@ -140688,15 +140732,6 @@ function restingVectorFrom(stdout) {
 }
 var fmt = (v) => `${v.x.toFixed(4)}:${v.y.toFixed(4)}:${v.z.toFixed(4)}`;
 var sleep12 = (ms) => new Promise((r) => setTimeout(r, ms));
-async function emuConsole(serial, args) {
-  const { stdout } = await runAdb(["-s", serial, "emu", ...args], { timeoutMs: 1e4 });
-  const lines = stdout.split("\n").map((line) => line.trim()).filter(Boolean);
-  const verdict = lines[lines.length - 1];
-  if (verdict?.startsWith("KO:")) {
-    throw new Error(`emulator console rejected \`${args.join(" ")}\` \u2014 ${verdict}`);
-  }
-  return stdout;
-}
 var inFlightByDevice = /* @__PURE__ */ new Map();
 function withDeviceLock(serial, fn) {
   const previous = inFlightByDevice.get(serial) ?? Promise.resolve();
@@ -140733,12 +140768,12 @@ var androidImpl6 = {
       );
     }
     const setAcceleration = async (v) => {
-      await emuConsole(serial, ["sensor", "set", "acceleration", fmt(v)]);
+      await runEmuConsole(serial, ["sensor", "set", "acceleration", fmt(v)]);
     };
     return withDeviceLock(serial, async () => {
       let rest;
       try {
-        rest = restingVectorFrom(await emuConsole(serial, ["sensor", "get", "acceleration"]));
+        rest = restingVectorFrom(await runEmuConsole(serial, ["sensor", "get", "acceleration"]));
       } catch (err) {
         const detail = err instanceof Error ? err.message : String(err);
         throw new FailureError(
@@ -140837,13 +140872,270 @@ Only phone/tablet simulators and emulators are supported.`,
 init_zod();
 init_src2();
 init_device_info();
+
+// ../tool-server/src/tools/fold/platforms/android.ts
+init_src2();
+init_adb();
 var POSTURES = ["closed", "half-open", "open"];
+var EMULATOR_POSTURES = {
+  "closed": { id: "1", state: "CLOSED" },
+  "half-open": { id: "2", state: "HALF_OPENED" },
+  "open": { id: "3", state: "OPENED" }
+};
+var POLL_MS = 250;
+var SETTLE_TIMEOUT_MS2 = 15e3;
+var STABLE_READS = 3;
+var MAX_DISMISS_ATTEMPTS = 3;
+var DISMISS_SPACING_MS = 1e3;
+var DISMISS_TIMEOUT_MS = 5e3;
+var WAKE_GRACE_READS = 2;
+var abortReason2 = (signal) => signal.reason instanceof Error ? signal.reason : new Error("The fold was cancelled.");
+var sleep13 = (ms, signal) => new Promise((resolve15, reject) => {
+  if (signal?.aborted) return reject(abortReason2(signal));
+  const timer = setTimeout(resolve15, ms);
+  signal?.addEventListener(
+    "abort",
+    () => {
+      clearTimeout(timer);
+      reject(abortReason2(signal));
+    },
+    { once: true }
+  );
+});
+function unsupported(message, stage) {
+  return new FailureError(message, {
+    error_code: FAILURE_CODES.ANDROID_FOLD_UNSUPPORTED,
+    failure_stage: stage,
+    failure_area: "tool_server",
+    error_kind: "unsupported"
+  });
+}
+function failed(message, stage, cause) {
+  return new FailureError(
+    message,
+    {
+      error_code: FAILURE_CODES.ANDROID_FOLD_FAILED,
+      failure_stage: stage,
+      failure_area: "tool_server",
+      error_kind: "subprocess"
+    },
+    cause instanceof Error ? { cause } : void 0
+  );
+}
+async function shell(serial, command) {
+  const { stdout } = await runAdb(["-s", serial, "shell", command], { timeoutMs: 1e4 });
+  return stdout;
+}
+function parseDeviceStates(stdout) {
+  const states = /* @__PURE__ */ new Map();
+  for (const match of stdout.matchAll(/identifier=(\d+), name='([A-Z_]+)'/g)) {
+    states.set(match[2], match[1]);
+  }
+  return states;
+}
+function parseSnapshot(stdout) {
+  const screenOn = !/mScreenOnFully=false/.test(stdout);
+  const wakefulness = /mWakefulness=([A-Za-z]+)/.exec(stdout)?.[1];
+  return {
+    state: /^\s*(\d+)\s*$/m.exec(stdout)?.[1],
+    screenOn,
+    awake: wakefulness ? !/^(Asleep|Dozing)$/.test(wakefulness) : screenOn,
+    keyguard: /isKeyguardShowing=true/.test(stdout)
+  };
+}
+async function readSnapshot(serial) {
+  return parseSnapshot(
+    await shell(
+      serial,
+      "cmd device_state print-state; dumpsys window displays | grep -o 'mScreenOnFully=[a-z]*'; dumpsys power | grep -o 'mWakefulness=[A-Za-z]*'; dumpsys window | grep -o 'isKeyguardShowing=[a-z]*'"
+    )
+  );
+}
+function parseHingeAngle(stdout) {
+  const match = /hinge-angle0\s*=\s*(-?\d+(?:\.\d+)?)/.exec(stdout);
+  return match ? Number(match[1]) : void 0;
+}
+function isReady(read, expected) {
+  return read.state !== void 0 && (read.screenOn || !read.awake) && (expected === void 0 || read.state === expected);
+}
+async function awaitSettled(serial, expected, wake, signal) {
+  let last;
+  let agreeing = 0;
+  const deadline = Date.now() + SETTLE_TIMEOUT_MS2;
+  while (Date.now() < deadline) {
+    await sleep13(POLL_MS, signal);
+    const read = await readSnapshot(serial);
+    const same = read.state === last?.state && read.awake === last?.awake;
+    if (!isReady(read, expected)) agreeing = 0;
+    else agreeing = agreeing > 0 && same ? agreeing + 1 : 1;
+    last = read;
+    const mayWake = wake.wasAsleep && !read.awake && read.state !== wake.closedId;
+    if (agreeing >= STABLE_READS + (mayWake ? WAKE_GRACE_READS : 0)) {
+      return { last, settled: true, steady: true };
+    }
+  }
+  const settled = last !== void 0 && isReady(last, expected);
+  return { last, settled, steady: false };
+}
+async function dismissFoldLockScreen(serial, signal) {
+  let clear = 0;
+  let attempts = 0;
+  let lastAttempt = -Infinity;
+  const deadline = Date.now() + DISMISS_TIMEOUT_MS;
+  for (; ; ) {
+    if (!(await readSnapshot(serial)).keyguard) {
+      if (++clear >= STABLE_READS) return void 0;
+    } else {
+      clear = 0;
+      if (Date.now() >= deadline) break;
+      if (attempts < MAX_DISMISS_ATTEMPTS && Date.now() - lastAttempt >= DISMISS_SPACING_MS) {
+        attempts++;
+        lastAttempt = Date.now();
+        await shell(serial, "wm dismiss-keyguard");
+      }
+    }
+    await sleep13(POLL_MS, signal);
+  }
+  return "The fold raised the lock screen and argent could not dismiss it (a PIN or password keeps it up). Unlock the device before the next action.";
+}
+function targetLabel(params) {
+  return params.posture ?? `${params.angle}\xB0`;
+}
+var inFlightByDevice2 = /* @__PURE__ */ new Map();
+function withDeviceLock2(serial, fn) {
+  const previous = inFlightByDevice2.get(serial) ?? Promise.resolve();
+  const run2 = previous.then(fn, fn);
+  const settled = run2.catch(() => {
+  });
+  inFlightByDevice2.set(serial, settled);
+  void settled.then(() => {
+    if (inFlightByDevice2.get(serial) === settled) inFlightByDevice2.delete(serial);
+  });
+  return run2;
+}
+var NO_DEVICE_STATE_SERVICE = /Can't find service: device_state|cmd: not found|No shell command implementation/i;
+async function readDeviceStates(serial) {
+  try {
+    return parseDeviceStates(await shell(serial, "cmd device_state print-states"));
+  } catch (err) {
+    if (!NO_DEVICE_STATE_SERVICE.test(err instanceof Error ? err.message : String(err))) throw err;
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function fold(serial, params, device, signal) {
+  signal?.throwIfAborted();
+  const states = await readDeviceStates(serial);
+  const byId = new Map([...states].map(([name, id]) => [id, name]));
+  const supported2 = POSTURES.filter((p) => states.has(EMULATOR_POSTURES[p].state));
+  if (supported2.length === 0) {
+    throw unsupported(
+      `${device.id} is not a foldable emulator: it lists no CLOSED, HALF_OPENED or OPENED device state. Boot a foldable AVD (a Pixel Fold or a generic foldable profile); \`list-devices\` marks them with \`foldable: true\`.`,
+      "android_fold_not_foldable"
+    );
+  }
+  const expected = params.posture ? states.get(EMULATOR_POSTURES[params.posture].state) : void 0;
+  if (params.posture && expected === void 0) {
+    throw unsupported(
+      `${device.id} has no ${EMULATOR_POSTURES[params.posture].state} device state for the ${params.posture} posture; it supports ${supported2.join(", ")}.`,
+      "android_fold_posture_unsupported"
+    );
+  }
+  const before = await readSnapshot(serial);
+  signal?.throwIfAborted();
+  try {
+    if (params.posture) {
+      await runEmuConsole(serial, ["posture", EMULATOR_POSTURES[params.posture].id]);
+    } else {
+      await runEmuConsole(serial, ["sensor", "set", "hinge-angle0", String(params.angle)]);
+    }
+  } catch (err) {
+    throw failed(
+      `Failed to fold ${serial} to ${targetLabel(params)}: ${err instanceof Error ? err.message : String(err)}`,
+      "android_fold_console",
+      err
+    );
+  }
+  const { last, settled, steady } = await awaitSettled(
+    serial,
+    expected,
+    { wasAsleep: !before.awake, closedId: states.get("CLOSED") },
+    signal
+  );
+  const stateName = last?.state !== void 0 ? byId.get(last.state) ?? last.state : "unknown";
+  const darkAwake = last?.state !== void 0 && last.awake && !last.screenOn;
+  const budget = `${SETTLE_TIMEOUT_MS2 / 1e3} s`;
+  if (!settled && expected !== void 0) {
+    throw failed(
+      last?.state === expected ? `${serial} reached device state ${stateName} for the ${params.posture} posture, but the device is awake and the screen did not stay on within ${budget}. Take a screenshot before the next action.` : `${serial} did not reach the ${params.posture} posture: the guest still reports device state ${stateName}. Fold again; a screenshot shows what the device renders.`,
+      "android_fold_unverified"
+    );
+  }
+  const warnings = [];
+  if (!settled) {
+    warnings.push(
+      darkAwake ? `The device state is ${stateName}, but the screen did not stay on within ${budget}. Take a screenshot before the next action.` : `The device state did not settle within ${budget}; it last read ${stateName}. Take a screenshot before the next action.`
+    );
+  } else if (!steady) {
+    warnings.push(
+      `The screen did not hold steady within ${budget}. Take a screenshot before the next action.`
+    );
+  }
+  let lockScreen = last?.keyguard ?? false;
+  if (stateName === "CLOSED" && !before.keyguard && last?.awake) {
+    lockScreen = false;
+    const warning = await dismissFoldLockScreen(serial, signal);
+    if (warning) warnings.push(warning);
+  }
+  const screenOff = settled && last !== void 0 && !last.screenOn;
+  if (screenOff && lockScreen) {
+    warnings.push(
+      "The screen is off and the lock screen is showing after the fold. Wake and unlock the device before the next action."
+    );
+  } else if (screenOff) {
+    warnings.push("The screen is off after the fold. Wake the device before the next action.");
+  } else if (lockScreen) {
+    warnings.push(
+      "The lock screen is showing after the fold. Unlock or dismiss it before the next action."
+    );
+  }
+  let hingeAngle;
+  try {
+    hingeAngle = parseHingeAngle(await runEmuConsole(serial, ["sensor", "get", "hinge-angle0"]));
+  } catch {
+  }
+  const posture = POSTURES.find((p) => EMULATOR_POSTURES[p].state === stateName);
+  return {
+    ...posture ? { posture } : {},
+    deviceState: stateName,
+    ...hingeAngle !== void 0 ? { hingeAngle } : {},
+    ...warnings.length > 0 ? { warning: warnings.join(" ") } : {}
+  };
+}
+var androidImpl7 = {
+  requires: ["adb"],
+  async handler(_services, params, device, options) {
+    const serial = params.udid;
+    const signal = options?.signal;
+    if (!/^emulator-\d+$/.test(serial)) {
+      throw unsupported(
+        `Cannot fold ${serial}: only an Android emulator's hinge can be moved; fold a physical device by hand.`,
+        "android_fold_not_emulator"
+      );
+    }
+    return withDeviceLock2(serial, () => fold(serial, params, device, signal));
+  }
+};
+
+// ../tool-server/src/tools/fold/index.ts
+var POSTURES2 = ["closed", "half-open", "open"];
 var POSTURE_ANGLE = { "closed": 0, "half-open": 120, "open": 180 };
 var HINGE_REQUEST_TIMEOUT_MS = 3e4;
 var zodSchema27 = external_exports.object({
-  udid: external_exports.string().describe("Target device id from `list-devices` (a foldable iOS simulator UDID)."),
-  posture: external_exports.enum(POSTURES).optional().describe(
-    "Where to move the hinge: `closed` (0\xB0, the cover panel), `half-open` (120\xB0) or `open` (180\xB0, the inner panel). Exactly one of `posture` and `angle`."
+  udid: external_exports.string().describe(
+    "Target device id from `list-devices` (a foldable iOS simulator UDID or Android emulator serial)."
+  ),
+  posture: external_exports.enum(POSTURES2).optional().describe(
+    "Where to move the hinge: `closed` (the cover panel), `half-open` or `open` (the inner panel). Exactly one of `posture` and `angle`."
   ),
   angle: external_exports.number().min(0).max(180).optional().describe(
     "The hinge angle in degrees, 0 (closed) to 180 (open). Exactly one of `posture` and `angle`."
@@ -140855,10 +141147,14 @@ var capability21 = {
   // Local simulators only. A remote (MoQ) simulator is driven on its main
   // screen and carries no hinge message; the server itself rejects a device
   // that is not foldable, with its own reason.
-  apple: { simulator: true }
+  apple: { simulator: true },
+  // Emulators only: the hinge is moved through the emulator console. `unknown`
+  // is let through and the handler rejects a serial with no console; it also
+  // rejects a profile with no hinge, which the capability cannot see.
+  android: { emulator: true, unknown: true }
 };
 function presetAtAngle(angle) {
-  return POSTURES.find((p) => POSTURE_ANGLE[p] === angle);
+  return POSTURES2.find((p) => POSTURE_ANGLE[p] === angle);
 }
 function classifyHingeRefusal(err, known) {
   if (known?.foldable !== false) return err;
@@ -140880,7 +141176,7 @@ function hingeRequest(params) {
   if (params.angle !== void 0) request3.angle = params.angle;
   return request3;
 }
-function targetLabel(params) {
+function targetLabel2(params) {
   return params.posture ?? `${params.angle}\xB0`;
 }
 function targetAngle(params) {
@@ -140906,26 +141202,8 @@ function screenResult(activeScreen, panels) {
     ...panel ? { width: panel.width, height: panel.height } : {}
   };
 }
-var foldTool = {
-  id: "fold",
-  interaction: {
-    startedMsg: ({ params }) => `Folding device to ${targetLabel(params)}`,
-    completedMsg: ({ params, result }) => `Folded device to ${targetLabel(params)}; it renders to screen ${result.activeScreen} (${result.screen.panel})`,
-    failedMsg: ({ params, failureSignal: failureSignal2 }) => `Failed to fold device to ${targetLabel(params)}: ${failureSignal2.error_code}`
-  },
-  description: `Move the hinge of a foldable iOS simulator (the iPhone Duo) to a \`posture\` (closed, half-open, open) or to an \`angle\` (0-180\xB0). The tool returns when the device accepts input again, so the next tap lands.
-Use when you must see or test an app in a different posture: closed shows the cover panel, half-open and open show the inner panel. \`list-devices\` marks foldable simulators with \`foldable: true\`. To turn a device without a fold, use \`rotate\`.
-All tools use the active panel (the panel that shows the UI), also after a fold made outside argent. The coordinates and the screenshot size change with the panel. Before you tap, read the element tree in this result or run \`describe\` again. Unfolded, the UI is landscape, as on a rotated iPhone.
-A fold between two angles that are not closed or open can keep the current panel. To change panels, fold to closed or open.
-Returns { activeScreen, screen: { id, panel, width, height }, posture?, hingeAngle, warning? }. screen names the active panel and gives its size in pixels. posture is set only at 0\xB0, 120\xB0 and 180\xB0. warning is set when argent cannot find the active panel, or when the device did not change to the expected panel.
-Fails if the device is not foldable or is a remote simulator.`,
-  searchHint: "fold unfold hinge foldable duo posture open closed half-open panel screen",
-  zodSchema: zodSchema27,
-  capability: capability21,
-  services: (params) => ({
-    simulatorServer: simulatorServerRef(resolveDevice(params.udid))
-  }),
-  async execute(services, params, ctx) {
+var iosImpl5 = {
+  async handler(services, params, _device, ctx) {
     const api = services.simulatorServer;
     const udid = params.udid;
     const signal = ctx?.signal ? AbortSignal.any([ctx.signal, AbortSignal.timeout(HINGE_REQUEST_TIMEOUT_MS)]) : AbortSignal.timeout(HINGE_REQUEST_TIMEOUT_MS);
@@ -140972,7 +141250,7 @@ Fails if the device is not foldable or is a remote simulator.`,
       warning = `${unresolvedPanelNote(udid, reason2, "commands target", panels)} Take a screenshot to see the screen.`;
     } else if (expected !== void 0 && settled.screen !== expected) {
       const advice = atStop(angle) ? "Fold again if the device did not switch; a screenshot shows what it renders." : "To switch panels, fold to closed or open first, then to the angle wanted.";
-      warning = `The hinge was swept to ${targetLabel(params)}, but the device kept rendering to ${screenLabel(activeScreen, panels)} rather than switching to ${screenLabel(expected, panels)}. Commands target the panel the device renders to. ${advice}`;
+      warning = `The hinge was swept to ${targetLabel2(params)}, but the device kept rendering to ${screenLabel(activeScreen, panels)} rather than switching to ${screenLabel(expected, panels)}. Commands target the panel the device renders to. ${advice}`;
     }
     return {
       activeScreen,
@@ -140983,6 +141261,36 @@ Fails if the device is not foldable or is a remote simulator.`,
     };
   }
 };
+var foldTool = {
+  id: "fold",
+  interaction: {
+    startedMsg: ({ params }) => `Folding device to ${targetLabel2(params)}`,
+    completedMsg: ({ params, result }) => "activeScreen" in result ? `Folded device to ${targetLabel2(params)}; it renders to screen ${result.activeScreen} (${result.screen.panel})` : `Folded device to ${targetLabel2(params)}; it is in device state ${result.deviceState}`,
+    failedMsg: ({ params, failureSignal: failureSignal2 }) => `Failed to fold device to ${targetLabel2(params)}: ${failureSignal2.error_code}`
+  },
+  description: `Move the hinge of a foldable iOS simulator (the iPhone Duo) or Android emulator (a Pixel Fold or generic foldable AVD) to a \`posture\` (closed, half-open, open) or to an \`angle\` (0-180\xB0). The tool returns when the device accepts input again, so the next tap lands.
+Use when you must see or test an app in a different posture: closed shows the cover panel, half-open and open show the inner panel. \`list-devices\` marks foldable devices with \`foldable: true\`. To turn a device without a fold, use \`rotate\`.
+All tools use the active panel (the panel that shows the UI), also after a fold made outside argent. The coordinates and the screenshot size change with the panel. Before you tap, read the element tree in this result or run \`describe\` again.
+iOS: unfolded, the UI is landscape, as on a rotated iPhone. A fold between two angles that are not closed or open can keep the current panel. To change panels, fold to closed or open.
+iOS returns { activeScreen, screen: { id, panel, width, height }, posture?, hingeAngle, warning? }. screen names the active panel and gives its size in pixels. posture is set only at 0\xB0, 120\xB0 and 180\xB0. warning is set when argent cannot find the active panel, or when the device did not change to the expected panel.
+Android returns { posture?, deviceState, hingeAngle?, warning? }. deviceState is the state Android committed (CLOSED, HALF_OPENED, OPENED), and posture is the matching preset. A lock screen the fold raises is dismissed; warning is set when it cannot be, or when a lock screen is showing or the screen is off after the fold. On a generic foldable AVD, closed shows only the left part of the display and describe frames do not match tap coordinates; use a Pixel Fold AVD to test the cover panel.
+Fails if the device is not foldable, is a remote simulator or a physical Android device.`,
+  searchHint: "fold unfold hinge foldable duo posture open closed half-open panel screen",
+  zodSchema: zodSchema27,
+  capability: capability21,
+  // The Android hinge is moved through `adb`, so no simulator-server is
+  // spawned for it; the server follows the new panel on its own.
+  services: (params) => {
+    const device = resolveDevice(params.udid);
+    return device.platform === "android" ? {} : { simulatorServer: simulatorServerRef(device) };
+  },
+  execute: dispatchByPlatform({
+    toolId: "fold",
+    capability: capability21,
+    ios: iosImpl5,
+    android: androidImpl7
+  })
+};
 
 // ../tool-server/src/tools/tv-remote/index.ts
 init_zod();
@@ -140995,11 +141303,11 @@ function expandButtons(button, repeat) {
 }
 
 // ../tool-server/src/tools/tv-remote/platforms/focus-remote.ts
-async function pressFocusRemote(registry2, device, params, unsupported, options) {
+async function pressFocusRemote(registry2, device, params, unsupported2, options) {
   const buttons = expandButtons(params.button, params.repeat);
   const api = await resolveTvApi(registry2, device.id);
-  if (unsupported?.size) {
-    const bad = [...new Set(buttons.filter((b) => unsupported.has(b)))];
+  if (unsupported2?.size) {
+    const bad = [...new Set(buttons.filter((b) => unsupported2.has(b)))];
     if (bad.length) {
       throw new UnsupportedOperationError(
         "tv-remote",
@@ -146885,7 +147193,7 @@ Allowed tools and their args (udid is auto-injected, do NOT include it in args):
   paste:          { text: string }  (device clipboard + paste shortcut; only where a user would paste, e.g. an OTP; keyboard otherwise)   [ios sim/android emu]
   rotate:         { orientation: "Portrait"|"LandscapeLeft"|"LandscapeRight"|"PortraitUpsideDown" }                     [ios/android]
   shake:          { count?: number }                                                                                    [ios sim/android emu]
-  fold:           { posture?: "closed"|"half-open"|"open", angle?: 0-180 }  (one of posture/angle; the next step lands on the new panel, whose coordinates are different)  [foldable ios sim]
+  fold:           { posture?: "closed"|"half-open"|"open", angle?: 0-180 }  (one of posture/angle; the next step lands on the new panel, whose coordinates are different)  [foldable ios sim/android emu]
   tv-remote:      { button: <remote button | array of them>, repeat?: number }                                          [apple tv/android tv/vega]
                   buttons: up/down/left/right/select/back/home/menu/playPause (+ rewind/fastForward/next/previous/volumeUp/volumeDown/mute work on Android TV and Vega; rejected on the Apple TV simulator)
   await-ui-element: { condition: "exists"|"visible"|"hidden"|"text", selector: {text?,identifier?,role?}, expectedText?, timeoutMs?, pollIntervalMs? }  [ios/android/chromium]
@@ -149356,7 +149664,7 @@ function formatDescribeTree(root, opts) {
 }
 
 // ../tool-server/src/tools/describe/platforms/tv.ts
-var sleep13 = (ms) => new Promise((r) => setTimeout(r, ms));
+var sleep14 = (ms) => new Promise((r) => setTimeout(r, ms));
 var EMPTY_RETRY_ATTEMPTS = 3;
 var EMPTY_RETRY_DELAY_MS = 600;
 var EMPTY_HINT = "No focusable elements after retrying and recycling the read path. The app is most likely still launching (splash / loading screen) or mid-transition \u2014 this is normal right after launch-app / restart-app. Wait ~2-3s and call describe again; a React Native app only exposes focus once its JS bundle has loaded. If it stays empty, take a screenshot to confirm what's actually on screen.";
@@ -149397,7 +149705,7 @@ async function describeTv(registry2, device) {
   let res = await api.describe();
   if (device.platform !== "android") {
     for (let attempt = 1; attempt < EMPTY_RETRY_ATTEMPTS && isEmpty(res); attempt++) {
-      await sleep13(EMPTY_RETRY_DELAY_MS);
+      await sleep14(EMPTY_RETRY_DELAY_MS);
       res = await api.describe();
     }
   }
@@ -149981,12 +150289,12 @@ function adaptAndroidTree(capture, screen) {
     unsupportedFields: LEGACY_UNSUPPORTED_FIELDS2
   };
   if (!v2) return tree;
-  const unsupported = [];
+  const unsupported2 = [];
   const sdk = capture.sdkInt ?? 0;
-  if (sdk < 26) unsupported.push("placeholder", "hintShowing");
-  if (sdk < 28) unsupported.push("heading");
+  if (sdk < 26) unsupported2.push("placeholder", "hintShowing");
+  if (sdk < 28) unsupported2.push("heading");
   if (capture.captureMode === "active-window") {
-    unsupported.push("keyboardVisible", "foregroundApp", "alertVisible");
+    unsupported2.push("keyboardVisible", "foregroundApp", "alertVisible");
   } else {
     let keyboard = false;
     let foreground;
@@ -150012,7 +150320,7 @@ function adaptAndroidTree(capture, screen) {
       }
     }
   }
-  tree.unsupportedFields = unsupported;
+  tree.unsupportedFields = unsupported2;
   return tree;
 }
 async function readAndroidUiTree(registry2, device) {
@@ -150209,7 +150517,7 @@ 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));
+var sleep15 = (ms) => new Promise((r) => setTimeout(r, ms));
 function typeableOnSimulator(text) {
   for (const char of text) if (!charToKeyPress(char)) return false;
   return true;
@@ -150234,9 +150542,9 @@ 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 sleep15(KEY_TIMING.holdMs);
   await api.pressKey("Up", NAMED_KEYS.backspace);
-  await sleep14(KEY_TIMING.settleMs);
+  await sleep15(KEY_TIMING.settleMs);
 }
 async function typeOnSimulator(registry2, device, text) {
   if (!text) return;
@@ -164206,7 +164514,7 @@ var FOCUS_REPORTING_SOURCES = /* @__PURE__ */ new Set([
   "cdp-dom"
 ]);
 var SETTLE_POLL_MS2 = 250;
-var SETTLE_TIMEOUT_MS2 = 3e3;
+var SETTLE_TIMEOUT_MS3 = 3e3;
 var SETTLE_MIN_READS = 2;
 var MAX_SCROLL_ITERATIONS = 25;
 var SCROLL_INCREMENT = 0.5;
@@ -164273,7 +164581,7 @@ function readFlowTree(env) {
   });
 }
 async function settleTree(env, opts = {}) {
-  const deadline = Date.now() + SETTLE_TIMEOUT_MS2;
+  const deadline = Date.now() + SETTLE_TIMEOUT_MS3;
   let prevFp;
   let prevTree;
   let lastError;
@@ -165522,12 +165830,12 @@ function flowExecuteOutcome(result) {
 function runSequenceOutcome(result) {
   const steps = result.steps;
   if (!Array.isArray(steps)) return void 0;
-  const failed2 = steps.find((s) => isRecord(s) && typeof s.error === "string");
-  if (failed2 && isRecord(failed2)) {
-    const tool = typeof failed2.tool === "string" ? failed2.tool : "step";
+  const failed3 = steps.find((s) => isRecord(s) && typeof s.error === "string");
+  if (failed3 && isRecord(failed3)) {
+    const tool = typeof failed3.tool === "string" ? failed3.tool : "step";
     return {
       status: "fail",
-      reason: `run-sequence stopped at ${tool} after ${count(result.completed)} of ${count(result.total)} steps: ${String(failed2.error)}`
+      reason: `run-sequence stopped at ${tool} after ${count(result.completed)} of ${count(result.total)} steps: ${String(failed3.error)}`
     };
   }
   const total = count(result.total);
@@ -166532,7 +166840,7 @@ function isTerminalResponse(response) {
 var DEFAULT_SCRIPT_TIMEOUT_MS = 3e4;
 var SCRIPT_STEP_LOG_LIMIT_BYTES = 64 * 1024;
 var SCRIPT_RUN_LOG_LIMIT_BYTES = 256 * 1024;
-var SETTLE_TIMEOUT_MS3 = 500;
+var SETTLE_TIMEOUT_MS4 = 500;
 var STOP_GRACE_MS2 = 1500;
 var CHILD_DEADLINE_MARGIN_MS = 2e3;
 var GROUP_POLL_MS = 50;
@@ -166943,7 +167251,7 @@ var FlowScriptExecutor = class {
     const deadlinePassed = Date.now() >= deadlineAt;
     clearTimeout(timer);
     request3.signal?.removeEventListener("abort", onAbort);
-    await Promise.race([closed, sleep(SETTLE_TIMEOUT_MS3)]);
+    await Promise.race([closed, sleep(SETTLE_TIMEOUT_MS4)]);
     await stop();
     capture.end();
     child.stdout?.destroy();
@@ -166983,11 +167291,11 @@ function flowScriptExecutor() {
 }
 function classifyOutcome(input2) {
   const { exit } = input2;
-  if (input2.spawnProblem) return failed("spawn", input2.spawnProblem);
-  if (input2.protocolProblem) return failed("protocol", input2.protocolProblem);
+  if (input2.spawnProblem) return failed2("spawn", input2.spawnProblem);
+  if (input2.protocolProblem) return failed2("protocol", input2.protocolProblem);
   if (input2.terminal) {
     if (input2.terminal.type === "failure") {
-      return failed(
+      return failed2(
         input2.terminal.failureType,
         clampText(input2.terminal.message, SCRIPT_MAX_FAILURE_MESSAGE_CHARS),
         clampText(input2.terminal.stack, SCRIPT_MAX_FAILURE_STACK_CHARS)
@@ -166996,26 +167304,26 @@ function classifyOutcome(input2) {
     return commitOutput(input2.terminal.outputJson);
   }
   if (input2.interrupted === "cancelled") {
-    return failed("cancelled", "The run was cancelled and the script process was stopped.");
+    return failed2("cancelled", "The run was cancelled and the script process was stopped.");
   }
   if (input2.interrupted === "timeout") return timedOut(input2.timeoutMs);
   if (isHeapAbort(exit, input2.heapFatalSeen)) {
-    return failed("heap", `The script exceeded its ${input2.heapLimitMb} MiB heap limit.`);
+    return failed2("heap", `The script exceeded its ${input2.heapLimitMb} MiB heap limit.`);
   }
   if (!input2.startedSeen) {
-    return failed(
+    return failed2(
       "protocol",
       `The script runner exited before it started the script (${describeExit(exit)}).`
     );
   }
   if (exit.signal) {
     if (input2.deadlinePassed) return timedOut(input2.timeoutMs);
-    return failed(
+    return failed2(
       "signal",
       `The script process was killed by ${exit.signal} before it returned output. It did not stop itself.`
     );
   }
-  return failed(
+  return failed2(
     "exit",
     `The script stopped its own process with exit code ${exit.code ?? 0} instead of returning; no output was captured.`
   );
@@ -167025,7 +167333,7 @@ function redactSecrets(verdict, secrets) {
   if (verdict.output) {
     const collision = scrubDocument(verdict.output, secrets);
     if (collision) {
-      return failed(
+      return failed2(
         "output",
         `Two keys in the script's output become "${collision}" once the secret in them is redacted, so one would silently replace the other. Rename one of them.`
       );
@@ -167072,7 +167380,7 @@ function scrubDocument(root, secrets) {
 function commitOutput(outputJson) {
   const bytes = Buffer.byteLength(outputJson, "utf8");
   if (bytes > SCRIPT_MAX_OUTPUT_BYTES) {
-    return failed(
+    return failed2(
       "output",
       `The script returned ${describeBytes(bytes)} of encoded output; the limit is ${describeBytes(SCRIPT_MAX_OUTPUT_BYTES)}.`
     );
@@ -167081,14 +167389,14 @@ function commitOutput(outputJson) {
   try {
     parsed = JSON.parse(outputJson);
   } catch (err) {
-    return failed("output", `The script's output did not parse: ${errorMessage(err)}`);
+    return failed2("output", `The script's output did not parse: ${errorMessage(err)}`);
   }
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    return failed("output", "The script's output was not an object.");
+    return failed2("output", "The script's output was not an object.");
   }
   const polluted = findOwnProtoKey(parsed);
   if (polluted !== void 0) {
-    return failed(
+    return failed2(
       "output",
       `${polluted} has an own "__proto__" key; output must be JSON-compatible data.`
     );
@@ -167149,12 +167457,12 @@ function clampText(text, max) {
   return marked;
 }
 function timedOut(timeoutMs) {
-  return failed(
+  return failed2(
     "timeout",
     `The script did not finish within its ${describeDuration(timeoutMs)} time limit and its process tree was stopped.`
   );
 }
-function failed(kind, message, stack) {
+function failed2(kind, message, stack) {
   return { ok: false, failure: { kind, message, ...stack ? { stack } : {} } };
 }
 function isHeapAbort(exit, heapFatalSeen) {
@@ -171255,13 +171563,13 @@ async function frontChromiumPage(registry2, device) {
 }
 function summarize(flowName, deviceId, executionPrerequisite, steps, aborted2, timing) {
   let passed = 0;
-  let failed2 = 0;
+  let failed3 = 0;
   let skipped = 0;
   let errored = 0;
   for (const s of steps) {
     if (s.kind === "echo") continue;
     if (s.status === "pass") passed++;
-    else if (s.status === "fail") failed2++;
+    else if (s.status === "fail") failed3++;
     else if (s.status === "skip") skipped++;
     else errored++;
   }
@@ -171273,10 +171581,10 @@ function summarize(flowName, deviceId, executionPrerequisite, steps, aborted2, t
     // (no fail/error report), so the verdict folds the abort in directly. A
     // skip by itself is NOT a failure: an unmet `when:` guard skips its block
     // as a successful omission.
-    ok: failed2 === 0 && errored === 0 && !aborted2,
+    ok: failed3 === 0 && errored === 0 && !aborted2,
     ...aborted2 ? { aborted: true } : {},
     passed,
-    failed: failed2,
+    failed: failed3,
     skipped,
     errored,
     steps,
@@ -171579,9 +171887,10 @@ async function runFold(state3, step) {
     const result = await invokeSubTool(registry2, ctx, "fold", args);
     const size = result.screen?.width !== void 0 && result.screen?.height !== void 0 ? ` ${result.screen.width}x${result.screen.height}` : "";
     const target = step.posture ?? `${step.angle}\xB0`;
+    const landed = result.deviceState !== void 0 ? `device state ${result.deviceState}` : `screen ${result.activeScreen ?? "?"} (${result.screen?.panel ?? "?"}${size})`;
     return {
       ok: true,
-      reason: `${target}: screen ${result.activeScreen ?? "?"} (${result.screen?.panel ?? "?"}${size})`,
+      reason: `${target}: ${landed}`,
       ...result.warning !== void 0 ? { warning: result.warning } : {}
     };
   } catch (err) {
@@ -172485,7 +172794,7 @@ var updateArgentTool = {
       });
       child.unref();
     }, 2e3);
-    const targetLabel2 = effectiveTarget === "both" ? "global and project-local installs" : `${effectiveTarget} install`;
+    const targetLabel3 = effectiveTarget === "both" ? "global and project-local installs" : `${effectiveTarget} install`;
     const otherHint = requested === "auto" && resolved !== "both" ? resolved === "local" ? ` If you also have a global install, call this tool again with target "global" to update it too.` : ` If you also have a project-local install, run \`argent update --local\` in that project to update it too.` : "";
     const bothDegradedNote = resolved === "both" && effectiveTarget === "global" ? ` The project-local install was skipped: no project declaring ${PACKAGE_NAME2} could be located from this server \u2014 run \`argent update --local\` in the project directory for it.` : "";
     const versionInfo = targetsOnlyRunningInstall ? `(v${currentVersion} -> v${installableVersion}) ` : "";
@@ -172493,7 +172802,7 @@ var updateArgentTool = {
     const coversRunningInstall = targetsOnlyRunningInstall || effectiveTarget === "both";
     const restartNote = coversRunningInstall ? ` The tool server will stop and restart automatically once the update is installed. Subsequent tool calls will reconnect to the updated server.` : ` This session's tool server is not affected and keeps running; the update applies only to the targeted install.`;
     return {
-      message: `Argent update initiated ${versionInfo}for the ${targetLabel2}.` + crossTargetNote + restartNote + `${otherHint}${bothDegradedNote}`
+      message: `Argent update initiated ${versionInfo}for the ${targetLabel3}.` + crossTargetNote + restartNote + `${otherHint}${bothDegradedNote}`
     };
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swmansion/argent",
-  "version": "0.29.1-next.14",
+  "version": "0.29.1-next.15",
   "mcpName": "io.github.software-mansion/argent",
   "description": "MCP server for iOS Simulator and Android Emulator control",
   "license": "Apache-2.0",

package/skills/argent-create-flow/references/flow-yaml.md

@@ -111,12 +111,12 @@ Scopes can combine and nest, with at most six scope keys. Use strict selectors f
 
 Directives stop the flow on failure and skip later steps. The available directives are `launch`, `tap`, `long-press`, `swipe`, `type`, `scroll-to`, `pinch`, `rotate`, `fold`, `await`, `assert`, `wait`, `snapshot`, `run`, `script`, `when`, `echo`, and `tool`.
 
-`fold` folds or unfolds a foldable iOS simulator. Write a posture (`fold: closed`, `fold: half-open`, `fold: open`) or an angle from 0 to 180 (`fold: 120`). The step waits until the device accepts input again. A recorded `fold` tool call becomes a `fold:` step. After a `fold` step:
+`fold` folds or unfolds a foldable iOS simulator or Android emulator. Write a posture (`fold: closed`, `fold: half-open`, `fold: open`) or an angle from 0 to 180 (`fold: 120`). The step waits until the device accepts input again. A recorded `fold` tool call becomes a `fold:` step. After a `fold` step:
 
 - The coordinates change with the panel. Selectors resolve against a new tree.
 - A `snapshot` baseline is valid only for the posture that made it.
-- Unfolded, the UI is landscape. `swipe` and `scroll-to` directions and the reading order stay as the user sees the UI. Coordinates stay in the space of the `describe` frames.
-- A fold between two angles that are not `closed` or `open` can keep the current panel. The step passes, and the report names the panel. To change panels, fold to `closed` or `open`.
+- iOS: unfolded, the UI is landscape. `swipe` and `scroll-to` directions and the reading order stay as the user sees the UI. Coordinates stay in the space of the `describe` frames.
+- iOS: a fold between two angles that are not `closed` or `open` can keep the current panel. The step passes, and the report names the panel. To change panels, fold to `closed` or `open`.
 
 Use the launch map for cross-platform flows. A bare launch applies everywhere and becomes an app path on Chromium. The map takes `native:`, `ios:`, `android:`, `vega:`, and `chromium:`. `native:` is one id shared by iOS, Android, and Vega, and a per-platform key overrides it for that platform. `chromium:` accepts a relative or absolute app path. `ios:` also accepts `{ app, args }`; a simulator passes `args` to the app at launch. A launch that declares no id for the run's platform is an error, not a cue to switch platforms. A run on a remote simulator uses the `ios:` id, or the `native:` id when the map has no `ios:` key, so no flow needs a key for a remote run. On iOS, a successful launch also pins later tree reads to that app until the next raw `tool:` step, so read [The runner tree is not the discovery tree](#the-runner-tree-is-not-the-discovery-tree) when a read describes the wrong screen.
 

package/skills/argent-device-interact/SKILL.md

@@ -67,7 +67,7 @@ Common schemes: `messages://`, `settings://`, `maps://?q=<query>`, `tel://<numbe
 | Type text         | `keyboard`          | Every platform. Text or one named key per call, never both        |
 | Paste text        | `paste`             | Only where a user would paste (OTP code, long link). Sim/emu only |
 | Rotate device     | `rotate`            | Orientation changes                                               |
-| Fold device       | `fold`              | Foldable iOS simulator: closed / half-open / open, or an angle    |
+| Fold device       | `fold`              | Foldable simulator/emulator: closed / half-open / open, or angle  |
 | Shake device      | `shake`             | Shake handlers (sim/emu only), Undo-typing prompt, RN dev menu    |
 | Wait for UI       | `await-ui-element`  | Block until an element is visible/hidden/exists/contains text     |
 | Wait for idle     | `await-screen-idle` | Block until a non-empty screen tree stops changing                |
@@ -201,7 +201,7 @@ Values: `Portrait`, `LandscapeLeft`, `LandscapeRight`, `PortraitUpsideDown`
 
 On an unfolded foldable simulator, the value sets the orientation of the device, not of the UI. `Portrait` gives a landscape UI. `LandscapeLeft` gives a portrait UI.
 
-### fold: Fold or unfold a foldable simulator
+### fold: Fold or unfold a foldable device
 
 ```json
 { "udid": "<UDID>", "posture": "open" }
@@ -209,7 +209,7 @@ On an unfolded foldable simulator, the value sets the orientation of the device,
 
 Give `posture` (`closed`, `half-open` or `open`) or `angle` (0–180). Do not give both.
 
-Use `fold` only on a foldable iOS simulator. `list-devices` marks it with `foldable: true`, for example the iPhone Duo. Other devices reject the call.
+Use `fold` only on a foldable iOS simulator (the iPhone Duo) or Android emulator (a Pixel Fold or generic foldable AVD). `list-devices` marks them with `foldable: true`. Other devices reject the call.
 
 Closed, the cover panel shows the UI. Half-open and open, the inner panel shows the UI. All tools use the active panel (the panel that shows the UI), also after a fold made outside argent. `fold` returns when the device accepts input again, so the next tap lands. This is also true for the next step in `run-sequence`.
 
@@ -217,10 +217,12 @@ Rules:
 
 - The coordinates change with the panel. Before you tap, read the element tree in the `fold` result, or run `describe` again. Do not use frames from before the fold.
 - The screenshot size changes with the panel. Keep one screenshot-diff baseline for each posture.
-- Unfolded, the UI is landscape. The screenshot shows the UI turned 90 degrees, and the `describe` frames use the same axes, as on a rotated iPhone.
-- A fold between two angles that are not 0 or 180 can keep the current panel. The result names the active panel. To change panels, fold to `closed` or `open`.
+- iOS: unfolded, the UI is landscape. The screenshot shows the UI turned 90 degrees, and the `describe` frames use the same axes, as on a rotated iPhone.
+- iOS: a fold between two angles that are not 0 or 180 can keep the current panel. The result names the active panel. To change panels, fold to `closed` or `open`.
 - Fold between gestures, not during a gesture. A gesture stays on the panel where it started.
-- If argent cannot find the active panel, it uses the cover panel. The tool result then has a `warning`, and a screenshot-diff summary has a `panel:` line. Take a screenshot to see what the device shows, then do the check that the warning gives.
+- Android: the result gives `deviceState` (`CLOSED`, `HALF_OPENED`, `OPENED`). A lock screen that the fold to closed shows is dismissed; a `warning` says when it cannot be, or when a lock screen is up after the fold. Unlock the device before the next action.
+- Android: only a Pixel Fold AVD has a cover panel. When a generic foldable AVD is closed, the emulator shows only the left part of the display. `describe` frames do not match tap coordinates. Argent can reliably tap only an element that covers the visible part, for example a full-width row. Use a Pixel Fold AVD to test the cover panel.
+- iOS: if argent cannot find the active panel, it uses the cover panel. The tool result then has a `warning`, and a screenshot-diff summary has a `panel:` line. Take a screenshot to see what the device shows, then do the check that the warning gives.
 
 ### await-ui-element: Block until a UI element reaches a state