observatory: add Qualcomm ADB lens and --lens-recipe multi-select

Introduces AdbLens, a Qualcomm-specific Observatory lens that captures
SimpleADB activity (push/pull/execute) and surfaces it in the report:
- Run dashboard: Device Info (serial, host, soc, htp_arch, workspace,
  build_path) + compact Transfer Summary per push/pull group.
- Left-panel record per execute() call: full qnn_executor_runner
  command (copyable), PASS/FAIL badge, scrollable monospace log with
  error-line highlighting, logcat -d and dmesg panels (default ON for
  inference, configurable via adb.fetch_logcat / adb.fetch_dmesg).
- JS renderers inlined via Frontend.resources() - no template files.

Also renames --lens_recipe to --lens-recipe in both QNN and XNNPACK
Observatory CLIs and switches to multi-value (action='append' +
comma-separated support), enabling e.g. --lens-recipe adb accuracy.

Verified with 13 unit tests (mocked subprocess) and an end-to-end run
of swin_transformer on SM8850 device 5382e6d2.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: quic-boyuc

backends/qualcomm/debugger/README.md

@@ -96,13 +96,15 @@ A new, review-focused Observatory implementation is available under:
 
 `backends/qualcomm/debugger/observatory`
 
-Use the Observatory CLI to wrap any Qualcomm AOT export script. Use `--lens_recipe=accuracy`
-to enable accuracy lenses.
+Use the Observatory CLI to wrap any Qualcomm AOT export script. Pass
+one or more lens recipes via `--lens-recipe` (space-separated):
+`accuracy` enables per-stage / per-layer accuracy lenses; `adb`
+enables device info, transfer summary, and inference log capture.
 
 ```bash
 python -m executorch.backends.qualcomm.debugger.observatory \
     --output-html obs_report.html \
-    --lens_recipe=accuracy \
+    --lens-recipe accuracy \
     {original script and args}
 ```
 
@@ -111,7 +113,7 @@ For example:
 ```bash
 python -m executorch.backends.qualcomm.debugger.observatory \
     --output-html obs_report.html \
-    --lens_recipe=accuracy \
+    --lens-recipe accuracy --lens-recipe adb \
     examples/qualcomm/oss_scripts/mobilevit_v2.py \
     --backend htp --model SM8650 -d ./imagenet-mini-val/ -b build-android/ --compile_only
 ```

backends/qualcomm/debugger/observatory/README.md

@@ -13,15 +13,28 @@ python -m executorch.backends.qualcomm.debugger.observatory \
     [--output-html PATH] [--output-json PATH] SCRIPT [SCRIPT_ARGS...]
 ```
 
-### With accuracy debugging
+### With one or more lens recipes
+
+Repeat the flag or comma-separate the values:
 
 ```bash
 python -m executorch.backends.qualcomm.debugger.observatory \
-    --lens_recipe=accuracy \
+    --lens-recipe adb --lens-recipe accuracy \
     [--output-html PATH] [--output-json PATH] \
     SCRIPT [SCRIPT_ARGS...]
+
+python -m executorch.backends.qualcomm.debugger.observatory \
+    --lens-recipe adb,accuracy \
+    SCRIPT [SCRIPT_ARGS...]
 ```
 
+Available recipes:
+
+- `accuracy` — `AccuracyLens` + `PerLayerAccuracyLens` (per-stage and
+  per-layer accuracy on the graph).
+- `adb` — `AdbLens` (device info, transfer summary, inference command +
+  logs with logcat/dmesg). See the *ADB lens* section below.
+
 ### Visualize mode (JSON → HTML, no re-execution)
 
 ```bash
@@ -43,7 +56,7 @@ source $QNN_SDK_ROOT/bin/envsetup.sh
 python -m executorch.backends.qualcomm.debugger.observatory \
     --output-html /tmp/obs_vit/report.html \
     --output-json /tmp/obs_vit/report.json \
-    --lens_recipe=accuracy \
+    --lens-recipe accuracy \
     examples/qualcomm/scripts/torchvision_vit.py \
     -m SM8650 -b ./build-android \
     --dataset imagenet-mini-val/ \
@@ -56,7 +69,7 @@ python -m executorch.backends.qualcomm.debugger.observatory \
 ```bash
 python -m executorch.backends.qualcomm.debugger.observatory \
     --output-html /tmp/obs_roberta/report.html \
-    --lens_recipe=accuracy \
+    --lens-recipe accuracy \
     examples/qualcomm/oss_scripts/roberta.py \
     -m SM8650 -b ./build-android \
     -H mlgtw-linux -s <device_serial> \
@@ -97,7 +110,7 @@ Dataset: Wikipedia sentences (`wikisent2.txt`). Pass with `-d <path>`.
 Common flags: `-m <SOC_MODEL>` (e.g. `SM8650`), `-b <build_folder>`, `-H <host>`,
 `-s <device_serial>`, `-a <artifact_dir>`, `--compile_only`.
 
-## Accuracy lenses (`--lens_recipe=accuracy`)
+## Accuracy lenses (`--lens-recipe accuracy`)
 
 Registers `AccuracyLens` and `PerLayerAccuracyLens` (with QNN dataset patches) on top of the
 default `PipelineGraphCollectorLens`. These produce:
@@ -109,6 +122,44 @@ default `PipelineGraphCollectorLens`. These produce:
 QNN dataset patches (`lenses/qnn_dataset_patches.py`) wire the on-device inference output back
 into the accuracy lens so metrics reflect true QNN outputs, not emulated CPU results.
 
+## ADB lens (`--lens-recipe adb`)
+
+Captures the device-side life of a QNN run by patching `SimpleADB`:
+every `push`, `pull`, and the inference invocation is recorded with
+exit code, duration, and (for the inference) full stdout. The HTML
+report gains:
+
+- A **Device Info** dashboard block (serial, host, soc, htp arch,
+  workspace, build path).
+- A compact **Transfers** dashboard block (one row per push/pull
+  group) so 20+ file transfers do not crowd out the inference detail.
+- A left-panel **`adb.execute`** record per inference call, showing
+  the full `qnn_executor_runner ...` command with one-click copy, a
+  scrollable log with errors highlighted in red, and collapsible
+  `logcat -d` / `adb shell dmesg` panels fetched after the run.
+
+Config (override via `Observatory.enable_context(config={"adb": {...}})`):
+
+| Key | Default | Effect |
+|---|---|---|
+| `enabled` | `True` | Master switch. `False` disables patching. |
+| `forward_to_stdout` | `True` | Tee captured inference stdout to terminal. |
+| `max_stdout_bytes` | `4 * 1024 * 1024` | Cap on captured streams. |
+| `fetch_logcat` | `"auto"` | `"auto"`: only after `execute()`; `True`/`False` force. |
+| `fetch_dmesg` | `"auto"` | Same shape as `fetch_logcat`. |
+
+Example combining both recipes:
+
+```bash
+python -m executorch.backends.qualcomm.debugger.observatory \
+    --output-html /tmp/obs/report.html \
+    --lens-recipe accuracy --lens-recipe adb \
+    examples/qualcomm/oss_scripts/swin_transformer.py \
+    -m SM8850 -b ./build-android \
+    --dataset imagenet-mini-val/ \
+    -H weilhuan-linux -s <device_serial>
+```
+
 ## Two-step workflow
 
 Collect on-device in CI, visualize locally without re-running:

backends/qualcomm/debugger/observatory/cli.py

@@ -10,9 +10,11 @@
     python -m executorch.backends.qualcomm.debugger.observatory \\
         [--output-html PATH] [--output-json PATH] SCRIPT [SCRIPT_ARGS...]
 
-With accuracy debugging:
+With one or more lens recipes (repeat the flag or comma-separate):
     python -m executorch.backends.qualcomm.debugger.observatory \\
-        --lens_recipe=accuracy SCRIPT [SCRIPT_ARGS...]
+        --lens-recipe adb --lens-recipe accuracy SCRIPT [SCRIPT_ARGS...]
+    python -m executorch.backends.qualcomm.debugger.observatory \\
+        --lens-recipe adb,accuracy SCRIPT [SCRIPT_ARGS...]
 
 Visualize mode (JSON -> HTML):
     python -m executorch.backends.qualcomm.debugger.observatory visualize \\
@@ -24,6 +26,26 @@
 import sys
 
 
+_RECIPE_CHOICES = ["accuracy", "adb"]
+
+
+def _parse_recipe_values(values):
+    """Split repeated and comma-separated --lens-recipe values."""
+    recipes: set = set()
+    for v in values or []:
+        for token in str(v).split(","):
+            token = token.strip()
+            if not token:
+                continue
+            if token not in _RECIPE_CHOICES:
+                raise SystemExit(
+                    "argument --lens-recipe: invalid choice: "
+                    f"{token!r} (choose from {', '.join(repr(c) for c in _RECIPE_CHOICES)})"
+                )
+            recipes.add(token)
+    return recipes
+
+
 def main():
     from executorch.devtools.observatory.cli import (
         make_collect_parser,
@@ -42,12 +64,19 @@ def main():
         prog="python -m executorch.backends.qualcomm.debugger.observatory"
     )
     parser.add_argument(
-        "--lens_recipe",
-        choices=["accuracy"],
-        default=None,
-        help="Lens recipe to enable (e.g. accuracy)",
+        "--lens-recipe",
+        action="append",
+        default=[],
+        metavar="RECIPE",
+        help=(
+            "Lens recipe to enable. Repeat the flag or comma-separate to "
+            "enable multiple (e.g. '--lens-recipe adb --lens-recipe accuracy' "
+            "or '--lens-recipe adb,accuracy'). "
+            f"Choices: {', '.join(_RECIPE_CHOICES)}"
+        ),
     )
     args = parser.parse_args(sys.argv[1:])
+    recipes = _parse_recipe_values(args.lens_recipe)
 
     from executorch.devtools.observatory.observatory import Observatory
     from executorch.devtools.observatory.lenses.pipeline_graph_collector import (
@@ -59,7 +88,7 @@ def main():
     PipelineGraphCollectorLens.register_backend_patches(install_qnn_patches)
     Observatory.register_lens(PipelineGraphCollectorLens)
 
-    if args.lens_recipe == "accuracy":
+    if "accuracy" in recipes:
         from executorch.devtools.observatory.lenses.accuracy import AccuracyLens
         from .lenses.qnn_dataset_patches import install_qnn_dataset_patches
 
@@ -72,6 +101,13 @@ def main():
 
         Observatory.register_lens(PerLayerAccuracyLens)
 
+    if "adb" in recipes:
+        from .lenses.adb import AdbLens
+        from .lenses.adb_patches import install_adb_patches
+
+        AdbLens.register_adb_patches(install_adb_patches)
+        Observatory.register_lens(AdbLens)
+
     run_observatory(
         args.script, args.script_args, Observatory, args.output_html, args.output_json
     )