adb-ready 0.6.0 → 0.8.0

package/dist/cli.js

@@ -3298,13 +3298,13 @@ async function activateAgentTaskFromEnvironment(env) {
 }
 
 // src/cli/main.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
-import path24 from "node:path";
+import { randomUUID as randomUUID17 } from "node:crypto";
+import path26 from "node:path";
 import process15 from "node:process";
 // package.json
 var package_default = {
   name: "adb-ready",
-  version: "0.6.0",
+  version: "0.8.0",
   description: "Agent-ready Android CLI for reliable ADB sessions, app automation, and verified evidence.",
   private: false,
   type: "module",
@@ -3403,7 +3403,7 @@ var package_default = {
     "@yarnpkg/cli-dist": "4.18.0",
     npm: "12.0.2",
     publint: "0.3.24",
-    runpalette: "0.3.0",
+    runpalette: "0.5.0",
     tinyexec: "1.3.1",
     typescript: "7.0.2",
     yarn: "1.22.22"
@@ -37551,6 +37551,7 @@ async function runProcess(request) {
   let spawnError;
   let streamError;
   return await new Promise((resolve) => {
+    const ownsProcessGroup = request.killProcessGroup === true;
     const child = spawn2(request.executable, args, {
       cwd: request.cwd,
       env: request.inheritEnv === false ? request.env : { ...process5.env, ...request.env },
@@ -37560,21 +37561,41 @@ async function runProcess(request) {
         "pipe",
         "pipe"
       ],
-      windowsHide: true
+      windowsHide: true,
+      detached: ownsProcessGroup && process5.platform !== "win32"
     });
     const killSignal = request.killSignal ?? "SIGTERM";
     let idleTimer;
     let escalationTimer;
+    let closed = false;
+    const signalOwnedProcess = (signal) => {
+      if (ownsProcessGroup && process5.platform === "win32" && child.pid !== undefined) {
+        killEscalated = true;
+        spawn2("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
+          shell: false,
+          stdio: "ignore",
+          windowsHide: true
+        }).once("error", () => child.kill(signal));
+        return;
+      }
+      if (ownsProcessGroup && child.pid !== undefined) {
+        try {
+          process5.kill(-child.pid, signal);
+          return;
+        } catch {}
+      }
+      child.kill(signal);
+    };
     const terminate = () => {
-      if (child.exitCode !== null || child.signalCode !== null) {
+      if (closed || !ownsProcessGroup && (child.exitCode !== null || child.signalCode !== null)) {
         return;
       }
-      child.kill(killSignal);
+      signalOwnedProcess(killSignal);
       if (killSignal !== "SIGKILL" && escalationTimer === undefined) {
         escalationTimer = setTimeout(() => {
-          if (child.exitCode === null && child.signalCode === null) {
+          if (!closed) {
             killEscalated = true;
-            child.kill("SIGKILL");
+            signalOwnedProcess("SIGKILL");
           }
         }, killGraceMs);
       }
@@ -37649,6 +37670,7 @@ async function runProcess(request) {
       };
     });
     child.once("close", (exitCode, signal) => {
+      closed = true;
       if (timeout !== undefined) {
         clearTimeout(timeout);
       }
@@ -38063,6 +38085,137 @@ function parseLogcatThreadtimeLine(raw) {
   return { timestamp, pid, tid, priority, tag, message, raw: line };
 }
 
+// src/adb/remote-server-probe.ts
+import { createConnection } from "node:net";
+var REQUEST = "000chost:version";
+var MAX_RESPONSE_BYTES = 4096;
+function normalizedSocketHost(host) {
+  return host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+}
+function protocolFrame(buffer) {
+  if (buffer.length < 4)
+    return { kind: "incomplete" };
+  const status = buffer.subarray(0, 4).toString("ascii");
+  if (status !== "OKAY" && status !== "FAIL") {
+    return { kind: "invalid", message: "The server returned an unknown ADB status." };
+  }
+  if (buffer.length < 8)
+    return { kind: "incomplete" };
+  const lengthText = buffer.subarray(4, 8).toString("ascii");
+  if (!/^[0-9a-fA-F]{4}$/u.test(lengthText)) {
+    return { kind: "invalid", message: "The server returned an invalid ADB payload length." };
+  }
+  const length = Number.parseInt(lengthText, 16);
+  if (length > MAX_RESPONSE_BYTES) {
+    return { kind: "invalid", message: "The server returned an oversized ADB payload." };
+  }
+  if (buffer.length < 8 + length)
+    return { kind: "incomplete" };
+  const payload = buffer.subarray(8, 8 + length).toString("utf8");
+  return status === "OKAY" ? { kind: "okay", payload } : { kind: "rejected", message: payload || "The server rejected host:version." };
+}
+function adbProtocolVersion(value) {
+  const match = value?.match(/^1\.0\.(\d+)$/u);
+  if (match?.[1] === undefined)
+    return;
+  const parsed = Number(match[1]);
+  return Number.isSafeInteger(parsed) && parsed >= 0 && parsed <= 65535 ? parsed : undefined;
+}
+var probeRemoteAdbServer = async (options) => {
+  if (options.host.trim() === "")
+    throw new RangeError("remote ADB host cannot be empty");
+  if (!Number.isSafeInteger(options.port) || options.port < 1 || options.port > 65535) {
+    throw new RangeError("remote ADB port must be from 1 to 65535");
+  }
+  if (!Number.isSafeInteger(options.expectedProtocolVersion) || options.expectedProtocolVersion < 0 || options.expectedProtocolVersion > 65535) {
+    throw new RangeError("expected ADB protocol version must be from 0 to 65535");
+  }
+  if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > 60000) {
+    throw new RangeError("remote ADB probe timeout must be from 1 to 60000");
+  }
+  if (options.signal?.aborted === true) {
+    return { ok: false, kind: "cancelled", message: "Remote ADB preflight was cancelled." };
+  }
+  return await new Promise((resolve) => {
+    const socket = createConnection({
+      host: normalizedSocketHost(options.host),
+      port: options.port
+    });
+    let buffer = Buffer.alloc(0);
+    let settled = false;
+    const finish = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", abort);
+      socket.destroy();
+      resolve(result);
+    };
+    const abort = () => finish({ ok: false, kind: "cancelled", message: "Remote ADB preflight was cancelled." });
+    const timer = setTimeout(() => finish({
+      ok: false,
+      kind: "timeout",
+      message: "The configured ADB server did not answer the safety preflight in time."
+    }), options.timeoutMs);
+    options.signal?.addEventListener("abort", abort, { once: true });
+    socket.once("connect", () => socket.write(REQUEST, "ascii"));
+    socket.on("data", (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      if (buffer.length > MAX_RESPONSE_BYTES + 8) {
+        finish({
+          ok: false,
+          kind: "invalid-response",
+          message: "The configured endpoint returned an oversized ADB response."
+        });
+        return;
+      }
+      const frame = protocolFrame(buffer);
+      if (frame.kind === "incomplete")
+        return;
+      if (frame.kind === "invalid") {
+        finish({ ok: false, kind: "invalid-response", message: frame.message });
+        return;
+      }
+      if (frame.kind === "rejected") {
+        finish({ ok: false, kind: "rejected", message: frame.message });
+        return;
+      }
+      if (!/^[0-9a-fA-F]{4}$/u.test(frame.payload)) {
+        finish({
+          ok: false,
+          kind: "invalid-response",
+          message: "The configured endpoint returned an invalid ADB protocol version."
+        });
+        return;
+      }
+      const actualProtocolVersion = Number.parseInt(frame.payload, 16);
+      if (actualProtocolVersion !== options.expectedProtocolVersion) {
+        finish({
+          ok: false,
+          kind: "protocol-mismatch",
+          message: "The remote ADB server protocol does not match the local ADB client.",
+          expectedProtocolVersion: options.expectedProtocolVersion,
+          actualProtocolVersion
+        });
+        return;
+      }
+      finish({ ok: true, protocolVersion: actualProtocolVersion });
+    });
+    socket.once("end", () => finish({
+      ok: false,
+      kind: "invalid-response",
+      message: "The configured endpoint closed before completing the ADB preflight."
+    }));
+    socket.once("error", (caught) => finish({
+      ok: false,
+      kind: "unreachable",
+      message: "The configured ADB server could not be reached.",
+      ...caught.code === undefined ? {} : { networkCode: caught.code }
+    }));
+  });
+};
+
 // src/adb/client.ts
 function targetArguments(target) {
   if (typeof target === "string") {
@@ -38095,13 +38248,21 @@ class AdbClient {
   #options;
   #runner;
   #idFactory;
+  #remoteServerProbe;
+  #expectedProtocolVersion;
   constructor(options) {
     this.#options = options;
     this.#runner = options.runner ?? runProcess;
     this.#idFactory = options.idFactory ?? randomUUID2;
+    this.#remoteServerProbe = options.remoteServerProbe ?? (options.runner === undefined ? probeRemoteAdbServer : false);
   }
   async version(signal) {
-    return await this.#observe("version", "Checking ADB version", ["version"], parseAdbVersion, signal, { useServerArguments: false });
+    const observation = await this.#observe("version", "Checking ADB version", ["version"], parseAdbVersion, signal, { useServerArguments: false });
+    const protocolVersion = adbProtocolVersion(observation.value.protocolVersion);
+    if (protocolVersion !== undefined) {
+      this.#expectedProtocolVersion = Promise.resolve(protocolVersion);
+    }
+    return observation;
   }
   async hostFeatures(signal) {
     return await this.#observe("host-features", "Checking ADB host features", ["host-features"], parseFeatureList, signal);
@@ -38159,6 +38320,47 @@ class AdbClient {
       ...this.#options.port === undefined ? [] : ["-P", String(this.#options.port)]
     ];
   }
+  async#localProtocolVersion(signal) {
+    if (this.#expectedProtocolVersion !== undefined)
+      return await this.#expectedProtocolVersion;
+    this.#expectedProtocolVersion = (async () => {
+      const result = await this.#runner({
+        executable: this.#options.executable,
+        args: ["version"],
+        timeoutMs: Math.min(this.#options.timeoutMs ?? 3000, 3000),
+        ...signal === undefined ? {} : { signal }
+      });
+      if (result.spawnError !== undefined || result.streamError !== undefined || result.exitCode !== 0 || result.timedOut || result.aborted) {
+        return;
+      }
+      return adbProtocolVersion(parseAdbVersion(result.stdout).protocolVersion);
+    })();
+    return await this.#expectedProtocolVersion;
+  }
+  async#remoteSafetyPreflight(signal) {
+    if (this.#options.host === undefined && this.#options.port === undefined || this.#remoteServerProbe === false) {
+      return;
+    }
+    const expectedProtocolVersion = await this.#localProtocolVersion(signal);
+    if (signal?.aborted === true) {
+      return { ok: false, kind: "cancelled", message: "Remote ADB preflight was cancelled." };
+    }
+    if (expectedProtocolVersion === undefined) {
+      return {
+        ok: false,
+        kind: "client-version-unavailable",
+        message: "The local ADB protocol version could not be verified safely."
+      };
+    }
+    const result = await this.#remoteServerProbe({
+      host: this.#options.host ?? "localhost",
+      port: this.#options.port ?? 5037,
+      expectedProtocolVersion,
+      timeoutMs: Math.min(this.#options.timeoutMs ?? 3000, 3000),
+      ...signal === undefined ? {} : { signal }
+    });
+    return result.ok ? undefined : result;
+  }
   async#observe(operation, message, args, parse10, signal, options = {}) {
     const operationId = this.#idFactory();
     const correlation = { ...this.#options.correlation, operationId };
@@ -38179,6 +38381,41 @@ class AdbClient {
         ...background ? { presentation: "background", retention: "transient" } : {}
       }
     });
+    const clientFailure = options.useServerArguments === false ? undefined : await this.#remoteSafetyPreflight(signal);
+    if (clientFailure !== undefined) {
+      const now = new Date().toISOString();
+      const result2 = {
+        executable: this.#options.executable,
+        args: finalArgs,
+        startedAt: now,
+        finishedAt: now,
+        durationMs: 0,
+        exitCode: clientFailure.kind === "cancelled" ? null : 1,
+        signal: null,
+        stdout: "",
+        stderr: clientFailure.message,
+        stdoutTruncated: false,
+        stderrTruncated: false,
+        timedOut: clientFailure.kind === "timeout",
+        aborted: clientFailure.kind === "cancelled",
+        stoppedAfterIdle: false,
+        killEscalated: false
+      };
+      this.#options.bus.emit({
+        type: "operation.failed",
+        source: `adb.${operation}`,
+        severity: clientFailure.kind === "cancelled" && background ? "debug" : "error",
+        message: clientFailure.kind === "cancelled" && background ? `${message} cancelled` : `${message} failed`,
+        correlation,
+        data: {
+          ...processMetadata(result2),
+          preflight: "remote-server",
+          failure: clientFailure.kind,
+          ...background ? { presentation: "background" } : {}
+        }
+      });
+      return { operationId, process: result2, value: parse10(""), clientFailure };
+    }
     const request = {
       executable: this.#options.executable,
       args: finalArgs,
@@ -38554,6 +38791,9 @@ var ProblemCode = {
   AdbNotFound: "ADB_NOT_FOUND",
   AdbOptionalProbeFailed: "ADB_OPTIONAL_PROBE_FAILED",
   AdbServerUnavailable: "ADB_SERVER_UNAVAILABLE",
+  AdbRemoteServerInvalidResponse: "ADB_REMOTE_SERVER_INVALID_RESPONSE",
+  AdbRemoteServerProtocolMismatch: "ADB_REMOTE_SERVER_PROTOCOL_MISMATCH",
+  AdbRemoteServerUnreachable: "ADB_REMOTE_SERVER_UNREACHABLE",
   AdbVersionMismatch: "ADB_VERSION_MISMATCH",
   AdbTimeout: "ADB_TIMEOUT",
   InteractiveSelectionUnavailable: "INTERACTIVE_SELECTION_UNAVAILABLE",
@@ -38839,7 +39079,7 @@ function problemsForServerStatus(status, clientVersion, correlation) {
   }
   return problems;
 }
-function adbProcessProblem(operation, result, correlation) {
+function adbProcessProblem(operation, result, correlation, clientFailure) {
   if (result.spawnError?.code === "ENOENT") {
     return adbNotFoundProblem(correlation, result.executable);
   }
@@ -38856,6 +39096,88 @@ function adbProcessProblem(operation, result, correlation) {
       correlation
     };
   }
+  if (clientFailure?.kind === "protocol-mismatch") {
+    return {
+      code: ProblemCode.AdbRemoteServerProtocolMismatch,
+      category: "adb.remote-server",
+      severity: "error",
+      summary: "The remote ADB server uses a different protocol version.",
+      detail: "ADB Ready stopped before launching the ADB client because upstream ADB can terminate a mismatched shared server automatically.",
+      retryable: true,
+      evidence: [
+        {
+          source: "adb.remote-preflight",
+          field: "expectedProtocolVersion",
+          value: clientFailure.expectedProtocolVersion ?? null
+        },
+        {
+          source: "adb.remote-preflight",
+          field: "actualProtocolVersion",
+          value: clientFailure.actualProtocolVersion ?? null
+        }
+      ],
+      actions: [
+        {
+          id: "align_remote_platform_tools",
+          title: "Align Platform-Tools on the client and remote ADB host",
+          kind: "user",
+          risk: "shared-global",
+          automatic: false
+        }
+      ],
+      correlation
+    };
+  }
+  if (clientFailure?.kind === "unreachable") {
+    return {
+      code: ProblemCode.AdbRemoteServerUnreachable,
+      category: "network.route",
+      severity: "error",
+      summary: "The configured remote ADB server is unreachable.",
+      detail: "Verify the explicit host and port, then check the WSL, container, VM, VPN, firewall, or tunnel route without exposing the ADB socket publicly.",
+      retryable: true,
+      evidence: [
+        ...clientFailure.networkCode === undefined ? [] : [
+          {
+            source: "adb.remote-preflight",
+            field: "networkCode",
+            value: clientFailure.networkCode
+          }
+        ]
+      ],
+      actions: [
+        {
+          id: "review_remote_adb_route",
+          title: "Check the protected route to the configured ADB server",
+          kind: "user",
+          risk: "none",
+          automatic: false
+        }
+      ],
+      correlation
+    };
+  }
+  if (clientFailure !== undefined && (clientFailure.kind === "invalid-response" || clientFailure.kind === "rejected" || clientFailure.kind === "client-version-unavailable")) {
+    return {
+      code: ProblemCode.AdbRemoteServerInvalidResponse,
+      category: "adb.remote-server",
+      severity: "error",
+      summary: "The configured endpoint could not be verified as a compatible ADB server.",
+      detail: "ADB Ready refused to send a normal ADB command until the endpoint and local client protocol can be verified safely.",
+      retryable: true,
+      evidence: [{ source: "adb.remote-preflight", field: "failure", value: clientFailure.kind }],
+      actions: [
+        {
+          id: "verify_remote_adb_endpoint",
+          title: "Verify the configured ADB host, port, and Platform-Tools installation",
+          kind: "user",
+          risk: "none",
+          automatic: false
+        }
+      ],
+      correlation
+    };
+  }
   if (result.timedOut) {
     return {
       code: ProblemCode.AdbTimeout,
@@ -38905,8 +39227,8 @@ ${result.stdout}`;
     correlation
   };
 }
-function adbOptionalProbeProblem(operation, result, correlation) {
-  const failure3 = adbProcessProblem(operation, result, correlation);
+function adbOptionalProbeProblem(operation, result, correlation, clientFailure) {
+  const failure3 = adbProcessProblem(operation, result, correlation, clientFailure);
   return {
     ...failure3,
     code: ProblemCode.AdbOptionalProbeFailed,
@@ -39391,6 +39713,7 @@ var NATIVE_EXTENSIONS = new Set([
   ".log",
   ".mp4",
   ".png",
+  ".proto",
   ".txt",
   ".webm",
   ".xml"
@@ -39536,7 +39859,7 @@ async function collectNativeVerifierArtifacts(directory, limits = {}) {
       const file = await stat4(absolute).catch(() => {
         return;
       });
-      if (file === undefined || file.size > maxFileBytes || total + file.size > maxTotalBytes || artifacts.length >= maxFiles) {
+      if (file === undefined || limits.modifiedSinceMs !== undefined && file.mtimeMs < limits.modifiedSinceMs || file.size > maxFileBytes || total + file.size > maxTotalBytes || artifacts.length >= maxFiles) {
         omitted += 1;
         continue;
       }
@@ -39812,7 +40135,7 @@ async function staleLease(directory, owner, now, options) {
   });
   return metadata !== undefined && now.getTime() - metadata.mtimeMs >= (options.ttlMs ?? DEFAULT_TTL_MS);
 }
-async function acquireTargetLease(request, options = {}) {
+async function tryAcquireTargetLease(request, options = {}) {
   const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
   const heartbeatMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_MS;
   if (!Number.isSafeInteger(ttlMs) || ttlMs < 1000) {
@@ -39932,6 +40255,51 @@ async function acquireTargetLease(request, options = {}) {
     message: "ADB Ready could not safely recover the stale target lease."
   };
 }
+function wait2(milliseconds, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted === true) {
+      resolve();
+      return;
+    }
+    const finish = () => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    };
+    const timer = setTimeout(finish, milliseconds);
+    const abort = () => {
+      clearTimeout(timer);
+      finish();
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+async function acquireTargetLease(request, options = {}) {
+  const waitTimeoutMs = options.waitTimeoutMs ?? 0;
+  const pollIntervalMs = options.waitPollIntervalMs ?? 250;
+  if (!Number.isSafeInteger(waitTimeoutMs) || waitTimeoutMs < 0 || waitTimeoutMs > 3600000) {
+    throw new RangeError("target lease waitTimeoutMs must be from 0 to 3600000");
+  }
+  if (!Number.isSafeInteger(pollIntervalMs) || pollIntervalMs < 10 || pollIntervalMs > 1e4) {
+    throw new RangeError("target lease waitPollIntervalMs must be from 10 to 10000");
+  }
+  const clock = options.clock ?? (() => new Date);
+  const deadline = clock().getTime() + waitTimeoutMs;
+  while (true) {
+    if (options.signal?.aborted === true) {
+      return {
+        ok: false,
+        code: "TARGET_LEASE_CANCELLED",
+        message: "Target ownership wait was cancelled."
+      };
+    }
+    const acquired = await tryAcquireTargetLease(request, options);
+    if (acquired.ok || acquired.code !== "TARGET_BUSY" || clock().getTime() >= deadline) {
+      return acquired;
+    }
+    const remaining = Math.max(0, deadline - clock().getTime());
+    await (options.sleep ?? wait2)(Math.min(pollIntervalMs, remaining), options.signal);
+  }
+}
 
 // src/evidence/ui-hierarchy-capture.ts
 var DEFAULT_LOCK_POLL_INTERVAL_MS = 50;
@@ -40630,7 +40998,7 @@ async function sendExpoControl(options) {
 
 // src/dev/expo-launch.ts
 var DEFAULT_TIMEOUT_MS2 = 2000;
-var MAX_RESPONSE_BYTES = 16 * 1024;
+var MAX_RESPONSE_BYTES2 = 16 * 1024;
 var MAX_URL_LENGTH = 8 * 1024;
 function aborted4(signal) {
   return signal?.aborted === true;
@@ -40692,7 +41060,7 @@ async function boundedBody(response) {
       if (chunk.done)
         break;
       bytes += chunk.value.byteLength;
-      if (bytes > MAX_RESPONSE_BYTES)
+      if (bytes > MAX_RESPONSE_BYTES2)
         throw new RangeError("Expo response is too large");
       body += decoder.decode(chunk.value, { stream: true });
     }
@@ -42386,6 +42754,7 @@ function createClient(executable, context, config4, dependencies) {
     ...config4.adbPort === undefined ? {} : { port: config4.adbPort },
     ...config4.timeoutMs === undefined ? {} : { timeoutMs: config4.timeoutMs },
     ...dependencies.runner === undefined ? {} : { runner: dependencies.runner },
+    ...dependencies.remoteServerProbe === undefined ? {} : { remoteServerProbe: dependencies.remoteServerProbe },
     ...dependencies.idFactory === undefined ? {} : { idFactory: dependencies.idFactory }
   });
 }
@@ -42393,7 +42762,7 @@ function operationProblem2(operation, observation, commandId) {
   return adbProcessProblem(operation, observation.process, {
     commandId,
     operationId: observation.operationId
-  });
+  }, observation.clientFailure);
 }
 function isConnectableDiscoveryService(service) {
   return service.serviceType === "legacy" || service.serviceType === "connect" && service.knownDevice !== false;
@@ -42584,7 +42953,7 @@ async function runDoctor(config4 = {}, dependencies = {}, signal) {
   const hostFeatures = await client.hostFeatures(signal);
   if (!processSucceeded(hostFeatures.process)) {
     const problem2 = operationProblem2("host-features", hostFeatures, context.commandId);
-    if (problem2.code === ProblemCode.OperationInterrupted) {
+    if (problem2.code === ProblemCode.OperationInterrupted || hostFeatures.clientFailure !== undefined) {
       problems.push(problem2);
       return finish(context, null, problems);
     }
@@ -42601,7 +42970,7 @@ async function runDoctor(config4 = {}, dependencies = {}, signal) {
       }));
     } else {
       const problem2 = operationProblem2("server-status", status, context.commandId);
-      if (problem2.code === ProblemCode.OperationInterrupted) {
+      if (problem2.code === ProblemCode.OperationInterrupted || status.clientFailure !== undefined) {
         problems.push(problem2);
         return finish(context, null, problems);
       }
@@ -43239,6 +43608,7 @@ async function runLogs(options, config4 = {}, dependencies = {}, signal) {
     ...config4.adbPort === undefined ? {} : { port: config4.adbPort },
     ...config4.timeoutMs === undefined ? {} : { timeoutMs: config4.timeoutMs },
     ...dependencies.runner === undefined ? {} : { runner: dependencies.runner },
+    ...dependencies.remoteServerProbe === undefined ? {} : { remoteServerProbe: dependencies.remoteServerProbe },
     ...dependencies.idFactory === undefined ? {} : { idFactory: dependencies.idFactory }
   });
   let resolvedPid = options.pid;
@@ -44020,6 +44390,7 @@ async function runDev(options, config4 = {}, dependencies = {}, signal) {
     ...config4.adbPort === undefined ? {} : { port: config4.adbPort },
     ...config4.timeoutMs === undefined ? {} : { timeoutMs: config4.timeoutMs },
     ...dependencies.runner === undefined ? {} : { runner: dependencies.runner },
+    ...dependencies.remoteServerProbe === undefined ? {} : { remoteServerProbe: dependencies.remoteServerProbe },
     idFactory
   });
   const devices = await discoveryClient.devices(signal);
@@ -44107,6 +44478,7 @@ async function runDev(options, config4 = {}, dependencies = {}, signal) {
     ...config4.adbPort === undefined ? {} : { port: config4.adbPort },
     ...config4.timeoutMs === undefined ? {} : { timeoutMs: config4.timeoutMs },
     ...dependencies.runner === undefined ? {} : { runner: dependencies.runner },
+    ...dependencies.remoteServerProbe === undefined ? {} : { remoteServerProbe: dependencies.remoteServerProbe },
     idFactory
   };
   const client = new AdbClient(clientOptions);
@@ -45480,7 +45852,7 @@ function operationProblem(name, observation, commandId) {
   return adbProcessProblem(name, observation.process, {
     commandId,
     operationId: observation.operationId
-  });
+  }, observation.clientFailure);
 }
 async function readyTarget(current, config4, dependencies, problems, signal) {
   const inventory = await runDevices(config4, { ...dependencies, bus: current.bus }, signal);
@@ -45526,6 +45898,7 @@ async function readyTarget(current, config4, dependencies, problems, signal) {
       ...config4.adbPort === undefined ? {} : { port: config4.adbPort },
       ...config4.timeoutMs === undefined ? {} : { timeoutMs: config4.timeoutMs },
       ...dependencies.runner === undefined ? {} : { runner: dependencies.runner },
+      ...dependencies.remoteServerProbe === undefined ? {} : { remoteServerProbe: dependencies.remoteServerProbe },
       ...dependencies.idFactory === undefined ? {} : { idFactory: dependencies.idFactory }
     })
   };
@@ -45647,11 +46020,11 @@ async function launchApp(ready, applicationId, explicitActivity, commandId, prob
     if (succeeded(active.process) && active.value?.applicationId === applicationId)
       break;
     if (attempt < 4) {
-      const wait2 = dependencies.sleep ?? (async (milliseconds) => {
+      const wait3 = dependencies.sleep ?? (async (milliseconds) => {
         await new Promise((resolve) => setTimeout(resolve, milliseconds));
         return true;
       });
-      if (!await wait2(150, signal ?? new AbortController().signal))
+      if (!await wait3(150, signal ?? new AbortController().signal))
         break;
     }
   }
@@ -46395,7 +46768,27 @@ var ROOT_KEYS2 = new Set([
 var PROFILE_KEYS = new Set(["extends", "adb", "timeoutMs", "output", "targets", "app", "dev"]);
 var ADB_KEYS = new Set(["path", "host", "port"]);
 var OUTPUT_KEYS = new Set(["color", "unicode", "animation", "interactive"]);
-var TARGET_KEYS = new Set(["aliases"]);
+var TARGET_KEYS = new Set(["aliases", "pools"]);
+var TARGET_POOL_KEYS = new Set(["members", "maxConcurrency", "failFast", "leaseWaitMs"]);
+var TARGET_POOL_MEMBER_KEYS = new Set([
+  "id",
+  "kind",
+  "required",
+  "serial",
+  "name",
+  "host",
+  "port",
+  "model",
+  "version",
+  "locale",
+  "orientation"
+]);
+var TARGET_POOL_MEMBER_KEYS_BY_KIND = {
+  adb: new Set(["id", "kind", "required", "serial"]),
+  avd: new Set(["id", "kind", "required", "name"]),
+  "remote-adb": new Set(["id", "kind", "required", "host", "port", "serial"]),
+  firebase: new Set(["id", "kind", "required", "model", "version", "locale", "orientation"])
+};
 var APP_KEYS = new Set(["android"]);
 var ANDROID_APP_KEYS = new Set(["package"]);
 var DEV_KEYS = new Set([
@@ -46635,6 +47028,127 @@ function validateDocument(document2, source, location) {
           values.targetAliases = aliases;
         }
       }
+      if (document2.targets.pools !== undefined) {
+        if (!isObject4(document2.targets.pools)) {
+          errors6.push(error4(source, location, "targets.pools", "targets.pools must be an object."));
+        } else {
+          const pools = {};
+          for (const [poolName, candidate] of Object.entries(document2.targets.pools)) {
+            const poolPath = `targets.pools.${poolName}`;
+            if (!PROFILE_NAME.test(poolName)) {
+              errors6.push(error4(source, location, poolPath, "Target pool name must be 1-64 letters, numbers, dots, underscores, or hyphens."));
+              continue;
+            }
+            if (!isObject4(candidate)) {
+              errors6.push(error4(source, location, poolPath, "Target pool must be an object."));
+              continue;
+            }
+            validateUnknownKeys(candidate, TARGET_POOL_KEYS, `${poolPath}.`, source, location, errors6);
+            const members4 = candidate.members;
+            const maxConcurrency = candidate.maxConcurrency;
+            const failFast = candidate.failFast ?? false;
+            const leaseWaitMs = candidate.leaseWaitMs ?? 30000;
+            let valid = true;
+            if (!Array.isArray(members4) || members4.length < 1 || members4.length > 64) {
+              errors6.push(error4(source, location, `${poolPath}.members`, "Target pool members must be an array with 1-64 entries."));
+              valid = false;
+            }
+            if (!Number.isSafeInteger(maxConcurrency) || maxConcurrency < 1 || maxConcurrency > 32) {
+              errors6.push(error4(source, location, `${poolPath}.maxConcurrency`, "Target pool maxConcurrency must be an integer from 1 to 32."));
+              valid = false;
+            }
+            if (typeof failFast !== "boolean") {
+              errors6.push(error4(source, location, `${poolPath}.failFast`, "Target pool failFast must be a boolean."));
+              valid = false;
+            }
+            if (!Number.isSafeInteger(leaseWaitMs) || leaseWaitMs < 0 || leaseWaitMs > 3600000) {
+              errors6.push(error4(source, location, `${poolPath}.leaseWaitMs`, "Target pool leaseWaitMs must be an integer from 0 to 3600000."));
+              valid = false;
+            }
+            const parsedMembers = [];
+            const memberIds = new Set;
+            const resourceIds = new Set;
+            if (Array.isArray(members4)) {
+              members4.forEach((member, index) => {
+                const memberPath = `${poolPath}.members.${String(index)}`;
+                if (!isObject4(member)) {
+                  errors6.push(error4(source, location, memberPath, "Target pool member must be an object."));
+                  valid = false;
+                  return;
+                }
+                validateUnknownKeys(member, TARGET_POOL_MEMBER_KEYS, `${memberPath}.`, source, location, errors6);
+                const id = member.id;
+                const kind = member.kind;
+                const required4 = member.required ?? true;
+                if (kind === "adb" || kind === "avd" || kind === "remote-adb" || kind === "firebase") {
+                  validateUnknownKeys(member, TARGET_POOL_MEMBER_KEYS_BY_KIND[kind], `${memberPath}.`, source, location, errors6);
+                }
+                if (typeof id !== "string" || !PROFILE_NAME.test(id) || memberIds.has(id)) {
+                  errors6.push(error4(source, location, `${memberPath}.id`, "Target pool member id must be unique and use 1-64 letters, numbers, dots, underscores, or hyphens."));
+                  valid = false;
+                  return;
+                }
+                memberIds.add(id);
+                if (typeof required4 !== "boolean") {
+                  errors6.push(error4(source, location, `${memberPath}.required`, "Target pool member required must be a boolean."));
+                  valid = false;
+                  return;
+                }
+                const optionalRequired = required4 ? {} : { required: false };
+                const nonEmpty = (value) => typeof value === "string" && value.trim() === value && value.length > 0;
+                let resourceId;
+                if (kind === "adb" && nonEmpty(member.serial)) {
+                  parsedMembers.push({ id, kind, serial: member.serial, ...optionalRequired });
+                  resourceId = `adb:${member.serial}`;
+                } else if (kind === "avd" && nonEmpty(member.name)) {
+                  parsedMembers.push({ id, kind, name: member.name, ...optionalRequired });
+                  resourceId = `avd:${member.name}`;
+                } else if (kind === "remote-adb" && nonEmpty(member.host) && nonEmpty(member.serial) && (member.port === undefined || Number.isSafeInteger(member.port) && member.port >= 1 && member.port <= 65535)) {
+                  parsedMembers.push({
+                    id,
+                    kind,
+                    host: member.host,
+                    port: member.port ?? 5037,
+                    serial: member.serial,
+                    ...optionalRequired
+                  });
+                  resourceId = `remote-adb:${member.host}:${String(member.port ?? 5037)}:${member.serial}`;
+                } else if (kind === "firebase" && nonEmpty(member.model) && nonEmpty(member.version) && (member.locale === undefined || nonEmpty(member.locale)) && (member.orientation === undefined || member.orientation === "landscape" || member.orientation === "portrait")) {
+                  parsedMembers.push({
+                    id,
+                    kind,
+                    model: member.model,
+                    version: member.version,
+                    locale: member.locale ?? "en",
+                    orientation: member.orientation ?? "portrait",
+                    ...optionalRequired
+                  });
+                  resourceId = `firebase:${member.model}:${member.version}:${String(member.locale ?? "en")}:${String(member.orientation ?? "portrait")}`;
+                } else {
+                  errors6.push(error4(source, location, memberPath, "Target pool member must be adb(serial), avd(name), remote-adb(host, optional port, serial), or firebase(model, version, optional locale/orientation)."));
+                  valid = false;
+                }
+                if (resourceId !== undefined) {
+                  if (resourceIds.has(resourceId)) {
+                    errors6.push(error4(source, location, memberPath, "Target pool members must identify unique resources or provider dimensions."));
+                    valid = false;
+                  }
+                  resourceIds.add(resourceId);
+                }
+              });
+            }
+            if (valid) {
+              pools[poolName] = {
+                members: parsedMembers,
+                maxConcurrency,
+                failFast,
+                leaseWaitMs
+              };
+            }
+          }
+          values.targetPools = pools;
+        }
+      }
     }
   }
   if (document2.app !== undefined) {
@@ -53209,6 +53723,1143 @@ ${githubSummary(result)}
   }
 }
 
+// src/automation/firebase-test-lab.ts
+import { randomUUID as randomUUID13 } from "node:crypto";
+import { chmod, mkdir as mkdir8, rename as rename8, rm as rm9, stat as stat15, writeFile as writeFile8 } from "node:fs/promises";
+import path23 from "node:path";
+var AUTH_PATTERN = /active account|auth login|authentication|credentials|permission denied|unauthenticated|unauthorized/iu;
+var MATRIX_PATTERN = /Test \[([^\]\r\n]+)\] has been created in the Google Cloud\./u;
+var CONSOLE_URL_PATTERN = /https:\/\/console\.firebase\.google\.com\/[A-Za-z0-9%_./?=&-]+/u;
+var SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u;
+var PROVIDER_FILE_LIMIT = 100;
+var PROVIDER_FILE_BYTES = 20 * 1024 * 1024;
+var PROVIDER_TOTAL_BYTES = 50 * 1024 * 1024;
+var PROVIDER_EXTENSIONS = new Set([
+  ".ec",
+  ".html",
+  ".jpeg",
+  ".jpg",
+  ".json",
+  ".log",
+  ".mp4",
+  ".png",
+  ".proto",
+  ".txt",
+  ".webm",
+  ".xml"
+]);
+function problem2(code, category, summary2, detail, commandId, retryable = true) {
+  return {
+    code,
+    category,
+    severity: "error",
+    summary: summary2,
+    detail,
+    retryable,
+    evidence: [],
+    actions: [],
+    correlation: { commandId }
+  };
+}
+function finish3(started, finished, commandId, data, problems, exitCode2) {
+  return {
+    exitCode: exitCode2,
+    result: {
+      schemaVersion: SCHEMA_VERSION,
+      command: "test firebase",
+      commandId,
+      ok: exitCode2 === 0 /* Success */,
+      startedAt: started.toISOString(),
+      finishedAt: finished.toISOString(),
+      durationMs: Math.max(0, finished.getTime() - started.getTime()),
+      data,
+      problems
+    }
+  };
+}
+function parseJsonArray(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function success(result) {
+  return result.spawnError === undefined && result.streamError === undefined && result.exitCode === 0 && !result.timedOut && !result.aborted;
+}
+function capacity(value) {
+  const normalized = value?.replace(/^DEVICE_CAPACITY_/u, "").toLowerCase();
+  return normalized === "high" || normalized === "medium" || normalized === "low" || normalized === "none" ? normalized : "unknown";
+}
+function hasTag(tags, expected) {
+  return tags.some((tag) => tag.toLowerCase().includes(expected));
+}
+function artifactArgument(cwd, value) {
+  return value.startsWith("gs://") ? value : path23.resolve(cwd, value);
+}
+function parseFirebaseDevice(value) {
+  const fields = new Map;
+  for (const part of value.split(",")) {
+    const separator = part.indexOf("=");
+    if (separator < 1)
+      return;
+    const key = part.slice(0, separator).trim();
+    const fieldValue = part.slice(separator + 1).trim();
+    if (!new Set(["locale", "model", "orientation", "version"]).has(key) || fieldValue === "") {
+      return;
+    }
+    if (fields.has(key))
+      return;
+    fields.set(key, fieldValue);
+  }
+  const model = fields.get("model");
+  const version4 = fields.get("version");
+  const locale = fields.get("locale") ?? "en";
+  const orientation = fields.get("orientation") ?? "portrait";
+  if (model === undefined || version4 === undefined || !SAFE_ID.test(model) || !SAFE_ID.test(version4) || !/^[A-Za-z]{2,3}(?:[_-][A-Za-z0-9]{2,8})?$/u.test(locale) || orientation !== "portrait" && orientation !== "landscape") {
+    return;
+  }
+  return { model, version: version4, locale, orientation };
+}
+function parseFirebaseCatalog(modelsOutput, versionsOutput) {
+  const models = parseJsonArray(modelsOutput);
+  const versions4 = parseJsonArray(versionsOutput);
+  if (models === undefined || versions4 === undefined)
+    return;
+  const versionTags = new Map(versions4.filter((version4) => typeof version4.id === "string").map((version4) => [version4.id, version4.tags ?? []]));
+  const devices = [];
+  for (const model of models) {
+    if (typeof model.id !== "string" || !SAFE_ID.test(model.id))
+      continue;
+    for (const version4 of model.supportedVersionIds ?? []) {
+      if (!SAFE_ID.test(version4))
+        continue;
+      const info = model.perVersionInfo?.find((candidate) => candidate.versionId === version4);
+      devices.push({
+        model: model.id,
+        version: version4,
+        locale: "en",
+        orientation: "portrait",
+        name: model.name ?? model.id,
+        form: model.form ?? "UNKNOWN",
+        ...model.formFactor === undefined ? {} : { formFactor: model.formFactor },
+        capacity: capacity(info?.deviceCapacity),
+        tags: [
+          ...new Set([
+            ...model.tags ?? [],
+            ...(model.accessDeniedReasons?.length ?? 0) === 0 ? [] : ["access_denied"],
+            ...versionTags.get(version4) ?? [],
+            ...info?.tags ?? []
+          ])
+        ].map((tag) => tag.toLowerCase()).sort()
+      });
+    }
+  }
+  return devices.sort((left, right) => `${left.model}/${left.version}`.localeCompare(`${right.model}/${right.version}`));
+}
+function validateDevices(requested, catalog, options) {
+  for (const device of requested) {
+    const current = catalog.find((candidate) => candidate.model === device.model && candidate.version === device.version);
+    if (current === undefined)
+      return `${device.model}/${device.version} is unavailable or incompatible.`;
+    if (hasTag(current.tags, "access_denied"))
+      return `${device.model}/${device.version} is not accessible to this project.`;
+    if (hasTag(current.tags, "deprecated") && options.allowDeprecated !== true)
+      return `${device.model}/${device.version} is deprecated.`;
+    if (hasTag(current.tags, "reduced_stability") && options.allowReducedStability !== true)
+      return `${device.model}/${device.version} currently has reduced stability.`;
+    if (current.capacity === "none")
+      return `${device.model}/${device.version} currently has no capacity.`;
+    if (current.capacity === "low" && options.allowLowCapacity !== true)
+      return `${device.model}/${device.version} currently has low capacity.`;
+  }
+  return;
+}
+function gcloudBase(options) {
+  return ["--quiet", ...options.project === undefined ? [] : [`--project=${options.project}`]];
+}
+function deviceArgument(device) {
+  return `model=${device.model},version=${device.version},locale=${device.locale},orientation=${device.orientation}`;
+}
+function runArguments(options, resultsDir) {
+  return [
+    "firebase",
+    "test",
+    "android",
+    "run",
+    `--type=${options.action}`,
+    `--app=${artifactArgument(options.cwd, options.app ?? "")}`,
+    ...options.action === "instrumentation" ? [`--test=${artifactArgument(options.cwd, options.test ?? "")}`] : [],
+    ...(options.devices ?? []).flatMap((device) => ["--device", deviceArgument(device)]),
+    ...options.testTimeout === undefined ? [] : [`--timeout=${options.testTimeout}`],
+    ...options.resultsBucket === undefined ? [] : [`--results-bucket=${options.resultsBucket}`],
+    ...options.resultsBucket === undefined ? [] : [`--results-dir=${resultsDir}`],
+    "--format=json",
+    ...gcloudBase(options)
+  ];
+}
+function extractProviderIdentity(output) {
+  const matrixId = output.match(MATRIX_PATTERN)?.[1];
+  const consoleUrl = output.match(CONSOLE_URL_PATTERN)?.[0];
+  return {
+    ...matrixId === undefined ? {} : { matrixId },
+    ...consoleUrl === undefined ? {} : { consoleUrl }
+  };
+}
+function parseOutcomes(output) {
+  const values = parseJsonArray(output) ?? [];
+  return values.flatMap((value) => {
+    if (typeof value.outcome !== "string")
+      return [];
+    return [
+      {
+        outcome: value.outcome,
+        axis: typeof value.axis_value === "string" ? value.axis_value : "unknown",
+        details: typeof value.test_details === "string" ? value.test_details : ""
+      }
+    ];
+  });
+}
+function classify(result, outcomes) {
+  if (result.timedOut)
+    return {
+      outcome: "observation-timed-out",
+      exitCode: 40 /* ChildProcess */,
+      code: "FTL_OBSERVATION_TIMED_OUT"
+    };
+  if (result.aborted)
+    return {
+      outcome: "observation-stopped",
+      exitCode: 130 /* Interrupted */,
+      code: "FTL_OBSERVATION_STOPPED"
+    };
+  if (AUTH_PATTERN.test(`${result.stderr}
+${result.stdout}`))
+    return { outcome: "auth-failed", exitCode: 10 /* Environment */, code: "FTL_AUTH_FAILED" };
+  if (result.exitCode === 0) {
+    return {
+      outcome: outcomes.some(({ outcome: outcome2 }) => outcome2.toLowerCase() === "flaky") ? "flaky" : "passed",
+      exitCode: 0 /* Success */,
+      code: ""
+    };
+  }
+  if (result.exitCode === 10)
+    return {
+      outcome: "assertion-failed",
+      exitCode: 40 /* ChildProcess */,
+      code: "FTL_ASSERTION_FAILED"
+    };
+  if (result.exitCode === 15)
+    return { outcome: "inconclusive", exitCode: 40 /* ChildProcess */, code: "FTL_INCONCLUSIVE" };
+  if (result.exitCode === 18)
+    return { outcome: "unsupported", exitCode: 2 /* InvalidInput */, code: "FTL_UNSUPPORTED" };
+  if (result.exitCode === 19)
+    return { outcome: "cancelled", exitCode: 130 /* Interrupted */, code: "FTL_CANCELLED" };
+  return {
+    outcome: "infrastructure-failed",
+    exitCode: 40 /* ChildProcess */,
+    code: "FTL_INFRASTRUCTURE_FAILED"
+  };
+}
+function parseStorageObjects(output) {
+  try {
+    const parsed = JSON.parse(output);
+    if (Array.isArray(parsed))
+      return parsed;
+    if (typeof parsed === "object" && parsed !== null)
+      return [parsed];
+  } catch {
+    const records = [];
+    for (const line of output.split(/\r?\n/u).filter((value) => value.trim() !== "")) {
+      try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+          return;
+        records.push(parsed);
+      } catch {
+        return;
+      }
+    }
+    return records.length === 0 ? undefined : records;
+  }
+  return;
+}
+function safeProviderName(index, url4) {
+  const raw = url4.slice(url4.lastIndexOf("/") + 1) || "artifact";
+  const safe = raw.replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 120) || "artifact";
+  return `${String(index + 1).padStart(3, "0")}-${safe}`;
+}
+async function collectProviderEvidence(options, runner, destination, resultsDir, remoteRunning) {
+  if (options.resultsBucket === undefined) {
+    return { providerFiles: 0, omittedFiles: 0, collection: "not-configured" };
+  }
+  const remotePrefix = `${options.resultsBucket}/${resultsDir.replace(/^\/+|\/+$/gu, "")}`;
+  if (remoteRunning) {
+    return {
+      providerFiles: 0,
+      omittedFiles: 0,
+      collection: "remote-running",
+      remotePrefix
+    };
+  }
+  const listed = await runner({
+    executable: options.gcloudPath ?? "gcloud",
+    args: ["storage", "ls", "--recursive", "--json", remotePrefix, ...gcloudBase(options)],
+    cwd: options.cwd,
+    timeoutMs: 120000,
+    maxBufferBytes: 4 * 1024 * 1024
+  });
+  if (!success(listed)) {
+    return {
+      providerFiles: 0,
+      omittedFiles: 0,
+      collection: "unavailable",
+      remotePrefix,
+      warning: redactText(listed.stderr || listed.stdout || "gcloud storage listing failed.").value
+    };
+  }
+  const objects = parseStorageObjects(listed.stdout);
+  if (objects === undefined) {
+    return {
+      providerFiles: 0,
+      omittedFiles: 0,
+      collection: "unavailable",
+      remotePrefix,
+      warning: "gcloud storage returned an unreadable artifact listing."
+    };
+  }
+  const prefix = `${remotePrefix}/`;
+  const eligible = objects.flatMap((object5) => {
+    if (object5.type !== "cloud_object" || typeof object5.url !== "string" || !object5.url.startsWith(prefix) || object5.url.includes("?") || !PROVIDER_EXTENSIONS.has(path23.extname(object5.url).toLowerCase())) {
+      return [];
+    }
+    const bytes = Number(object5.metadata?.size);
+    if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > PROVIDER_FILE_BYTES)
+      return [];
+    return [{ url: object5.url, bytes }];
+  });
+  const selected = [];
+  let totalBytes = 0;
+  for (const object5 of eligible) {
+    if (selected.length >= PROVIDER_FILE_LIMIT || totalBytes + object5.bytes > PROVIDER_TOTAL_BYTES) {
+      continue;
+    }
+    selected.push(object5);
+    totalBytes += object5.bytes;
+  }
+  const providerDirectory = path23.join(destination, "provider");
+  await mkdir8(providerDirectory, { recursive: true, mode: 448 });
+  const manifest = [];
+  for (const [index, object5] of selected.entries()) {
+    const file = safeProviderName(index, object5.url);
+    const copied = await runner({
+      executable: options.gcloudPath ?? "gcloud",
+      args: [
+        "storage",
+        "cp",
+        object5.url,
+        path23.join(providerDirectory, file),
+        ...gcloudBase(options)
+      ],
+      cwd: options.cwd,
+      timeoutMs: 120000,
+      maxBufferBytes: 256 * 1024
+    });
+    if (!success(copied)) {
+      return {
+        providerFiles: manifest.length,
+        omittedFiles: objects.length - manifest.length,
+        collection: "unavailable",
+        remotePrefix,
+        warning: redactText(copied.stderr || copied.stdout || "gcloud storage copy failed.").value
+      };
+    }
+    const localPath = path23.join(providerDirectory, file);
+    const local = await stat15(localPath).catch(() => {
+      return;
+    });
+    if (local === undefined || !local.isFile() || local.size !== object5.bytes) {
+      return {
+        providerFiles: manifest.length,
+        omittedFiles: objects.length - manifest.length,
+        collection: "unavailable",
+        remotePrefix,
+        warning: `Downloaded provider artifact failed size verification: ${file}`
+      };
+    }
+    await chmod(localPath, 384);
+    manifest.push({ source: object5.url, file, bytes: object5.bytes });
+  }
+  await writeFile8(path23.join(destination, "provider-files.json"), `${JSON.stringify(manifest, null, 2)}
+`, { mode: 384 });
+  return {
+    providerFiles: manifest.length,
+    omittedFiles: Math.max(0, objects.length - manifest.length),
+    collection: "complete",
+    remotePrefix
+  };
+}
+async function retainEvidence(options, commandId, processResult, data, runner, resultsDir) {
+  const relative = path23.join(".adb-ready", "artifacts", `firebase-${commandId}`);
+  const destination = path23.resolve(options.cwd, relative);
+  const temporary = `${destination}.tmp`;
+  await rm9(temporary, { recursive: true, force: true });
+  await mkdir8(temporary, { recursive: true, mode: 448 });
+  try {
+    const provider = await collectProviderEvidence(options, runner, temporary, resultsDir, processResult.timedOut || processResult.aborted);
+    const evidence = {
+      path: relative.split(path23.sep).join("/"),
+      providerFiles: provider.providerFiles,
+      omittedFiles: provider.omittedFiles,
+      collection: provider.collection,
+      ...provider.remotePrefix === undefined ? {} : { remotePrefix: provider.remotePrefix }
+    };
+    data.evidence = evidence;
+    await writeFile8(path23.join(temporary, "stdout.txt"), redactText(processResult.stdout).value, {
+      mode: 384
+    });
+    await writeFile8(path23.join(temporary, "stderr.txt"), redactText(processResult.stderr).value, {
+      mode: 384
+    });
+    await writeFile8(path23.join(temporary, "result.json"), `${JSON.stringify(data, null, 2)}
+`, {
+      mode: 384
+    });
+    await rm9(destination, { recursive: true, force: true });
+    await rename8(temporary, destination);
+    return { evidence, ...provider.warning === undefined ? {} : { warning: provider.warning } };
+  } catch (error5) {
+    await rm9(temporary, { recursive: true, force: true }).catch(() => {
+      return;
+    });
+    throw error5;
+  }
+}
+async function readCatalog(options, runner) {
+  const executable = options.gcloudPath ?? "gcloud";
+  const base = gcloudBase(options);
+  const models = await runner({
+    executable,
+    args: ["firebase", "test", "android", "models", "list", "--format=json", ...base],
+    cwd: options.cwd,
+    timeoutMs: 120000
+  });
+  if (!success(models))
+    return { failure: models };
+  const versions4 = await runner({
+    executable,
+    args: ["firebase", "test", "android", "versions", "list", "--format=json", ...base],
+    cwd: options.cwd,
+    timeoutMs: 120000
+  });
+  if (!success(versions4))
+    return { failure: versions4 };
+  const catalog = parseFirebaseCatalog(models.stdout, versions4.stdout);
+  return catalog === undefined ? {} : { catalog };
+}
+async function cancelMatrix(options, runner, request) {
+  const token = await runner({
+    executable: options.gcloudPath ?? "gcloud",
+    args: ["auth", "print-access-token", "--quiet"],
+    cwd: options.cwd,
+    timeoutMs: 30000,
+    maxBufferBytes: 64 * 1024
+  });
+  if (!success(token) || token.stdout.trim() === "") {
+    return { ok: false, detail: "Google Cloud authentication is unavailable.", auth: true };
+  }
+  const response = await request(`https://testing.googleapis.com/v1/projects/${encodeURIComponent(options.project ?? "")}/testMatrices/${encodeURIComponent(options.matrixId ?? "")}:cancel`, {
+    method: "POST",
+    headers: { authorization: `Bearer ${token.stdout.trim()}` },
+    signal: AbortSignal.timeout(30000)
+  }).catch(() => {
+    return;
+  });
+  if (response === undefined)
+    return {
+      ok: false,
+      detail: "Firebase Test Lab cancellation could not be reached.",
+      auth: false
+    };
+  if (!response.ok) {
+    const detail = redactText(await response.text()).value;
+    return {
+      ok: false,
+      detail: detail || `Firebase Test Lab returned HTTP ${String(response.status)}.`,
+      auth: response.status === 401 || response.status === 403
+    };
+  }
+  return { ok: true };
+}
+async function runFirebaseTestLab(options, dependencies = {}, signal) {
+  const clock = dependencies.clock ?? (() => new Date);
+  const started = clock();
+  const commandId = (dependencies.idFactory ?? randomUUID13)();
+  const runner = dependencies.runner ?? runProcess;
+  const executable = options.gcloudPath ?? "gcloud";
+  if (options.action === "cancel") {
+    if (options.project === undefined || options.matrixId === undefined) {
+      return finish3(started, clock(), commandId, null, [
+        problem2("FTL_CANCEL_INPUT_INVALID", "input.firebase", "Cancellation requires a project and matrix ID.", "Pass --project PROJECT and one exact matrix ID.", commandId, false)
+      ], 2 /* InvalidInput */);
+    }
+    if (options.dryRun === true) {
+      const plan2 = {
+        schemaVersion: SCHEMA_VERSION,
+        dryRun: true,
+        steps: [
+          {
+            id: "firebase-cancel",
+            title: `Cancel Firebase Test Lab matrix ${options.matrixId}`,
+            risk: "destructive",
+            executable: "Firebase Testing API",
+            args: [options.project, options.matrixId]
+          }
+        ]
+      };
+      return finish3(started, clock(), commandId, {
+        status: "planned",
+        action: "cancel",
+        project: options.project,
+        matrixId: options.matrixId,
+        plan: plan2
+      }, [], 0 /* Success */);
+    }
+    const cancelled = await cancelMatrix(options, runner, dependencies.fetch ?? fetch);
+    if (!cancelled.ok) {
+      return finish3(started, clock(), commandId, null, [
+        problem2(cancelled.auth ? "FTL_AUTH_FAILED" : "FTL_CANCEL_FAILED", cancelled.auth ? "environment.auth" : "provider.firebase", "Firebase Test Lab matrix cancellation failed.", cancelled.detail, commandId)
+      ], cancelled.auth ? 10 /* Environment */ : 40 /* ChildProcess */);
+    }
+    return finish3(started, clock(), commandId, {
+      status: "cancelled",
+      action: "cancel",
+      project: options.project,
+      matrixId: options.matrixId,
+      outcome: "cancelled"
+    }, [], 0 /* Success */);
+  }
+  if (options.action === "devices") {
+    const catalogResult2 = await readCatalog(options, runner);
+    if (catalogResult2.failure !== undefined || catalogResult2.catalog === undefined) {
+      const failure4 = catalogResult2.failure;
+      const auth = AUTH_PATTERN.test(`${failure4?.stderr ?? ""}
+${failure4?.stdout ?? ""}`);
+      return finish3(started, clock(), commandId, null, [
+        problem2(auth ? "FTL_AUTH_FAILED" : "FTL_CATALOG_FAILED", auth ? "environment.auth" : "provider.firebase.catalog", "Firebase Test Lab device catalog is unavailable.", auth ? "Authenticate gcloud for the selected project." : "gcloud did not return a valid machine-readable device catalog.", commandId)
+      ], auth ? 10 /* Environment */ : 40 /* ChildProcess */);
+    }
+    return finish3(started, clock(), commandId, {
+      status: "catalogued",
+      action: "devices",
+      ...options.project === undefined ? {} : { project: options.project },
+      devices: catalogResult2.catalog
+    }, [], 0 /* Success */);
+  }
+  if (options.app === undefined || options.action === "instrumentation" && options.test === undefined || options.devices === undefined || options.devices.length === 0) {
+    return finish3(started, clock(), commandId, null, [
+      problem2("FTL_RUN_INPUT_INVALID", "input.firebase", "Firebase Test Lab requires explicit artifacts and at least one device.", "Pass --app, --test for instrumentation, and one or more --test-device values.", commandId, false)
+    ], 2 /* InvalidInput */);
+  }
+  for (const candidate of [options.app, ...options.test === undefined ? [] : [options.test]]) {
+    if (candidate.startsWith("gs://"))
+      continue;
+    const exists = await stat15(path23.resolve(options.cwd, candidate)).then((entry) => entry.isFile()).catch(() => false);
+    if (!exists)
+      return finish3(started, clock(), commandId, null, [
+        problem2("FTL_ARTIFACT_NOT_FOUND", "input.artifact", "A Firebase Test Lab artifact was not found.", candidate, commandId, false)
+      ], 2 /* InvalidInput */);
+  }
+  const catalogResult = await readCatalog(options, runner);
+  if (catalogResult.failure !== undefined || catalogResult.catalog === undefined) {
+    const failure4 = catalogResult.failure;
+    const auth = AUTH_PATTERN.test(`${failure4?.stderr ?? ""}
+${failure4?.stdout ?? ""}`);
+    return finish3(started, clock(), commandId, null, [
+      problem2(auth ? "FTL_AUTH_FAILED" : "FTL_CATALOG_FAILED", auth ? "environment.auth" : "provider.firebase.catalog", "Firebase Test Lab preflight could not read the live device catalog.", auth ? "Authenticate gcloud for the selected project." : "Retry after checking gcloud and Firebase Test Lab availability.", commandId)
+    ], auth ? 10 /* Environment */ : 40 /* ChildProcess */);
+  }
+  const rejected = validateDevices(options.devices, catalogResult.catalog, options);
+  if (rejected !== undefined)
+    return finish3(started, clock(), commandId, null, [
+      problem2("FTL_DEVICE_POLICY_REJECTED", "input.firebase.device", "The requested Firebase Test Lab device was rejected by policy.", rejected, commandId, false)
+    ], 2 /* InvalidInput */);
+  const resultsDir = options.resultsDir ?? `adb-ready/${commandId}`;
+  const args = runArguments(options, resultsDir);
+  const plan = {
+    schemaVersion: SCHEMA_VERSION,
+    dryRun: options.dryRun === true,
+    steps: [
+      {
+        id: "firebase-test",
+        title: `Run one bounded Firebase Test Lab ${options.action} matrix`,
+        risk: "open-world",
+        executable,
+        args
+      }
+    ]
+  };
+  if (options.dryRun === true)
+    return finish3(started, clock(), commandId, {
+      status: "planned",
+      action: options.action,
+      ...options.project === undefined ? {} : { project: options.project },
+      selectedDevices: options.devices,
+      command: { executable, args },
+      plan
+    }, [], 0 /* Success */);
+  const executed = await runner({
+    executable,
+    args,
+    cwd: options.cwd,
+    ...signal === undefined ? {} : { signal },
+    timeoutMs: options.observationTimeoutMs ?? 30 * 60000,
+    killSignal: "SIGKILL",
+    killProcessGroup: true,
+    maxBufferBytes: 4 * 1024 * 1024
+  });
+  const results = parseOutcomes(executed.stdout);
+  const classified = classify(executed, results);
+  const identity = extractProviderIdentity(`${executed.stderr}
+${executed.stdout}`);
+  const data = {
+    status: "completed",
+    action: options.action,
+    ...options.project === undefined ? {} : { project: options.project },
+    selectedDevices: options.devices,
+    command: { executable, args },
+    outcome: classified.outcome,
+    ...identity,
+    results,
+    ...(executed.timedOut || executed.aborted) && identity.matrixId !== undefined ? { remoteContinues: true } : {}
+  };
+  const retained = await retainEvidence(options, commandId, executed, data, runner, resultsDir);
+  const problems = classified.exitCode === 0 /* Success */ ? [] : [
+    problem2(classified.code, `provider.firebase.${classified.outcome}`, `Firebase Test Lab ${classified.outcome.replaceAll("-", " ")}.`, executed.timedOut || executed.aborted ? "Local observation stopped without cancelling the remote matrix. Use test firebase cancel explicitly if cancellation is intended." : redactText(executed.stderr || executed.stdout || "Firebase Test Lab returned no diagnostic output.").value, commandId, classified.outcome !== "assertion-failed")
+  ];
+  if (retained.warning !== undefined) {
+    problems.push({
+      ...problem2("FTL_EVIDENCE_COLLECTION_FAILED", "evidence.firebase", "Firebase Test Lab provider evidence could not be collected completely.", retained.warning, commandId),
+      severity: "warning"
+    });
+  }
+  return finish3(started, clock(), commandId, data, problems, classified.exitCode);
+}
+
+// src/automation/gradle-managed-devices.ts
+import { randomUUID as randomUUID14 } from "node:crypto";
+import { mkdir as mkdir9, readdir as readdir5, rename as rename9, rm as rm10, stat as stat16, writeFile as writeFile9 } from "node:fs/promises";
+import path24 from "node:path";
+var MANAGED_RESULT_SUFFIX = path24.join("build", "outputs", "androidTest-results", "managedDevice");
+var MANAGED_REPORT_SUFFIX = path24.join("build", "reports", "androidTests", "managedDevice");
+var MANAGED_ADDITIONAL_OUTPUT_SUFFIX = path24.join("build", "outputs", "managed_device_android_test_additional_output");
+var SKIPPED_DIRECTORIES = new Set([".git", ".gradle", ".idea", ".adb-ready", "node_modules"]);
+function problem3(code, category, summary2, detail, commandId, evidence = []) {
+  return {
+    code,
+    category,
+    severity: "error",
+    summary: summary2,
+    detail,
+    retryable: true,
+    evidence,
+    actions: [],
+    correlation: { commandId }
+  };
+}
+function finish4(started, finished, commandId, data, problems, exitCode2) {
+  return {
+    exitCode: exitCode2,
+    result: {
+      schemaVersion: SCHEMA_VERSION,
+      command: "test gradle",
+      commandId,
+      ok: exitCode2 === 0 /* Success */,
+      startedAt: started.toISOString(),
+      finishedAt: finished.toISOString(),
+      durationMs: Math.max(0, finished.getTime() - started.getTime()),
+      data,
+      problems
+    }
+  };
+}
+async function regularFile3(candidate) {
+  return await stat16(candidate).then((entry) => entry.isFile()).catch(() => false);
+}
+async function resolveGradle2(cwd, explicit) {
+  if (explicit !== undefined) {
+    const executable = path24.isAbsolute(explicit) ? explicit : path24.resolve(cwd, explicit);
+    return { executable, display: explicit };
+  }
+  const wrapper = process.platform === "win32" ? "gradlew.bat" : "gradlew";
+  for (const relative of [wrapper, path24.join("android", wrapper)]) {
+    const executable = path24.join(cwd, relative);
+    if (await regularFile3(executable))
+      return { executable, display: relative.split(path24.sep).join("/") };
+  }
+  return;
+}
+function validManagedTask(task) {
+  const leaf = task.split(":").filter(Boolean).at(-1) ?? "";
+  return /^[A-Za-z][A-Za-z0-9_]*AndroidTest$/u.test(leaf) && !/^connected[A-Z]/u.test(leaf) && !/^device[A-Z].*AndroidTest$/u.test(leaf);
+}
+function parseGradleManagedTasks(output) {
+  const tasks = new Set;
+  for (const line of output.split(/\r?\n/u)) {
+    const match = line.match(/^\s*(:?[A-Za-z0-9_.:-]+AndroidTest)\s+-\s+(.+)$/u);
+    if (match === null)
+      continue;
+    const task = match[1];
+    const description = (match[2] ?? "").toLowerCase();
+    const leaf = task?.split(":").filter(Boolean).at(-1) ?? "";
+    if (task !== undefined && validManagedTask(task) && (/managed device|all devices (?:defined|in)/u.test(description) || /Group[A-Z].*AndroidTest$/u.test(leaf))) {
+      tasks.add(task);
+    }
+  }
+  return [...tasks].sort((left, right) => left.localeCompare(right));
+}
+function gradleArgs(options, task) {
+  return [
+    task,
+    "--console=plain",
+    "--no-daemon",
+    ...options.shards === undefined ? [] : [`-Pandroid.experimental.androidTest.numManagedDeviceShards=${String(options.shards)}`],
+    ...options.softwareRendering === true ? ["-Pandroid.testoptions.manageddevices.emulator.gpu=swiftshader_indirect"] : []
+  ];
+}
+async function findManagedRoots(root) {
+  const found = [];
+  const visit = async (directory, depth) => {
+    if (depth > 8 || found.length >= 100)
+      return;
+    const resultRoot = path24.join(directory, MANAGED_RESULT_SUFFIX);
+    const reportRoot = path24.join(directory, MANAGED_REPORT_SUFFIX);
+    const additionalOutputRoot = path24.join(directory, MANAGED_ADDITIONAL_OUTPUT_SUFFIX);
+    for (const candidate of [resultRoot, reportRoot, additionalOutputRoot]) {
+      const directoryExists = await stat16(candidate).then((entry) => entry.isDirectory()).catch(() => false);
+      if (directoryExists)
+        found.push(candidate);
+    }
+    const entries = await readdir5(directory, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.isSymbolicLink() || SKIPPED_DIRECTORIES.has(entry.name))
+        continue;
+      if (entry.name === "build")
+        continue;
+      await visit(path24.join(directory, entry.name), depth + 1);
+    }
+  };
+  await visit(root, 0);
+  return [...new Set(found)].sort((left, right) => left.localeCompare(right));
+}
+function junitSummary(documents) {
+  const summary2 = { total: 0, failed: 0, errors: 0, skipped: 0 };
+  for (const document2 of documents) {
+    for (const match of document2.matchAll(/<testsuite\b([^>]*)>/giu)) {
+      const attributes2 = match[1] ?? "";
+      const read = (name) => {
+        const value = attributes2.match(new RegExp(`\\b${name}=["'](\\d+)["']`, "iu"))?.[1];
+        return value === undefined ? 0 : Number(value);
+      };
+      summary2.total += read("tests");
+      summary2.failed += read("failures");
+      summary2.errors += read("errors");
+      summary2.skipped += read("skipped");
+    }
+  }
+  return summary2;
+}
+async function retainEvidence2(options) {
+  const safeId = options.commandId.replace(/[^A-Za-z0-9._-]+/gu, "-").slice(0, 80);
+  const relative = path24.posix.join(".adb-ready", "artifacts", `gradle-managed-${safeId}`);
+  const destination = path24.join(options.cwd, ...relative.split("/"));
+  const temporary = `${destination}.tmp-${randomUUID14()}`;
+  const collect = async (freshOnly) => {
+    const files = [];
+    let omitted = 0;
+    let retainedBytes = 0;
+    for (const [rootIndex, root] of options.roots.entries()) {
+      const native = await collectNativeVerifierArtifacts(root, {
+        maxFiles: Math.max(0, 100 - files.length),
+        maxFileBytes: 20 * 1024 * 1024,
+        maxTotalBytes: Math.max(0, 50 * 1024 * 1024 - retainedBytes),
+        ...freshOnly ? { modifiedSinceMs: Date.parse(options.process.startedAt) - 2000 } : {}
+      });
+      omitted += native.omitted;
+      for (const artifact of native.artifacts) {
+        files.push({
+          name: path24.posix.join(`root-${String(rootIndex + 1)}`, artifact.relativePath),
+          content: artifact.content
+        });
+        retainedBytes += artifact.content.byteLength;
+      }
+    }
+    return { files, omitted };
+  };
+  let collected = await collect(true);
+  let provenance = collected.files.length === 0 ? "none" : "fresh";
+  if (collected.files.length === 0 && options.outcome === "passed") {
+    collected = await collect(false);
+    if (collected.files.length > 0)
+      provenance = "gradle-cache";
+  }
+  const nativeFiles = collected.files;
+  const omittedFiles = collected.omitted;
+  const reports = nativeFiles.map(({ name }) => path24.posix.join(relative, "native", name));
+  const junitDocuments = nativeFiles.filter(({ name }) => name.toLowerCase().endsWith(".xml")).map(({ content }) => new TextDecoder().decode(content));
+  const tests = junitSummary(junitDocuments);
+  const outcome2 = provenance === "fresh" && tests.failed + tests.errors > 0 ? "assertion-failed" : options.outcome;
+  await mkdir9(path24.dirname(destination), { recursive: true, mode: 448 });
+  await mkdir9(path24.join(temporary, "native"), { recursive: true, mode: 448 });
+  try {
+    for (const file of nativeFiles) {
+      const target = path24.join(temporary, "native", ...file.name.split("/"));
+      await mkdir9(path24.dirname(target), { recursive: true, mode: 448 });
+      const text = /\.(?:html|json|log|txt|xml)$/iu.test(file.name);
+      await writeFile9(target, text ? redactText(new TextDecoder().decode(file.content)).value : file.content, { mode: 384 });
+    }
+    await writeFile9(path24.join(temporary, "stdout.txt"), redactText(options.process.stdout).value, {
+      mode: 384
+    });
+    await writeFile9(path24.join(temporary, "stderr.txt"), redactText(options.process.stderr).value, {
+      mode: 384
+    });
+    await writeFile9(path24.join(temporary, "result.json"), `${JSON.stringify({ schemaVersion: 1, task: options.task, outcome: outcome2, provenance, tests, reports }, null, 2)}
+`, { mode: 384 });
+    await rename9(temporary, destination);
+  } catch (error5) {
+    await rm10(temporary, { recursive: true, force: true }).catch(() => {
+      return;
+    });
+    throw error5;
+  }
+  return {
+    path: relative,
+    nativeFiles: nativeFiles.length,
+    omittedFiles,
+    reports,
+    tests,
+    outcome: outcome2,
+    provenance
+  };
+}
+function successfulProcess(result) {
+  return result.spawnError === undefined && result.streamError === undefined && result.exitCode === 0 && !result.timedOut && !result.aborted;
+}
+function identifiesManagedDeviceTask(output, task) {
+  const leaf = task.split(":").filter(Boolean).at(-1) ?? "";
+  return /ManagedDevice|managed[ -]device/iu.test(output) || /Group[A-Z].*AndroidTest$/u.test(leaf) && /all devices defined/iu.test(output);
+}
+async function runGradleManagedTest(options, dependencies = {}, signal) {
+  const clock = dependencies.clock ?? (() => new Date);
+  const commandId = (dependencies.idFactory ?? randomUUID14)();
+  const started = clock();
+  const runner = dependencies.runner ?? runProcess;
+  const gradle = await resolveGradle2(options.cwd, options.gradlePath);
+  if (gradle === undefined) {
+    return finish4(started, clock(), commandId, null, [
+      problem3("GRADLE_WRAPPER_NOT_FOUND", "environment.gradle", "No Gradle Wrapper was found for this project.", "Run from the Android project root, keep the Wrapper checked in, or pass --gradle PATH.", commandId)
+    ], 10 /* Environment */);
+  }
+  if (options.task === undefined) {
+    const discovered = await runner({
+      executable: gradle.executable,
+      args: ["tasks", "--all", "--console=plain", "--no-daemon"],
+      cwd: options.cwd,
+      ...signal === undefined ? {} : { signal },
+      timeoutMs: options.timeoutMs ?? 120000,
+      killProcessGroup: true
+    });
+    if (!successfulProcess(discovered)) {
+      const interrupted = discovered.aborted;
+      return finish4(started, clock(), commandId, null, [
+        problem3(interrupted ? "GRADLE_DISCOVERY_CANCELLED" : "GRADLE_DISCOVERY_FAILED", "automation.gradle.discovery", interrupted ? "Gradle managed-device discovery was cancelled." : "Gradle managed-device tasks could not be discovered.", discovered.timedOut ? "Gradle task discovery exceeded its timeout." : redactText(discovered.stderr || discovered.stdout || "Gradle did not start.").value, commandId)
+      ], interrupted ? 130 /* Interrupted */ : 40 /* ChildProcess */);
+    }
+    return finish4(started, clock(), commandId, {
+      status: "discovered",
+      wrapper: gradle.display,
+      tasks: parseGradleManagedTasks(discovered.stdout)
+    }, [], 0 /* Success */);
+  }
+  if (!validManagedTask(options.task)) {
+    return finish4(started, clock(), commandId, null, [
+      problem3("GRADLE_MANAGED_TASK_INVALID", "input.gradle.task", "The requested Gradle task is not a managed-device test task.", "Use a declared task ending in AndroidTest; connected* tasks remain target-bound and belong under adb-ready run.", commandId, [{ source: "cli", field: "task", value: options.task }])
+    ], 2 /* InvalidInput */);
+  }
+  const args = gradleArgs(options, options.task);
+  const command = { executable: gradle.display, args };
+  const plan = {
+    schemaVersion: SCHEMA_VERSION,
+    dryRun: options.dryRun === true,
+    steps: [
+      {
+        id: "gradle-managed-test",
+        title: `Let Gradle provision, test, and tear down ${options.task}`,
+        risk: "local-additive",
+        executable: gradle.display,
+        args
+      },
+      {
+        id: "retain-gradle-evidence",
+        title: "Retain bounded native reports and normalized result",
+        risk: "local-additive"
+      }
+    ]
+  };
+  if (options.dryRun) {
+    return finish4(started, clock(), commandId, { status: "planned", wrapper: gradle.display, task: options.task, command, plan }, [], 0 /* Success */);
+  }
+  const preflight = await runner({
+    executable: gradle.executable,
+    args: ["help", "--task", options.task, "--console=plain", "--no-daemon"],
+    cwd: options.cwd,
+    ...signal === undefined ? {} : { signal },
+    timeoutMs: Math.min(options.timeoutMs ?? 15 * 60000, 120000),
+    killProcessGroup: true
+  });
+  if (!successfulProcess(preflight)) {
+    const cancelled = preflight.aborted;
+    return finish4(started, clock(), commandId, null, [
+      problem3(cancelled ? "GRADLE_TASK_PREFLIGHT_CANCELLED" : "GRADLE_MANAGED_TASK_NOT_FOUND", "automation.gradle.task", cancelled ? "Gradle task validation was cancelled." : "The requested Gradle managed-device task is not declared by this build.", cancelled ? "No Gradle test task was started." : "Run adb-ready test gradle to discover declared managed-device tasks.", commandId, [{ source: "gradle", field: "task", value: options.task }])
+    ], cancelled ? 130 /* Interrupted */ : 2 /* InvalidInput */);
+  }
+  if (!identifiesManagedDeviceTask(`${preflight.stdout}
+${preflight.stderr}`, options.task)) {
+    return finish4(started, clock(), commandId, null, [
+      problem3("GRADLE_TASK_NOT_MANAGED_DEVICE", "input.gradle.task", "Gradle resolved the task, but did not identify it as a managed-device task.", "Run adb-ready test gradle and select a task declared by Android Gradle Plugin managedDevices.", commandId, [{ source: "gradle", field: "task", value: options.task }])
+    ], 2 /* InvalidInput */);
+  }
+  const executed = await runner({
+    executable: gradle.executable,
+    args,
+    cwd: options.cwd,
+    ...signal === undefined ? {} : { signal },
+    timeoutMs: options.timeoutMs ?? 15 * 60000,
+    killProcessGroup: true
+  });
+  const roots = await findManagedRoots(options.cwd);
+  let provisionalOutcome = successfulProcess(executed) ? "passed" : executed.aborted ? "cancelled" : executed.timedOut ? "timed-out" : "infrastructure-failed";
+  const retained = await retainEvidence2({
+    cwd: options.cwd,
+    commandId,
+    process: executed,
+    task: options.task,
+    outcome: provisionalOutcome,
+    roots
+  });
+  provisionalOutcome = retained.outcome;
+  const exitCode2 = provisionalOutcome === "passed" ? 0 /* Success */ : provisionalOutcome === "cancelled" ? 130 /* Interrupted */ : 40 /* ChildProcess */;
+  const problems = provisionalOutcome === "passed" ? [] : [
+    problem3(provisionalOutcome === "assertion-failed" ? "GRADLE_TEST_ASSERTION_FAILED" : provisionalOutcome === "timed-out" ? "GRADLE_MANAGED_TEST_TIMED_OUT" : provisionalOutcome === "cancelled" ? "GRADLE_MANAGED_TEST_CANCELLED" : "GRADLE_MANAGED_INFRASTRUCTURE_FAILED", provisionalOutcome === "assertion-failed" ? "automation.test.assertion" : "automation.gradle.infrastructure", provisionalOutcome === "assertion-failed" ? "One or more Gradle managed-device assertions failed." : provisionalOutcome === "timed-out" ? "The Gradle managed-device task exceeded its timeout." : provisionalOutcome === "cancelled" ? "The Gradle managed-device task was cancelled." : "Gradle could not complete the managed-device infrastructure lifecycle.", `Review the retained native reports and Gradle output in ${retained.path}.`, commandId)
+  ];
+  return finish4(started, clock(), commandId, {
+    status: "completed",
+    wrapper: gradle.display,
+    task: options.task,
+    command,
+    outcome: provisionalOutcome,
+    tests: retained.tests,
+    reports: retained.reports,
+    evidence: {
+      path: retained.path,
+      nativeFiles: retained.nativeFiles,
+      omittedFiles: retained.omittedFiles,
+      provenance: retained.provenance
+    }
+  }, problems, exitCode2);
+}
+
+// src/automation/target-pool.ts
+import { randomUUID as randomUUID15 } from "node:crypto";
+function skipped(member, status) {
+  return {
+    id: member.id,
+    kind: member.kind,
+    required: member.required !== false,
+    status,
+    exitCode: 130 /* Interrupted */
+  };
+}
+async function runTargetPool(options, runMember) {
+  const started = (options.clock ?? (() => new Date))();
+  const commandId = options.idFactory?.() ?? randomUUID15();
+  const maxConcurrency = options.maxConcurrency ?? options.pool.maxConcurrency;
+  const failFast = options.failFast ?? options.pool.failFast;
+  const controller = new AbortController;
+  const cancel = () => controller.abort(options.signal?.reason);
+  options.signal?.addEventListener("abort", cancel, { once: true });
+  if (options.signal?.aborted === true)
+    cancel();
+  const members4 = options.pool.members;
+  const results = new Array(members4.length);
+  let nextIndex = 0;
+  let stopScheduling = controller.signal.aborted;
+  const worker = async () => {
+    while (!stopScheduling) {
+      const index = nextIndex;
+      nextIndex += 1;
+      const member = members4[index];
+      if (member === undefined)
+        return;
+      if (controller.signal.aborted) {
+        results[index] = skipped(member, "cancelled");
+        options.onMemberFinish?.(results[index]);
+        return;
+      }
+      try {
+        options.onMemberStart?.(member);
+        const executed = await runMember(member, controller.signal);
+        const status = executed.exitCode === 0 /* Success */ ? "passed" : controller.signal.aborted ? "cancelled" : "failed";
+        results[index] = {
+          id: member.id,
+          kind: member.kind,
+          required: member.required !== false,
+          status,
+          exitCode: executed.exitCode,
+          result: executed.result
+        };
+        options.onMemberFinish?.(results[index]);
+        if (failFast && member.required !== false && status !== "passed") {
+          stopScheduling = true;
+          if (options.cancelRunningOnFailFast !== false) {
+            controller.abort(new Error(`Required pool member ${member.id} failed.`));
+          }
+        }
+      } catch (caught) {
+        const interrupted = controller.signal.aborted;
+        results[index] = {
+          id: member.id,
+          kind: member.kind,
+          required: member.required !== false,
+          status: interrupted ? "cancelled" : "failed",
+          exitCode: interrupted ? 130 /* Interrupted */ : 70 /* Internal */
+        };
+        options.onMemberFinish?.(results[index]);
+        if (failFast && member.required !== false) {
+          stopScheduling = true;
+          if (options.cancelRunningOnFailFast !== false)
+            controller.abort(caught);
+        }
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(maxConcurrency, members4.length) }, async () => await worker()));
+  options.signal?.removeEventListener("abort", cancel);
+  for (let index = 0;index < members4.length; index += 1) {
+    if (results[index] === undefined) {
+      const member = members4[index];
+      if (member !== undefined) {
+        const result = skipped(member, controller.signal.aborted ? "cancelled" : "skipped");
+        results[index] = result;
+        options.onMemberFinish?.(result);
+      }
+    }
+  }
+  const completed = results.filter((result) => result !== undefined);
+  const summary2 = {
+    passed: completed.filter(({ status }) => status === "passed").length,
+    failed: completed.filter(({ status }) => status === "failed").length,
+    cancelled: completed.filter(({ status }) => status === "cancelled").length,
+    skipped: completed.filter(({ status }) => status === "skipped").length
+  };
+  const requiredFailure = completed.find(({ required: required4, status }) => required4 && status !== "passed");
+  const exitCode2 = requiredFailure === undefined ? 0 /* Success */ : requiredFailure.status === "cancelled" || requiredFailure.status === "skipped" ? 130 /* Interrupted */ : requiredFailure.exitCode;
+  const finished = (options.clock ?? (() => new Date))();
+  const problems = requiredFailure === undefined ? [] : [
+    {
+      code: "TARGET_POOL_REQUIRED_MEMBER_FAILED",
+      category: "automation.pool",
+      severity: "error",
+      summary: `Required target pool member ${requiredFailure.id} did not pass.`,
+      detail: `The aggregate preserves every member result and cannot succeed while a required member is ${requiredFailure.status}.`,
+      retryable: true,
+      evidence: [
+        { source: "target.pool", field: "member", value: requiredFailure.id },
+        { source: "target.pool", field: "status", value: requiredFailure.status }
+      ],
+      actions: [],
+      correlation: { commandId }
+    }
+  ];
+  return {
+    exitCode: exitCode2,
+    result: {
+      schemaVersion: SCHEMA_VERSION,
+      command: options.command ?? "run pool",
+      commandId,
+      ok: exitCode2 === 0 /* Success */,
+      startedAt: started.toISOString(),
+      finishedAt: finished.toISOString(),
+      durationMs: Math.max(0, finished.getTime() - started.getTime()),
+      data: {
+        pool: options.name,
+        maxConcurrency,
+        failFast,
+        coordination: options.coordination ?? "host-local-filesystem",
+        members: completed,
+        summary: summary2
+      },
+      problems
+    }
+  };
+}
+var VALUE_OPTIONS = new Set([
+  "--pool",
+  "--max-concurrency",
+  "--lease-wait",
+  "--device",
+  "--serial",
+  "-s",
+  "--transport-id",
+  "--avd",
+  "--adb-host",
+  "--adb-port",
+  "--format"
+]);
+var FLAG_OPTIONS = new Set([
+  "--fail-fast",
+  "--no-fail-fast",
+  "--json",
+  "--select",
+  "--last",
+  "--non-interactive",
+  "--color",
+  "--no-color",
+  "--animation",
+  "--no-animation"
+]);
+function targetPoolMemberArguments(argv, member) {
+  const separator = argv.indexOf("--");
+  const options = separator === -1 ? argv : argv.slice(0, separator);
+  const passthrough = separator === -1 ? [] : argv.slice(separator);
+  const retained = [];
+  for (let index = 0;index < options.length; index += 1) {
+    const argument = options[index];
+    if (argument === undefined)
+      continue;
+    const option = argument.split("=", 1)[0] ?? argument;
+    if (VALUE_OPTIONS.has(option)) {
+      if (!argument.includes("="))
+        index += 1;
+      continue;
+    }
+    if (FLAG_OPTIONS.has(option))
+      continue;
+    retained.push(argument);
+  }
+  retained.push("--format", "json", "--non-interactive", "--no-color", "--no-animation");
+  if (member.kind === "adb")
+    retained.push("--device", member.serial);
+  else if (member.kind === "avd")
+    retained.push("--avd", member.name);
+  else {
+    retained.push("--adb-host", member.host, "--adb-port", String(member.port), "--device", member.serial);
+  }
+  return [...retained, ...passthrough];
+}
+
 // src/automation/target-profile.ts
 var PROBE_TIMEOUT_MS3 = 1e4;
 function validValue(value) {
@@ -53342,10 +54993,10 @@ async function inspectAndroidTargetProfile(options, runner = runProcess) {
 }
 
 // src/state/target-state.ts
-import { randomUUID as randomUUID13 } from "node:crypto";
-import { mkdir as mkdir8, readFile as readFile14, rename as rename8, rm as rm9, writeFile as writeFile8 } from "node:fs/promises";
+import { randomUUID as randomUUID16 } from "node:crypto";
+import { mkdir as mkdir10, readFile as readFile14, rename as rename10, rm as rm11, writeFile as writeFile10 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import path23 from "node:path";
+import path25 from "node:path";
 import process14 from "node:process";
 var EMPTY_STATE = { version: 1, targets: {} };
 var MAX_REMEMBERED_SERVERS = 20;
@@ -53370,7 +55021,7 @@ function parseState(value) {
   return { version: 1, targets };
 }
 function defaultTargetStatePath(platform, env, homeDirectory) {
-  const platformPath = platform === "win32" ? path23.win32 : path23.posix;
+  const platformPath = platform === "win32" ? path25.win32 : path25.posix;
   if (env.XDG_STATE_HOME !== undefined && env.XDG_STATE_HOME.trim() !== "") {
     return platformPath.join(env.XDG_STATE_HOME, "adb-ready", "state.json");
   }
@@ -53449,20 +55100,20 @@ async function writeRememberedTarget(target, options = {}) {
     }
   }).sort(([, left], [, right]) => right.updatedAt.localeCompare(left.updatedAt)).slice(0, MAX_REMEMBERED_SERVERS);
   const document2 = { version: 1, targets: Object.fromEntries(entries) };
-  const directory = path23.dirname(statePath);
-  const temporary = path23.join(directory, `.state-${String(process14.pid)}-${randomUUID13()}.tmp`);
+  const directory = path25.dirname(statePath);
+  const temporary = path25.join(directory, `.state-${String(process14.pid)}-${randomUUID16()}.tmp`);
   try {
-    await mkdir8(directory, { recursive: true, mode: 448 });
-    await writeFile8(temporary, `${JSON.stringify(document2, null, 2)}
+    await mkdir10(directory, { recursive: true, mode: 448 });
+    await writeFile10(temporary, `${JSON.stringify(document2, null, 2)}
 `, {
       encoding: "utf8",
       flag: "wx",
       mode: 384
     });
-    await rename8(temporary, statePath);
+    await rename10(temporary, statePath);
     return { ok: true, path: statePath };
   } catch {
-    await rm9(temporary, { force: true }).catch(() => {
+    await rm11(temporary, { force: true }).catch(() => {
       return;
     });
     return {
@@ -54358,6 +56009,16 @@ async function showHomeScreen(options) {
         label: "Preview project plan",
         description: "Resolve the development workflow without allocating a target."
       },
+      {
+        value: "test-gradle",
+        label: "Gradle managed-device tests",
+        description: "Discover build-owned virtual-device and group test tasks."
+      },
+      {
+        value: "test-firebase",
+        label: "Firebase Test Lab",
+        description: "Browse cloud devices before running a remote test matrix."
+      },
       {
         value: "run-help",
         label: "Run a bounded verification",
@@ -54924,6 +56585,18 @@ function isDevData(value) {
 function isAutomationRunData(value) {
   return isRecord2(value) && typeof value.outcome === "string" && isRecord2(value.evidence) && (value.session === null || isDevData(value.session));
 }
+function isGradleManagedTestData(value) {
+  return isRecord2(value) && (value.status === "completed" || value.status === "discovered" || value.status === "planned") && typeof value.wrapper === "string";
+}
+function isFirebaseTestLabData(value) {
+  return isRecord2(value) && (value.status === "cancelled" || value.status === "catalogued" || value.status === "completed" || value.status === "planned") && (value.action === "cancel" || value.action === "devices" || value.action === "instrumentation" || value.action === "robo");
+}
+function isTargetPoolData(value) {
+  if (!isRecord2(value) || typeof value.pool !== "string" || !Array.isArray(value.members)) {
+    return false;
+  }
+  return typeof value.maxConcurrency === "number" && typeof value.failFast === "boolean" && isRecord2(value.summary) && value.members.every((member) => isRecord2(member) && typeof member.id === "string" && typeof member.kind === "string" && typeof member.required === "boolean" && typeof member.status === "string" && typeof member.exitCode === "number");
+}
 function isVersionData(value) {
   return isRecord2(value) && typeof value.version === "string";
 }
@@ -54995,19 +56668,19 @@ function wirelessServiceLabel(service) {
   const pairingState = service.serviceType !== "connect" || service.knownDevice === undefined ? "" : service.knownDevice ? " · paired" : " · pair first";
   return `${clean(identity)} · ${clean(service.endpoint.serial)} · ${clean(service.serviceType)}${pairingState}`;
 }
-function problemLines(problem2, capabilities, verbose) {
+function problemLines(problem4, capabilities, verbose) {
   const glyphs = symbols(capabilities);
-  const marker = problem2.severity === "error" && problem2.code !== ProblemCode.OperationInterrupted ? style.failure(glyphs.failure, capabilities) : style.warning(glyphs.warning, capabilities);
+  const marker = problem4.severity === "error" && problem4.code !== ProblemCode.OperationInterrupted ? style.failure(glyphs.failure, capabilities) : style.warning(glyphs.warning, capabilities);
   const lines = [
-    `${marker} ${style.strong(clean(problem2.summary), capabilities)}`,
-    `  ${clean(problem2.detail)}`
+    `${marker} ${style.strong(clean(problem4.summary), capabilities)}`,
+    `  ${clean(problem4.detail)}`
   ];
-  const action = problem2.actions[0];
+  const action = problem4.actions[0];
   if (action !== undefined) {
     lines.push(`  ${style.accent("Next:", capabilities)} ${clean(action.title)}`);
   }
   if (verbose) {
-    for (const evidence of problem2.evidence) {
+    for (const evidence of problem4.evidence) {
       const field = evidence.field === undefined ? evidence.source : `${evidence.source}.${evidence.field}`;
       lines.push(`  ${style.dim(`${clean(field)}: ${clean(JSON.stringify(evidence.value))}`, capabilities)}`);
     }
@@ -55069,6 +56742,60 @@ function renderHuman(result, options) {
   if (result.command === "run" && isAutomationRunData(result.data)) {
     lines.push(...automationHumanLines(result.data, capabilities));
   }
+  if (result.command === "test gradle" && isGradleManagedTestData(result.data)) {
+    const data = result.data;
+    if (data.status === "discovered") {
+      const tasks = data.tasks ?? [];
+      lines.push(`${style.success(glyphs.success, capabilities)} Gradle   ${clean(data.wrapper)}`, "", style.strong(`Managed-device tasks (${String(tasks.length)})`, capabilities), ...tasks.length === 0 ? [`${style.dim(glyphs.end, capabilities)} None declared`] : tasks.map((task, index) => {
+        const branch = index === tasks.length - 1 ? glyphs.end : glyphs.branch;
+        return `${style.dim(branch, capabilities)} ${clean(task)}`;
+      }));
+    } else {
+      const marker = data.outcome === undefined || data.outcome === "passed" ? style.success(glyphs.success, capabilities) : style.failure(glyphs.failure, capabilities);
+      lines.push(`${style.success(glyphs.success, capabilities)} Gradle   ${clean(data.wrapper)}`, `${marker} Task     ${clean(data.task ?? "unresolved")}${data.outcome === undefined ? " · planned" : ` · ${clean(data.outcome)}`}`);
+      if (data.tests !== undefined) {
+        lines.push(`${data.tests.failed + data.tests.errors === 0 ? style.success(glyphs.success, capabilities) : style.failure(glyphs.failure, capabilities)} Tests    ${String(data.tests.total)} total · ${String(data.tests.failed)} failed · ${String(data.tests.errors)} errors · ${String(data.tests.skipped)} skipped`);
+      }
+      if (data.evidence !== undefined) {
+        lines.push(`${style.accent(glyphs.active, capabilities)} Evidence ${clean(data.evidence.path)} · ${String(data.evidence.nativeFiles)} native files · ${clean(data.evidence.provenance)}`);
+      }
+    }
+  }
+  if (result.command === "test firebase" && isFirebaseTestLabData(result.data)) {
+    const data = result.data;
+    const marker = data.outcome === "flaky" ? style.warning(glyphs.warning, capabilities) : data.outcome === undefined || data.outcome === "passed" || data.status === "catalogued" ? style.success(glyphs.success, capabilities) : style.failure(glyphs.failure, capabilities);
+    lines.push(`${marker} Firebase ${clean(data.action)} · ${clean(data.status)}${data.outcome === undefined ? "" : ` · ${clean(data.outcome)}`}`);
+    if (data.status === "catalogued") {
+      const devices = data.devices ?? [];
+      lines.push(`${style.accent(glyphs.active, capabilities)} Catalog  ${String(devices.length)} compatible model/version choices`, ...devices.slice(0, 20).map((device, index) => {
+        const branch = index === Math.min(devices.length, 20) - 1 ? glyphs.end : glyphs.branch;
+        return `${style.dim(branch, capabilities)} ${clean(device.model)}/${clean(device.version)} · ${clean(device.form.toLowerCase())} · ${clean(device.capacity)} capacity${device.tags.length === 0 ? "" : ` · ${device.tags.map(clean).join(", ")}`}`;
+      }), ...devices.length > 20 ? [
+        style.dim(`  ${String(devices.length - 20)} more · use --json for the full catalog`, capabilities)
+      ] : []);
+    }
+    if (data.matrixId !== undefined) {
+      lines.push(`${style.accent(glyphs.active, capabilities)} Matrix   ${clean(data.matrixId)}`);
+    }
+    if (data.consoleUrl !== undefined) {
+      lines.push(`${style.accent(glyphs.active, capabilities)} Results  ${clean(data.consoleUrl)}`);
+    }
+    if (data.remoteContinues === true) {
+      lines.push(`${style.warning(glyphs.warning, capabilities)} Remote   still running · explicit cancel required`);
+    }
+    if (data.evidence !== undefined) {
+      lines.push(`${style.accent(glyphs.active, capabilities)} Evidence ${clean(data.evidence.path)} · ${String(data.evidence.providerFiles)} provider files · ${clean(data.evidence.collection)}`);
+    }
+  }
+  if ((result.command === "run pool" || result.command === "test firebase pool") && isTargetPoolData(result.data)) {
+    const data = result.data;
+    lines.push(`${style.accent(glyphs.active, capabilities)} Pool     ${clean(data.pool)} · concurrency ${String(data.maxConcurrency)} · ${data.failFast ? "fail fast" : "run all"}`, `${style.success(glyphs.success, capabilities)} Summary  ${String(data.summary.passed)} passed · ${String(data.summary.failed)} failed · ${String(data.summary.cancelled)} cancelled · ${String(data.summary.skipped)} skipped`, `${style.dim(glyphs.branch, capabilities)} Coordination ${clean(data.coordination)}`, "", style.strong(`Members (${String(data.members.length)})`, capabilities));
+    data.members.forEach((member, index) => {
+      const branch = index === data.members.length - 1 ? glyphs.end : glyphs.branch;
+      const marker = member.status === "passed" ? style.success(glyphs.success, capabilities) : member.status === "failed" ? style.failure(glyphs.failure, capabilities) : member.status === "cancelled" ? style.warning(glyphs.warning, capabilities) : style.dim(glyphs.skipped, capabilities);
+      lines.push(`${style.dim(branch, capabilities)} ${marker} ${clean(member.id)} · ${clean(member.kind)} · ${clean(member.status)}${member.required ? "" : " · optional"}`);
+    });
+  }
   if (result.command === "logs" && isLogsData(result.data)) {
     const data = result.data;
     lines.push(`${style.success(glyphs.success, capabilities)} Target   ${clean(data.selected.target.name)} · ${clean(data.selected.transport.serial)}`, `${style.success(glyphs.success, capabilities)} Filter   ${data.filters.map(clean).join(" ")}${data.packageName === undefined ? "" : ` · ${clean(data.packageName)}`}${data.uid === undefined ? "" : ` · UID ${String(data.uid)}`}${data.pid === undefined ? "" : ` · PID ${String(data.pid)}`}`, `${style.success(glyphs.success, capabilities)} Buffers  ${data.buffers.length === 0 ? "device default" : data.buffers.map(clean).join(", ")}`, `${style.success(glyphs.success, capabilities)} Records  ${String(data.records.length)} retained${data.dropped === 0 ? "" : ` · ${String(data.dropped)} dropped`}`);
@@ -55224,9 +56951,9 @@ function renderHuman(result, options) {
     if (data.problems.length === 0) {
       lines.push(`${style.dim(glyphs.end, capabilities)} No recorded problems`);
     } else {
-      data.problems.forEach((problem2, index) => {
+      data.problems.forEach((problem4, index) => {
         const branch = index === data.problems.length - 1 ? glyphs.end : glyphs.branch;
-        lines.push(`${style.dim(branch, capabilities)} ${style.failure(clean(problem2.code), capabilities)} · ${clean(problem2.summary)}`, `  ${clean(problem2.detail)}`);
+        lines.push(`${style.dim(branch, capabilities)} ${style.failure(clean(problem4.code), capabilities)} · ${clean(problem4.summary)}`, `  ${clean(problem4.detail)}`);
       });
     }
   }
@@ -55313,8 +57040,8 @@ function renderHuman(result, options) {
   }
   if (result.problems.length > 0) {
     lines.push("", style.strong("Diagnostics", capabilities));
-    for (const problem2 of result.problems) {
-      lines.push(...problemLines(problem2, capabilities, options.verbose ?? false));
+    for (const problem4 of result.problems) {
+      lines.push(...problemLines(problem4, capabilities, options.verbose ?? false));
     }
   }
   const interrupted = result.problems.some(({ code }) => code === ProblemCode.OperationInterrupted) && !result.problems.some(({ code, severity }) => severity === "error" && code !== ProblemCode.OperationInterrupted);
@@ -55343,6 +57070,26 @@ function renderPlain(result, sink) {
   if (isVersionData(result.data))
     sink.write(`version=${clean(result.data.version)}
 `);
+  if (isTargetPoolData(result.data)) {
+    sink.write(`pool=${clean(result.data.pool)}
+`);
+    sink.write(`max_concurrency=${String(result.data.maxConcurrency)}
+`);
+    sink.write(`fail_fast=${String(result.data.failFast)}
+`);
+    sink.write(`passed=${String(result.data.summary.passed)}
+`);
+    sink.write(`failed=${String(result.data.summary.failed)}
+`);
+    sink.write(`cancelled=${String(result.data.summary.cancelled)}
+`);
+    sink.write(`skipped=${String(result.data.summary.skipped)}
+`);
+    result.data.members.forEach((member, index) => {
+      sink.write(`member_${String(index)}=${clean(member.id)}:${clean(member.kind)}:${clean(member.status)}:${String(member.exitCode)}
+`);
+    });
+  }
   if (isConnectData(result.data)) {
     sink.write(`endpoint=${clean(result.data.endpoint)}
 `);
@@ -55429,6 +57176,81 @@ function renderPlain(result, sink) {
   }
   if (isAutomationRunData(result.data))
     renderAutomationPlain(result.data, sink);
+  if (isGradleManagedTestData(result.data)) {
+    sink.write(`status=${clean(result.data.status)}
+`);
+    sink.write(`gradle=${clean(result.data.wrapper)}
+`);
+    if (result.data.task !== undefined)
+      sink.write(`task=${clean(result.data.task)}
+`);
+    if (result.data.tasks !== undefined) {
+      sink.write(`task_count=${String(result.data.tasks.length)}
+`);
+      result.data.tasks.forEach((task, index) => {
+        sink.write(`task_${String(index)}=${clean(task)}
+`);
+      });
+    }
+    if (result.data.outcome !== undefined)
+      sink.write(`outcome=${clean(result.data.outcome)}
+`);
+    if (result.data.tests !== undefined) {
+      sink.write(`tests=${String(result.data.tests.total)}
+`);
+      sink.write(`test_failures=${String(result.data.tests.failed)}
+`);
+      sink.write(`test_errors=${String(result.data.tests.errors)}
+`);
+      sink.write(`test_skipped=${String(result.data.tests.skipped)}
+`);
+    }
+    if (result.data.evidence !== undefined) {
+      sink.write(`evidence=${clean(result.data.evidence.path)}
+`);
+      sink.write(`native_file_count=${String(result.data.evidence.nativeFiles)}
+`);
+      sink.write(`evidence_provenance=${clean(result.data.evidence.provenance)}
+`);
+    }
+  }
+  if (isFirebaseTestLabData(result.data)) {
+    sink.write(`status=${clean(result.data.status)}
+`);
+    sink.write(`action=${clean(result.data.action)}
+`);
+    if (result.data.project !== undefined)
+      sink.write(`project=${clean(result.data.project)}
+`);
+    if (result.data.outcome !== undefined)
+      sink.write(`outcome=${clean(result.data.outcome)}
+`);
+    if (result.data.matrixId !== undefined)
+      sink.write(`matrix_id=${clean(result.data.matrixId)}
+`);
+    if (result.data.consoleUrl !== undefined)
+      sink.write(`console_url=${clean(result.data.consoleUrl)}
+`);
+    if (result.data.devices !== undefined)
+      sink.write(`device_count=${String(result.data.devices.length)}
+`);
+    if (result.data.evidence !== undefined) {
+      sink.write(`evidence=${clean(result.data.evidence.path)}
+`);
+      sink.write(`provider_file_count=${String(result.data.evidence.providerFiles)}
+`);
+      sink.write(`provider_file_omitted=${String(result.data.evidence.omittedFiles)}
+`);
+      sink.write(`evidence_collection=${clean(result.data.evidence.collection)}
+`);
+      if (result.data.evidence.remotePrefix !== undefined)
+        sink.write(`provider_result_prefix=${clean(result.data.evidence.remotePrefix)}
+`);
+    }
+    if (result.data.remoteContinues !== undefined)
+      sink.write(`remote_continues=${String(result.data.remoteContinues)}
+`);
+  }
   if (isLogsData(result.data)) {
     sink.write(`serial=${clean(result.data.selected.transport.serial)}
 `);
@@ -55621,8 +57443,8 @@ function renderPlain(result, sink) {
 `);
     sink.write(`problem_count=${String(result.data.problems.length)}
 `);
-    result.data.problems.forEach((problem2) => {
-      sink.write(`problem=${clean(problem2.code)}:${clean(problem2.summary)}
+    result.data.problems.forEach((problem4) => {
+      sink.write(`problem=${clean(problem4.code)}:${clean(problem4.summary)}
 `);
     });
   }
@@ -55740,8 +57562,8 @@ function renderPlain(result, sink) {
 `);
     });
   }
-  for (const problem2 of result.problems) {
-    sink.write(`problem=${clean(problem2.code)}:${clean(problem2.summary)}
+  for (const problem4 of result.problems) {
+    sink.write(`problem=${clean(problem4.code)}:${clean(problem4.summary)}
 `);
   }
 }
@@ -55910,12 +57732,259 @@ function resolveTerminalCapabilities(preferences) {
   };
 }
 
+// src/cli/completion.ts
+var COMPLETION_SHELLS = ["bash", "zsh", "fish", "powershell", "nushell"];
+var COMMANDS = [
+  { name: "agent", description: "Configure a project-local AI agent bridge", values: ["setup"] },
+  {
+    name: "app",
+    description: "Resolve, inspect, install, or control one app",
+    values: ["resolve", "info", "install", "launch", "stop", "restart", "clear-data", "uninstall"]
+  },
+  { name: "apps", description: "List packages on one Android target", values: ["list"] },
+  {
+    name: "capture",
+    description: "Capture verified device evidence",
+    values: ["screenshot", "screen-record"]
+  },
+  { name: "completion", description: "Generate shell completion", values: COMPLETION_SHELLS },
+  {
+    name: "config",
+    description: "Validate or explain configuration",
+    values: ["validate", "explain"]
+  },
+  { name: "connect", description: "Connect a wireless Android target" },
+  { name: "context", description: "Export bounded AI-ready context" },
+  { name: "dev", description: "Start a target-bound development session" },
+  { name: "devices", description: "List visible Android targets" },
+  { name: "doctor", description: "Inspect the local ADB environment" },
+  { name: "help", description: "Show command help" },
+  { name: "init", description: "Create detected project configuration" },
+  {
+    name: "inspect",
+    description: "Build bounded device evidence",
+    values: ["app", "failures", "ui"]
+  },
+  { name: "logs", description: "Stream focused target logs" },
+  { name: "mcp", description: "Serve typed tools over local stdio" },
+  { name: "open", description: "Open a deep link or web URL" },
+  { name: "pair", description: "Pair through Wireless debugging" },
+  { name: "ports", description: "Manage verified TCP mappings", values: ["forward", "reverse"] },
+  { name: "problems", description: "Show saved session problems" },
+  { name: "run", description: "Run one bounded verification job" },
+  { name: "sessions", description: "Inspect saved sessions", values: ["list", "show", "events"] },
+  { name: "test", description: "Run managed Android tests", values: ["gradle", "firebase"] },
+  {
+    name: "ui",
+    description: "Perform a bounded verified UI action",
+    values: [
+      "audit",
+      "find",
+      "get",
+      "assert",
+      "compare",
+      "tap",
+      "long-press",
+      "scroll",
+      "swipe",
+      "fill",
+      "clear",
+      "type",
+      "press",
+      "keyboard",
+      "permission",
+      "wait"
+    ]
+  },
+  { name: "version", description: "Show version" }
+];
+var GLOBAL_OPTIONS = [
+  "--help",
+  "-h",
+  "--version",
+  "-V",
+  "--format",
+  "--json",
+  "--quiet",
+  "--verbose",
+  "--color",
+  "--no-color",
+  "--unicode",
+  "--no-unicode",
+  "--animation",
+  "--no-animation",
+  "--non-interactive",
+  "--timeout",
+  "--adb",
+  "--adb-host",
+  "--adb-port",
+  "--config",
+  "--profile",
+  "--select",
+  "--device",
+  "--serial",
+  "-s",
+  "--transport-id",
+  "--last",
+  "--dry-run"
+];
+var commandNames = () => COMMANDS.map(({ name }) => name).join(" ");
+var optionNames = () => GLOBAL_OPTIONS.join(" ");
+function bash() {
+  const cases = COMMANDS.filter(({ values: values2 }) => values2 !== undefined).map(({ name, values: values2 }) => `      ${name}) candidates="${values2?.join(" ")}" ;;`).join(`
+`);
+  return `# Generated by adb-ready. Source this file from ~/.bashrc.
+_adb_ready_complete() {
+  local current command candidates
+  COMPREPLY=()
+  current="\${COMP_WORDS[COMP_CWORD]}"
+  command="\${COMP_WORDS[1]}"
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    candidates="${commandNames()} ${optionNames()}"
+  elif [[ \${COMP_CWORD} -eq 2 ]]; then
+    case "\${command}" in
+${cases}
+      help) candidates="${commandNames()}" ;;
+      *) candidates="${optionNames()}" ;;
+    esac
+  else
+    candidates="${optionNames()}"
+  fi
+  COMPREPLY=( $(compgen -W "\${candidates}" -- "\${current}") )
+}
+complete -F _adb_ready_complete adb-ready adbr
+`;
+}
+function zsh() {
+  const commands = COMMANDS.map(({ name, description }) => `    '${name}:${description.replaceAll("'", "'\\''")}'`).join(`
+`);
+  const cases = COMMANDS.filter(({ values: values2 }) => values2 !== undefined).map(({ name, values: values2 }) => `      ${name}) _values 'action' ${values2?.join(" ")} ;;`).join(`
+`);
+  return `#compdef adb-ready adbr
+# Generated by adb-ready. Add its directory to fpath, then run compinit.
+_adb_ready() {
+  local -a commands
+  commands=(
+${commands}
+  )
+  _arguments -C \\
+    '(-h --help)'{-h,--help}'[show help]' \\
+    '(-V --version)'{-V,--version}'[show version]' \\
+    '--format[select output format]:format:(human plain json ndjson)' \\
+    '--json[emit JSON]' \\
+    '--non-interactive[never prompt]' \\
+    '1:command:->command' \\
+    '*::argument:->argument'
+  case $state in
+    command) _describe 'command' commands ;;
+    argument)
+      case $words[2] in
+${cases}
+        help) _describe 'command' commands ;;
+      esac
+      ;;
+  esac
+}
+_adb_ready "$@"
+`;
+}
+function fish() {
+  const lines = [
+    "# Generated by adb-ready. Save as ~/.config/fish/completions/adb-ready.fish."
+  ];
+  for (const binary of ["adb-ready", "adbr"]) {
+    for (const { name, description } of COMMANDS) {
+      const safeDescription = description.replaceAll("'", "\\'");
+      lines.push(`complete -c ${binary} -f -n '__fish_use_subcommand' -a '${name}' -d '${safeDescription}'`);
+    }
+    for (const { name, values: values2 } of COMMANDS) {
+      if (values2 === undefined)
+        continue;
+      lines.push(`complete -c ${binary} -f -n '__fish_seen_subcommand_from ${name}' -a '${values2.join(" ")}'`);
+    }
+    lines.push(`complete -c ${binary} -s h -l help -d 'Show help'`, `complete -c ${binary} -s V -l version -d 'Show version'`, `complete -c ${binary} -l json -d 'Emit JSON'`, `complete -c ${binary} -l non-interactive -d 'Never prompt'`, `complete -c ${binary} -l dry-run -d 'Plan without mutation'`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function powershell() {
+  const map = COMMANDS.filter(({ values: values2 }) => values2 !== undefined).map(({ name, values: values2 }) => `  '${name}' = @('${values2?.join("','")}')`).join(`
+`);
+  return `# Generated by adb-ready. Add this script to your PowerShell profile.
+$AdbReadyCommands = @('${commandNames().replaceAll(" ", "','")}')
+$AdbReadyOptions = @('${optionNames().replaceAll(" ", "','")}')
+$AdbReadyActions = @{
+${map}
+}
+Register-ArgumentCompleter -Native -CommandName adb-ready,adbr -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+  $words = $commandAst.CommandElements | ForEach-Object { $_.Extent.Text }
+  $candidates = if ($words.Count -le 1) {
+    $AdbReadyCommands + $AdbReadyOptions
+  } elseif ($words.Count -eq 2 -and $AdbReadyActions.ContainsKey($words[1])) {
+    $AdbReadyActions[$words[1]] + $AdbReadyOptions
+  } elseif ($words[1] -eq 'help') {
+    $AdbReadyCommands
+  } else {
+    $AdbReadyOptions
+  }
+  $candidates | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+  }
+}
+`;
+}
+function nushellExtern(binary) {
+  return `export extern "${binary}" [
+  command?: string@"nu-complete adb-ready commands"
+  ...args: string
+  --help(-h)
+  --version(-V)
+  --json
+  --quiet
+  --verbose
+  --non-interactive
+  --dry-run
+]`;
+}
+function nushell() {
+  const records = COMMANDS.map(({ name, description }) => `  { value: "${name}", description: "${description}" }`).join(`
+`);
+  return `# Generated by adb-ready. Source this file from config.nu.
+def "nu-complete adb-ready commands" [] {
+[
+${records}
+]
+}
+
+${nushellExtern("adb-ready")}
+
+${nushellExtern("adbr")}
+`;
+}
+function generateCompletion(shell) {
+  switch (shell) {
+    case "bash":
+      return bash();
+    case "zsh":
+      return zsh();
+    case "fish":
+      return fish();
+    case "powershell":
+      return powershell();
+    case "nushell":
+      return nushell();
+  }
+}
+
 // src/cli/arguments.ts
-var COMMANDS = new Set([
+var COMMANDS2 = new Set([
   "agent",
   "app",
   "apps",
   "capture",
+  "completion",
   "config",
   "connect",
   "context",
@@ -55933,6 +58002,7 @@ var COMMANDS = new Set([
   "problems",
   "run",
   "sessions",
+  "test",
   "ui",
   "version"
 ]);
@@ -56008,6 +58078,12 @@ var BOOLEAN_OPTIONS = new Set([
   "--all",
   "--all-projects",
   "--interactive-only",
+  "--software-rendering",
+  "--allow-deprecated",
+  "--allow-reduced-stability",
+  "--allow-low-capacity",
+  "--fail-fast",
+  "--no-fail-fast",
   "--submit",
   "--secret-stdin"
 ]);
@@ -56058,6 +58134,7 @@ function splitLongOption(argument) {
 function parseArguments(argv) {
   let command;
   let helpTarget;
+  let completionShell;
   let format = "human";
   let quiet = false;
   let verbose = false;
@@ -56079,6 +58156,10 @@ function parseArguments(argv) {
   let pairingCodeStdin = false;
   let remembered = false;
   let dryRun = false;
+  let poolName;
+  let maxConcurrency;
+  let failFast;
+  let leaseWaitMs;
   let allProjects = false;
   let portDirection;
   let portAction;
@@ -56093,6 +58174,24 @@ function parseArguments(argv) {
   let customCommand;
   let runCommand;
   let runTimeoutMs;
+  let testKind;
+  let gradleTask;
+  let gradlePath;
+  let gradleShards;
+  let gradleSoftwareRendering = false;
+  let firebaseAction;
+  let firebaseMatrixId;
+  const firebaseDevices = [];
+  let gcloudPath;
+  let cloudProject;
+  let firebaseApp;
+  let firebaseTest;
+  let firebaseResultsBucket;
+  let firebaseResultsDir;
+  let firebaseTestTimeout;
+  let firebaseAllowDeprecated = false;
+  let firebaseAllowReducedStability = false;
+  let firebaseAllowLowCapacity = false;
   let avdName;
   let deployArtifact = false;
   const runArtifactPaths = [];
@@ -56173,17 +58272,17 @@ function parseArguments(argv) {
     }
     if (!argument.startsWith("-")) {
       if (command === undefined) {
-        if (!COMMANDS.has(argument)) {
-          const hint = suggestion(argument, COMMANDS);
+        if (!COMMANDS2.has(argument)) {
+          const hint = suggestion(argument, COMMANDS2);
           return failure4("CLI_USAGE", `Unknown command: ${argument}${hint === "" ? "" : `. ${hint}`}`);
         }
         const candidate = argument;
         command = candidate;
         continue;
       }
-      if (command === "help" && COMMANDS.has(argument)) {
+      if (command === "help" && COMMANDS2.has(argument)) {
         const candidate = argument;
-        if (candidate === "agent" || candidate === "app" || candidate === "apps" || candidate === "capture" || candidate === "connect" || candidate === "config" || candidate === "context" || candidate === "dev" || candidate === "devices" || candidate === "doctor" || candidate === "logs" || candidate === "mcp" || candidate === "open" || candidate === "init" || candidate === "inspect" || candidate === "pair" || candidate === "ports" || candidate === "problems" || candidate === "run" || candidate === "sessions" || candidate === "ui" || candidate === "version") {
+        if (candidate === "agent" || candidate === "app" || candidate === "apps" || candidate === "capture" || candidate === "completion" || candidate === "connect" || candidate === "config" || candidate === "context" || candidate === "dev" || candidate === "devices" || candidate === "doctor" || candidate === "logs" || candidate === "mcp" || candidate === "open" || candidate === "init" || candidate === "inspect" || candidate === "pair" || candidate === "ports" || candidate === "problems" || candidate === "run" || candidate === "sessions" || candidate === "test" || candidate === "ui" || candidate === "version") {
           helpTarget = candidate;
           continue;
         }
@@ -56192,10 +58291,35 @@ function parseArguments(argv) {
         endpoint = argument;
         continue;
       }
+      if (command === "completion" && completionShell === undefined) {
+        if (!COMPLETION_SHELLS.includes(argument)) {
+          return failure4("CLI_INVALID_VALUE", `Invalid completion shell: ${argument}. Expected bash, zsh, fish, powershell, or nushell.`);
+        }
+        completionShell = argument;
+        continue;
+      }
       if (command === "agent" && argument === "setup" && !agentSetupSeen) {
         agentSetupSeen = true;
         continue;
       }
+      if (command === "test") {
+        if (testKind === undefined && (argument === "firebase" || argument === "gradle")) {
+          testKind = argument;
+          continue;
+        }
+        if (testKind === "gradle" && gradleTask === undefined) {
+          gradleTask = argument;
+          continue;
+        }
+        if (testKind === "firebase" && firebaseAction === undefined && (argument === "cancel" || argument === "devices" || argument === "instrumentation" || argument === "robo")) {
+          firebaseAction = argument;
+          continue;
+        }
+        if (testKind === "firebase" && firebaseAction === "cancel" && firebaseMatrixId === undefined) {
+          firebaseMatrixId = argument;
+          continue;
+        }
+      }
       if (command === "agent" && agentSetupSeen && agentClient === undefined) {
         if (!AGENT_CLIENTS.has(argument)) {
           return failure4("CLI_INVALID_VALUE", `Invalid agent client: ${argument}. Expected codex, claude-code, cursor, vscode, windsurf, or generic.`);
@@ -56373,6 +58497,35 @@ function parseArguments(argv) {
       remembered = true;
     } else if (option === "--dry-run") {
       dryRun = true;
+    } else if (option === "--pool") {
+      const value = readValue();
+      if (typeof value !== "string")
+        return value;
+      if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/u.test(value)) {
+        return failure4("CLI_INVALID_VALUE", `Invalid target pool name: ${value}.`, option);
+      }
+      poolName = value;
+    } else if (option === "--max-concurrency") {
+      const value = readValue();
+      if (typeof value !== "string")
+        return value;
+      const parsed = Number(value);
+      if (!/^\d+$/u.test(value) || !Number.isSafeInteger(parsed) || parsed < 1 || parsed > 32) {
+        return failure4("CLI_INVALID_VALUE", "--max-concurrency must be an integer from 1 to 32.", option);
+      }
+      maxConcurrency = parsed;
+    } else if (option === "--fail-fast") {
+      failFast = true;
+    } else if (option === "--no-fail-fast") {
+      failFast = false;
+    } else if (option === "--lease-wait") {
+      const value = readValue();
+      if (typeof value !== "string")
+        return value;
+      leaseWaitMs = parseDuration(value);
+      if (leaseWaitMs === undefined || leaseWaitMs > 3600000) {
+        return failure4("CLI_INVALID_VALUE", "--lease-wait must be a positive duration up to 1h.", option);
+      }
     } else if (option === "--deploy") {
       deployArtifact = true;
     } else if (option === "--all-projects") {
@@ -56692,6 +58845,96 @@ function parseArguments(argv) {
       if (runTimeoutMs === undefined) {
         return failure4("CLI_INVALID_VALUE", `Invalid run timeout: ${value}. Use a positive duration such as 30s or 10m.`, option);
       }
+    } else if (option === "--gradle") {
+      const value = readValue();
+      if (typeof value !== "string")
+        return value;
+      if (value.trim() !== value || value.length === 0 || !printableValue(value)) {
+        return failure4("CLI_INVALID_VALUE", "--gradle must be a non-empty printable path.", option);
+      }
+      gradlePath = value;
+    } else if (option === "--shards") {
+      const value = readValue();
+      if (typeof value !== "string")
+        return value;
+      const parsed = Number(value);
+      if (!/^\d+$/u.test(value) || !Number.isSafeInteger(parsed) || parsed < 1 || parsed > 256) {
+        return failure4("CLI_INVALID_VALUE", "--shards must be an integer from 1 to 256.", option);
+      }
+      gradleShards = parsed;
+    } else if (option === "--software-rendering") {
+      gradleSoftwareRendering = true;
+    } else if (option === "--allow-deprecated") {
+      firebaseAllowDeprecated = true;
+    } else if (option === "--allow-reduced-stability") {
+      firebaseAllowReducedStability = true;
+    } else if (option === "--allow-low-capacity") {
+      firebaseAllowLowCapacity = true;
+    } else if (option === "--gcloud") {
+      const value = readValue();
+      if (typeof value !== "string")
+        return value;
+      if (value.trim() !== value || value.length === 0 || !printableValue(value)) {
+        return failure4("CLI_INVALID_VALUE", "--gcloud must be a non-empty printable path.", option);
+      }
+      gcloudPath = value;
+    } else if (option === "--project") {
+      const value = readValue();
+      if (typeof value !== "string")
+        return value;
+      if (!/^[a-z][a-z0-9-]{4,28}[a-z0-9]$/u.test(value)) {
+        return failure4("CLI_INVALID_VALUE", "--project must be an explicit Google Cloud project ID.", option);
+      }
+      cloudProject = value;
+    } else if (option === "--app") {
+      const value = readValue();
+      if (typeof value !== "string")
+        return value;
+      if (value.trim() !== value || value.length === 0 || !printableValue(value) || value.startsWith("gs://") && !/^gs:\/\/[a-z0-9][a-z0-9._-]{1,221}[a-z0-9]\/.+/u.test(value) || value.includes("?")) {
+        return failure4("CLI_INVALID_VALUE", "--app must be a non-empty printable artifact path.", option);
+      }
+      firebaseApp = value;
+    } else if (option === "--test-apk") {
+      const value = readValue();
+      if (typeof value !== "string")
+        return value;
+      if (value.trim() !== value || value.length === 0 || !printableValue(value) || value.startsWith("gs://") && !/^gs:\/\/[a-z0-9][a-z0-9._-]{1,221}[a-z0-9]\/.+/u.test(value) || value.includes("?")) {
+        return failure4("CLI_INVALID_VALUE", "--test-apk must be a non-empty printable path.", option);
+      }
+      firebaseTest = value;
+    } else if (option === "--test-device") {
+      const value = readValue();
+      if (typeof value !== "string")
+        return value;
+      const parsed = parseFirebaseDevice(value);
+      if (parsed === undefined) {
+        return failure4("CLI_INVALID_VALUE", "--test-device requires model=ID,version=ID with optional locale and orientation.", option);
+      }
+      firebaseDevices.push(parsed);
+    } else if (option === "--results-bucket") {
+      const value = readValue();
+      if (typeof value !== "string")
+        return value;
+      if (!/^gs:\/\/[a-z0-9][a-z0-9._-]{1,221}[a-z0-9]$/u.test(value)) {
+        return failure4("CLI_INVALID_VALUE", "--results-bucket must be a gs:// bucket URI.", option);
+      }
+      firebaseResultsBucket = value;
+    } else if (option === "--results-dir") {
+      const value = readValue();
+      if (typeof value !== "string")
+        return value;
+      if (value.length > 512 || !/^[A-Za-z0-9][A-Za-z0-9._/-]*$/u.test(value) || value.trim() !== value || value.startsWith("/") || value.endsWith("/") || value.includes("//") || value.split("/").some((segment) => segment === "." || segment === "..") || !printableValue(value)) {
+        return failure4("CLI_INVALID_VALUE", "--results-dir must be a safe unique bucket-relative path.", option);
+      }
+      firebaseResultsDir = value;
+    } else if (option === "--test-timeout") {
+      const value = readValue();
+      if (typeof value !== "string")
+        return value;
+      if (parseDuration(value) === undefined) {
+        return failure4("CLI_INVALID_VALUE", "--test-timeout must be a positive duration such as 5m.", option);
+      }
+      firebaseTestTimeout = value;
     } else if (option === "--avd") {
       const value = readValue();
       if (typeof value !== "string")
@@ -56797,6 +59040,9 @@ function parseArguments(argv) {
         "--adb-port",
         "--config",
         "--profile",
+        "--pool",
+        "--max-concurrency",
+        "--lease-wait",
         "--mcp-profile",
         "--device",
         "--serial",
@@ -56827,6 +59073,16 @@ function parseArguments(argv) {
         "--max-records",
         "--budget",
         "--run-timeout",
+        "--gradle",
+        "--shards",
+        "--gcloud",
+        "--project",
+        "--app",
+        "--test-apk",
+        "--test-device",
+        "--results-bucket",
+        "--results-dir",
+        "--test-timeout",
         "--avd",
         "--artifact",
         "--variant",
@@ -56891,8 +59147,8 @@ function parseArguments(argv) {
   if (remembered && (select || device !== undefined || transportId !== undefined)) {
     return failure4("CLI_USAGE", "--last cannot be combined with another target selector.");
   }
-  if (dryRun && command !== "connect" && command !== "dev" && command !== "run" && command !== "app" && command !== "open" && command !== "pair" && command !== "ports" && command !== "init" && command !== "agent" && command !== "ui") {
-    return failure4("CLI_USAGE", "--dry-run can only be used with app, connect, dev, run, init, open, pair, or ports.", "--dry-run");
+  if (dryRun && command !== "connect" && command !== "dev" && command !== "run" && command !== "app" && command !== "open" && command !== "pair" && command !== "ports" && command !== "init" && command !== "agent" && command !== "test" && command !== "ui") {
+    return failure4("CLI_USAGE", "--dry-run can only be used with app, connect, dev, run, init, open, pair, ports, test, or agent setup.", "--dry-run");
   }
   if (command === "ports") {
     if (portDirection === undefined) {
@@ -56926,6 +59182,12 @@ function parseArguments(argv) {
   if (command === "capture" && captureKind === undefined) {
     return failure4("CLI_USAGE", "capture requires screenshot or screen-record.");
   }
+  if (command === "completion" && completionShell === undefined) {
+    return failure4("CLI_USAGE", "completion requires bash, zsh, fish, powershell, or nushell.");
+  }
+  if (command === "completion" && argv.some((argument) => argument !== "completion" && argument !== completionShell)) {
+    return failure4("CLI_USAGE", "completion accepts only one shell name; redirect its exact script output to a file.");
+  }
   if (command === "inspect" && inspectKind === undefined) {
     return failure4("CLI_USAGE", "inspect requires app, failures, or ui.");
   }
@@ -57122,8 +59384,56 @@ function parseArguments(argv) {
   if (command === "run" && runCommand === undefined) {
     return failure4("CLI_USAGE", "run requires a bounded command after --.");
   }
+  const poolCommand = command === "run" || command === "test" && testKind === "firebase" && (firebaseAction === "instrumentation" || firebaseAction === "robo");
+  if (poolName !== undefined && !poolCommand) {
+    return failure4("CLI_USAGE", "--pool can only be used with run or a Firebase instrumentation/Robo workflow.", "--pool");
+  }
+  if (poolName !== undefined && (select || remembered || device !== undefined || transportId !== undefined || avdName !== undefined)) {
+    return failure4("CLI_USAGE", "--pool cannot be combined with another target selector.", "--pool");
+  }
+  if (poolName !== undefined && firebaseDevices.length > 0) {
+    return failure4("CLI_USAGE", "--pool cannot be combined with --test-device.", "--pool");
+  }
+  if ((maxConcurrency !== undefined || failFast !== undefined || leaseWaitMs !== undefined) && poolName === undefined) {
+    return failure4("CLI_USAGE", "--max-concurrency, --fail-fast, --no-fail-fast, and --lease-wait require --pool.");
+  }
+  if (leaseWaitMs !== undefined && command !== "run") {
+    return failure4("CLI_USAGE", "--lease-wait only applies to local run pools.", "--lease-wait");
+  }
   if (runTimeoutMs !== undefined && command !== "run") {
-    return failure4("CLI_USAGE", "--run-timeout can only be used with run.", "--run-timeout");
+    if (command !== "test") {
+      return failure4("CLI_USAGE", "--run-timeout can only be used with run or a supported test workflow.", "--run-timeout");
+    }
+  }
+  if (command === "test" && testKind === undefined) {
+    return failure4("CLI_USAGE", "test requires a workflow: adb-ready test gradle [TASK] or adb-ready test firebase ACTION.");
+  }
+  if (testKind !== "gradle" && (gradlePath !== undefined || gradleShards !== undefined || gradleSoftwareRendering)) {
+    return failure4("CLI_USAGE", "--gradle, --shards, and --software-rendering can only be used with test gradle.");
+  }
+  const firebaseOptions = firebaseAction !== undefined || firebaseMatrixId !== undefined || firebaseDevices.length > 0 || gcloudPath !== undefined || cloudProject !== undefined || firebaseApp !== undefined || firebaseTest !== undefined || firebaseResultsBucket !== undefined || firebaseResultsDir !== undefined || firebaseTestTimeout !== undefined || firebaseAllowDeprecated || firebaseAllowReducedStability || firebaseAllowLowCapacity;
+  if (firebaseOptions && (command !== "test" || testKind !== "firebase")) {
+    return failure4("CLI_USAGE", "Firebase options can only be used with adb-ready test firebase.");
+  }
+  if (testKind === "firebase") {
+    if (firebaseAction === undefined) {
+      return failure4("CLI_USAGE", "test firebase requires devices, instrumentation, robo, or cancel.");
+    }
+    if (firebaseResultsDir !== undefined && firebaseResultsBucket === undefined) {
+      return failure4("CLI_USAGE", "--results-dir requires --results-bucket.");
+    }
+    if (firebaseAction === "instrumentation" && firebaseTest === undefined) {
+      return failure4("CLI_USAGE", "Firebase instrumentation requires --test-apk PATH.");
+    }
+    if ((firebaseAction === "instrumentation" || firebaseAction === "robo") && (firebaseApp === undefined || firebaseDevices.length === 0 && poolName === undefined)) {
+      return failure4("CLI_USAGE", `Firebase ${firebaseAction} requires --app PATH and at least one --test-device.`);
+    }
+    if (firebaseAction === "cancel" && (firebaseMatrixId === undefined || cloudProject === undefined)) {
+      return failure4("CLI_USAGE", "Firebase cancellation requires MATRIX_ID and --project PROJECT.");
+    }
+    if ((firebaseAction === "cancel" || firebaseAction === "devices") && (firebaseApp !== undefined || firebaseTest !== undefined || firebaseDevices.length > 0 || firebaseResultsBucket !== undefined || firebaseResultsDir !== undefined || firebaseTestTimeout !== undefined)) {
+      return failure4("CLI_USAGE", `Firebase ${firebaseAction} does not accept test artifacts, dimensions, or result storage options.`);
+    }
   }
   const autonomousRunOptions = avdName !== undefined || deployArtifact || runArtifactPaths.length > 0 || runVariant !== undefined || javaPath !== undefined || bundletoolPath !== undefined;
   if (autonomousRunOptions && command !== "run") {
@@ -57183,6 +59493,7 @@ function parseArguments(argv) {
     options: {
       command,
       ...helpTarget === undefined ? {} : { helpTarget },
+      ...completionShell === undefined ? {} : { completionShell },
       format,
       quiet,
       verbose,
@@ -57204,6 +59515,10 @@ function parseArguments(argv) {
       pairingCodeStdin,
       remembered,
       dryRun,
+      ...poolName === undefined ? {} : { poolName },
+      ...maxConcurrency === undefined ? {} : { maxConcurrency },
+      ...failFast === undefined ? {} : { failFast },
+      ...leaseWaitMs === undefined ? {} : { leaseWaitMs },
       allProjects,
       ...portDirection === undefined ? {} : { portDirection },
       ...portAction === undefined ? {} : { portAction },
@@ -57218,6 +59533,24 @@ function parseArguments(argv) {
       ...customCommand === undefined ? {} : { customCommand },
       ...runCommand === undefined ? {} : { runCommand },
       ...runTimeoutMs === undefined ? {} : { runTimeoutMs },
+      ...testKind === undefined ? {} : { testKind },
+      ...gradleTask === undefined ? {} : { gradleTask },
+      ...gradlePath === undefined ? {} : { gradlePath },
+      ...gradleShards === undefined ? {} : { gradleShards },
+      ...gradleSoftwareRendering ? { gradleSoftwareRendering: true } : {},
+      ...firebaseAction === undefined ? {} : { firebaseAction },
+      ...firebaseMatrixId === undefined ? {} : { firebaseMatrixId },
+      ...firebaseDevices.length === 0 ? {} : { firebaseDevices },
+      ...gcloudPath === undefined ? {} : { gcloudPath },
+      ...cloudProject === undefined ? {} : { cloudProject },
+      ...firebaseApp === undefined ? {} : { firebaseApp },
+      ...firebaseTest === undefined ? {} : { firebaseTest },
+      ...firebaseResultsBucket === undefined ? {} : { firebaseResultsBucket },
+      ...firebaseResultsDir === undefined ? {} : { firebaseResultsDir },
+      ...firebaseTestTimeout === undefined ? {} : { firebaseTestTimeout },
+      ...firebaseAllowDeprecated ? { firebaseAllowDeprecated: true } : {},
+      ...firebaseAllowReducedStability ? { firebaseAllowReducedStability: true } : {},
+      ...firebaseAllowLowCapacity ? { firebaseAllowLowCapacity: true } : {},
       ...avdName === undefined ? {} : { avdName },
       ...deployArtifact ? { deployArtifact: true } : {},
       ...runArtifactPaths.length === 0 ? {} : { runArtifactPaths },
@@ -57289,6 +59622,7 @@ Commands:
   app ACTION [APP_ID]   Resolve, inspect, install, or control one app
   apps list             List packages on one Android target
   capture ACTION         Save a verified screenshot or bounded screen recording
+  completion SHELL       Generate completion for bash, zsh, fish, PowerShell, or Nushell
   config ACTION          Validate or explain resolved configuration
   connect [HOST:PORT]    Connect and verify a wireless Android target
   context [SESSION]      Export bounded AI-ready diagnostic context
@@ -57304,6 +59638,8 @@ Commands:
   pair [HOST:PORT]       Pair using Android's six-digit pairing code
   ports DIRECTION ACTION Manage verified TCP forward/reverse mappings
   sessions [ACTION]      Inspect saved development sessions
+  test gradle [TASK]     Discover or run a Gradle managed-device test
+  test firebase ACTION   Run or manage a Firebase Test Lab matrix
   ui ACTION              Perform a bounded, verified Android UI action
   problems [SESSION]     Show problems from a saved session
   help [COMMAND]         Show help
@@ -57393,6 +59729,12 @@ Writes verified binary evidence inside the current project. Existing files are
 never replaced unless --force is explicit. Recordings are bounded to 180s.
 Screenshot crops use source pixels. Dimension limits preserve aspect ratio and
 never upscale the image. The CLI keeps full resolution unless limits are set.
+`,
+  completion: `Usage: adb-ready completion bash|zsh|fish|powershell|nushell
+
+Prints a static completion script for both adb-ready and adbr. Generation is
+offline, deterministic, and never loads project configuration or contacts ADB.
+See docs/completions.md for one-time installation instructions.
 `,
   config: `Usage:
   adb-ready config validate [options]
@@ -57446,6 +59788,10 @@ waits for every readiness assertion, runs one bounded verification command,
 then cleans owned resources. The verification exit code is preserved.
 
 Run options:
+  --pool NAME             Fan out through one explicit project target pool
+  --max-concurrency N     Override the pool's bounded concurrency (1-32)
+  --[no-]fail-fast        Override whether a required failure stops queued work
+  --lease-wait DURATION   Bound host-local target queueing (maximum: 1h)
   --avd NAME              Reuse or start this exact existing AVD
   --deploy                Discover and deploy one compatible Android artifact
   --artifact PATH         Deploy this project-local APK, APK Set, or AAB; repeat for splits
@@ -57462,6 +59808,8 @@ Verification processes also receive ANDROID_SERIAL, ADB_READY_TARGET_SERIAL, and
 ADB_READY_VERIFIER_OUTPUT_DIR. Direct Maestro test and Android CLI layout/screen-capture commands
 are pinned to the selected target and their native reports are retained automatically.
 AVDs must already exist. ADB Ready never creates or upgrades an SDK or AVD implicitly.
+Pool members each retain an isolated session and result. Pool mode never changes the
+single-target invariant inside a run.
 `,
   doctor: `Usage: adb-ready doctor [options]
 
@@ -57611,6 +59959,50 @@ List filters:
   --since DURATION       Keep sessions updated in the final window
   --preset NAME          Keep sessions using one development preset
   --limit COUNT          Return at most 1-100 sessions
+`,
+  test: `Usage:
+  adb-ready test gradle
+  adb-ready test gradle TASK [options]
+  adb-ready test firebase devices [options]
+  adb-ready test firebase instrumentation [options]
+  adb-ready test firebase robo [options]
+  adb-ready test firebase cancel MATRIX_ID --project PROJECT [options]
+
+Discovers declared Gradle Managed Device tasks or hands one exact task to the
+project's checked-in Gradle Wrapper. Gradle owns provisioning, test execution,
+sharding, and teardown; ADB Ready never leases or controls its transient target.
+
+Gradle managed-device options:
+  --gradle PATH           Use an explicit Gradle Wrapper or executable
+  --shards COUNT          Request 1-256 uniform managed-device shards
+  --software-rendering    Request Gradle's SwiftShader server rendering mode
+  --run-timeout DURATION  Bound task execution (default: 15m)
+  --dry-run               Print the exact task plan without starting Gradle
+
+Native JUnit XML and HTML reports are retained with bounded Gradle output under
+.adb-ready/artifacts/. Product assertion failures, infrastructure failures,
+timeouts, cancellation, and missing tasks remain distinct structured outcomes.
+
+Firebase Test Lab options:
+  --pool NAME                Run one matrix per named Firebase dimension
+  --max-concurrency N        Bound simultaneously observed matrices (1-32)
+  --[no-]fail-fast           Stop submitting queued dimensions after a required failure
+  --project PROJECT          Use one explicit Google Cloud project
+  --gcloud PATH              Use an explicit gcloud executable
+  --app PATH                 App APK or supported app bundle
+  --test-apk PATH            Instrumentation test APK
+  --test-device DIMENSIONS   Exact model=ID,version=ID[,locale=..,orientation=..]
+  --test-timeout DURATION    Provider-side timeout for each execution
+  --run-timeout DURATION     Bound local observation (default: 30m)
+  --results-bucket GS_URI    Store provider artifacts in an owned GCS bucket
+  --results-dir PATH         Unique bucket-relative result directory
+  --allow-deprecated         Explicitly accept a deprecated catalog dimension
+  --allow-reduced-stability  Explicitly accept a reduced-stability dimension
+  --allow-low-capacity       Explicitly accept a low-capacity dimension
+
+Every run validates dimensions against the live catalog before upload. Stopping
+local observation leaves the remote matrix running; only the explicit cancel
+action cancels it.
 `,
   version: `Usage: adb-ready version
 
@@ -57619,6 +60011,92 @@ configuration or ADB. Human output and --version remain one bare version line;
 --format plain, --json, and --format ndjson use the global automation contract.
 `
 };
+
+class CapturedOutput {
+  isTTY = false;
+  columns = 120;
+  rows = 40;
+  #chunks = [];
+  write(value) {
+    this.#chunks.push(value);
+  }
+  text() {
+    return this.#chunks.join("");
+  }
+}
+function parsedResultEnvelope(value) {
+  try {
+    const parsed = JSON.parse(value.trim());
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+      return;
+    const result = parsed;
+    return result.schemaVersion === SCHEMA_VERSION && typeof result.command === "string" && typeof result.commandId === "string" && typeof result.ok === "boolean" && typeof result.startedAt === "string" && typeof result.finishedAt === "string" && typeof result.durationMs === "number" && Array.isArray(result.problems) ? result : undefined;
+  } catch {
+    return;
+  }
+}
+function targetPoolProblem(code, summary2, detail2, commandId = "target-pool", retryable = false) {
+  return {
+    code,
+    category: "automation.pool",
+    severity: "error",
+    summary: summary2,
+    detail: detail2,
+    retryable,
+    evidence: [],
+    actions: [],
+    correlation: { commandId }
+  };
+}
+function targetPoolProgress(options, io) {
+  if (options.format !== "human" || options.quiet)
+    return {};
+  return {
+    onMemberStart: (member) => io.error.write(`pool ${member.id}  running
+`),
+    onMemberFinish: (member) => io.error.write(`pool ${member.id}  ${member.status} · exit ${String(member.exitCode)}
+`)
+  };
+}
+async function runLocalTargetPool(argv, options, pool, io, dependencies, signal) {
+  return await runTargetPool({
+    name: options.poolName ?? "",
+    pool,
+    ...options.maxConcurrency === undefined ? {} : { maxConcurrency: options.maxConcurrency },
+    ...options.failFast === undefined ? {} : { failFast: options.failFast },
+    ...dependencies.clock === undefined ? {} : { clock: dependencies.clock },
+    ...dependencies.idFactory === undefined ? {} : { idFactory: dependencies.idFactory },
+    ...signal === undefined ? {} : { signal },
+    ...targetPoolProgress(options, io)
+  }, async (member, memberSignal) => {
+    if (member.kind === "firebase") {
+      throw new Error("Firebase dimensions cannot execute through a local run pool.");
+    }
+    const output = new CapturedOutput;
+    const error5 = new CapturedOutput;
+    const memberDependencies = {
+      ...dependencies,
+      targetLease: dependencies.targetLease === false ? false : {
+        ...dependencies.targetLease ?? {},
+        waitTimeoutMs: options.leaseWaitMs ?? pool.leaseWaitMs,
+        signal: memberSignal
+      },
+      writeRememberedTarget: async () => ({ ok: true, path: "target-pool" })
+    };
+    const exitCode2 = await runCli(targetPoolMemberArguments(argv, member), {
+      input: io.input,
+      output,
+      error: error5,
+      cwd: io.cwd,
+      env: io.env
+    }, memberDependencies, memberSignal);
+    const result = parsedResultEnvelope(output.text());
+    if (result === undefined) {
+      throw new Error(`Pool member ${member.id} did not return one JSON result envelope.`);
+    }
+    return { exitCode: exitCode2, result };
+  });
+}
 function requiresTargetLease(options) {
   if (options.dryRun)
     return false;
@@ -57694,7 +60172,7 @@ function capabilities(options, values2, io, target, fallbackFormat) {
 function failureResult(command, problems, dependencies) {
   const clock = dependencies.clock ?? (() => new Date);
   const now = clock();
-  const commandId = (dependencies.idFactory ?? randomUUID14)();
+  const commandId = (dependencies.idFactory ?? randomUUID17)();
   return {
     schemaVersion: SCHEMA_VERSION,
     command,
@@ -57704,9 +60182,9 @@ function failureResult(command, problems, dependencies) {
     finishedAt: now.toISOString(),
     durationMs: 0,
     data: null,
-    problems: problems.map((problem2) => ({
-      ...problem2,
-      correlation: { ...problem2.correlation, commandId }
+    problems: problems.map((problem4) => ({
+      ...problem4,
+      correlation: { ...problem4.correlation, commandId }
     }))
   };
 }
@@ -57880,6 +60358,8 @@ async function runInteractiveSession(io, dependencies, terminal2, signal) {
       pair: ["pair"],
       "run-help": ["help", "run"],
       sessions: ["sessions"],
+      "test-firebase": ["test", "firebase", "devices"],
+      "test-gradle": ["test", "gradle"],
       version: ["version"]
     };
     clearInteractiveScreen(io.error, terminal2);
@@ -57909,10 +60389,10 @@ async function selectDevice(execution2, io, terminal2, remembered, signal) {
   }
   const selectable = data.targets.filter((target) => target.transports.some(({ stable, state }) => stable && state === "device"));
   if (selectable.length === 0) {
-    const problem2 = inputProblem(ProblemCode.NoSelectableTarget, "No ready Android target can be selected.", "Connect or recover a target until ADB reports the device state.", execution2.result.commandId);
+    const problem4 = inputProblem(ProblemCode.NoSelectableTarget, "No ready Android target can be selected.", "Connect or recover a target until ADB reports the device state.", execution2.result.commandId);
     return {
       exitCode: 20 /* Target */,
-      result: { ...execution2.result, ok: false, problems: [...execution2.result.problems, problem2] }
+      result: { ...execution2.result, ok: false, problems: [...execution2.result.problems, problem4] }
     };
   }
   const selection2 = await selectOne({
@@ -58014,10 +60494,14 @@ async function runCliInternal(argv, io, dependencies = {}, signal) {
     });
     return 0 /* Success */;
   }
+  if (options.command === "completion") {
+    io.output.write(generateCompletion(options.completionShell ?? "bash"));
+    return 0 /* Success */;
+  }
   if (options.command === "mcp") {
     const explicitRoot = io.env.ADB_READY_MCP_PROJECT_ROOT?.trim();
     await runMcpStdio({
-      cwd: explicitRoot === undefined || explicitRoot === "" ? io.cwd : path24.resolve(explicitRoot),
+      cwd: explicitRoot === undefined || explicitRoot === "" ? io.cwd : path26.resolve(explicitRoot),
       env: io.env,
       dependencies,
       version: VERSION,
@@ -58060,6 +60544,119 @@ async function runCliInternal(argv, io, dependencies = {}, signal) {
     });
     return execution3.exitCode;
   }
+  if (options.command === "test") {
+    if (options.testKind === "firebase" && options.firebaseAction !== undefined) {
+      const firebaseAction = options.firebaseAction;
+      const executeFirebase = async (devices, memberSignal, resultsDirSuffix) => await runFirebaseTestLab({
+        cwd: io.cwd,
+        action: firebaseAction,
+        ...options.gcloudPath === undefined ? {} : { gcloudPath: options.gcloudPath },
+        ...options.cloudProject === undefined ? {} : { project: options.cloudProject },
+        ...options.firebaseApp === undefined ? {} : { app: options.firebaseApp },
+        ...options.firebaseTest === undefined ? {} : { test: options.firebaseTest },
+        ...devices === undefined ? {} : { devices },
+        ...options.firebaseMatrixId === undefined ? {} : { matrixId: options.firebaseMatrixId },
+        ...options.firebaseResultsBucket === undefined ? {} : { resultsBucket: options.firebaseResultsBucket },
+        ...options.firebaseResultsDir === undefined ? {} : {
+          resultsDir: resultsDirSuffix === undefined ? options.firebaseResultsDir : `${options.firebaseResultsDir}/${resultsDirSuffix}`
+        },
+        ...options.firebaseTestTimeout === undefined ? {} : { testTimeout: options.firebaseTestTimeout },
+        ...options.runTimeoutMs === undefined ? {} : { observationTimeoutMs: options.runTimeoutMs },
+        ...options.firebaseAllowDeprecated === true ? { allowDeprecated: true } : {},
+        ...options.firebaseAllowReducedStability === true ? { allowReducedStability: true } : {},
+        ...options.firebaseAllowLowCapacity === true ? { allowLowCapacity: true } : {},
+        ...options.dryRun ? { dryRun: true } : {}
+      }, {
+        ...dependencies.clock === undefined ? {} : { clock: dependencies.clock },
+        ...dependencies.idFactory === undefined ? {} : { idFactory: dependencies.idFactory },
+        ...dependencies.runner === undefined ? {} : { runner: dependencies.runner },
+        ...dependencies.firebaseFetch === undefined ? {} : { fetch: dependencies.firebaseFetch }
+      }, memberSignal);
+      let execution4;
+      if (options.poolName === undefined) {
+        execution4 = await executeFirebase(options.firebaseDevices, signal);
+      } else {
+        const loadedPool = await (dependencies.loadConfig ?? loadConfig)({
+          cwd: io.cwd,
+          env: io.env,
+          ...options.configPath === undefined ? {} : { projectConfigPath: options.configPath },
+          explicitProjectConfig: options.configPath !== undefined,
+          ...options.profileName === undefined ? {} : { profileName: options.profileName },
+          cli: cliConfig(options)
+        });
+        if (!loadedPool.ok) {
+          const failed2 = failureResult("test firebase pool", configProblems(loadedPool.errors), dependencies);
+          renderFailure(failed2, options.format, io);
+          return 2 /* InvalidInput */;
+        }
+        const pool = loadedPool.config.values.targetPools?.[options.poolName];
+        if (pool === undefined) {
+          const failed2 = failureResult("test firebase pool", [
+            targetPoolProblem("TARGET_POOL_NOT_FOUND", `Target pool ${options.poolName} was not found.`, "Define the named pool under targets.pools in the project configuration.")
+          ], dependencies);
+          renderFailure(failed2, options.format, io);
+          return 2 /* InvalidInput */;
+        }
+        if (pool.members.some((member) => member.kind !== "firebase")) {
+          const failed2 = failureResult("test firebase pool", [
+            targetPoolProblem("TARGET_POOL_KIND_MISMATCH", `Target pool ${options.poolName} contains a non-Firebase member.`, "Firebase pool runs require every member to declare kind firebase.")
+          ], dependencies);
+          renderFailure(failed2, options.format, io);
+          return 2 /* InvalidInput */;
+        }
+        execution4 = await runTargetPool({
+          name: options.poolName,
+          command: "test firebase pool",
+          pool,
+          coordination: "provider-managed",
+          cancelRunningOnFailFast: false,
+          ...options.maxConcurrency === undefined ? {} : { maxConcurrency: options.maxConcurrency },
+          ...options.failFast === undefined ? {} : { failFast: options.failFast },
+          ...dependencies.clock === undefined ? {} : { clock: dependencies.clock },
+          ...dependencies.idFactory === undefined ? {} : { idFactory: dependencies.idFactory },
+          ...signal === undefined ? {} : { signal },
+          ...targetPoolProgress(options, io)
+        }, async (member, memberSignal) => {
+          const firebase = member;
+          return await executeFirebase([
+            {
+              model: firebase.model,
+              version: firebase.version,
+              locale: firebase.locale,
+              orientation: firebase.orientation
+            }
+          ], memberSignal, firebase.id);
+        });
+      }
+      renderResult(execution4.result, {
+        format: options.format,
+        capabilities: capabilities(options, cliConfig(options), io, "output", options.format),
+        sink: options.format === "human" ? io.error : io.output,
+        verbose: options.verbose
+      });
+      return execution4.exitCode;
+    }
+    const execution3 = await runGradleManagedTest({
+      cwd: io.cwd,
+      ...options.gradleTask === undefined ? {} : { task: options.gradleTask },
+      ...options.gradlePath === undefined ? {} : { gradlePath: options.gradlePath },
+      ...options.gradleShards === undefined ? {} : { shards: options.gradleShards },
+      ...options.gradleSoftwareRendering === true ? { softwareRendering: true } : {},
+      ...options.runTimeoutMs === undefined ? {} : { timeoutMs: options.runTimeoutMs },
+      ...options.dryRun ? { dryRun: true } : {}
+    }, {
+      ...dependencies.clock === undefined ? {} : { clock: dependencies.clock },
+      ...dependencies.idFactory === undefined ? {} : { idFactory: dependencies.idFactory },
+      ...dependencies.runner === undefined ? {} : { runner: dependencies.runner }
+    }, signal);
+    renderResult(execution3.result, {
+      format: options.format,
+      capabilities: capabilities(options, cliConfig(options), io, "output", options.format),
+      sink: options.format === "human" ? io.error : io.output,
+      verbose: options.verbose
+    });
+    return execution3.exitCode;
+  }
   if (options.command === "context" || options.command === "sessions" || options.command === "problems") {
     const storeOptions = dependencies.sessionStore === false ? { env: io.env, projectRoot: io.cwd, allProjects: options.allProjects } : {
       ...dependencies.sessionStore ?? { env: io.env },
@@ -58107,6 +60704,31 @@ async function runCliInternal(argv, io, dependencies = {}, signal) {
     return execution3.exitCode;
   }
   const values2 = loaded.config.values;
+  if (options.command === "run" && options.poolName !== undefined) {
+    const pool = values2.targetPools?.[options.poolName];
+    if (pool === undefined) {
+      const failed2 = failureResult("run pool", [
+        targetPoolProblem("TARGET_POOL_NOT_FOUND", `Target pool ${options.poolName} was not found.`, "Define the named pool under targets.pools in the project configuration.")
+      ], dependencies);
+      renderFailure(failed2, options.format, io);
+      return 2 /* InvalidInput */;
+    }
+    if (pool.members.some((member) => member.kind === "firebase")) {
+      const failed2 = failureResult("run pool", [
+        targetPoolProblem("TARGET_POOL_KIND_MISMATCH", `Target pool ${options.poolName} contains a Firebase member.`, "Local run pools accept adb, avd, and remote-adb members only. Use test firebase with a Firebase-only pool.")
+      ], dependencies);
+      renderFailure(failed2, options.format, io);
+      return 2 /* InvalidInput */;
+    }
+    const execution3 = await runLocalTargetPool(argv, options, pool, io, dependencies, signal);
+    renderResult(execution3.result, {
+      format: options.format,
+      capabilities: capabilities(options, values2, io, "output", options.format),
+      sink: options.format === "human" ? io.error : io.output,
+      verbose: options.verbose
+    });
+    return execution3.exitCode;
+  }
   const errorCapabilities = capabilities(options, values2, io, "error", options.format);
   const outputCapabilities = capabilities(options, values2, io, "output", options.format);
   let lastTarget;
@@ -58118,7 +60740,7 @@ async function runCliInternal(argv, io, dependencies = {}, signal) {
       ...values2.adbPort === undefined ? {} : { adbPort: values2.adbPort }
     });
     if (!state.ok) {
-      const problem2 = {
+      const problem4 = {
         code: state.code,
         category: options.remembered ? "environment.state" : "state.persistence",
         severity: options.remembered ? "error" : "warning",
@@ -58130,11 +60752,11 @@ async function runCliInternal(argv, io, dependencies = {}, signal) {
         correlation: { commandId: "state" }
       };
       if (options.remembered) {
-        const failure5 = failureResult(options.command, [problem2], dependencies);
+        const failure5 = failureResult(options.command, [problem4], dependencies);
         renderFailure(failure5, options.format, io);
         return 10 /* Environment */;
       }
-      stateWarning = problem2;
+      stateWarning = problem4;
     }
     if (state.ok) {
       lastTarget = rememberedTarget(state.document, {
@@ -58162,10 +60784,11 @@ async function runCliInternal(argv, io, dependencies = {}, signal) {
   };
   let androidCapabilities;
   let preparedAvd;
+  let avdResourceLease;
   let autonomousEvidence;
   let autonomousAdb;
   const autonomousRun = options.command === "run" && (options.avdName !== undefined || options.deployArtifact === true);
-  const runPreparationCommandId = autonomousRun ? (dependencies.idFactory ?? randomUUID14)() : "run-preparation";
+  const runPreparationCommandId = autonomousRun ? (dependencies.idFactory ?? randomUUID17)() : "run-preparation";
   const finishAutonomousFailure = async (problems, requestedExitCode) => {
     let exitCode2 = requestedExitCode;
     if (preparedAvd !== undefined) {
@@ -58178,6 +60801,8 @@ async function runCliInternal(argv, io, dependencies = {}, signal) {
       }
       preparedAvd = undefined;
     }
+    await avdResourceLease?.release();
+    avdResourceLease = undefined;
     const failed2 = {
       result: { ...failureResult("run", problems, dependencies), data: null },
       exitCode: exitCode2
@@ -58226,6 +60851,19 @@ async function runCliInternal(argv, io, dependencies = {}, signal) {
     });
   }
   if (options.avdName !== undefined && !options.dryRun) {
+    if (dependencies.targetLease !== false) {
+      const acquired = await acquireTargetLease({
+        targetIdentity: `avd:${options.avdName}`,
+        projectRoot: io.cwd,
+        purpose: `run avd ${options.avdName}`
+      }, { env: io.env, ...dependencies.targetLease ?? {} });
+      if (!acquired.ok) {
+        return await finishAutonomousFailure([
+          targetPoolProblem(acquired.code, acquired.message, acquired.code === "TARGET_LEASE_CANCELLED" ? "The queued AVD was not started or changed." : "Wait for the owning workflow to finish or choose another AVD.", "target-pool", true)
+        ], acquired.code === "TARGET_LEASE_CANCELLED" ? 130 /* Interrupted */ : 20 /* Target */);
+      }
+      avdResourceLease = acquired.lease;
+    }
     const emulator = capability(androidCapabilities, "emulator");
     if (emulator.status !== "supported" || emulator.invocation === undefined) {
       return await finishAutonomousFailure([
@@ -58256,16 +60894,27 @@ async function runCliInternal(argv, io, dependencies = {}, signal) {
       return await finishAutonomousFailure([autonomousProblem(preparation.failure, "target.avd")], preparation.failure.code === "AVD_CANCELLED" ? 130 /* Interrupted */ : 20 /* Target */);
     }
     const avd = preparation.avd;
-    preparedAvd = avd;
+    const releaseAvd = avd.release.bind(avd);
+    preparedAvd = {
+      ...avd,
+      release: async (releaseSignal) => {
+        try {
+          return await releaseAvd(releaseSignal);
+        } finally {
+          await avdResourceLease?.release();
+          avdResourceLease = undefined;
+        }
+      }
+    };
     autonomousEvidence = {
       avd: {
-        name: avd.name,
-        serial: avd.serial,
-        ownership: avd.ownership,
-        readiness: avd.readiness
+        name: preparedAvd.name,
+        serial: preparedAvd.serial,
+        ownership: preparedAvd.ownership,
+        readiness: preparedAvd.readiness
       }
     };
-    config4.targetSelector = avd.serial;
+    config4.targetSelector = preparedAvd.serial;
     delete config4.targetTransportId;
     delete config4.rememberedSerial;
     delete config4.rememberedHardwareSerial;
@@ -58438,11 +61087,11 @@ async function runCliInternal(argv, io, dependencies = {}, signal) {
     if (!acquired.ok) {
       const failure5 = failureResult(options.command, [
         {
-          code: acquired.code === "TARGET_BUSY" ? ProblemCode.TargetBusy : ProblemCode.TargetLeaseUnavailable,
+          code: acquired.code === "TARGET_BUSY" ? ProblemCode.TargetBusy : acquired.code === "TARGET_LEASE_CANCELLED" ? ProblemCode.OperationInterrupted : ProblemCode.TargetLeaseUnavailable,
           category: "target.lease",
           severity: "error",
           summary: acquired.message,
-          detail: acquired.code === "TARGET_BUSY" ? "Wait for the owning workflow to finish, or select another Android target. Expired leases are recovered automatically." : "Check the per-user state directory permissions, then retry.",
+          detail: acquired.code === "TARGET_BUSY" ? "Wait for the owning workflow to finish, or select another Android target. Expired leases are recovered automatically." : acquired.code === "TARGET_LEASE_CANCELLED" ? "The queued target was not mutated. Re-run the pool when the target is available." : "Check the per-user state directory permissions, then retry.",
           retryable: true,
           evidence: acquired.owner === undefined ? [] : [
             { source: "target.lease", field: "purpose", value: acquired.owner.purpose },
@@ -58461,13 +61110,14 @@ async function runCliInternal(argv, io, dependencies = {}, signal) {
           correlation: { commandId: "target-lease", targetId: preparedSelection.target.id }
         }
       ], dependencies);
+      const leaseExitCode = acquired.code === "TARGET_LEASE_CANCELLED" ? 130 /* Interrupted */ : 20 /* Target */;
       if (autonomousRun) {
-        return await finishAutonomousFailure([...failure5.problems], 20 /* Target */);
+        return await finishAutonomousFailure([...failure5.problems], leaseExitCode);
       }
       await preparedAvd?.release(signal);
       preparedAvd = undefined;
       renderFailure(failure5, options.format, io);
-      return 20 /* Target */;
+      return leaseExitCode;
     }
     targetLease = acquired.lease;
   }
@@ -58939,7 +61589,7 @@ async function runCli(argv, io, dependencies = {}, signal) {
     return await runCliInternal(argv, io, dependencies, signal);
   } catch (caught) {
     const message = redactText(caught instanceof Error ? caught.message : String(caught)).value;
-    const problem2 = {
+    const problem4 = {
       code: "INTERNAL_ERROR",
       category: "internal.unexpected",
       severity: "error",
@@ -58950,7 +61600,7 @@ async function runCli(argv, io, dependencies = {}, signal) {
       actions: [],
       correlation: { commandId: "cli" }
     };
-    renderFailure(failureResult("cli", [problem2], dependencies), inferredFormat(argv), io);
+    renderFailure(failureResult("cli", [problem4], dependencies), inferredFormat(argv), io);
     return 70 /* Internal */;
   }
 }
@@ -58978,4 +61628,4 @@ try {
   process16.removeListener("SIGTERM", abort);
 }
 
-//# debugId=7127D338B7D94B7264756E2164756E21
+//# debugId=2AD0AEC355B9989464756E2164756E21