@@ -114,10 +114,14 @@ Dart 3.13 and Flutter 3.47 — and none of them is a session error.
   "Connecting to the VM Service is taking longer than expected" (measured, 60 s). The same
   recipe works for desktop apps and Dart programs. Launch the app through mcp-debugger instead;
   #882 tracks the `--device-vmservice-port` / `--host-vmservice-port` / `--no-dds` measurements.
-- **On an Android emulator, stop the previous app instance before the next launch.** A live
-  instance being replaced by the next install, or a stale adb port forward, made a launch hang
-  or end without a stop (measured). `adb shell am force-stop <package>` and
-  `adb forward --remove-all` first; the e2e helper does both, and installs the APK up front.
+- **On an Android emulator, the first launch after a fresh install may end without a stop.**
+  Seen once: the first `flutter run` right after the debug APK was first installed ended with
+  "The program ended without reporting an exit code" instead of pausing; the next launch was
+  fine. `flutter run` stops and reinstalls the app itself on every launch, so there is nothing
+  to do by hand; relaunch. The e2e helper warms the Gradle build and does the first install
+  before the timed cases. A cold Gradle build on a fresh machine (minutes) belongs to the first
+  build, not to the debugger: the launch answers `pending: true` and `wait_for_stop` collects
+  the stop.
 - **`dart test` fails under `%LOCALAPPDATA%\Temp` with the winget SDK (Windows).**
   package:test spawns its frontend server through a cwd-relative SDK path that does not
   resolve from there (`The system cannot find the file specified … dartaotruntime.exe`).
 
@@ -138,11 +138,11 @@ Android emulator (`deviceId: "emulator-5554"`, the AVD booted first; measured th
 `tests/e2e/mcp-server-smoke-flutter-android.test.ts`, Gradle warm): a `build()` breakpoint under
 `flutter run` in ~21 s, an `integration_test` breakpoint in ~28 s with the app's breakpoint hit by
 the test's tap right after; a cold Gradle build on a fresh machine takes minutes and belongs to
-the first build, not to the debugger. Stop the previous app instance (`adb shell am force-stop
-<package>`) and clear forwards (`adb forward --remove-all`) before launching again; the e2e helper
-does so, and installs the debug APK up front because the first run after a fresh install once
-ended without stopping. Attaching to an app another `flutter run` started on the emulator does
-not connect yet (#882; see `docs/KNOWN_ISSUES.md`).
+the first build, not to the debugger. `flutter run` stops and reinstalls the app itself on every
+launch; the e2e helper only warms the build for the device's ABI and does the first install
+ahead of the timed cases, because the first run right after a fresh install once ended without
+stopping (relaunch if that happens). Attaching to an app another `flutter run` started on the
+emulator does not connect yet (#882; see `docs/KNOWN_ISSUES.md`).
 
 ## Troubleshooting
 
 
@@ -355,10 +355,10 @@ Measured through `dist/index.js` with `tests/e2e/mcp-server-smoke-flutter-androi
 | Case | Result |
 |---|---|
 | `flutter run -d emulator-5554`, breakpoint in `build()` | `pending: true` at 2.5 s; the breakpoint at **21.3 s**; `_ProbeAppState.build`, `counter` → `0`; `continue` keeps it running; `close_debug_session` terminates the app |
-| the same, first launch right after a fresh APK install | ended at 27.9 s with "The program ended without reporting an exit code" and no stop (once; the next launch was fine) — hence the up-front install and the force-stop before every launch |
+| the same, first launch right after a fresh APK install | ended at 27.9 s with "The program ended without reporting an exit code" and no stop (once; the next launch was fine) — hence the helper's warm prebuild for the device's ABI and first install ahead of the timed cases; `flutter run` itself stops and reinstalls the app every time |
 | `integration_test` on the emulator | test breakpoint at **28.3 s**, the app's `increment()` breakpoint at **28.7 s** on the test's tap, `counter` → `0`, `✓ device increment`, end `stopped` at 31.6 s |
 
 - `flutter build apk --debug` on the fresh example with warm Gradle caches: **45 s**.
-- Before each launch: `adb shell am force-stop com.example.flutter_probe`, `adb forward --remove-all`.
+- Before each launch the helper force-stops a leftover instance and removes this emulator's own adb forwards (from `adb forward --list`; `adb forward --remove-all` is host-wide). Whether a stale forward ever caused the "device offline" failure is not established — the force-stop may be all that mattered.
 - The proxy log records output events by shape only (issue #852): to read the device's output
   after the fact, `get_output` before the session closes.
@@ -88,8 +88,9 @@ This directory contains end-to-end smoke tests that verify the MCP debugger serv
 - `mcp-server-smoke-flutter-android.test.ts` runs `flutter run` and the `integration_test` on a
   booted Android emulator (`flutter emulators --launch <id>` is the opt-in; it self-skips without
   Flutter, adb or an online emulator, and with `MCP_SKIP_FLUTTER_ANDROID=1`). The helper generates
-  `android/`, builds the debug APK once, installs it, and stops the app and clears adb forwards
-  before each launch. Never runs on CI
+  `android/`, builds the debug APK once for the device's ABI and installs it (a warm build; `flutter
+  run` stops and reinstalls on its own anyway), and before each launch stops a leftover instance
+  and removes that emulator's own adb forwards. Never runs on CI
 
 ### 13. `mcp-server-smoke-javascript-sse.test.ts`
 - Tests JavaScript adapter over SSE transport
 
@@ -214,18 +214,27 @@ export function adbPath(): string | null {
   }
   const onPath = which.sync('adb', { nothrow: true });
   if (onPath) return onPath;
-  if (process.platform === 'win32' && process.env.LOCALAPPDATA) {
-    const candidate = path.join(process.env.LOCALAPPDATA, 'Android', 'Sdk', 'platform-tools', exe);
+  // Android Studio's default SDK locations, the ones flutter_tools probes too.
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? '';
+  const defaults = process.platform === 'win32'
+    ? [path.join(process.env.LOCALAPPDATA ?? '', 'Android', 'Sdk')]
+    : process.platform === 'darwin'
+      ? [path.join(home, 'Library', 'Android', 'sdk')]
+      : [path.join(home, 'Android', 'Sdk')];
+  for (const sdk of defaults) {
+    const candidate = path.join(sdk, 'platform-tools', exe);
     if (existsSync(candidate)) return candidate;
   }
   return null;
 }
 
-function adb(args: string[], timeoutMs = 120_000): { status: number | null; stdout: string } {
+function adb(args: string[], timeoutMs = 120_000): { status: number | null; stdout: string; out: string } {
   const exe = adbPath();
-  if (!exe) return { status: null, stdout: '' };
+  if (!exe) return { status: null, stdout: '', out: '' };
   const r = spawnSync(exe, args, { encoding: 'utf8', windowsHide: true, timeout: timeoutMs });
-  return { status: r.status, stdout: r.stdout ?? '' };
+  const stdout = r.stdout ?? '';
+  // adb reports install failures on stderr (`adb: failed to install …`).
+  return { status: r.status, stdout, out: `${stdout}${r.stderr ?? ''}` };
 }
 
 let cachedEmulator: string | null | undefined;
@@ -238,25 +247,47 @@ let cachedEmulator: string | null | undefined;
 export function flutterEmulatorDeviceId(): string | null {
   if (cachedEmulator !== undefined) return cachedEmulator;
   if (process.env.MCP_SKIP_FLUTTER_ANDROID === '1' || !adbPath()) return (cachedEmulator = null);
+  // Flutter's own list first: no emulator there means no adb server to start for nothing.
+  const emulators = flutterDeviceIds().filter((id) => id.startsWith('emulator-'));
+  if (emulators.length === 0) return (cachedEmulator = null);
   const online = new Set(
     adb(['devices']).stdout.split(/\r?\n/).map((l) => l.trim().split(/\s+/)).filter((p) => p.length === 2 && p[1] === 'device').map((p) => p[0])
   );
-  cachedEmulator = flutterDeviceIds().find((id) => id.startsWith('emulator-') && online.has(id)) ?? null;
+  cachedEmulator = emulators.find((id) => online.has(id)) ?? null;
   return cachedEmulator;
 }
 
-/** Stop the probe app and drop stale port forwards: a live previous instance or a stale forward makes the next launch hang (measured). */
+/**
+ * Before a launch: stop the probe app and drop the port forwards that belong to this emulator.
+ * `flutter run` force-stops and reinstalls on its own (android_device.dart `startApp`), so the
+ * stop only matters for an instance a previous test left behind; the forwards are removed one by
+ * one from `adb forward --list` because `adb forward --remove-all` is host-wide and would take
+ * other tools' forwards with it.
+ */
 export function resetAndroidApp(deviceId: string): void {
   adb(['-s', deviceId, 'shell', 'am', 'force-stop', FLUTTER_PROBE_PACKAGE], 30_000);
-  adb(['forward', '--remove-all'], 30_000);
+  for (const line of adb(['forward', '--list'], 30_000).stdout.split(/\r?\n/)) {
+    const [serial, local] = line.trim().split(/\s+/);
+    if (serial === deviceId && local) adb(['-s', deviceId, 'forward', '--remove', local], 30_000);
+  }
 }
 
 let androidPrepared = false;
 
+/** The `--target-platform` matching the device's ABI, so the warm-up builds what `flutter run` will run. */
+function androidTargetPlatform(deviceId: string): string {
+  const abi = adb(['-s', deviceId, 'shell', 'getprop', 'ro.product.cpu.abi'], 30_000).stdout.trim();
+  if (abi.startsWith('arm64')) return 'android-arm64';
+  if (abi.startsWith('armeabi')) return 'android-arm';
+  return 'android-x64';
+}
+
 /**
- * Generate the probe's `android/` folder, build the debug APK once and install it on the device,
- * so the launches under test never pay the first install (the first `flutter run` after a fresh
- * install ended without a stop once, measured; the next one was fine). Warm Gradle: ~45 s.
+ * Generate the probe's `android/` folder, build the debug APK for the device's ABI once and
+ * install it. `flutter run` stops, builds and installs on its own every time, so what this buys
+ * the timed launches is a warm Gradle and dependency cache (the spike measured 425 s cold, 6–45 s
+ * warm) and the first-ever `pm install` out of the way; the first `flutter run` after a fresh
+ * install was seen to end without a stop once. A stale `android/` is not regenerated: delete it.
  */
 export function prepareFlutterAndroid(deviceId: string): void {
   if (androidPrepared) return;
@@ -267,11 +298,19 @@ export function prepareFlutterAndroid(deviceId: string): void {
     const r = runFlutter(root, ['create', '--platforms=android', '--project-name', 'flutter_probe', '.'], FLUTTER_PROBE_DIR);
     if (r.status !== 0) throw new Error(`flutter create --platforms=android failed: ${r.out}`);
   }
-  const built = runFlutter(root, ['build', 'apk', '--debug'], FLUTTER_PROBE_DIR, 900_000);
-  if (built.status !== 0) throw new Error(`flutter build apk --debug failed: ${built.out}`);
+  const built = runFlutter(root, ['build', 'apk', '--debug', '--target-platform', androidTargetPlatform(deviceId)], FLUTTER_PROBE_DIR, 900_000);
+  if (built.status !== 0) {
+    throw new Error(`flutter build apk --debug failed (a stale examples/dart/flutter_probe/android can be deleted and regenerated): ${built.out}`);
+  }
   const apk = path.join(FLUTTER_PROBE_DIR, 'build', 'app', 'outputs', 'flutter-apk', 'app-debug.apk');
-  const installed = adb(['-s', deviceId, 'install', '-r', '-t', apk], 180_000);
-  if (installed.status !== 0) throw new Error(`adb install failed: ${installed.stdout}`);
+  let installed = adb(['-s', deviceId, 'install', '-r', '-t', apk], 180_000);
+  if (installed.status !== 0) {
+    // An older signature or version on the device (INSTALL_FAILED_UPDATE_INCOMPATIBLE): the way
+    // flutter_tools handles it too — uninstall once and retry.
+    adb(['-s', deviceId, 'uninstall', FLUTTER_PROBE_PACKAGE], 60_000);
+    installed = adb(['-s', deviceId, 'install', '-r', '-t', apk], 180_000);
+    if (installed.status !== 0) throw new Error(`adb install failed: ${installed.out}`);
+  }
   androidPrepared = true;
 }
 
 
@@ -3,9 +3,11 @@
  * emulator-NNNN` with a breakpoint in `build()`, and an `integration_test` on the emulator whose
  * tap hits the app's breakpoint. Measured through the real server on 2026-10-09 (Flutter 3.47.7,
  * Windows, AVD `mcp_api35` booted headless, Gradle warm): the `build()` breakpoint in ~21 s, the
- * integration test's breakpoints in ~28 s; the first `flutter run` after a fresh APK install once
- * ended without a stop, so the helper installs the APK up front and stops the app and clears
- * port forwards before every launch.
+ * integration test's breakpoints in ~28 s. `flutter run` stops, builds and installs the app on
+ * its own every launch; the helper warms the Gradle build for the device's ABI and does the
+ * first install ahead of the timed cases (the first run right after a fresh install once ended
+ * without a stop), and before each launch stops a leftover instance and removes this emulator's
+ * own adb forwards.
  *
  * Opt-in by booting an emulator (`flutter emulators --launch <id>`); self-skips without Flutter,
  * adb, an online emulator, or with `MCP_SKIP_FLUTTER_ANDROID=1`. CI never runs it.
@@ -112,11 +114,27 @@ describe.skipIf(!EMULATOR)(`MCP Server Flutter Android Smoke Test @requires-flut
     return res;
   }
 
+  /**
+   * `wait_for_stop` in slices under the MCP client's 60 s request cap: a Gradle build can keep
+   * the first stop away for longer than that (seen: 63 s), and a single long server-side wait
+   * then fails on the client side, not the debugger's.
+   */
+  async function waitForPause(timeoutMs: number, what: string) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+      const slice = Math.min(45_000, Math.max(1_000, deadline - Date.now()));
+      const waited = await call('wait_for_stop', { timeout: slice });
+      if (waited.state === 'paused') return (await getSession())!;
+      const stillRunning = waited.pending === true || waited.state === 'running';
+      if (!stillRunning || Date.now() >= deadline) {
+        throw new Error(`${what}: wait_for_stop answered ${JSON.stringify(waited)}; output tail: ${(await output()).slice(-600)}`);
+      }
+    }
+  }
+
   async function firstStop(launched: Record<string, unknown>, timeoutMs: number) {
     if (launched.state === 'paused') return (await getSession())!;
-    const waited = await call('wait_for_stop', { timeout: timeoutMs });
-    expect(waited.state, `first stop (wait_for_stop answered ${JSON.stringify(waited)}; output: ${(await output()).slice(-600)})`).toBe('paused');
-    return (await getSession())!;
+    return waitForPause(timeoutMs, 'first stop');
   }
 
   async function createSession(name: string) {
@@ -160,8 +178,7 @@ describe.skipIf(!EMULATOR)(`MCP Server Flutter Android Smoke Test @requires-flut
     expect((await frames())[0].line).toBe(testLine);
 
     await callToolSafely(mcpClient!, 'continue_execution', { sessionId });
-    const atApp = await call('wait_for_stop', { timeout: 120000 });
-    expect(atApp.state, JSON.stringify(atApp)).toBe('paused');
+    await waitForPause(120000, "the app's breakpoint on the test's tap");
     const top = (await frames())[0];
     expect(top.file?.toLowerCase()).toBe(FLUTTER_EXAMPLES.main.toLowerCase());
     expect(top.line).toBe(appLine);
 
@@ -120,12 +120,28 @@ describe.skipIf(SKIP_FLUTTER)('MCP Server Flutter Debugging Smoke Test @requires
     return res;
   }
 
+  /**
+   * `wait_for_stop` in slices under the MCP client's 60 s request cap: a cold compile or a
+   * runner build can keep the first stop away for longer than that, and a single long
+   * server-side wait then fails on the client side, not the debugger's.
+   */
+  async function waitForPause(timeoutMs: number, what: string) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+      const slice = Math.min(45_000, Math.max(1_000, deadline - Date.now()));
+      const waited = await call('wait_for_stop', { timeout: slice });
+      if (waited.state === 'paused') return (await getSession())!;
+      const stillRunning = waited.pending === true || waited.state === 'running';
+      if (!stillRunning || Date.now() >= deadline) {
+        throw new Error(`${what}: wait_for_stop answered ${JSON.stringify(waited)}; output tail: ${(await output()).slice(-600)}`);
+      }
+    }
+  }
+
   /** The launch answers `pending` while the test VM compiles; the first stop is what matters. */
   async function firstStop(launched: Record<string, unknown>, timeoutMs: number) {
     if (launched.state === 'paused') return (await getSession())!;
-    const waited = await call('wait_for_stop', { timeout: timeoutMs });
-    expect(waited.state, `first stop (wait_for_stop answered ${JSON.stringify(waited)})`).toBe('paused');
-    return (await getSession())!;
+    return waitForPause(timeoutMs, 'first stop');
   }
 
   async function createSession(name: string) {
@@ -219,8 +235,7 @@ describe.skipIf(SKIP_FLUTTER)('MCP Server Flutter Debugging Smoke Test @requires
       expect((await frames())[0].line).toBe(testLine);
 
       await callToolSafely(mcpClient!, 'continue_execution', { sessionId });
-      const atApp = await call('wait_for_stop', { timeout: 60000 });
-      expect(atApp.state, JSON.stringify(atApp)).toBe('paused');
+      await waitForPause(60000, "the app's breakpoint on the test's tap");
       const top = (await frames())[0];
       expect(top.file?.toLowerCase()).toBe(FLUTTER_EXAMPLES.main.toLowerCase());
       expect(top.line).toBe(appLine);