adb-ready 0.6.0 → 0.7.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.7.0",
   description: "Agent-ready Android CLI for reliable ADB sessions, app automation, and verified evidence.",
   private: false,
   type: "module",
@@ -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)}
 `);
   }
 }
@@ -55933,6 +57755,7 @@ var COMMANDS = new Set([
   "problems",
   "run",
   "sessions",
+  "test",
   "ui",
   "version"
 ]);
@@ -56008,6 +57831,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"
 ]);
@@ -56079,6 +57908,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 +57926,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 = [];
@@ -56183,7 +58034,7 @@ function parseArguments(argv) {
       }
       if (command === "help" && COMMANDS.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 === "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;
         }
@@ -56196,6 +58047,24 @@ function parseArguments(argv) {
         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 +58242,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 +58590,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 +58785,9 @@ function parseArguments(argv) {
         "--adb-port",
         "--config",
         "--profile",
+        "--pool",
+        "--max-concurrency",
+        "--lease-wait",
         "--mcp-profile",
         "--device",
         "--serial",
@@ -56827,6 +58818,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 +58892,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) {
@@ -57122,8 +59123,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") {
@@ -57204,6 +59253,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 +59271,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 },
@@ -57304,6 +59375,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
@@ -57446,6 +59519,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 +59539,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 +59690,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 +59742,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 +59903,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 +59913,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 +60089,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 +60120,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({
@@ -58017,7 +60228,7 @@ async function runCliInternal(argv, io, dependencies = {}, signal) {
   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 +60271,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 +60431,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 +60467,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 +60479,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 +60511,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 +60528,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 +60578,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 +60621,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 +60814,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 +60837,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 +61316,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 +61327,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 +61355,4 @@ try {
   process16.removeListener("SIGTERM", abort);
 }
 
-//# debugId=7127D338B7D94B7264756E2164756E21
+//# debugId=8986C9014073E12364756E2164756E21