feat(comet): upgrade Comet to .NET 11 Preview 7

.github/skills/maui-devflow-debug/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: maui-devflow-debug
+description: >-
+  Run build, deploy, inspect, and fix loops for .NET MAUI apps that already have
+  MAUI DevFlow integrated. USE FOR: launching MAUI apps, selecting devices or
+  emulators, waiting for or recovering agent connections, broker/port/adb
+  connectivity issues, visual tree inspection, screenshots, UI interaction,
+  Blazor WebView CDP debugging, reading DevFlow logs, and iterative app
+  debugging. DO NOT USE FOR: first-time DevFlow package setup (use
+  maui-devflow-onboard), or generic desktop automation unrelated to MAUI. INVOKES:
+  maui devflow CLI, dotnet CLI, Android adb/android tools, and Apple simctl
+  tools.
+---
+
+# DevFlow Debug
+
+Use this skill for the active debugging loop after a MAUI app has DevFlow
+packages and `builder.AddMauiDevFlowAgent()` registered.
+
+## When to Use
+
+- Build and run a MAUI app on Android, iOS, Mac Catalyst, macOS, Windows, or GTK.
+- Choose or create a simulator/emulator for a project.
+- Wait for a DevFlow agent, inspect the visual tree, tap/fill UI, or capture screenshots.
+- Recover from DevFlow connection failures after the app is integrated, including broker, port, and Android adb forwarding issues.
+- Debug Blazor Hybrid content through DevFlow WebView/CDP commands.
+- Read app logs, network captures, preferences, device info, or recordings through DevFlow.
+- Iterate on an app bug with a build -> deploy -> inspect -> fix loop.
+
+## Route Elsewhere
+
+- If DevFlow packages or `MauiProgram.cs` registration are missing, use `maui-devflow-onboard`.
+- If the failure is a generic build or SDK issue with no DevFlow angle, use normal .NET/MAUI diagnostics.
+
+## Core Loop
+
+1. Confirm the app is already integrated:
+
+   ```bash
+   grep -rl "Microsoft.Maui.DevFlow" --include="*.csproj" .
+   ```
+
+   If no project has DevFlow package references, stop and switch to `maui-devflow-onboard`.
+
+2. Pick the target framework and launch target. Do not assume `net10.0`; inspect the project first.
+
+   ```bash
+   grep -i "TargetFramework" *.csproj Directory.Build.props 2>/dev/null
+   ```
+
+3. Start or select the device/emulator. For Android and iOS, avoid reusing a simulator/emulator that is already running another app under investigation.
+
+4. Launch the app and keep the launch process alive when required.
+
+   - iOS, Android, and Mac Catalyst `dotnet build -t:Run` usually block for the app lifetime.
+   - GTK `dotnet run` blocks for the app lifetime.
+   - macOS AppKit builds can exit after compiling; launch the `.app` separately.
+
+5. Wait for the DevFlow agent before inspecting UI:
+
+   ```bash
+   maui devflow wait
+   maui devflow ui tree --depth 3 --fields "id,type,text,automationId"
+   ```
+
+   If `wait`, `list`, or `ui tree` cannot connect after the app is running, load `references/connectivity.md` and recover the broker/agent connection before continuing.
+
+6. Inspect, interact, capture evidence, then edit the app and repeat from launch.
+
+## Critical Anti-patterns
+
+- Do not treat an empty `maui devflow list` as proof the project is not integrated. `list` is runtime state; project files are source of truth.
+- Do not use arbitrary sleeps after launch. Use `maui devflow wait` to gate on the actual agent connection.
+- Do not kill an async `dotnet build -t:Run` or `dotnet run` shell while you still need the app; that often kills the app.
+- Do not reuse a busy simulator/emulator when multiple MAUI apps or agents may be running.
+- Do not debug Blazor WebView DOM issues through the native visual tree alone; use the WebView/CDP commands.
+
+## Stop Signals
+
+- Stop and switch to `maui-devflow-onboard` when package references or `AddMauiDevFlowAgent()` are absent.
+- Stop and ask which project, device, or agent to target when multiple candidates match.
+- Stop rebuilding after two identical failures until you inspect the first meaningful build/runtime error.
+- Stop using screenshots for exact property values; query the visual tree or properties instead.
+
+## Reference Map
+
+Load these only when needed:
+
+- `references/setup.md` - detailed integration, package, entitlement, and update notes.
+- `references/connectivity.md` - broker, agent, port, Android forwarding, and "no agents connected" recovery.
+- `references/android.md` - Android SDK, emulator, adb, build, deploy, and port forwarding details.
+- `references/ios-and-mac.md` - iOS simulator, Mac Catalyst, permissions, entitlements, and Apple tooling.
+- `references/macos.md` - macOS AppKit project shape, launch model, and troubleshooting.
+- `references/linux.md` - GTK/Linux launch, packages, and WebKitGTK notes.
+- `references/batch.md` - batching multiple DevFlow UI/WebView operations.
+- `references/troubleshooting.md` - build, connection, CDP, and platform-specific failure recovery.

.github/skills/maui-devflow-debug/references/android.md

@@ -0,0 +1,213 @@
+# Android Reference
+
+## Table of Contents
+- [Emulator Management](#emulator-management)
+- [Building and Deploying](#building-and-deploying)
+- [Android CLI Tool](#android-cli-tool)
+- [ADB Reference](#adb-reference)
+- [SDK Management](#sdk-management)
+- [Troubleshooting](#troubleshooting)
+
+## Emulator Management
+
+### Avoiding multi-project conflicts
+
+When multiple projects (or AI agents) may deploy to Android emulators simultaneously,
+each project should use its own dedicated AVD. Two apps deployed to the same emulator
+will coexist (unlike iOS), but `adb reverse`/`adb forward` port forwarding is per-device
+and can cause confusion when multiple emulators are running.
+
+**Before creating or starting an emulator, check what's already in use:**
+```bash
+maui devflow list                             # shows agents with platform + port
+adb devices                                   # shows connected emulators
+```
+
+If an emulator is already running another project's agent, create a new AVD:
+```bash
+android avd create --name "ProjectName-Pixel8" \
+  --sdk "system-images;android-35;google_apis;arm64-v8a" --device pixel_8
+android avd start --name "ProjectName-Pixel8"
+```
+
+**When multiple emulators are running**, use `-s <serial>` to target a specific one:
+```bash
+adb -s emulator-5554 reverse tcp:19223 tcp:19223   # first emulator
+adb -s emulator-5556 reverse tcp:19223 tcp:19223   # second emulator
+```
+
+**Naming convention:** Use `<ProjectName>-<DeviceType>` (e.g. `TodoApp-Pixel8`) so it's
+clear which AVD belongs to which project.
+
+### List and start AVDs
+```bash
+android avd list                              # list available AVDs
+android avd start --name <avd-name>           # start emulator
+```
+
+### Create AVD
+```bash
+# List available targets and device profiles
+android avd targets                           # system images
+android avd devices                           # device profiles (pixel, etc.)
+
+android avd create --name "Pixel8API35" \
+  --sdk "system-images;android-35;google_apis;arm64-v8a" \
+  --device pixel_8
+```
+
+### Delete AVD
+```bash
+android avd delete --name <avd-name>
+```
+
+### Verify emulator is running
+```bash
+adb devices                                   # should show "emulator-5554 device"
+android device list                           # formatted list
+```
+
+## Building and Deploying
+
+```bash
+# Build and deploy to running emulator
+dotnet build -f net10.0-android -t:Run
+
+# Build only (no deploy)
+dotnet build -f net10.0-android
+```
+
+**Critical: Port forwarding after deploy** — the Android emulator runs in its own network.
+Forward the broker port and the agent port:
+```bash
+adb reverse tcp:19223 tcp:19223              # Broker (lets agent register)
+adb forward tcp:<port> tcp:<port>            # Agent (lets CLI reach agent)
+```
+
+The broker reverse is needed so the agent inside the emulator can connect to the host's
+broker daemon. The agent forward uses the port shown in `maui devflow list` after the agent
+registers (range 10223–10899).
+
+If the broker isn't available (fallback mode), forward the port from `.mauidevflow` instead:
+```bash
+adb forward tcp:9223 tcp:9223                # Fallback: direct agent port
+```
+
+Then verify: `maui devflow ui status` and `maui devflow webview status`.
+
+### Install APK manually
+```bash
+adb install -r path/to/app.apk               # install/reinstall
+android device install --package path/to/app.apk
+```
+
+## Android CLI Tool
+
+The `android` command (from `androidsdk.tool` NuGet) wraps SDK tools.
+
+### SDK management
+```
+android sdk list                              # all packages
+android sdk list --installed                  # installed only
+android sdk list --available                  # available for install
+android sdk install --package "platforms;android-35"
+android sdk install --package "system-images;android-35;google_apis;arm64-v8a"
+android sdk install --package "emulator"
+android sdk uninstall --package <package-name>
+android sdk info                              # SDK location, tools versions
+android sdk accept-licenses                   # accept all SDK licenses
+android sdk download                          # download cmdline-tools
+```
+
+### AVD management
+```
+android avd list                              # available AVDs
+android avd targets                           # available system images
+android avd devices                           # available device profiles
+android avd create --name <name> --sdk <system-image> --device <device>
+android avd delete --name <name>
+android avd start --name <name>
+```
+
+### Device/emulator operations
+```
+android device list                           # connected devices/emulators
+android device info [--device <serial>]       # device properties
+android device install --package <apk>        # install APK
+android device uninstall --package <pkg-id>   # uninstall by package name
+```
+
+### JDK management
+```
+android jdk list                              # available JDKs
+android jdk info                              # current JDK info
+```
+
+## ADB Reference
+
+### Device/emulator basics
+```bash
+adb devices                                   # list connected devices
+adb -s <serial> shell                         # shell into specific device
+adb shell pm list packages | grep <name>      # find installed packages
+adb shell am start -n <pkg>/<activity>        # launch activity
+adb shell am force-stop <pkg>                 # kill app
+```
+
+### Port forwarding (critical for MAUI DevFlow)
+```bash
+adb reverse tcp:19223 tcp:19223              # Broker (agent → host)
+adb forward tcp:<port> tcp:<port>            # Agent (CLI → emulator, get port from `maui devflow list`)
+adb reverse --list                            # verify forwarding
+adb forward --list                            # verify forwarding
+adb reverse --remove-all                      # clean up reverse
+adb forward --remove-all                      # clean up forward
+```
+
+### File operations
+```bash
+adb push local/file /sdcard/path              # push file to device
+adb pull /sdcard/path local/file              # pull file from device
+```
+
+### Logs
+```bash
+adb logcat -s "DOTNET" --format brief         # .NET runtime logs
+adb logcat -s "MauiDevFlow"                   # agent logs
+adb logcat --pid=$(adb shell pidof <pkg>)     # app-specific logs
+adb logcat -c                                 # clear log buffer
+```
+
+### Screenshots and screen recording
+```bash
+adb shell screencap /sdcard/screen.png && adb pull /sdcard/screen.png
+adb shell screenrecord /sdcard/video.mp4      # Ctrl+C to stop
+```
+
+## SDK Management
+
+### Typical setup for MAUI Android development
+```bash
+android sdk accept-licenses
+android sdk install --package "platforms;android-35"
+android sdk install --package "build-tools;35.0.0"
+android sdk install --package "system-images;android-35;google_apis;arm64-v8a"
+android sdk install --package "emulator"
+android sdk install --package "platform-tools"
+```
+
+### Environment variables
+```bash
+export ANDROID_HOME=$HOME/Library/Android/sdk
+export ANDROID_SDK_ROOT=$ANDROID_HOME
+export PATH=$PATH:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator
+```
+
+## Troubleshooting
+
+- **`adb devices` shows "unauthorized"**: Accept the USB debugging prompt on the device/emulator.
+- **Agent not connecting on emulator**: Forgot `adb reverse tcp:19223 tcp:19223` for the broker. Run port forwarding, then check `maui devflow list`.
+- **Emulator won't start**: Check available system images with `android avd targets`. May need
+  to install with `android sdk install --package "system-images;..."`.
+- **Build error "No Android devices found"**: Ensure emulator is booted (`adb devices`).
+- **Slow emulator**: Use hardware acceleration. Prefer `arm64-v8a` images on Apple Silicon Macs.

.github/skills/maui-devflow-debug/references/batch.md

@@ -0,0 +1,50 @@
+# Batch Command Reference
+
+Execute multiple MAUI/cdp commands in a single CLI invocation via stdin. Outputs JSONL
+responses (one JSON object per line) to stdout — ideal for AI agents and scripting.
+
+## Usage
+
+```bash
+# Pipe multiple commands (semicolons or newlines as separators)
+echo "MAUI fill textUsername user; MAUI fill textPassword pwd123; MAUI tap buttonLogin" | maui devflow batch
+
+# Multi-line input
+printf "MAUI status\nMAUI tree\nMAUI screenshot --output screen.png" | maui devflow batch
+
+# With options
+echo "MAUI status; MAUI tree" | maui devflow batch --delay 500 --continue-on-error --agent-port 10224
+
+# Human-readable output instead of JSONL
+echo "MAUI status; MAUI tree" | maui devflow batch --human
+```
+
+## Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `--delay <ms>` | 250 | Delay between commands (lets UI settle) |
+| `--continue-on-error` | false | Continue after a command fails (default: stop) |
+| `--human` | false | Human-readable output instead of JSONL |
+
+## JSONL Response Format
+
+One JSON object per command, streamed as each completes:
+```json
+{"command":"MAUI fill textUsername user","exit_code":0,"output":"Filled: textUsername"}
+{"command":"MAUI tap buttonLogin","exit_code":1,"output":"Error: Element not found: buttonLogin"}
+```
+
+## Interactive Streaming
+
+The batch command processes stdin line-by-line, so a caller can read each JSONL response
+before sending the next command. This enables reactive workflows where the AI agent inspects
+results and decides the next action.
+
+## Input Rules
+
+- Lines starting with `#` are comments (skipped)
+- Empty lines are skipped
+- Semicolons separate multiple commands on one line
+- Quoted strings are preserved: `MAUI fill myEntry "hello world"`
+- Only `MAUI` and `cdp` commands are allowed (broker/list/etc. are rejected)