Merge branch 'master' into 129-hardware-support-agent

Use OBS instead of launchpad (#10375 )
Upgrade trunk (#10364 )
2026-10-04 03:18:10 +10:00 · 2026-05-03 06:15:23 -05:00 · 2026-05-02 09:25:24 -04:00 · 2026-05-02 07:23:49 -05:00 · 2026-05-01 18:25:08 -04:00 · 2026-05-01 10:55:32 -04:00
1111 changed files with 66700 additions and 8442 deletions
@@ -0,0 +1,49 @@
+# Claude Code slash commands for the mcp-server test suite
+
+Three AI-assisted workflows wrapping `mcp-server/run-tests.sh` and the meshtastic MCP tools. Each one has a twin in `.github/prompts/` for Copilot users.
+
+| Slash command         | What it does                                                              | Copilot equivalent                       |
+| --------------------- | ------------------------------------------------------------------------- | ---------------------------------------- |
+| `/test [args]`        | Runs the test suite (auto-detects hardware) and interprets failures       | `.github/prompts/mcp-test.prompt.md`     |
+| `/diagnose [role]`    | Read-only device health report via the meshtastic MCP tools               | `.github/prompts/mcp-diagnose.prompt.md` |
+| `/repro <test> [n=5]` | Re-runs one test N times, diffs firmware logs between passes and failures | `.github/prompts/mcp-repro.prompt.md`    |
+
+## Why two surfaces
+
+The Claude Code commands and Copilot prompts cover the same three workflows but each speaks its host's idiom:
+
+- **Claude Code** (`/test`) uses `$ARGUMENTS` for pass-through, has direct access to Bash + all MCP tools registered in the user's settings, and runs in the terminal context.
+- **Copilot** (`/mcp-test`) runs in VS Code's agent mode; it has terminal + MCP access too but typically asks the operator to confirm inputs interactively.
+
+A contributor using either IDE gets equivalent assistance. Keep the two in sync when behavior changes — the diff of intent should be minimal.
+
+## House rules
+
+- **No destructive writes without explicit operator approval.** Skills that could reflash, factory-reset, or reboot a device must describe the action and stop — the operator authorizes.
+- **Interpret failures, don't just echo them.** The skill body should pull firmware log lines from `mcp-server/tests/report.html` (the `Meshtastic debug` section, attached by `tests/conftest.py::pytest_runtest_makereport`) and classify the failure.
+- **Keep MCP tool calls sequential per port.** SerialInterface holds an exclusive port lock; two parallel tool calls on the same port deadlock.
+- **Never speculate about root cause.** If the evidence doesn't support a classification, say "unknown" and list what you'd need to disambiguate.
+
+## Adding a new command
+
+1. Write the Claude Code version at `.claude/commands/<name>.md` with YAML frontmatter:
+
+   ```yaml
+   ---
+   description: one-line purpose (used for auto-invocation by the model)
+   argument-hint: [optional-hint]
+   ---
+   ```
+
+2. Write the Copilot equivalent at `.github/prompts/mcp-<name>.prompt.md` with:
+
+   ```yaml
+   ---
+   mode: agent
+   description: ...
+   ---
+   ```
+
+3. Add the row to the table above. Cross-link in both bodies.
+
+4. Smoke-test on Claude Code first (`/<name>` should appear in autocomplete), then in VS Code Copilot (`/mcp-<name>` in Chat).
@@ -0,0 +1,62 @@
+---
+description: Produce a device health report using the meshtastic MCP tools (device_info, list_nodes, get_config, short serial log capture)
+argument-hint: [role=all|nrf52|esp32s3|<port>]
+---
+
+# `/diagnose` — device health report
+
+Call the meshtastic MCP tool bundle and format a structured health report for one or all detected devices. Zero guesswork for the operator.
+
+## What to do
+
+1. **Enumerate hardware.** Call `mcp__meshtastic__list_devices(include_unknown=True)`. For each entry where `likely_meshtastic=True`, capture `port`, `vid`, `pid`, `description`.
+
+2. **Filter by `$ARGUMENTS`**:
+   - No args, `all` → every likely-meshtastic device.
+   - `nrf52` → only devices with `vid == 0x239a`.
+   - `esp32s3` → only devices with `vid == 0x303a` or `vid == 0x10c4`.
+   - A `/dev/cu.*` path → only that one port.
+   - Anything else → treat as a substring match against the `port` string.
+
+3. **For each selected device, in sequence (NOT parallel — SerialInterface holds an exclusive port lock):**
+   - `mcp__meshtastic__device_info(port=<p>)` — captures `my_node_num`, `long_name`, `short_name`, `firmware_version`, `hw_model`, `region`, `num_nodes`, `primary_channel`.
+   - `mcp__meshtastic__list_nodes(port=<p>)` — count of peers, which ones have `publicKey` set, SNR/RSSI distribution.
+   - `mcp__meshtastic__get_config(section="lora", port=<p>)` — region, preset, channel_num, tx_power, hop_limit.
+   - Optionally, if the device seems unhappy (fails to connect, `num_nodes==1` when ≥2 are plugged in, missing firmware*version), open a short firmware log window: `mcp__meshtastic__serial_open(port=<p>, env=<inferred-env>)`, wait 3s, `serial_read(session_id=<s>, max_lines=100)`, `serial_close(session_id=<s>)`. The env should be inferred from the VID map in `mcp-server/run-tests.sh` (nrf52 → rak4631, esp32s3 → heltec-v3) unless `MESHTASTIC_MCP_ENV*<ROLE>` is set.
+
+4. **Hub health** (call once, not per-device): `mcp__meshtastic__uhubctl_list()` — enumerates every USB hub the host can see. Note which hubs advertise `ppps=true` and which hub hosts each Meshtastic device (cross-reference by VID). Flag it in the report if:
+   - No hub advertises PPPS → `tests/recovery/` can't run on this setup; hard-recovery via `uhubctl_cycle` isn't available.
+   - A Meshtastic device is on a non-PPPS hub → note it; operator may want to move the device to a PPPS hub to unlock auto-recovery.
+   - `uhubctl_list` raises `ConfigError: uhubctl not found` → just say `uhubctl not installed` in the report; don't treat as a fault.
+
+5. **Render per-device report** as:
+
+   ```text
+   [nrf52 @ /dev/cu.usbmodem1101]      fw=2.7.23.bce2825, hw=RAK4631
+     owner       : Meshtastic 40eb / 40eb
+     region/band : US, channel 88, LONG_FAST
+     tx_power    : 30 dBm, hop_limit=3
+     peers       : 1 (esp32s3 0x433c2428, pubkey ✓, SNR 6.0 / RSSI -24 dBm)
+     primary ch  : McpTest
+     hub         : 1-1.3 port 2 (PPPS, uhubctl-controllable)
+     firmware    : no panics in last 3s; NodeInfoModule emitted 2 broadcasts
+   ```
+
+   Keep it scannable. If a field is missing or abnormal (no pubkey for a known peer, region=UNSET, num_nodes inconsistent with the hub, device on non-PPPS hub), flag it inline with a short `⚠︎ <one-line reason>`.
+
+6. **Cross-device correlation** (only when >1 device is inspected):
+   - Do both sides see each other in `nodesByNum`? If one does and the other doesn't, that's asymmetric NodeInfo — flag it.
+   - Do the LoRa configs match? (region, channel_num, modem_preset should all agree; mismatch = no mesh)
+   - Do the primary channel NAMES match? Mismatch = different PSK = no decode.
+
+7. **Suggest next actions only for specific, recognisable failure modes**:
+   - Stale PKI pubkey one-way → "run `/test tests/mesh/test_direct_with_ack.py` — the retry + nodeinfo-ping heals this in the test path."
+   - Region mismatch → "re-bake one side via `./mcp-server/run-tests.sh --force-bake`."
+   - Device unreachable, reachable via DFU → `touch_1200bps(port=...)` + `pio_flash`. If not even DFU responds AND the device is on a PPPS hub, escalate to `uhubctl_cycle(role=..., confirm=True)`.
+   - CP2102-wedged-driver on macOS → see the note in `run-tests.sh`.
+
+## What NOT to do
+
+- No writes. No `set_config`, no `reboot`, no `factory_reset`. This is a read-only diagnostic skill — if the operator wants to change state, they'll ask explicitly.
+- No `flash` / `erase_and_flash`. Those are separate escalations.
+- No holding SerialInterface across tool calls — open, query, close; next device. The port lock is exclusive.
@@ -0,0 +1,66 @@
+---
+description: Re-run a specific test N times in isolation to triage flakes, diff firmware logs between passes and failures
+argument-hint: <test-node-id> [count=5]
+---
+
+# `/repro` — flakiness triage for one test
+
+Re-run a single pytest node ID N times in isolation, track pass rate, and surface what's _different_ in the firmware logs between the passing attempts and the failing ones. Turns "it's flaky, I guess" into "it fails when X, passes when Y."
+
+## What to do
+
+1. **Parse `$ARGUMENTS`**: first token is the pytest node id (e.g. `tests/mesh/test_direct_with_ack.py::test_direct_with_ack_roundtrip[nrf52->esp32s3]`); second token is an integer count (default `5`, cap at `20`). If the first token doesn't look like a test path (no `::` and no `tests/` prefix), treat the whole `$ARGUMENTS` as a `-k` filter instead.
+
+2. **Sanity-check the hub first** (so we're not measuring "nothing plugged in" N times): call `mcp__meshtastic__list_devices`. If the test name contains `nrf52` or `esp32s3` and the matching VID isn't present, stop and report — re-running won't help.
+
+3. **Loop N times**. For each iteration:
+
+   ```bash
+   ./mcp-server/run-tests.sh <test-id> --tb=short -p no:cacheprovider
+   ```
+
+   Capture: exit code, duration, and (on failure) the `Meshtastic debug` firmware log section from `mcp-server/tests/report.html`. `-p no:cacheprovider` suppresses pytest's `.pytest_cache` writes so iterations don't influence each other.
+
+4. **Track a small structured tally**:
+
+   ```text
+   attempt 1: PASS (42s)
+   attempt 2: FAIL (128s)  ← firmware log 200-line tail captured
+   attempt 3: PASS (39s)
+   attempt 4: FAIL (121s)
+   attempt 5: PASS (41s)
+   --------------------------------------
+   pass rate: 3/5 (60%)   |   mean duration: 74s
+   ```
+
+5. **On mixed outcomes**: diff the firmware log tails between a representative passing attempt and a representative failing attempt. Focus on:
+   - Error-level lines only present in failures (`PKI_UNKNOWN_PUBKEY`, `Alloc an err=`, `Skip send`, `No suitable channel`)
+   - Timing around the assertion event — did a broadcast go out, was there an ACK, did NAK fire?
+   - Device state fields that changed (nodesByNum entries, region/preset, channel_num)
+
+   Surface the top 3 differences as a "passes when / fails when" table. Don't dump full logs — pull specific lines with uptime timestamps.
+
+6. **Classify the flake** into one of:
+   - **LoRa airtime collision** → pass rate improves with fewer concurrent transmitters; propose a `time.sleep` gap or retry bump in the test body.
+   - **PKI key staleness** → fails on first attempt, passes after self-heal; existing retry loop in `test_direct_with_ack.py` handles this.
+   - **NodeInfo cooldown** → `Skip send NodeInfo since we sent it <600s ago` in fail-only logs; needs `broadcast_nodeinfo_ping()` warmup.
+   - **Hardware-specific** (one direction fails, other passes; one device's firmware is older; driver wedged) → specific recovery pointer. For a device that's wedged past `touch_1200bps`, the next escalation is `uhubctl_cycle(role=..., confirm=True)` to hard-power-cycle its hub port (requires `uhubctl` installed).
+   - **Device went dark mid-run** → fails from some attempt onward, never recovers, firmware log stops arriving. Almost always hardware: a Guru crash + frozen CDC. Hard-power-cycle via `uhubctl_cycle(role=..., confirm=True)` before the next iteration; if that also fails, escalate to replug.
+   - **Genuinely unknown** → say so; don't invent a root cause.
+
+7. **Report back** with:
+   - Pass rate and mean duration.
+   - Classification + evidence (the specific log lines that support it).
+   - A suggested next step (re-run with specific args, open `/diagnose`, edit a specific test file, nothing).
+
+## Examples
+
+- `/repro tests/mesh/test_direct_with_ack.py::test_direct_with_ack_roundtrip[esp32s3->nrf52] 10` — runs 10 times, diffs firmware logs.
+- `/repro broadcast_delivers` — no `::`, no `tests/`, so interpreted as `-k broadcast_delivers`; runs every matching test the default 5 times.
+- `/repro tests/telemetry/test_device_telemetry_broadcast.py 3` — shorter run for a slow test.
+
+## Constraints
+
+- Don't exceed `count=20` per invocation — airtime and USB wear add up. If the user asks for 50, negotiate down.
+- Don't rebuild firmware as part of triage; flakes that only reproduce under different firmware belong in a separate session.
+- If the FIRST attempt fails AND the rest all pass, that's a classic "state leak from a prior test" → say so and suggest running with `--force-bake` or starting from a clean state rather than chasing the first failure.
@@ -0,0 +1,47 @@
+---
+description: Run the mcp-server test suite (auto-detects devices) and interpret the results
+argument-hint: [pytest-args]
+---
+
+# `/test` — mcp-server test runner with interpretation
+
+Run `mcp-server/run-tests.sh` and make sense of the output so the operator doesn't have to.
+
+## What to do
+
+1. **Invoke the wrapper.** From the firmware repo root, run:
+
+   ```bash
+   ./mcp-server/run-tests.sh $ARGUMENTS
+   ```
+
+   The wrapper auto-detects connected Meshtastic devices, maps each to its PlatformIO env, exports the required `MESHTASTIC_MCP_ENV_*` env vars, and invokes pytest. If the user passed no arguments, the wrapper supplies a sensible default set (`tests/ --html=tests/report.html --self-contained-html --junitxml=tests/junit.xml -v --tb=short`). A `--report-log=tests/reportlog.jsonl` arg is always appended (unless the operator passed their own). `--assume-baked` is deliberately NOT in the defaults — `test_00_bake.py` has its own skip-if-already-baked check and runs the ~8 s verification by default. Operators can opt into the fast path with `--assume-baked`, or force a reflash with `--force-bake`.
+
+2. **Read the pre-flight header.** First ~6 lines print the detected hub (role → port → env). If that line reads `detected hub : (none)`, the wrapper will narrow to `tests/unit` only — say so explicitly in your summary so the operator knows hardware tiers were skipped.
+
+3. **On pass**: one-line summary of the form `N passed, M skipped in <duration>`. Don't enumerate the test names — the user can read those. Do mention any SKIPPED tests and name the cause:
+   - `"role not present on hub"` → device unplugged; operator knows to reconnect.
+   - `"firmware not baked with USERPREFS_UI_TEST_LOG"` → tests/ui skipped because the macro isn't in firmware yet; suggest `--force-bake`.
+   - `"uhubctl not installed"` → tests/recovery + peer-offline skipped; suggest `brew install uhubctl` / `apt install uhubctl`.
+   - `"no PPPS-capable hubs detected"` → tests/recovery skipped because the hub doesn't support per-port power; the tier will never run on that setup.
+   - `"opencv-python-headless is not installed"` → tests/ui auto-deselected by run-tests.sh; suggest `pip install -e 'mcp-server/.[ui]'`.
+
+4. **On failure**: for every FAILED test, open `mcp-server/tests/report.html` and extract the `Meshtastic debug` section for that test. pytest-html embeds the firmware log stream + device state dump there; the 200-line firmware log tail is usually enough to explain the failure. Summarise: which test, one-line assertion message, the firmware log lines that matter (things like `PKI_UNKNOWN_PUBKEY`, `Skip send NodeInfo`, `Error=`, `Guru Meditation`, `assertion failed`). For UI-tier failures also glance at `mcp-server/tests/ui_captures/<session>/<test>/transcript.md` — it records each step's frame + OCR.
+
+5. **Classify the failure** as one of:
+   - **Transient/flake**: LoRa collision, timing-sensitive assertion, first-attempt NAK + successful retry pattern. Propose `/repro <test_node_id>` to confirm.
+   - **Environmental**: device unreachable, port busy, CP2102 driver wedged. Suggest the specific recovery in escalation order: (a) replug USB, (b) `touch_1200bps(port=...)` + `pio_flash` for nRF52 DFU, (c) `uhubctl_cycle(role="nrf52", confirm=True)` when a device is fully wedged past DFU (needs `uhubctl` installed — `baked_single`'s auto-recovery hook does this once automatically). Also check `git status userPrefs.jsonc`.
+   - **Regression**: same assertion fails repeatedly, firmware log shows a new/unusual error. Surface the diff between expected and observed, identify the module likely responsible.
+
+6. **Never run destructive recovery automatically.** If a failure looks like it needs a reflash, factory*reset, `uhubctl_cycle`, or USB replug, \_describe what to do* — don't execute. The operator decides.
+
+## Arguments handling
+
+- No args → wrapper's defaults (full suite).
+- `$ARGUMENTS` passed verbatim to the wrapper, which passes them to pytest.
+- Common operator invocations: `/test tests/mesh`, `/test tests/mesh/test_direct_with_ack.py::test_direct_with_ack_roundtrip`, `/test --force-bake`, `/test -k telemetry`.
+
+## Side-effects to mention in summary
+
+- The session fixture snapshots `userPrefs.jsonc` at session start and restores at teardown (plus on `atexit`). After a clean run, `git status userPrefs.jsonc` should be empty. If the wrapper's pre-flight printed a warning about a stale sidecar, call that out — means a prior session crashed.
+- `mcp-server/tests/report.html` and `junit.xml` are regenerated on every run; the HTML is self-contained (shareable).
@@ -20,7 +20,7 @@ ENV PIP_ROOT_USER_ACTION=ignore
 RUN apt-get update && apt-get install --no-install-recommends -y \
        cmake git zip libgpiod-dev libbluetooth-dev libi2c-dev \
        libunistring-dev libmicrohttpd-dev libgnutls28-dev libgcrypt20-dev \
-        libusb-1.0-0-dev libssl-dev pkg-config && \
+        libusb-1.0-0-dev libssl-dev pkg-config libsqlite3-dev libsdl2-dev && \
    apt-get clean && rm -rf /var/lib/apt/lists/* && \
    pip install --no-cache-dir -U \
        platformio==6.1.16 \
@@ -0,0 +1 @@
+use nix
@@ -75,11 +75,11 @@ body:
  - type: checkboxes
    id: mui
    attributes:
-      label: Is this bug report about any UI component firmware like InkHUD or Meshtatic UI (MUI)?
+      label: Is this bug report about any UI (https://meshtastic.org/docs/configuration/device-uis/) component firmware?
      options:
-        - label: Meshtastic UI aka MUI colorTFT
-        - label: InkHUD ePaper
-        - label: OLED slide UI on any display
+        - label: Meshtastic UI aka MUI
+        - label: InkHUD
+        - label: BaseUI

  - type: input
    id: version
@@ -76,7 +76,7 @@ runs:
        done

    - name: PlatformIO ${{ inputs.arch }} download cache
-      uses: actions/cache@v4
+      uses: actions/cache@v5
      with:
        path: ~/.platformio/.cache
        key: pio-cache-${{ inputs.arch }}-${{ hashFiles('.github/actions/**', '**.ini') }}
@@ -100,7 +100,7 @@ runs:
      id: version

    - name: Store binaries as an artifact
-      uses: actions/upload-artifact@v5
+      uses: actions/upload-artifact@v7
      with:
        name: firmware-${{ inputs.arch }}-${{ inputs.board }}-${{ steps.version.outputs.long }}
        overwrite: true
@@ -8,8 +8,6 @@ runs:
      uses: actions/checkout@v6
      with:
        submodules: recursive
-        ref: ${{github.event.pull_request.head.ref}}
-        repository: ${{github.event.pull_request.head.repo.full_name}}

    - name: Install dependencies
      shell: bash
@@ -0,0 +1,29 @@
+# firmware Development Guidelines
+
+Auto-generated from all feature plans. Last updated: 2026-03-25
+
+## Active Technologies
+
+- Python 3.x for workflow tooling, Markdown for generated artifacts, existing C/C++/PlatformIO repository conventions for downstream scaffold targets + Python standard library for inventory/intake tooling, existing Spec Kit artifacts, repository-local Copilot prompt/agent files, PlatformIO environment metadata conventions already in `variants/**/platformio.ini` (129-hardware-support-agent)
+
+## Project Structure
+
+```text
+src/
+tests/
+```
+
+## Commands
+
+cd src [ONLY COMMANDS FOR ACTIVE TECHNOLOGIES][ONLY COMMANDS FOR ACTIVE TECHNOLOGIES] pytest [ONLY COMMANDS FOR ACTIVE TECHNOLOGIES][ONLY COMMANDS FOR ACTIVE TECHNOLOGIES] ruff check .
+
+## Code Style
+
+Python 3.x for workflow tooling, Markdown for generated artifacts, existing C/C++/PlatformIO repository conventions for downstream scaffold targets: Follow standard conventions
+
+## Recent Changes
+
+- 129-hardware-support-agent: Added Python 3.x for workflow tooling, Markdown for generated artifacts, existing C/C++/PlatformIO repository conventions for downstream scaffold targets + Python standard library for inventory/intake tooling, existing Spec Kit artifacts, repository-local Copilot prompt/agent files, PlatformIO environment metadata conventions already in `variants/**/platformio.ini`
+
+<!-- MANUAL ADDITIONS START -->
+<!-- MANUAL ADDITIONS END -->
@@ -0,0 +1,124 @@
+---
+description: Guide maintainers through Meshtastic hardware support context generation, board intake assessment, and optional scaffold generation.
+---
+
+# Hardware Support Workflow
+
+Use this workflow when a maintainer wants to add support for a new board variant in the Meshtastic firmware repository.
+
+## Goals
+
+- Reuse repository-backed hardware patterns before drafting new board files.
+- Keep all generated output scoped to the requested architecture and board.
+- Stop and surface evidence gaps instead of inventing pin mappings or metadata.
+
+## Required Inputs
+
+Collect or confirm these fields before scaffold generation:
+
+- PlatformIO environment name
+- hardware model identifier
+- display name
+- architecture
+
+Recommended additional inputs:
+
+- hardware model slug
+- actively supported flag
+- support level
+- source materials such as schematic, pinout, or datasheet links
+- board notes covering revision scope and known uncertainty
+
+## Workflow
+
+### 1. Refresh Repository Context
+
+Run from the repository root:
+
+```bash
+python3 bin/generate_hardware_support_context.py
+```
+
+Review [docs/hardware-support-context.md](../../docs/hardware-support-context.md) for architecture-specific examples, metadata keys, and inherited-default notes.
+
+### 2. Capture The Intake Request
+
+Create or update a JSON file matching the contract in [specs/129-hardware-support-agent/contracts/board-intake-contract.md](../../specs/129-hardware-support-agent/contracts/board-intake-contract.md).
+
+### 3. Assess Intake Readiness
+
+Run:
+
+```bash
+python3 bin/board_intake.py path/to/intake.json
+```
+
+What to look for:
+
+- expected artifacts
+- required metadata
+- matched repository patterns
+- evidence gaps
+- risk flags
+- next actions
+- scaffold readiness decision
+
+For CI-style gating, use:
+
+```bash
+python3 bin/board_intake.py path/to/intake.json --validate
+```
+
+If the assessment is not scaffold-ready, stop and resolve the blocking gaps before continuing.
+
+### 4. Generate Scaffold Output When Ready
+
+Only run this when the intake assessment reports `Scaffold ready: Yes`.
+
+```bash
+python3 bin/board_scaffold.py path/to/intake.json --output-dir generated/hardware-support
+```
+
+Expected outputs:
+
+- draft `variant.h`
+- draft `platformio.ini`
+- optional `variant.cpp` for ESP32-family targets
+
+Review all `// TODO: verify — ...` annotations before treating the scaffold as merge-ready.
+
+### 5. Compile-Gate The Target Environment (Required)
+
+The end stage must always validate that the target environment is at least compilable.
+
+Run:
+
+```bash
+pio run -e <environment_name>
+```
+
+Expected behavior:
+
+- If compile succeeds, include a "compile check passed" note in the review summary.
+- If compile fails, treat it as a blocking issue and report the exact failing error.
+- Do not mark the workflow complete while compile is failing.
+
+Common first-pass blocker for new scaffolds:
+
+- Missing or placeholder `board = ...` in `platformio.ini` causes `BoardConfig: Board is not defined`.
+
+## Guardrails
+
+- Do not change live firmware runtime code under `src/` as part of this workflow.
+- Do not modify existing board definitions under `variants/` automatically.
+- Do not guess unresolved radio, display, GPS, power, or input pin mappings.
+- Treat multi-revision or multi-option board notes as blocking until the revision scope is explicit.
+- Check inherited BSP defaults for `nrf52840`, `rp2040`, `stm32`, and `native` targets before declaring a missing define.
+
+## Validation Expectations
+
+- Run `trunk fmt --force` on touched Python workflow files.
+- Re-run `python3 bin/generate_hardware_support_context.py` after changes affecting context output.
+- Use fixture-driven smoke tests in `bin/fixtures/` for intake and scaffold workflows.
+- Run `pio run -e <environment_name>` as a required final compile gate for the generated board environment.
+- Report any skipped validation or remaining TODO annotations in the review notes.
@@ -0,0 +1,184 @@
+---
+description: Perform a non-destructive cross-artifact consistency and quality analysis across spec.md, plan.md, and tasks.md after task generation.
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Goal
+
+Identify inconsistencies, duplications, ambiguities, and underspecified items across the three core artifacts (`spec.md`, `plan.md`, `tasks.md`) before implementation. This command MUST run only after `/speckit.tasks` has successfully produced a complete `tasks.md`.
+
+## Operating Constraints
+
+**STRICTLY READ-ONLY**: Do **not** modify any files. Output a structured analysis report. Offer an optional remediation plan (user must explicitly approve before any follow-up editing commands would be invoked manually).
+
+**Constitution Authority**: The project constitution (`.specify/memory/constitution.md`) is **non-negotiable** within this analysis scope. Constitution conflicts are automatically CRITICAL and require adjustment of the spec, plan, or tasks—not dilution, reinterpretation, or silent ignoring of the principle. If a principle itself needs to change, that must occur in a separate, explicit constitution update outside `/speckit.analyze`.
+
+## Execution Steps
+
+### 1. Initialize Analysis Context
+
+Run `.specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks` once from repo root and parse JSON for FEATURE_DIR and AVAILABLE_DOCS. Derive absolute paths:
+
+- SPEC = FEATURE_DIR/spec.md
+- PLAN = FEATURE_DIR/plan.md
+- TASKS = FEATURE_DIR/tasks.md
+
+Abort with an error message if any required file is missing (instruct the user to run missing prerequisite command).
+For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").
+
+### 2. Load Artifacts (Progressive Disclosure)
+
+Load only the minimal necessary context from each artifact:
+
+**From spec.md:**
+
+- Overview/Context
+- Functional Requirements
+- Success Criteria (measurable outcomes — e.g., performance, security, availability, user success, business impact)
+- User Stories
+- Edge Cases (if present)
+
+**From plan.md:**
+
+- Architecture/stack choices
+- Data Model references
+- Phases
+- Technical constraints
+
+**From tasks.md:**
+
+- Task IDs
+- Descriptions
+- Phase grouping
+- Parallel markers [P]
+- Referenced file paths
+
+**From constitution:**
+
+- Load `.specify/memory/constitution.md` for principle validation
+
+### 3. Build Semantic Models
+
+Create internal representations (do not include raw artifacts in output):
+
+- **Requirements inventory**: For each Functional Requirement (FR-###) and Success Criterion (SC-###), record a stable key. Use the explicit FR-/SC- identifier as the primary key when present, and optionally also derive an imperative-phrase slug for readability (e.g., "User can upload file" → `user-can-upload-file`). Include only Success Criteria items that require buildable work (e.g., load-testing infrastructure, security audit tooling), and exclude post-launch outcome metrics and business KPIs (e.g., "Reduce support tickets by 50%").
+- **User story/action inventory**: Discrete user actions with acceptance criteria
+- **Task coverage mapping**: Map each task to one or more requirements or stories (inference by keyword / explicit reference patterns like IDs or key phrases)
+- **Constitution rule set**: Extract principle names and MUST/SHOULD normative statements
+
+### 4. Detection Passes (Token-Efficient Analysis)
+
+Focus on high-signal findings. Limit to 50 findings total; aggregate remainder in overflow summary.
+
+#### A. Duplication Detection
+
+- Identify near-duplicate requirements
+- Mark lower-quality phrasing for consolidation
+
+#### B. Ambiguity Detection
+
+- Flag vague adjectives (fast, scalable, secure, intuitive, robust) lacking measurable criteria
+- Flag unresolved placeholders (TODO, TKTK, ???, `<placeholder>`, etc.)
+
+#### C. Underspecification
+
+- Requirements with verbs but missing object or measurable outcome
+- User stories missing acceptance criteria alignment
+- Tasks referencing files or components not defined in spec/plan
+
+#### D. Constitution Alignment
+
+- Any requirement or plan element conflicting with a MUST principle
+- Missing mandated sections or quality gates from constitution
+
+#### E. Coverage Gaps
+
+- Requirements with zero associated tasks
+- Tasks with no mapped requirement/story
+- Success Criteria requiring buildable work (performance, security, availability) not reflected in tasks
+
+#### F. Inconsistency
+
+- Terminology drift (same concept named differently across files)
+- Data entities referenced in plan but absent in spec (or vice versa)
+- Task ordering contradictions (e.g., integration tasks before foundational setup tasks without dependency note)
+- Conflicting requirements (e.g., one requires Next.js while other specifies Vue)
+
+### 5. Severity Assignment
+
+Use this heuristic to prioritize findings:
+
+- **CRITICAL**: Violates constitution MUST, missing core spec artifact, or requirement with zero coverage that blocks baseline functionality
+- **HIGH**: Duplicate or conflicting requirement, ambiguous security/performance attribute, untestable acceptance criterion
+- **MEDIUM**: Terminology drift, missing non-functional task coverage, underspecified edge case
+- **LOW**: Style/wording improvements, minor redundancy not affecting execution order
+
+### 6. Produce Compact Analysis Report
+
+Output a Markdown report (no file writes) with the following structure:
+
+## Specification Analysis Report
+
+| ID  | Category    | Severity | Location(s)      | Summary                      | Recommendation                       |
+| --- | ----------- | -------- | ---------------- | ---------------------------- | ------------------------------------ |
+| A1  | Duplication | HIGH     | spec.md:L120-134 | Two similar requirements ... | Merge phrasing; keep clearer version |
+
+(Add one row per finding; generate stable IDs prefixed by category initial.)
+
+**Coverage Summary Table:**
+
+| Requirement Key | Has Task? | Task IDs | Notes |
+| --------------- | --------- | -------- | ----- |
+
+**Constitution Alignment Issues:** (if any)
+
+**Unmapped Tasks:** (if any)
+
+**Metrics:**
+
+- Total Requirements
+- Total Tasks
+- Coverage % (requirements with >=1 task)
+- Ambiguity Count
+- Duplication Count
+- Critical Issues Count
+
+### 7. Provide Next Actions
+
+At end of report, output a concise Next Actions block:
+
+- If CRITICAL issues exist: Recommend resolving before `/speckit.implement`
+- If only LOW/MEDIUM: User may proceed, but provide improvement suggestions
+- Provide explicit command suggestions: e.g., "Run /speckit.specify with refinement", "Run /speckit.plan to adjust architecture", "Manually edit tasks.md to add coverage for 'performance-metrics'"
+
+### 8. Offer Remediation
+
+Ask the user: "Would you like me to suggest concrete remediation edits for the top N issues?" (Do NOT apply them automatically.)
+
+## Operating Principles
+
+### Context Efficiency
+
+- **Minimal high-signal tokens**: Focus on actionable findings, not exhaustive documentation
+- **Progressive disclosure**: Load artifacts incrementally; don't dump all content into analysis
+- **Token-efficient output**: Limit findings table to 50 rows; summarize overflow
+- **Deterministic results**: Rerunning without changes should produce consistent IDs and counts
+
+### Analysis Guidelines
+
+- **NEVER modify files** (this is read-only analysis)
+- **NEVER hallucinate missing sections** (if absent, report them accurately)
+- **Prioritize constitution violations** (these are always CRITICAL)
+- **Use examples over exhaustive rules** (cite specific instances, not generic patterns)
+- **Report zero issues gracefully** (emit success report with coverage statistics)
+
+## Context
+
+$ARGUMENTS
@@ -0,0 +1,295 @@
+---
+description: Generate a custom checklist for the current feature based on user requirements.
+---
+
+## Checklist Purpose: "Unit Tests for English"
+
+**CRITICAL CONCEPT**: Checklists are **UNIT TESTS FOR REQUIREMENTS WRITING** - they validate the quality, clarity, and completeness of requirements in a given domain.
+
+**NOT for verification/testing**:
+
+- ❌ NOT "Verify the button clicks correctly"
+- ❌ NOT "Test error handling works"
+- ❌ NOT "Confirm the API returns 200"
+- ❌ NOT checking if code/implementation matches the spec
+
+**FOR requirements quality validation**:
+
+- ✅ "Are visual hierarchy requirements defined for all card types?" (completeness)
+- ✅ "Is 'prominent display' quantified with specific sizing/positioning?" (clarity)
+- ✅ "Are hover state requirements consistent across all interactive elements?" (consistency)
+- ✅ "Are accessibility requirements defined for keyboard navigation?" (coverage)
+- ✅ "Does the spec define what happens when logo image fails to load?" (edge cases)
+
+**Metaphor**: If your spec is code written in English, the checklist is its unit test suite. You're testing whether the requirements are well-written, complete, unambiguous, and ready for implementation - NOT whether the implementation works.
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Execution Steps
+
+1. **Setup**: Run `.specify/scripts/bash/check-prerequisites.sh --json` from repo root and parse JSON for FEATURE_DIR and AVAILABLE_DOCS list.
+   - All file paths must be absolute.
+   - For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").
+
+2. **Clarify intent (dynamic)**: Derive up to THREE initial contextual clarifying questions (no pre-baked catalog). They MUST:
+   - Be generated from the user's phrasing + extracted signals from spec/plan/tasks
+   - Only ask about information that materially changes checklist content
+   - Be skipped individually if already unambiguous in `$ARGUMENTS`
+   - Prefer precision over breadth
+
+   Generation algorithm:
+   1. Extract signals: feature domain keywords (e.g., auth, latency, UX, API), risk indicators ("critical", "must", "compliance"), stakeholder hints ("QA", "review", "security team"), and explicit deliverables ("a11y", "rollback", "contracts").
+   2. Cluster signals into candidate focus areas (max 4) ranked by relevance.
+   3. Identify probable audience & timing (author, reviewer, QA, release) if not explicit.
+   4. Detect missing dimensions: scope breadth, depth/rigor, risk emphasis, exclusion boundaries, measurable acceptance criteria.
+   5. Formulate questions chosen from these archetypes:
+      - Scope refinement (e.g., "Should this include integration touchpoints with X and Y or stay limited to local module correctness?")
+      - Risk prioritization (e.g., "Which of these potential risk areas should receive mandatory gating checks?")
+      - Depth calibration (e.g., "Is this a lightweight pre-commit sanity list or a formal release gate?")
+      - Audience framing (e.g., "Will this be used by the author only or peers during PR review?")
+      - Boundary exclusion (e.g., "Should we explicitly exclude performance tuning items this round?")
+      - Scenario class gap (e.g., "No recovery flows detected—are rollback / partial failure paths in scope?")
+
+   Question formatting rules:
+   - If presenting options, generate a compact table with columns: Option | Candidate | Why It Matters
+   - Limit to A–E options maximum; omit table if a free-form answer is clearer
+   - Never ask the user to restate what they already said
+   - Avoid speculative categories (no hallucination). If uncertain, ask explicitly: "Confirm whether X belongs in scope."
+
+   Defaults when interaction impossible:
+   - Depth: Standard
+   - Audience: Reviewer (PR) if code-related; Author otherwise
+   - Focus: Top 2 relevance clusters
+
+   Output the questions (label Q1/Q2/Q3). After answers: if ≥2 scenario classes (Alternate / Exception / Recovery / Non-Functional domain) remain unclear, you MAY ask up to TWO more targeted follow‑ups (Q4/Q5) with a one-line justification each (e.g., "Unresolved recovery path risk"). Do not exceed five total questions. Skip escalation if user explicitly declines more.
+
+3. **Understand user request**: Combine `$ARGUMENTS` + clarifying answers:
+   - Derive checklist theme (e.g., security, review, deploy, ux)
+   - Consolidate explicit must-have items mentioned by user
+   - Map focus selections to category scaffolding
+   - Infer any missing context from spec/plan/tasks (do NOT hallucinate)
+
+4. **Load feature context**: Read from FEATURE_DIR:
+   - spec.md: Feature requirements and scope
+   - plan.md (if exists): Technical details, dependencies
+   - tasks.md (if exists): Implementation tasks
+
+   **Context Loading Strategy**:
+   - Load only necessary portions relevant to active focus areas (avoid full-file dumping)
+   - Prefer summarizing long sections into concise scenario/requirement bullets
+   - Use progressive disclosure: add follow-on retrieval only if gaps detected
+   - If source docs are large, generate interim summary items instead of embedding raw text
+
+5. **Generate checklist** - Create "Unit Tests for Requirements":
+   - Create `FEATURE_DIR/checklists/` directory if it doesn't exist
+   - Generate unique checklist filename:
+     - Use short, descriptive name based on domain (e.g., `ux.md`, `api.md`, `security.md`)
+     - Format: `[domain].md`
+   - File handling behavior:
+     - If file does NOT exist: Create new file and number items starting from CHK001
+     - If file exists: Append new items to existing file, continuing from the last CHK ID (e.g., if last item is CHK015, start new items at CHK016)
+   - Never delete or replace existing checklist content - always preserve and append
+
+   **CORE PRINCIPLE - Test the Requirements, Not the Implementation**:
+   Every checklist item MUST evaluate the REQUIREMENTS THEMSELVES for:
+   - **Completeness**: Are all necessary requirements present?
+   - **Clarity**: Are requirements unambiguous and specific?
+   - **Consistency**: Do requirements align with each other?
+   - **Measurability**: Can requirements be objectively verified?
+   - **Coverage**: Are all scenarios/edge cases addressed?
+
+   **Category Structure** - Group items by requirement quality dimensions:
+   - **Requirement Completeness** (Are all necessary requirements documented?)
+   - **Requirement Clarity** (Are requirements specific and unambiguous?)
+   - **Requirement Consistency** (Do requirements align without conflicts?)
+   - **Acceptance Criteria Quality** (Are success criteria measurable?)
+   - **Scenario Coverage** (Are all flows/cases addressed?)
+   - **Edge Case Coverage** (Are boundary conditions defined?)
+   - **Non-Functional Requirements** (Performance, Security, Accessibility, etc. - are they specified?)
+   - **Dependencies & Assumptions** (Are they documented and validated?)
+   - **Ambiguities & Conflicts** (What needs clarification?)
+
+   **HOW TO WRITE CHECKLIST ITEMS - "Unit Tests for English"**:
+
+   ❌ **WRONG** (Testing implementation):
+   - "Verify landing page displays 3 episode cards"
+   - "Test hover states work on desktop"
+   - "Confirm logo click navigates home"
+
+   ✅ **CORRECT** (Testing requirements quality):
+   - "Are the exact number and layout of featured episodes specified?" [Completeness]
+   - "Is 'prominent display' quantified with specific sizing/positioning?" [Clarity]
+   - "Are hover state requirements consistent across all interactive elements?" [Consistency]
+   - "Are keyboard navigation requirements defined for all interactive UI?" [Coverage]
+   - "Is the fallback behavior specified when logo image fails to load?" [Edge Cases]
+   - "Are loading states defined for asynchronous episode data?" [Completeness]
+   - "Does the spec define visual hierarchy for competing UI elements?" [Clarity]
+
+   **ITEM STRUCTURE**:
+   Each item should follow this pattern:
+   - Question format asking about requirement quality
+   - Focus on what's WRITTEN (or not written) in the spec/plan
+   - Include quality dimension in brackets [Completeness/Clarity/Consistency/etc.]
+   - Reference spec section `[Spec §X.Y]` when checking existing requirements
+   - Use `[Gap]` marker when checking for missing requirements
+
+   **EXAMPLES BY QUALITY DIMENSION**:
+
+   Completeness:
+   - "Are error handling requirements defined for all API failure modes? [Gap]"
+   - "Are accessibility requirements specified for all interactive elements? [Completeness]"
+   - "Are mobile breakpoint requirements defined for responsive layouts? [Gap]"
+
+   Clarity:
+   - "Is 'fast loading' quantified with specific timing thresholds? [Clarity, Spec §NFR-2]"
+   - "Are 'related episodes' selection criteria explicitly defined? [Clarity, Spec §FR-5]"
+   - "Is 'prominent' defined with measurable visual properties? [Ambiguity, Spec §FR-4]"
+
+   Consistency:
+   - "Do navigation requirements align across all pages? [Consistency, Spec §FR-10]"
+   - "Are card component requirements consistent between landing and detail pages? [Consistency]"
+
+   Coverage:
+   - "Are requirements defined for zero-state scenarios (no episodes)? [Coverage, Edge Case]"
+   - "Are concurrent user interaction scenarios addressed? [Coverage, Gap]"
+   - "Are requirements specified for partial data loading failures? [Coverage, Exception Flow]"
+
+   Measurability:
+   - "Are visual hierarchy requirements measurable/testable? [Acceptance Criteria, Spec §FR-1]"
+   - "Can 'balanced visual weight' be objectively verified? [Measurability, Spec §FR-2]"
+
+   **Scenario Classification & Coverage** (Requirements Quality Focus):
+   - Check if requirements exist for: Primary, Alternate, Exception/Error, Recovery, Non-Functional scenarios
+   - For each scenario class, ask: "Are [scenario type] requirements complete, clear, and consistent?"
+   - If scenario class missing: "Are [scenario type] requirements intentionally excluded or missing? [Gap]"
+   - Include resilience/rollback when state mutation occurs: "Are rollback requirements defined for migration failures? [Gap]"
+
+   **Traceability Requirements**:
+   - MINIMUM: ≥80% of items MUST include at least one traceability reference
+   - Each item should reference: spec section `[Spec §X.Y]`, or use markers: `[Gap]`, `[Ambiguity]`, `[Conflict]`, `[Assumption]`
+   - If no ID system exists: "Is a requirement & acceptance criteria ID scheme established? [Traceability]"
+
+   **Surface & Resolve Issues** (Requirements Quality Problems):
+   Ask questions about the requirements themselves:
+   - Ambiguities: "Is the term 'fast' quantified with specific metrics? [Ambiguity, Spec §NFR-1]"
+   - Conflicts: "Do navigation requirements conflict between §FR-10 and §FR-10a? [Conflict]"
+   - Assumptions: "Is the assumption of 'always available podcast API' validated? [Assumption]"
+   - Dependencies: "Are external podcast API requirements documented? [Dependency, Gap]"
+   - Missing definitions: "Is 'visual hierarchy' defined with measurable criteria? [Gap]"
+
+   **Content Consolidation**:
+   - Soft cap: If raw candidate items > 40, prioritize by risk/impact
+   - Merge near-duplicates checking the same requirement aspect
+   - If >5 low-impact edge cases, create one item: "Are edge cases X, Y, Z addressed in requirements? [Coverage]"
+
+   **🚫 ABSOLUTELY PROHIBITED** - These make it an implementation test, not a requirements test:
+   - ❌ Any item starting with "Verify", "Test", "Confirm", "Check" + implementation behavior
+   - ❌ References to code execution, user actions, system behavior
+   - ❌ "Displays correctly", "works properly", "functions as expected"
+   - ❌ "Click", "navigate", "render", "load", "execute"
+   - ❌ Test cases, test plans, QA procedures
+   - ❌ Implementation details (frameworks, APIs, algorithms)
+
+   **✅ REQUIRED PATTERNS** - These test requirements quality:
+   - ✅ "Are [requirement type] defined/specified/documented for [scenario]?"
+   - ✅ "Is [vague term] quantified/clarified with specific criteria?"
+   - ✅ "Are requirements consistent between [section A] and [section B]?"
+   - ✅ "Can [requirement] be objectively measured/verified?"
+   - ✅ "Are [edge cases/scenarios] addressed in requirements?"
+   - ✅ "Does the spec define [missing aspect]?"
+
+6. **Structure Reference**: Generate the checklist following the canonical template in `.specify/templates/checklist-template.md` for title, meta section, category headings, and ID formatting. If template is unavailable, use: H1 title, purpose/created meta lines, `##` category sections containing `- [ ] CHK### <requirement item>` lines with globally incrementing IDs starting at CHK001.
+
+7. **Report**: Output full path to checklist file, item count, and summarize whether the run created a new file or appended to an existing one. Summarize:
+   - Focus areas selected
+   - Depth level
+   - Actor/timing
+   - Any explicit user-specified must-have items incorporated
+
+**Important**: Each `/speckit.checklist` command invocation uses a short, descriptive checklist filename and either creates a new file or appends to an existing one. This allows:
+
+- Multiple checklists of different types (e.g., `ux.md`, `test.md`, `security.md`)
+- Simple, memorable filenames that indicate checklist purpose
+- Easy identification and navigation in the `checklists/` folder
+
+To avoid clutter, use descriptive types and clean up obsolete checklists when done.
+
+## Example Checklist Types & Sample Items
+
+**UX Requirements Quality:** `ux.md`
+
+Sample items (testing the requirements, NOT the implementation):
+
+- "Are visual hierarchy requirements defined with measurable criteria? [Clarity, Spec §FR-1]"
+- "Is the number and positioning of UI elements explicitly specified? [Completeness, Spec §FR-1]"
+- "Are interaction state requirements (hover, focus, active) consistently defined? [Consistency]"
+- "Are accessibility requirements specified for all interactive elements? [Coverage, Gap]"
+- "Is fallback behavior defined when images fail to load? [Edge Case, Gap]"
+- "Can 'prominent display' be objectively measured? [Measurability, Spec §FR-4]"
+
+**API Requirements Quality:** `api.md`
+
+Sample items:
+
+- "Are error response formats specified for all failure scenarios? [Completeness]"
+- "Are rate limiting requirements quantified with specific thresholds? [Clarity]"
+- "Are authentication requirements consistent across all endpoints? [Consistency]"
+- "Are retry/timeout requirements defined for external dependencies? [Coverage, Gap]"
+- "Is versioning strategy documented in requirements? [Gap]"
+
+**Performance Requirements Quality:** `performance.md`
+
+Sample items:
+
+- "Are performance requirements quantified with specific metrics? [Clarity]"
+- "Are performance targets defined for all critical user journeys? [Coverage]"
+- "Are performance requirements under different load conditions specified? [Completeness]"
+- "Can performance requirements be objectively measured? [Measurability]"
+- "Are degradation requirements defined for high-load scenarios? [Edge Case, Gap]"
+
+**Security Requirements Quality:** `security.md`
+
+Sample items:
+
+- "Are authentication requirements specified for all protected resources? [Coverage]"
+- "Are data protection requirements defined for sensitive information? [Completeness]"
+- "Is the threat model documented and requirements aligned to it? [Traceability]"
+- "Are security requirements consistent with compliance obligations? [Consistency]"
+- "Are security failure/breach response requirements defined? [Gap, Exception Flow]"
+
+## Anti-Examples: What NOT To Do
+
+**❌ WRONG - These test implementation, not requirements:**
+
+```markdown
+- [ ] CHK001 - Verify landing page displays 3 episode cards [Spec §FR-001]
+- [ ] CHK002 - Test hover states work correctly on desktop [Spec §FR-003]
+- [ ] CHK003 - Confirm logo click navigates to home page [Spec §FR-010]
+- [ ] CHK004 - Check that related episodes section shows 3-5 items [Spec §FR-005]
+```
+
+**✅ CORRECT - These test requirements quality:**
+
+```markdown
+- [ ] CHK001 - Are the number and layout of featured episodes explicitly specified? [Completeness, Spec §FR-001]
+- [ ] CHK002 - Are hover state requirements consistently defined for all interactive elements? [Consistency, Spec §FR-003]
+- [ ] CHK003 - Are navigation requirements clear for all clickable brand elements? [Clarity, Spec §FR-010]
+- [ ] CHK004 - Is the selection criteria for related episodes documented? [Gap, Spec §FR-005]
+- [ ] CHK005 - Are loading state requirements defined for asynchronous episode data? [Gap]
+- [ ] CHK006 - Can "visual hierarchy" requirements be objectively measured? [Measurability, Spec §FR-001]
+```
+
+**Key Differences:**
+
+- Wrong: Tests if the system works correctly
+- Correct: Tests if the requirements are written correctly
+- Wrong: Verification of behavior
+- Correct: Validation of requirement quality
+- Wrong: "Does it do X?"
+- Correct: "Is X clearly specified?"
@@ -0,0 +1,181 @@
+---
+description: Identify underspecified areas in the current feature spec by asking up to 5 highly targeted clarification questions and encoding answers back into the spec.
+handoffs:
+  - label: Build Technical Plan
+    agent: speckit.plan
+    prompt: Create a plan for the spec. I am building with...
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Outline
+
+Goal: Detect and reduce ambiguity or missing decision points in the active feature specification and record the clarifications directly in the spec file.
+
+Note: This clarification workflow is expected to run (and be completed) BEFORE invoking `/speckit.plan`. If the user explicitly states they are skipping clarification (e.g., exploratory spike), you may proceed, but must warn that downstream rework risk increases.
+
+Execution steps:
+
+1. Run `.specify/scripts/bash/check-prerequisites.sh --json --paths-only` from repo root **once** (combined `--json --paths-only` mode / `-Json -PathsOnly`). Parse minimal JSON payload fields:
+   - `FEATURE_DIR`
+   - `FEATURE_SPEC`
+   - (Optionally capture `IMPL_PLAN`, `TASKS` for future chained flows.)
+   - If JSON parsing fails, abort and instruct user to re-run `/speckit.specify` or verify feature branch environment.
+   - For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").
+
+2. Load the current spec file. Perform a structured ambiguity & coverage scan using this taxonomy. For each category, mark status: Clear / Partial / Missing. Produce an internal coverage map used for prioritization (do not output raw map unless no questions will be asked).
+
+   Functional Scope & Behavior:
+   - Core user goals & success criteria
+   - Explicit out-of-scope declarations
+   - User roles / personas differentiation
+
+   Domain & Data Model:
+   - Entities, attributes, relationships
+   - Identity & uniqueness rules
+   - Lifecycle/state transitions
+   - Data volume / scale assumptions
+
+   Interaction & UX Flow:
+   - Critical user journeys / sequences
+   - Error/empty/loading states
+   - Accessibility or localization notes
+
+   Non-Functional Quality Attributes:
+   - Performance (latency, throughput targets)
+   - Scalability (horizontal/vertical, limits)
+   - Reliability & availability (uptime, recovery expectations)
+   - Observability (logging, metrics, tracing signals)
+   - Security & privacy (authN/Z, data protection, threat assumptions)
+   - Compliance / regulatory constraints (if any)
+
+   Integration & External Dependencies:
+   - External services/APIs and failure modes
+   - Data import/export formats
+   - Protocol/versioning assumptions
+
+   Edge Cases & Failure Handling:
+   - Negative scenarios
+   - Rate limiting / throttling
+   - Conflict resolution (e.g., concurrent edits)
+
+   Constraints & Tradeoffs:
+   - Technical constraints (language, storage, hosting)
+   - Explicit tradeoffs or rejected alternatives
+
+   Terminology & Consistency:
+   - Canonical glossary terms
+   - Avoided synonyms / deprecated terms
+
+   Completion Signals:
+   - Acceptance criteria testability
+   - Measurable Definition of Done style indicators
+
+   Misc / Placeholders:
+   - TODO markers / unresolved decisions
+   - Ambiguous adjectives ("robust", "intuitive") lacking quantification
+
+   For each category with Partial or Missing status, add a candidate question opportunity unless:
+   - Clarification would not materially change implementation or validation strategy
+   - Information is better deferred to planning phase (note internally)
+
+3. Generate (internally) a prioritized queue of candidate clarification questions (maximum 5). Do NOT output them all at once. Apply these constraints:
+   - Maximum of 5 total questions across the whole session.
+   - Each question must be answerable with EITHER:
+     - A short multiple‑choice selection (2–5 distinct, mutually exclusive options), OR
+     - A one-word / short‑phrase answer (explicitly constrain: "Answer in <=5 words").
+   - Only include questions whose answers materially impact architecture, data modeling, task decomposition, test design, UX behavior, operational readiness, or compliance validation.
+   - Ensure category coverage balance: attempt to cover the highest impact unresolved categories first; avoid asking two low-impact questions when a single high-impact area (e.g., security posture) is unresolved.
+   - Exclude questions already answered, trivial stylistic preferences, or plan-level execution details (unless blocking correctness).
+   - Favor clarifications that reduce downstream rework risk or prevent misaligned acceptance tests.
+   - If more than 5 categories remain unresolved, select the top 5 by (Impact \* Uncertainty) heuristic.
+
+4. Sequential questioning loop (interactive):
+   - Present EXACTLY ONE question at a time.
+   - For multiple‑choice questions:
+     - **Analyze all options** and determine the **most suitable option** based on:
+       - Best practices for the project type
+       - Common patterns in similar implementations
+       - Risk reduction (security, performance, maintainability)
+       - Alignment with any explicit project goals or constraints visible in the spec
+     - Present your **recommended option prominently** at the top with clear reasoning (1-2 sentences explaining why this is the best choice).
+     - Format as: `**Recommended:** Option [X] - <reasoning>`
+     - Then render all options as a Markdown table:
+
+     | Option | Description                                                                                         |
+     | ------ | --------------------------------------------------------------------------------------------------- |
+     | A      | <Option A description>                                                                              |
+     | B      | <Option B description>                                                                              |
+     | C      | <Option C description> (add D/E as needed up to 5)                                                  |
+     | Short  | Provide a different short answer (<=5 words) (Include only if free-form alternative is appropriate) |
+     - After the table, add: `You can reply with the option letter (e.g., "A"), accept the recommendation by saying "yes" or "recommended", or provide your own short answer.`
+
+   - For short‑answer style (no meaningful discrete options):
+     - Provide your **suggested answer** based on best practices and context.
+     - Format as: `**Suggested:** <your proposed answer> - <brief reasoning>`
+     - Then output: `Format: Short answer (<=5 words). You can accept the suggestion by saying "yes" or "suggested", or provide your own answer.`
+   - After the user answers:
+     - If the user replies with "yes", "recommended", or "suggested", use your previously stated recommendation/suggestion as the answer.
+     - Otherwise, validate the answer maps to one option or fits the <=5 word constraint.
+     - If ambiguous, ask for a quick disambiguation (count still belongs to same question; do not advance).
+     - Once satisfactory, record it in working memory (do not yet write to disk) and move to the next queued question.
+   - Stop asking further questions when:
+     - All critical ambiguities resolved early (remaining queued items become unnecessary), OR
+     - User signals completion ("done", "good", "no more"), OR
+     - You reach 5 asked questions.
+   - Never reveal future queued questions in advance.
+   - If no valid questions exist at start, immediately report no critical ambiguities.
+
+5. Integration after EACH accepted answer (incremental update approach):
+   - Maintain in-memory representation of the spec (loaded once at start) plus the raw file contents.
+   - For the first integrated answer in this session:
+     - Ensure a `## Clarifications` section exists (create it just after the highest-level contextual/overview section per the spec template if missing).
+     - Under it, create (if not present) a `### Session YYYY-MM-DD` subheading for today.
+   - Append a bullet line immediately after acceptance: `- Q: <question> → A: <final answer>`.
+   - Then immediately apply the clarification to the most appropriate section(s):
+     - Functional ambiguity → Update or add a bullet in Functional Requirements.
+     - User interaction / actor distinction → Update User Stories or Actors subsection (if present) with clarified role, constraint, or scenario.
+     - Data shape / entities → Update Data Model (add fields, types, relationships) preserving ordering; note added constraints succinctly.
+     - Non-functional constraint → Add/modify measurable criteria in Success Criteria > Measurable Outcomes (convert vague adjective to metric or explicit target).
+     - Edge case / negative flow → Add a new bullet under Edge Cases / Error Handling (or create such subsection if template provides placeholder for it).
+     - Terminology conflict → Normalize term across spec; retain original only if necessary by adding `(formerly referred to as "X")` once.
+   - If the clarification invalidates an earlier ambiguous statement, replace that statement instead of duplicating; leave no obsolete contradictory text.
+   - Save the spec file AFTER each integration to minimize risk of context loss (atomic overwrite).
+   - Preserve formatting: do not reorder unrelated sections; keep heading hierarchy intact.
+   - Keep each inserted clarification minimal and testable (avoid narrative drift).
+
+6. Validation (performed after EACH write plus final pass):
+   - Clarifications session contains exactly one bullet per accepted answer (no duplicates).
+   - Total asked (accepted) questions ≤ 5.
+   - Updated sections contain no lingering vague placeholders the new answer was meant to resolve.
+   - No contradictory earlier statement remains (scan for now-invalid alternative choices removed).
+   - Markdown structure valid; only allowed new headings: `## Clarifications`, `### Session YYYY-MM-DD`.
+   - Terminology consistency: same canonical term used across all updated sections.
+
+7. Write the updated spec back to `FEATURE_SPEC`.
+
+8. Report completion (after questioning loop ends or early termination):
+   - Number of questions asked & answered.
+   - Path to updated spec.
+   - Sections touched (list names).
+   - Coverage summary table listing each taxonomy category with Status: Resolved (was Partial/Missing and addressed), Deferred (exceeds question quota or better suited for planning), Clear (already sufficient), Outstanding (still Partial/Missing but low impact).
+   - If any Outstanding or Deferred remain, recommend whether to proceed to `/speckit.plan` or run `/speckit.clarify` again later post-plan.
+   - Suggested next command.
+
+Behavior rules:
+
+- If no meaningful ambiguities found (or all potential questions would be low-impact), respond: "No critical ambiguities detected worth formal clarification." and suggest proceeding.
+- If spec file missing, instruct user to run `/speckit.specify` first (do not create a new spec here).
+- Never exceed 5 total asked questions (clarification retries for a single question do not count as new questions).
+- Avoid speculative tech stack questions unless the absence blocks functional clarity.
+- Respect user early termination signals ("stop", "done", "proceed").
+- If no questions asked due to full coverage, output a compact coverage summary (all categories Clear) then suggest advancing.
+- If quota reached with unresolved high-impact categories remaining, explicitly flag them under Deferred with rationale.
+
+Context for prioritization: $ARGUMENTS
@@ -0,0 +1,84 @@
+---
+description: Create or update the project constitution from interactive or provided principle inputs, ensuring all dependent templates stay in sync.
+handoffs:
+  - label: Build Specification
+    agent: speckit.specify
+    prompt: Implement the feature specification based on the updated constitution. I want to build...
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Outline
+
+You are updating the project constitution at `.specify/memory/constitution.md`. This file is a TEMPLATE containing placeholder tokens in square brackets (e.g. `[PROJECT_NAME]`, `[PRINCIPLE_1_NAME]`). Your job is to (a) collect/derive concrete values, (b) fill the template precisely, and (c) propagate any amendments across dependent artifacts.
+
+**Note**: If `.specify/memory/constitution.md` does not exist yet, it should have been initialized from `.specify/templates/constitution-template.md` during project setup. If it's missing, copy the template first.
+
+Follow this execution flow:
+
+1. Load the existing constitution at `.specify/memory/constitution.md`.
+   - Identify every placeholder token of the form `[ALL_CAPS_IDENTIFIER]`.
+     **IMPORTANT**: The user might require less or more principles than the ones used in the template. If a number is specified, respect that - follow the general template. You will update the doc accordingly.
+
+2. Collect/derive values for placeholders:
+   - If user input (conversation) supplies a value, use it.
+   - Otherwise infer from existing repo context (README, docs, prior constitution versions if embedded).
+   - For governance dates: `RATIFICATION_DATE` is the original adoption date (if unknown ask or mark TODO), `LAST_AMENDED_DATE` is today if changes are made, otherwise keep previous.
+   - `CONSTITUTION_VERSION` must increment according to semantic versioning rules:
+     - MAJOR: Backward incompatible governance/principle removals or redefinitions.
+     - MINOR: New principle/section added or materially expanded guidance.
+     - PATCH: Clarifications, wording, typo fixes, non-semantic refinements.
+   - If version bump type ambiguous, propose reasoning before finalizing.
+
+3. Draft the updated constitution content:
+   - Replace every placeholder with concrete text (no bracketed tokens left except intentionally retained template slots that the project has chosen not to define yet—explicitly justify any left).
+   - Preserve heading hierarchy and comments can be removed once replaced unless they still add clarifying guidance.
+   - Ensure each Principle section: succinct name line, paragraph (or bullet list) capturing non‑negotiable rules, explicit rationale if not obvious.
+   - Ensure Governance section lists amendment procedure, versioning policy, and compliance review expectations.
+
+4. Consistency propagation checklist (convert prior checklist into active validations):
+   - Read `.specify/templates/plan-template.md` and ensure any "Constitution Check" or rules align with updated principles.
+   - Read `.specify/templates/spec-template.md` for scope/requirements alignment—update if constitution adds/removes mandatory sections or constraints.
+   - Read `.specify/templates/tasks-template.md` and ensure task categorization reflects new or removed principle-driven task types (e.g., observability, versioning, testing discipline).
+   - Read each command file in `.specify/templates/commands/*.md` (including this one) to verify no outdated references (agent-specific names like CLAUDE only) remain when generic guidance is required.
+   - Read any runtime guidance docs (e.g., `README.md`, `docs/quickstart.md`, or agent-specific guidance files if present). Update references to principles changed.
+
+5. Produce a Sync Impact Report (prepend as an HTML comment at top of the constitution file after update):
+   - Version change: old → new
+   - List of modified principles (old title → new title if renamed)
+   - Added sections
+   - Removed sections
+   - Templates requiring updates (✅ updated / ⚠ pending) with file paths
+   - Follow-up TODOs if any placeholders intentionally deferred.
+
+6. Validation before final output:
+   - No remaining unexplained bracket tokens.
+   - Version line matches report.
+   - Dates ISO format YYYY-MM-DD.
+   - Principles are declarative, testable, and free of vague language ("should" → replace with MUST/SHOULD rationale where appropriate).
+
+7. Write the completed constitution back to `.specify/memory/constitution.md` (overwrite).
+
+8. Output a final summary to the user with:
+   - New version and bump rationale.
+   - Any files flagged for manual follow-up.
+   - Suggested commit message (e.g., `docs: amend constitution to vX.Y.Z (principle additions + governance update)`).
+
+Formatting & Style Requirements:
+
+- Use Markdown headings exactly as in the template (do not demote/promote levels).
+- Wrap long rationale lines to keep readability (<100 chars ideally) but do not hard enforce with awkward breaks.
+- Keep a single blank line between sections.
+- Avoid trailing whitespace.
+
+If the user supplies partial updates (e.g., only one principle revision), still perform validation and version decision steps.
+
+If critical info missing (e.g., ratification date truly unknown), insert `TODO(<FIELD_NAME>): explanation` and include in the Sync Impact Report under deferred items.
+
+Do not create a new template; always operate on the existing `.specify/memory/constitution.md` file.
@@ -0,0 +1,207 @@
+---
+description: Execute the implementation plan by processing and executing all tasks defined in tasks.md
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Pre-Execution Checks
+
+**Check for extension hooks (before implementation)**:
+
+- Check if `.specify/extensions.yml` exists in the project root.
+- If it exists, read it and look for entries under the `hooks.before_implement` key
+- If the YAML cannot be parsed or is invalid, skip hook checking silently and continue normally
+- Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
+- For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
+  - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
+  - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
+- For each executable hook, output the following based on its `optional` flag:
+  - **Optional hook** (`optional: true`):
+
+    ```
+    ## Extension Hooks
+
+    **Optional Pre-Hook**: {extension}
+    Command: `/{command}`
+    Description: {description}
+
+    Prompt: {prompt}
+    To execute: `/{command}`
+    ```
+
+  - **Mandatory hook** (`optional: false`):
+
+    ```
+    ## Extension Hooks
+
+    **Automatic Pre-Hook**: {extension}
+    Executing: `/{command}`
+    EXECUTE_COMMAND: {command}
+
+    Wait for the result of the hook command before proceeding to the Outline.
+    ```
+
+- If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently
+
+## Outline
+
+1. Run `.specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks` from repo root and parse FEATURE_DIR and AVAILABLE_DOCS list. All paths must be absolute. For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").
+
+2. **Check checklists status** (if FEATURE_DIR/checklists/ exists):
+   - Scan all checklist files in the checklists/ directory
+   - For each checklist, count:
+     - Total items: All lines matching `- [ ]` or `- [X]` or `- [x]`
+     - Completed items: Lines matching `- [X]` or `- [x]`
+     - Incomplete items: Lines matching `- [ ]`
+   - Create a status table:
+
+     ```text
+     | Checklist | Total | Completed | Incomplete | Status |
+     |-----------|-------|-----------|------------|--------|
+     | ux.md     | 12    | 12        | 0          | ✓ PASS |
+     | test.md   | 8     | 5         | 3          | ✗ FAIL |
+     | security.md | 6   | 6         | 0          | ✓ PASS |
+     ```
+
+   - Calculate overall status:
+     - **PASS**: All checklists have 0 incomplete items
+     - **FAIL**: One or more checklists have incomplete items
+
+   - **If any checklist is incomplete**:
+     - Display the table with incomplete item counts
+     - **STOP** and ask: "Some checklists are incomplete. Do you want to proceed with implementation anyway? (yes/no)"
+     - Wait for user response before continuing
+     - If user says "no" or "wait" or "stop", halt execution
+     - If user says "yes" or "proceed" or "continue", proceed to step 3
+
+   - **If all checklists are complete**:
+     - Display the table showing all checklists passed
+     - Automatically proceed to step 3
+
+3. Load and analyze the implementation context:
+   - **REQUIRED**: Read tasks.md for the complete task list and execution plan
+   - **REQUIRED**: Read plan.md for tech stack, architecture, and file structure
+   - **IF EXISTS**: Read data-model.md for entities and relationships
+   - **IF EXISTS**: Read contracts/ for API specifications and test requirements
+   - **IF EXISTS**: Read research.md for technical decisions and constraints
+   - **IF EXISTS**: Read quickstart.md for integration scenarios
+
+4. **Project Setup Verification**:
+   - **REQUIRED**: Create/verify ignore files based on actual project setup:
+
+   **Detection & Creation Logic**:
+   - Check if the following command succeeds to determine if the repository is a git repo (create/verify .gitignore if so):
+
+     ```sh
+     git rev-parse --git-dir 2>/dev/null
+     ```
+
+   - Check if Dockerfile\* exists or Docker in plan.md → create/verify .dockerignore
+   - Check if .eslintrc\* exists → create/verify .eslintignore
+   - Check if eslint.config.\* exists → ensure the config's `ignores` entries cover required patterns
+   - Check if .prettierrc\* exists → create/verify .prettierignore
+   - Check if .npmrc or package.json exists → create/verify .npmignore (if publishing)
+   - Check if terraform files (\*.tf) exist → create/verify .terraformignore
+   - Check if .helmignore needed (helm charts present) → create/verify .helmignore
+
+   **If ignore file already exists**: Verify it contains essential patterns, append missing critical patterns only
+   **If ignore file missing**: Create with full pattern set for detected technology
+
+   **Common Patterns by Technology** (from plan.md tech stack):
+   - **Node.js/JavaScript/TypeScript**: `node_modules/`, `dist/`, `build/`, `*.log`, `.env*`
+   - **Python**: `__pycache__/`, `*.pyc`, `.venv/`, `venv/`, `dist/`, `*.egg-info/`
+   - **Java**: `target/`, `*.class`, `*.jar`, `.gradle/`, `build/`
+   - **C#/.NET**: `bin/`, `obj/`, `*.user`, `*.suo`, `packages/`
+   - **Go**: `*.exe`, `*.test`, `vendor/`, `*.out`
+   - **Ruby**: `.bundle/`, `log/`, `tmp/`, `*.gem`, `vendor/bundle/`
+   - **PHP**: `vendor/`, `*.log`, `*.cache`, `*.env`
+   - **Rust**: `target/`, `debug/`, `release/`, `*.rs.bk`, `*.rlib`, `*.prof*`, `.idea/`, `*.log`, `.env*`
+   - **Kotlin**: `build/`, `out/`, `.gradle/`, `.idea/`, `*.class`, `*.jar`, `*.iml`, `*.log`, `.env*`
+   - **C++**: `build/`, `bin/`, `obj/`, `out/`, `*.o`, `*.so`, `*.a`, `*.exe`, `*.dll`, `.idea/`, `*.log`, `.env*`
+   - **C**: `build/`, `bin/`, `obj/`, `out/`, `*.o`, `*.a`, `*.so`, `*.exe`, `*.dll`, `autom4te.cache/`, `config.status`, `config.log`, `.idea/`, `*.log`, `.env*`
+   - **Swift**: `.build/`, `DerivedData/`, `*.swiftpm/`, `Packages/`
+   - **R**: `.Rproj.user/`, `.Rhistory`, `.RData`, `.Ruserdata`, `*.Rproj`, `packrat/`, `renv/`
+   - **Universal**: `.DS_Store`, `Thumbs.db`, `*.tmp`, `*.swp`, `.vscode/`, `.idea/`
+
+   **Tool-Specific Patterns**:
+   - **Docker**: `node_modules/`, `.git/`, `Dockerfile*`, `.dockerignore`, `*.log*`, `.env*`, `coverage/`
+   - **ESLint**: `node_modules/`, `dist/`, `build/`, `coverage/`, `*.min.js`
+   - **Prettier**: `node_modules/`, `dist/`, `build/`, `coverage/`, `package-lock.json`, `yarn.lock`, `pnpm-lock.yaml`
+   - **Terraform**: `.terraform/`, `*.tfstate*`, `*.tfvars`, `.terraform.lock.hcl`
+   - **Kubernetes/k8s**: `*.secret.yaml`, `secrets/`, `.kube/`, `kubeconfig*`, `*.key`, `*.crt`
+
+5. Parse tasks.md structure and extract:
+   - **Task phases**: Setup, Tests, Core, Integration, Polish
+   - **Task dependencies**: Sequential vs parallel execution rules
+   - **Task details**: ID, description, file paths, parallel markers [P]
+   - **Execution flow**: Order and dependency requirements
+
+6. Execute implementation following the task plan:
+   - **Phase-by-phase execution**: Complete each phase before moving to the next
+   - **Respect dependencies**: Run sequential tasks in order, parallel tasks [P] can run together
+   - **Follow TDD approach**: Execute test tasks before their corresponding implementation tasks
+   - **File-based coordination**: Tasks affecting the same files must run sequentially
+   - **Validation checkpoints**: Verify each phase completion before proceeding
+
+7. Implementation execution rules:
+   - **Setup first**: Initialize project structure, dependencies, configuration
+   - **Tests before code**: If you need to write tests for contracts, entities, and integration scenarios
+   - **Core development**: Implement models, services, CLI commands, endpoints
+   - **Integration work**: Database connections, middleware, logging, external services
+   - **Polish and validation**: Unit tests, performance optimization, documentation
+
+8. Progress tracking and error handling:
+   - Report progress after each completed task
+   - Halt execution if any non-parallel task fails
+   - For parallel tasks [P], continue with successful tasks, report failed ones
+   - Provide clear error messages with context for debugging
+   - Suggest next steps if implementation cannot proceed
+   - **IMPORTANT** For completed tasks, make sure to mark the task off as [X] in the tasks file.
+
+9. Completion validation:
+   - Verify all required tasks are completed
+   - Check that implemented features match the original specification
+   - Validate that tests pass and coverage meets requirements
+   - Confirm the implementation follows the technical plan
+   - Report final status with summary of completed work
+
+Note: This command assumes a complete task breakdown exists in tasks.md. If tasks are incomplete or missing, suggest running `/speckit.tasks` first to regenerate the task list.
+
+10. **Check for extension hooks**: After completion validation, check if `.specify/extensions.yml` exists in the project root.
+    - If it exists, read it and look for entries under the `hooks.after_implement` key
+    - If the YAML cannot be parsed or is invalid, skip hook checking silently and continue normally
+    - Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
+    - For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
+      - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
+      - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
+    - For each executable hook, output the following based on its `optional` flag:
+      - **Optional hook** (`optional: true`):
+
+        ```
+        ## Extension Hooks
+
+        **Optional Hook**: {extension}
+        Command: `/{command}`
+        Description: {description}
+
+        Prompt: {prompt}
+        To execute: `/{command}`
+        ```
+
+      - **Mandatory hook** (`optional: false`):
+
+        ```
+        ## Extension Hooks
+
+        **Automatic Hook**: {extension}
+        Executing: `/{command}`
+        EXECUTE_COMMAND: {command}
+        ```
+
+    - If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently
@@ -0,0 +1,162 @@
+---
+description: Execute the implementation planning workflow using the plan template to generate design artifacts.
+handoffs:
+  - label: Create Tasks
+    agent: speckit.tasks
+    prompt: Break the plan into tasks
+    send: true
+  - label: Create Checklist
+    agent: speckit.checklist
+    prompt: Create a checklist for the following domain...
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Pre-Execution Checks
+
+**Check for extension hooks (before planning)**:
+
+- Check if `.specify/extensions.yml` exists in the project root.
+- If it exists, read it and look for entries under the `hooks.before_plan` key
+- If the YAML cannot be parsed or is invalid, skip hook checking silently and continue normally
+- Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
+- For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
+  - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
+  - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
+- For each executable hook, output the following based on its `optional` flag:
+  - **Optional hook** (`optional: true`):
+
+    ```
+    ## Extension Hooks
+
+    **Optional Pre-Hook**: {extension}
+    Command: `/{command}`
+    Description: {description}
+
+    Prompt: {prompt}
+    To execute: `/{command}`
+    ```
+
+  - **Mandatory hook** (`optional: false`):
+
+    ```
+    ## Extension Hooks
+
+    **Automatic Pre-Hook**: {extension}
+    Executing: `/{command}`
+    EXECUTE_COMMAND: {command}
+
+    Wait for the result of the hook command before proceeding to the Outline.
+    ```
+
+- If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently
+
+## Outline
+
+1. **Setup**: Run `.specify/scripts/bash/setup-plan.sh --json` from repo root and parse JSON for FEATURE_SPEC, IMPL_PLAN, SPECS_DIR, BRANCH. For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").
+
+2. **Load context**: Read FEATURE_SPEC and `.specify/memory/constitution.md`. Load IMPL_PLAN template (already copied).
+
+3. **Execute plan workflow**: Follow the structure in IMPL_PLAN template to:
+   - Fill Technical Context (mark unknowns as "NEEDS CLARIFICATION")
+   - Fill Constitution Check section from constitution
+   - Evaluate gates (ERROR if violations unjustified)
+   - Phase 0: Generate research.md (resolve all NEEDS CLARIFICATION)
+   - Phase 1: Generate data-model.md, contracts/, quickstart.md
+   - Phase 1: Update agent context by running the agent script
+   - Re-evaluate Constitution Check post-design
+
+4. **Stop and report**: Command ends after Phase 2 planning. Report branch, IMPL_PLAN path, and generated artifacts.
+
+5. **Check for extension hooks**: After reporting, check if `.specify/extensions.yml` exists in the project root.
+   - If it exists, read it and look for entries under the `hooks.after_plan` key
+   - If the YAML cannot be parsed or is invalid, skip hook checking silently and continue normally
+   - Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
+   - For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
+     - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
+     - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
+   - For each executable hook, output the following based on its `optional` flag:
+     - **Optional hook** (`optional: true`):
+
+       ```
+       ## Extension Hooks
+
+       **Optional Hook**: {extension}
+       Command: `/{command}`
+       Description: {description}
+
+       Prompt: {prompt}
+       To execute: `/{command}`
+       ```
+
+     - **Mandatory hook** (`optional: false`):
+
+       ```
+       ## Extension Hooks
+
+       **Automatic Hook**: {extension}
+       Executing: `/{command}`
+       EXECUTE_COMMAND: {command}
+       ```
+
+   - If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently
+
+## Phases
+
+### Phase 0: Outline & Research
+
+1. **Extract unknowns from Technical Context** above:
+   - For each NEEDS CLARIFICATION → research task
+   - For each dependency → best practices task
+   - For each integration → patterns task
+
+2. **Generate and dispatch research agents**:
+
+   ```text
+   For each unknown in Technical Context:
+     Task: "Research {unknown} for {feature context}"
+   For each technology choice:
+     Task: "Find best practices for {tech} in {domain}"
+   ```
+
+3. **Consolidate findings** in `research.md` using format:
+   - Decision: [what was chosen]
+   - Rationale: [why chosen]
+   - Alternatives considered: [what else evaluated]
+
+**Output**: research.md with all NEEDS CLARIFICATION resolved
+
+### Phase 1: Design & Contracts
+
+**Prerequisites:** `research.md` complete
+
+1. **Extract entities from feature spec** → `data-model.md`:
+   - Entity name, fields, relationships
+   - Validation rules from requirements
+   - State transitions if applicable
+
+2. **Define interface contracts** (if project has external interfaces) → `/contracts/`:
+   - Identify what interfaces the project exposes to users or other systems
+   - Document the contract format appropriate for the project type
+   - Examples: public APIs for libraries, command schemas for CLI tools, endpoints for web services, grammars for parsers, UI contracts for applications
+   - Skip if project is purely internal (build scripts, one-off tools, etc.)
+
+3. **Agent context update**:
+   - Run `.specify/scripts/bash/update-agent-context.sh copilot`
+   - These scripts detect which AI agent is in use
+   - Update the appropriate agent-specific context file
+   - Add only new technology from current plan
+   - Preserve manual additions between markers
+
+**Output**: data-model.md, /contracts/\*, quickstart.md, agent-specific file
+
+## Key rules
+
+- Use absolute paths
+- ERROR on gate failures or unresolved clarifications
@@ -0,0 +1,313 @@
+---
+description: Create or update the feature specification from a natural language feature description.
+handoffs:
+  - label: Build Technical Plan
+    agent: speckit.plan
+    prompt: Create a plan for the spec. I am building with...
+  - label: Clarify Spec Requirements
+    agent: speckit.clarify
+    prompt: Clarify specification requirements
+    send: true
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Pre-Execution Checks
+
+**Check for extension hooks (before specification)**:
+
+- Check if `.specify/extensions.yml` exists in the project root.
+- If it exists, read it and look for entries under the `hooks.before_specify` key
+- If the YAML cannot be parsed or is invalid, skip hook checking silently and continue normally
+- Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
+- For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
+  - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
+  - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
+- For each executable hook, output the following based on its `optional` flag:
+  - **Optional hook** (`optional: true`):
+
+    ```
+    ## Extension Hooks
+
+    **Optional Pre-Hook**: {extension}
+    Command: `/{command}`
+    Description: {description}
+
+    Prompt: {prompt}
+    To execute: `/{command}`
+    ```
+
+  - **Mandatory hook** (`optional: false`):
+
+    ```
+    ## Extension Hooks
+
+    **Automatic Pre-Hook**: {extension}
+    Executing: `/{command}`
+    EXECUTE_COMMAND: {command}
+
+    Wait for the result of the hook command before proceeding to the Outline.
+    ```
+
+- If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently
+
+## Outline
+
+The text the user typed after `/speckit.specify` in the triggering message **is** the feature description. Assume you always have it available in this conversation even if `$ARGUMENTS` appears literally below. Do not ask the user to repeat it unless they provided an empty command.
+
+Given that feature description, do this:
+
+1. **Generate a concise short name** (2-4 words) for the branch:
+   - Analyze the feature description and extract the most meaningful keywords
+   - Create a 2-4 word short name that captures the essence of the feature
+   - Use action-noun format when possible (e.g., "add-user-auth", "fix-payment-bug")
+   - Preserve technical terms and acronyms (OAuth2, API, JWT, etc.)
+   - Keep it concise but descriptive enough to understand the feature at a glance
+   - Examples:
+     - "I want to add user authentication" → "user-auth"
+     - "Implement OAuth2 integration for the API" → "oauth2-api-integration"
+     - "Create a dashboard for analytics" → "analytics-dashboard"
+     - "Fix payment processing timeout bug" → "fix-payment-timeout"
+
+2. **Create the feature branch** by running the script with `--short-name` (and `--json`). In sequential mode, do NOT pass `--number` — the script auto-detects the next available number. In timestamp mode, the script generates a `YYYYMMDD-HHMMSS` prefix automatically:
+
+   **Branch numbering mode**: Before running the script, check if `.specify/init-options.json` exists and read the `branch_numbering` value.
+   - If `"timestamp"`, add `--timestamp` (Bash) or `-Timestamp` (PowerShell) to the script invocation
+   - If `"sequential"` or absent, do not add any extra flag (default behavior)
+
+   - Bash example: `.specify/scripts/bash/create-new-feature.sh "$ARGUMENTS" --json --short-name "user-auth" "Add user authentication"`
+   - Bash (timestamp): `.specify/scripts/bash/create-new-feature.sh "$ARGUMENTS" --json --timestamp --short-name "user-auth" "Add user authentication"`
+   - PowerShell example: `.specify/scripts/bash/create-new-feature.sh "$ARGUMENTS" -Json -ShortName "user-auth" "Add user authentication"`
+   - PowerShell (timestamp): `.specify/scripts/bash/create-new-feature.sh "$ARGUMENTS" -Json -Timestamp -ShortName "user-auth" "Add user authentication"`
+
+   **IMPORTANT**:
+   - Do NOT pass `--number` — the script determines the correct next number automatically
+   - Always include the JSON flag (`--json` for Bash, `-Json` for PowerShell) so the output can be parsed reliably
+   - You must only ever run this script once per feature
+   - The JSON is provided in the terminal as output - always refer to it to get the actual content you're looking for
+   - The JSON output will contain BRANCH_NAME and SPEC_FILE paths
+   - For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot")
+
+3. Load `.specify/templates/spec-template.md` to understand required sections.
+
+4. Follow this execution flow:
+   1. Parse user description from Input
+      If empty: ERROR "No feature description provided"
+   2. Extract key concepts from description
+      Identify: actors, actions, data, constraints
+   3. For unclear aspects:
+      - Make informed guesses based on context and industry standards
+      - Only mark with [NEEDS CLARIFICATION: specific question] if:
+        - The choice significantly impacts feature scope or user experience
+        - Multiple reasonable interpretations exist with different implications
+        - No reasonable default exists
+      - **LIMIT: Maximum 3 [NEEDS CLARIFICATION] markers total**
+      - Prioritize clarifications by impact: scope > security/privacy > user experience > technical details
+   4. Fill User Scenarios & Testing section
+      If no clear user flow: ERROR "Cannot determine user scenarios"
+   5. Generate Functional Requirements
+      Each requirement must be testable
+      Use reasonable defaults for unspecified details (document assumptions in Assumptions section)
+   6. Define Success Criteria
+      Create measurable, technology-agnostic outcomes
+      Include both quantitative metrics (time, performance, volume) and qualitative measures (user satisfaction, task completion)
+      Each criterion must be verifiable without implementation details
+   7. Identify Key Entities (if data involved)
+   8. Return: SUCCESS (spec ready for planning)
+
+5. Write the specification to SPEC_FILE using the template structure, replacing placeholders with concrete details derived from the feature description (arguments) while preserving section order and headings.
+
+6. **Specification Quality Validation**: After writing the initial spec, validate it against quality criteria:
+
+   a. **Create Spec Quality Checklist**: Generate a checklist file at `FEATURE_DIR/checklists/requirements.md` using the checklist template structure with these validation items:
+
+   ```markdown
+   # Specification Quality Checklist: [FEATURE NAME]
+
+   **Purpose**: Validate specification completeness and quality before proceeding to planning
+   **Created**: [DATE]
+   **Feature**: [Link to spec.md]
+
+   ## Content Quality
+
+   - [ ] No implementation details (languages, frameworks, APIs)
+   - [ ] Focused on user value and business needs
+   - [ ] Written for non-technical stakeholders
+   - [ ] All mandatory sections completed
+
+   ## Requirement Completeness
+
+   - [ ] No [NEEDS CLARIFICATION] markers remain
+   - [ ] Requirements are testable and unambiguous
+   - [ ] Success criteria are measurable
+   - [ ] Success criteria are technology-agnostic (no implementation details)
+   - [ ] All acceptance scenarios are defined
+   - [ ] Edge cases are identified
+   - [ ] Scope is clearly bounded
+   - [ ] Dependencies and assumptions identified
+
+   ## Feature Readiness
+
+   - [ ] All functional requirements have clear acceptance criteria
+   - [ ] User scenarios cover primary flows
+   - [ ] Feature meets measurable outcomes defined in Success Criteria
+   - [ ] No implementation details leak into specification
+
+   ## Notes
+
+   - Items marked incomplete require spec updates before `/speckit.clarify` or `/speckit.plan`
+   ```
+
+   b. **Run Validation Check**: Review the spec against each checklist item:
+   - For each item, determine if it passes or fails
+   - Document specific issues found (quote relevant spec sections)
+
+   c. **Handle Validation Results**:
+   - **If all items pass**: Mark checklist complete and proceed to step 7
+
+   - **If items fail (excluding [NEEDS CLARIFICATION])**:
+     1. List the failing items and specific issues
+     2. Update the spec to address each issue
+     3. Re-run validation until all items pass (max 3 iterations)
+     4. If still failing after 3 iterations, document remaining issues in checklist notes and warn user
+
+   - **If [NEEDS CLARIFICATION] markers remain**:
+     1. Extract all [NEEDS CLARIFICATION: ...] markers from the spec
+     2. **LIMIT CHECK**: If more than 3 markers exist, keep only the 3 most critical (by scope/security/UX impact) and make informed guesses for the rest
+     3. For each clarification needed (max 3), present options to user in this format:
+
+        ```markdown
+        ## Question [N]: [Topic]
+
+        **Context**: [Quote relevant spec section]
+
+        **What we need to know**: [Specific question from NEEDS CLARIFICATION marker]
+
+        **Suggested Answers**:
+
+        | Option | Answer                    | Implications                          |
+        | ------ | ------------------------- | ------------------------------------- |
+        | A      | [First suggested answer]  | [What this means for the feature]     |
+        | B      | [Second suggested answer] | [What this means for the feature]     |
+        | C      | [Third suggested answer]  | [What this means for the feature]     |
+        | Custom | Provide your own answer   | [Explain how to provide custom input] |
+
+        **Your choice**: _[Wait for user response]_
+        ```
+
+     4. **CRITICAL - Table Formatting**: Ensure markdown tables are properly formatted:
+        - Use consistent spacing with pipes aligned
+        - Each cell should have spaces around content: `| Content |` not `|Content|`
+        - Header separator must have at least 3 dashes: `|--------|`
+        - Test that the table renders correctly in markdown preview
+     5. Number questions sequentially (Q1, Q2, Q3 - max 3 total)
+     6. Present all questions together before waiting for responses
+     7. Wait for user to respond with their choices for all questions (e.g., "Q1: A, Q2: Custom - [details], Q3: B")
+     8. Update the spec by replacing each [NEEDS CLARIFICATION] marker with the user's selected or provided answer
+     9. Re-run validation after all clarifications are resolved
+
+   d. **Update Checklist**: After each validation iteration, update the checklist file with current pass/fail status
+
+7. Report completion with branch name, spec file path, checklist results, and readiness for the next phase (`/speckit.clarify` or `/speckit.plan`).
+
+8. **Check for extension hooks**: After reporting completion, check if `.specify/extensions.yml` exists in the project root.
+   - If it exists, read it and look for entries under the `hooks.after_specify` key
+   - If the YAML cannot be parsed or is invalid, skip hook checking silently and continue normally
+   - Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
+   - For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
+     - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
+     - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
+   - For each executable hook, output the following based on its `optional` flag:
+     - **Optional hook** (`optional: true`):
+
+       ```
+       ## Extension Hooks
+
+       **Optional Hook**: {extension}
+       Command: `/{command}`
+       Description: {description}
+
+       Prompt: {prompt}
+       To execute: `/{command}`
+       ```
+
+     - **Mandatory hook** (`optional: false`):
+
+       ```
+       ## Extension Hooks
+
+       **Automatic Hook**: {extension}
+       Executing: `/{command}`
+       EXECUTE_COMMAND: {command}
+       ```
+
+   - If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently
+
+**NOTE:** The script creates and checks out the new branch and initializes the spec file before writing.
+
+## Quick Guidelines
+
+- Focus on **WHAT** users need and **WHY**.
+- Avoid HOW to implement (no tech stack, APIs, code structure).
+- Written for business stakeholders, not developers.
+- DO NOT create any checklists that are embedded in the spec. That will be a separate command.
+
+### Section Requirements
+
+- **Mandatory sections**: Must be completed for every feature
+- **Optional sections**: Include only when relevant to the feature
+- When a section doesn't apply, remove it entirely (don't leave as "N/A")
+
+### For AI Generation
+
+When creating this spec from a user prompt:
+
+1. **Make informed guesses**: Use context, industry standards, and common patterns to fill gaps
+2. **Document assumptions**: Record reasonable defaults in the Assumptions section
+3. **Limit clarifications**: Maximum 3 [NEEDS CLARIFICATION] markers - use only for critical decisions that:
+   - Significantly impact feature scope or user experience
+   - Have multiple reasonable interpretations with different implications
+   - Lack any reasonable default
+4. **Prioritize clarifications**: scope > security/privacy > user experience > technical details
+5. **Think like a tester**: Every vague requirement should fail the "testable and unambiguous" checklist item
+6. **Common areas needing clarification** (only if no reasonable default exists):
+   - Feature scope and boundaries (include/exclude specific use cases)
+   - User types and permissions (if multiple conflicting interpretations possible)
+   - Security/compliance requirements (when legally/financially significant)
+
+**Examples of reasonable defaults** (don't ask about these):
+
+- Data retention: Industry-standard practices for the domain
+- Performance targets: Standard web/mobile app expectations unless specified
+- Error handling: User-friendly messages with appropriate fallbacks
+- Authentication method: Standard session-based or OAuth2 for web apps
+- Integration patterns: Use project-appropriate patterns (REST/GraphQL for web services, function calls for libraries, CLI args for tools, etc.)
+
+### Success Criteria Guidelines
+
+Success criteria must be:
+
+1. **Measurable**: Include specific metrics (time, percentage, count, rate)
+2. **Technology-agnostic**: No mention of frameworks, languages, databases, or tools
+3. **User-focused**: Describe outcomes from user/business perspective, not system internals
+4. **Verifiable**: Can be tested/validated without knowing implementation details
+
+**Good examples**:
+
+- "Users can complete checkout in under 3 minutes"
+- "System supports 10,000 concurrent users"
+- "95% of searches return results in under 1 second"
+- "Task completion rate improves by 40%"
+
+**Bad examples** (implementation-focused):
+
+- "API response time is under 200ms" (too technical, use "Users see results instantly")
+- "Database can handle 1000 TPS" (implementation detail, use user-facing metric)
+- "React components render efficiently" (framework-specific)
+- "Redis cache hit rate above 80%" (technology-specific)
@@ -0,0 +1,209 @@
+---
+description: Generate an actionable, dependency-ordered tasks.md for the feature based on available design artifacts.
+handoffs:
+  - label: Analyze For Consistency
+    agent: speckit.analyze
+    prompt: Run a project analysis for consistency
+    send: true
+  - label: Implement Project
+    agent: speckit.implement
+    prompt: Start the implementation in phases
+    send: true
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Pre-Execution Checks
+
+**Check for extension hooks (before tasks generation)**:
+
+- Check if `.specify/extensions.yml` exists in the project root.
+- If it exists, read it and look for entries under the `hooks.before_tasks` key
+- If the YAML cannot be parsed or is invalid, skip hook checking silently and continue normally
+- Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
+- For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
+  - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
+  - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
+- For each executable hook, output the following based on its `optional` flag:
+  - **Optional hook** (`optional: true`):
+
+    ```
+    ## Extension Hooks
+
+    **Optional Pre-Hook**: {extension}
+    Command: `/{command}`
+    Description: {description}
+
+    Prompt: {prompt}
+    To execute: `/{command}`
+    ```
+
+  - **Mandatory hook** (`optional: false`):
+
+    ```
+    ## Extension Hooks
+
+    **Automatic Pre-Hook**: {extension}
+    Executing: `/{command}`
+    EXECUTE_COMMAND: {command}
+
+    Wait for the result of the hook command before proceeding to the Outline.
+    ```
+
+- If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently
+
+## Outline
+
+1. **Setup**: Run `.specify/scripts/bash/check-prerequisites.sh --json` from repo root and parse FEATURE_DIR and AVAILABLE_DOCS list. All paths must be absolute. For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").
+
+2. **Load design documents**: Read from FEATURE_DIR:
+   - **Required**: plan.md (tech stack, libraries, structure), spec.md (user stories with priorities)
+   - **Optional**: data-model.md (entities), contracts/ (interface contracts), research.md (decisions), quickstart.md (test scenarios)
+   - Note: Not all projects have all documents. Generate tasks based on what's available.
+
+3. **Execute task generation workflow**:
+   - Load plan.md and extract tech stack, libraries, project structure
+   - Load spec.md and extract user stories with their priorities (P1, P2, P3, etc.)
+   - If data-model.md exists: Extract entities and map to user stories
+   - If contracts/ exists: Map interface contracts to user stories
+   - If research.md exists: Extract decisions for setup tasks
+   - Generate tasks organized by user story (see Task Generation Rules below)
+   - Generate dependency graph showing user story completion order
+   - Create parallel execution examples per user story
+   - Validate task completeness (each user story has all needed tasks, independently testable)
+
+4. **Generate tasks.md**: Use `.specify/templates/tasks-template.md` as structure, fill with:
+   - Correct feature name from plan.md
+   - Phase 1: Setup tasks (project initialization)
+   - Phase 2: Foundational tasks (blocking prerequisites for all user stories)
+   - Phase 3+: One phase per user story (in priority order from spec.md)
+   - Each phase includes: story goal, independent test criteria, tests (if requested), implementation tasks
+   - Final Phase: Polish & cross-cutting concerns
+   - All tasks must follow the strict checklist format (see Task Generation Rules below)
+   - Clear file paths for each task
+   - Dependencies section showing story completion order
+   - Parallel execution examples per story
+   - Implementation strategy section (MVP first, incremental delivery)
+
+5. **Report**: Output path to generated tasks.md and summary:
+   - Total task count
+   - Task count per user story
+   - Parallel opportunities identified
+   - Independent test criteria for each story
+   - Suggested MVP scope (typically just User Story 1)
+   - Format validation: Confirm ALL tasks follow the checklist format (checkbox, ID, labels, file paths)
+
+6. **Check for extension hooks**: After tasks.md is generated, check if `.specify/extensions.yml` exists in the project root.
+   - If it exists, read it and look for entries under the `hooks.after_tasks` key
+   - If the YAML cannot be parsed or is invalid, skip hook checking silently and continue normally
+   - Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
+   - For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
+     - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
+     - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
+   - For each executable hook, output the following based on its `optional` flag:
+     - **Optional hook** (`optional: true`):
+
+       ```
+       ## Extension Hooks
+
+       **Optional Hook**: {extension}
+       Command: `/{command}`
+       Description: {description}
+
+       Prompt: {prompt}
+       To execute: `/{command}`
+       ```
+
+     - **Mandatory hook** (`optional: false`):
+
+       ```
+       ## Extension Hooks
+
+       **Automatic Hook**: {extension}
+       Executing: `/{command}`
+       EXECUTE_COMMAND: {command}
+       ```
+
+   - If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently
+
+Context for task generation: $ARGUMENTS
+
+The tasks.md should be immediately executable - each task must be specific enough that an LLM can complete it without additional context.
+
+## Task Generation Rules
+
+**CRITICAL**: Tasks MUST be organized by user story to enable independent implementation and testing.
+
+**Tests are OPTIONAL**: Only generate test tasks if explicitly requested in the feature specification or if user requests TDD approach.
+
+### Checklist Format (REQUIRED)
+
+Every task MUST strictly follow this format:
+
+```text
+- [ ] [TaskID] [P?] [Story?] Description with file path
+```
+
+**Format Components**:
+
+1. **Checkbox**: ALWAYS start with `- [ ]` (markdown checkbox)
+2. **Task ID**: Sequential number (T001, T002, T003...) in execution order
+3. **[P] marker**: Include ONLY if task is parallelizable (different files, no dependencies on incomplete tasks)
+4. **[Story] label**: REQUIRED for user story phase tasks only
+   - Format: [US1], [US2], [US3], etc. (maps to user stories from spec.md)
+   - Setup phase: NO story label
+   - Foundational phase: NO story label
+   - User Story phases: MUST have story label
+   - Polish phase: NO story label
+5. **Description**: Clear action with exact file path
+
+**Examples**:
+
+- ✅ CORRECT: `- [ ] T001 Create project structure per implementation plan`
+- ✅ CORRECT: `- [ ] T005 [P] Implement authentication middleware in src/middleware/auth.py`
+- ✅ CORRECT: `- [ ] T012 [P] [US1] Create User model in src/models/user.py`
+- ✅ CORRECT: `- [ ] T014 [US1] Implement UserService in src/services/user_service.py`
+- ❌ WRONG: `- [ ] Create User model` (missing ID and Story label)
+- ❌ WRONG: `T001 [US1] Create model` (missing checkbox)
+- ❌ WRONG: `- [ ] [US1] Create User model` (missing Task ID)
+- ❌ WRONG: `- [ ] T001 [US1] Create model` (missing file path)
+
+### Task Organization
+
+1. **From User Stories (spec.md)** - PRIMARY ORGANIZATION:
+   - Each user story (P1, P2, P3...) gets its own phase
+   - Map all related components to their story:
+     - Models needed for that story
+     - Services needed for that story
+     - Interfaces/UI needed for that story
+     - If tests requested: Tests specific to that story
+   - Mark story dependencies (most stories should be independent)
+
+2. **From Contracts**:
+   - Map each interface contract → to the user story it serves
+   - If tests requested: Each interface contract → contract test task [P] before implementation in that story's phase
+
+3. **From Data Model**:
+   - Map each entity to the user story(ies) that need it
+   - If entity serves multiple stories: Put in earliest story or Setup phase
+   - Relationships → service layer tasks in appropriate story phase
+
+4. **From Setup/Infrastructure**:
+   - Shared infrastructure → Setup phase (Phase 1)
+   - Foundational/blocking tasks → Foundational phase (Phase 2)
+   - Story-specific setup → within that story's phase
+
+### Phase Structure
+
+- **Phase 1**: Setup (project initialization)
+- **Phase 2**: Foundational (blocking prerequisites - MUST complete before user stories)
+- **Phase 3+**: User Stories in priority order (P1, P2, P3...)
+  - Within each story: Tests (if requested) → Models → Services → Endpoints → Integration
+  - Each phase should be a complete, independently testable increment
+- **Final Phase**: Polish & Cross-Cutting Concerns
@@ -0,0 +1,30 @@
+---
+description: Convert existing tasks into actionable, dependency-ordered GitHub issues for the feature based on available design artifacts.
+tools: ["github/github-mcp-server/issue_write"]
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Outline
+
+1. Run `.specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks` from repo root and parse FEATURE_DIR and AVAILABLE_DOCS list. All paths must be absolute. For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").
+1. From the executed script, extract the path to **tasks**.
+1. Get the Git remote by running:
+
+```bash
+git config --get remote.origin.url
+```
+
+> [!CAUTION]
+> ONLY PROCEED TO NEXT STEPS IF THE REMOTE IS A GITHUB URL
+
+1. For each task in the list, use the GitHub MCP server to create a new issue in the repository that is representative of the Git remote.
+
+> [!CAUTION]
+> UNDER NO CIRCUMSTANCES EVER CREATE ISSUES IN REPOSITORIES THAT DO NOT MATCH THE REMOTE URL
@@ -0,0 +1,706 @@
+# Meshtastic Firmware - Copilot Instructions
+
+This document provides context and guidelines for AI assistants working with the Meshtastic firmware codebase.
+
+## Project Overview
+
+Meshtastic is an open-source LoRa mesh networking project for long-range, low-power communication without relying on internet or cellular infrastructure. The firmware enables text messaging, location sharing, and telemetry over a decentralized mesh network. The project uses **C++17** as its language standard across all platforms.
+
+### Supported Hardware Platforms
+
+- **ESP32** (ESP32, ESP32-S3, ESP32-C3, ESP32-C6) - Most common platform
+- **nRF52** (nRF52840, nRF52833) - Low power Nordic chips
+- **RP2040/RP2350** - Raspberry Pi Pico variants
+- **STM32WL** - STM32 with integrated LoRa
+- **Linux/Portduino** - Native Linux builds (Raspberry Pi, etc.)
+- **macOS native** - Headless `meshtasticd` on Apple Silicon / x86_64; see `variants/native/portduino/platformio.ini` for Homebrew prereqs + CH341 LoRa setup
+
+### Supported Radio Chips
+
+- **SX1262/SX1268** - Sub-GHz LoRa (868/915 MHz regions)
+- **SX1280** - 2.4 GHz LoRa
+- **LR1110/LR1120/LR1121** - Wideband radios (sub-GHz and 2.4 GHz capable, but not simultaneously)
+- **RF95** - Legacy RFM95 modules
+- **LLCC68** - Low-cost LoRa
+
+### MQTT Integration
+
+MQTT provides a bridge between Meshtastic mesh networks and the internet, enabling nodes with network connectivity to share messages with remote meshes or external services.
+
+#### Key Components
+
+- **`src/mqtt/MQTT.cpp`** - Main MQTT client singleton, handles connection and message routing
+- **`src/mqtt/ServiceEnvelope.cpp`** - Protobuf wrapper for mesh packets sent over MQTT
+- **`moduleConfig.mqtt`** - MQTT module configuration
+
+#### MQTT Topic Structure
+
+Messages are published/subscribed using a hierarchical topic format:
+
+```
+{root}/{channel_id}/{gateway_id}
+```
+
+- `root` - Configurable prefix (default: `msh`)
+- `channel_id` - Channel name/identifier
+- `gateway_id` - Node ID of the publishing gateway
+
+#### Configuration Defaults (from `Default.h`)
+
+```cpp
+#define default_mqtt_address "mqtt.meshtastic.org"
+#define default_mqtt_username "meshdev"
+#define default_mqtt_password "large4cats"
+#define default_mqtt_root "msh"
+#define default_mqtt_encryption_enabled true
+#define default_mqtt_tls_enabled false
+```
+
+#### Key Concepts
+
+- **Uplink** - Mesh packets sent TO the MQTT broker (controlled by `uplink_enabled` per channel)
+- **Downlink** - MQTT messages received and injected INTO the mesh (controlled by `downlink_enabled` per channel)
+- **Encryption** - When `encryption_enabled` is true, only encrypted packets are sent; plaintext JSON is disabled
+- **ServiceEnvelope** - Protobuf wrapper containing packet + channel_id + gateway_id for routing
+- **JSON Support** - Optional JSON encoding for integration with external systems (disabled on nRF52 by default)
+
+#### PKI Messages
+
+PKI (Public Key Infrastructure) messages have special handling:
+
+- Accepted on a special "PKI" channel
+- Allow encrypted DMs between nodes that discovered each other on downlink-enabled channels
+
+## Encryption & Key Management
+
+Meshtastic packets on the air are typically encrypted one of two ways: the **per-channel symmetric** layer (AES-CTR with a shared PSK) for broadcasts and channel traffic, and the **per-peer PKI** layer (X25519 ECDH → AES-256-CCM) for direct messages and remote admin. A channel with a 0-byte PSK (or Ham mode, which wipes PSKs) transmits cleartext — see the size table below. Both are implemented in `src/mesh/CryptoEngine.cpp`; the send/receive dispatch lives in `src/mesh/Router.cpp`; admin authorization lives in `src/modules/AdminModule.cpp`.
+
+### High-level model
+
+- **Channels** are symmetric rooms: anyone with the PSK can read any message on the channel. Channel 0 is the "primary" channel and ships with the short-form default PSK on factory devices, forming the public mesh most users join. (The LoRa modem preset `LONG_FAST` lives on `config.lora.modem_preset` and is an independent field — don't conflate "channel 0 default PSK" with the modem preset name.)
+- **DMs** addressed to a single node require PKI so that other holders of the channel PSK can't read them. Outside Ham mode, Meshtastic does not fall back to channel-symmetric encryption when the destination public key is unknown.
+- **Remote admin** is a DM carrying an `AdminMessage`. The receiver only acts on it if the sender's public key is on its allowlist (`config.security.admin_key[0..2]`).
+- **Ham mode** (`owner.is_licensed=true`, where `owner` is the local `meshtastic_User` record) disables PKI entirely and sends cleartext — FCC Part 97 prohibits encryption on amateur bands.
+- **No ratchet, no session.** Every packet is encrypted from scratch — a stateless design that matches the high-loss, store-and-forward nature of LoRa.
+
+### Symmetric channel encryption (AES-CTR)
+
+`CryptoEngine::encryptPacket` / `decrypt` / `encryptAESCtr` in `src/mesh/CryptoEngine.cpp`.
+
+- **Cipher**: AES-CTR, AES-128 or AES-256 depending on key length. Same routine in both directions (CTR is a stream cipher, so encrypt == decrypt).
+- **Key**: `ChannelSettings.psk` bytes. Size semantics:
+  - **0 bytes** → no encryption, cleartext on the air
+  - **1 byte** → short-form index into the well-known `defaultpsk[]` in `src/mesh/Channels.h`. Index 0 = cleartext; 1 = defaultpsk unchanged; 2..255 = defaultpsk with its last byte incremented by (index − 1). This is what the CLI's `--ch-set psk default` produces.
+  - **16 bytes** → raw AES-128 key
+  - **32 bytes** → raw AES-256 key
+  - **2..15 bytes** → zero-padded to 16 and used as AES-128 (with a warn log); **17..31 bytes** → zero-padded to 32 and used as AES-256 (with a warn log). Defensive fallback for malformed PSK input, not something to rely on.
+- **Nonce (128 bit)**: `packet_id` (u64 LE) ‖ `from_node` (u32 LE) ‖ `block_counter` (u32, starts at 0). Built in `CryptoEngine::initNonce`.
+- **No AEAD**: channel packets carry no MAC, so the channel-hash byte is not an integrity or authenticity check. `Channels::getHash` is a 1-byte XOR-derived hint over the channel name bytes and PSK bytes that helps receivers pick a candidate channel/PSK for decryption. Because it is only a small hint and collisions are easy to find, it should be described purely as a PSK-selection aid, not as a security filter an attacker cannot bypass.
+- **Channel 0 is special in one way only**: it's the channel the Router attempts PKI decryption on before falling through to AES-CTR. Non-zero channels always go straight to AES-CTR.
+
+### PKI encryption for DMs (X25519 ECDH + AES-256-CCM)
+
+`CryptoEngine::encryptCurve25519` / `decryptCurve25519` in `src/mesh/CryptoEngine.cpp`.
+
+- **Keypair**: Curve25519 (aka X25519), 32-byte public + 32-byte private. Stored in `config.security.public_key` / `private_key`; the public half is mirrored into `owner.public_key` so it rides along in NodeInfo broadcasts and propagates through the mesh like any other identity field.
+- **Key generation** (`generateKeyPair`): stirs `HardwareRNG::fill()` (64 B from platform TRNG when available), the 16-byte `myNodeInfo.device_id`, and a call to `random()` into the rweather/Crypto library's software RNG, then `Curve25519::dh1`. `regeneratePublicKey` recomputes the public half from a known private (used when restoring from backup).
+- **Keygen entry points**: at boot, `NodeDB` calls `generateKeyPair` (or `regeneratePublicKey` when a stored private key is present and passes a low-entropy check) **directly** when `!owner.is_licensed` and `config.lora.region != UNSET`. `ensurePkiKeys` wraps the same logic for runtime/admin flows — it's the path `AdminModule::handleSetConfig` runs when first assigning a valid region or when security config is written; **do not assume it's the universal boot-time gate**, because the NodeDB path bypasses it.
+- **Handshake**: `Curve25519::dh2(local_private, remote_public) → 32-byte shared secret → SHA-256 → 32-byte AES-256 key`. Recomputed per packet. The SHA-256 step is effectively a KDF over the raw ECDH output.
+- **Cipher**: AES-256-CCM via `aes_ccm_ae` / `aes_ccm_ad` (`src/mesh/aes-ccm.cpp`). MAC length (the `M` parameter) is **8 bytes**. No AAD — the MAC covers ciphertext only.
+- **Nonce (13 bytes / 104 bit)**: `aes_ccm_ae`/`aes_ccm_ad` use a 13-byte CCM nonce (`L = 2` is hardcoded in `src/mesh/aes-ccm.cpp`), not a 16-byte nonce. For PKI packets, `CryptoEngine::initNonce(fromNode, packetNum, extraNonce)` starts from the usual packet-derived nonce material, then overwrites nonce bytes `4..7` with a fresh 32-bit `extraNonce = random()`. The effective nonce bytes are therefore: bytes `0..3` = `packet_id`, bytes `4..7` = transmitted `extraNonce`, bytes `8..11` = `from_node`, byte `12` = `0x00`. The receiver reconstructs the same 13-byte nonce from the packet metadata plus the appended `extraNonce`.
+- **Wire overhead**: 12 bytes appended to the ciphertext = 8-byte MAC ‖ 4-byte extraNonce. Defined as `MESHTASTIC_PKC_OVERHEAD = 12` in `src/mesh/RadioInterface.h`. Only the 4-byte `extraNonce` is sent; the rest of the 13-byte CCM nonce is reconstructed from packet fields as described above. The Router's send path checks this overhead against `MAX_LORA_PAYLOAD_LEN` before committing to PKI.
+- **Send selection** (`Router::send`): the sender enters the PKI path when **all** hold — we're the originator AND not Ham mode AND not Portduino simradio AND not on the `serial`/`gpio` channels (unless the packet is already marked `pki_encrypted`) AND `config.security.private_key.size == 32` AND destination is a single node (not broadcast) AND the portnum isn't infrastructure. `TRACEROUTE_APP`, `NODEINFO_APP`, `ROUTING_APP`, and `POSITION_APP` are routed through channel encryption even when DMed (these need to be readable by relaying peers). Once on the PKI path, if the destination's public key isn't in our NodeDB the send **fails** with `PKI_SEND_FAIL_PUBLIC_KEY` — it does not silently fall back to channel encryption. If the client explicitly set `pki_encrypted=true` and any condition blocks PKI, the send fails with `PKI_FAILED`.
+- **Receive selection** (`Router::perhapsDecode`): try PKI decrypt first when `channel == 0` AND `isToUs(p)` AND not broadcast AND both peers have public keys in NodeDB AND `rawSize > MESHTASTIC_PKC_OVERHEAD`. On success the packet gets `pki_encrypted=true` stamped and the sender's public key copied into `p->public_key` for downstream authorization.
+
+### Remote admin authorization
+
+Implemented in `src/modules/AdminModule.cpp` → `handleReceivedProtobuf`. The authorization check runs in this order:
+
+1. **Response messages** — if `messageIsResponse(r)` is true (the payload is a response to one of our earlier admin requests), it's accepted without any further check. The in-file comment flags this as a known-untightened gap: a stricter implementation would remember which `public_key` we last queried and reject responses that don't match.
+2. **Local admin** — `mp.from == 0` (phone app over BLE, serial CLI, internal module); never travels over the air. **Rejected** if `config.security.is_managed` is true, because managed devices expect admin to arrive over the air through an authorized remote path.
+3. **Legacy admin channel (deprecated)** — the packet arrived on a channel named literally `"admin"`. Gated by `config.security.admin_channel_enabled`; returns `NOT_AUTHORIZED` if the flag is false. Kept for backward compatibility; new deployments should use PKI admin.
+4. **PKI admin (preferred for remote)** — `mp.pki_encrypted == true` AND `mp.public_key` matches one of `config.security.admin_key[0..2]` (up to three authorized 32-byte Curve25519 public keys, typically copied from the admin node's own `user.public_key`).
+5. **Fallthrough** → `NOT_AUTHORIZED`.
+
+On top of authorization, any remote admin message that **mutates** state (not a request, not a response) also has to pass a session-key check (`checkPassKey`): the client must first pull a fresh 8-byte `session_passkey` via `get_admin_session_key_request`, then echo that passkey back in the mutating message. The device rotates the passkey after 150 s and rejects values older than 300 s — a narrow anti-replay window on top of the PKI layer.
+
+`config.security.is_managed = true` disables **local** admin writes (`mp.from == 0` is rejected). It does not by itself force every admin action through PKI — the legacy `"admin"` channel still authorizes remote admin when `config.security.admin_channel_enabled == true`. The AdminModule refuses to persist `is_managed=true` unless at least one `admin_key` is populated — a deliberate guard against operators locking themselves out.
+
+### Key-rotation hazards (actions that invalidate peers)
+
+- **`factory_reset_device`** (the "full" variant, calls `NodeDB::factoryReset(eraseBleBonds=true)`) → **wipes** the X25519 private key; a fresh keypair is generated on the next region-set. Every existing peer holds the old public key, so DMs to this node silently fail PKI decrypt until every peer re-exchanges NodeInfo.
+- **`factory_reset_config`** (the "partial" variant, calls `NodeDB::factoryReset()` with `eraseBleBonds=false`) → **preserves** the X25519 private key in `installDefaultConfig(preserveKey=true)`; the public key is zeroed and gets rebuilt from the preserved private key on the next boot via the NodeDB path's `regeneratePublicKey` call. Identity is preserved and the mesh does not need to re-exchange keys.
+- **`region=UNSET → valid region`** → `ensurePkiKeys` runs inside the same `handleSetConfig` path; missing keys get generated at that moment.
+- **Ham mode transitions** — entering Ham mode (`user.is_licensed=true`) runs `Channels::ensureLicensedOperation`, which **wipes every channel PSK** (all traffic becomes cleartext) and disables the legacy admin channel. The X25519 private key is preserved on the device but not used because `Router::send` skips PKI when `owner.is_licensed` is true. Leaving Ham mode re-enables PKI with the preserved keypair but does not restore the wiped channel PSKs — the operator has to re-set them.
+- **Channel 0 PSK change** → every peer must re-learn the channel hash; cached NodeInfo becomes temporarily unreachable until the next broadcast.
+- **`security.private_key` blanked via admin** → regenerates both halves (unless in Ham mode) and propagates the new public key via NodeInfo.
+
+## Project Structure
+
+```
+firmware/
+├── src/                    # Main source code
+│   ├── main.cpp           # Application entry point
+│   ├── mesh/              # Core mesh networking
+│   │   ├── NodeDB.*       # Node database management
+│   │   ├── Router.*       # Packet routing
+│   │   ├── Channels.*     # Channel management
+│   │   ├── CryptoEngine.* # AES-CTR (channels) + X25519 ECDH→AES-256-CCM (PKI for DMs/admin)
+│   │   ├── *Interface.*   # Radio interface implementations
+│   │   ├── api/           # WiFi/Ethernet server APIs (ServerAPI, PacketAPI)
+│   │   ├── http/          # HTTP server (WebServer, ContentHandler)
+│   │   ├── wifi/          # WiFi support (WiFiAPClient)
+│   │   ├── eth/           # Ethernet support (ethClient)
+│   │   ├── udp/           # UDP multicast
+│   │   ├── compression/   # Message compression (unishox2)
+│   │   └── generated/     # Protobuf generated code
+│   ├── modules/           # Feature modules (Position, Telemetry, etc.)
+│   │   └── Telemetry/     # Telemetry subsystem
+│   │       └── Sensor/    # 50+ I2C sensor drivers
+│   ├── gps/               # GPS handling
+│   ├── graphics/          # Display drivers and UI
+│   │   └── niche/         # Specialized UIs (InkHUD e-ink framework)
+│   ├── platform/          # Platform-specific code (esp32, nrf52, rp2xx0, stm32wl, portduino)
+│   ├── input/             # Input device handling (InputBroker, keyboards, buttons)
+│   ├── detect/            # I2C hardware auto-detection (80+ device types)
+│   ├── motion/            # Accelerometer drivers (BMA423, BMI270, MPU6050, etc.)
+│   ├── mqtt/              # MQTT bridge client
+│   ├── power/             # Power HAL
+│   ├── nimble/            # BLE via NimBLE
+│   ├── buzz/              # Audio/notification (buzzer, RTTTL)
+│   ├── serialization/     # JSON serialization, COBS encoding
+│   ├── watchdog/          # Hardware watchdog thread
+│   ├── concurrency/       # Threading utilities (OSThread, Lock)
+│   ├── PowerFSM.*         # Power finite state machine
+│   └── Observer.h         # Observer/Observable event pattern
+├── variants/              # Hardware variant definitions
+│   ├── esp32/            # ESP32 variants
+│   ├── esp32s3/          # ESP32-S3 variants
+│   ├── esp32c3/          # ESP32-C3 variants
+│   ├── esp32c6/          # ESP32-C6 variants
+│   ├── nrf52840/         # nRF52 variants
+│   ├── rp2040/           # RP2040/RP2350 variants
+│   ├── stm32/            # STM32WL variants
+│   └── native/           # Linux/Portduino variants
+├── protobufs/            # Protocol buffer definitions
+├── boards/               # Custom PlatformIO board definitions
+├── test/                 # Unit tests (12 test suites)
+└── bin/                  # Build and utility scripts
+```
+
+## Coding Conventions
+
+### General Style
+
+- Follow existing code style - run `trunk fmt` before commits
+- Prefer `LOG_DEBUG`, `LOG_INFO`, `LOG_WARN`, `LOG_ERROR` for logging
+- Use `assert()` for invariants that should never fail
+- C++17 features are available (`std::optional`, structured bindings, `if constexpr`, etc.)
+
+### Naming Conventions
+
+- Classes: `PascalCase` (e.g., `PositionModule`, `NodeDB`)
+- Functions/Methods: `camelCase` (e.g., `sendOurPosition`, `getNodeNum`)
+- Constants/Defines: `UPPER_SNAKE_CASE` (e.g., `MAX_INTERVAL`, `ONE_DAY`)
+- Member variables: `camelCase` (e.g., `lastGpsSend`, `nodeDB`)
+- Config defines: `USERPREFS_*` for user-configurable options
+
+### Key Patterns
+
+#### Module System
+
+Modules use a three-tier class hierarchy:
+
+1. **`MeshModule`** - Base class. Implement `wantPacket()` and `handleReceived()`. Returns `ProcessMessage::STOP` or `ProcessMessage::CONTINUE`.
+2. **`SinglePortModule`** - Handles a single portnum. Simplified `wantPacket()` that checks `decoded.portnum`.
+3. **`ProtobufModule<T>`** - Template for protobuf-based modules. Handles encoding/decoding automatically.
+
+Most modules also inherit from **`OSThread`** for periodic tasks (the "mixin" pattern):
+
+```cpp
+class MyModule : public ProtobufModule<meshtastic_MyMessage>, private concurrency::OSThread
+{
+  public:
+    MyModule();
+
+  protected:
+    virtual bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_MyMessage *msg) override;
+    virtual meshtastic_MeshPacket *allocReply() override;       // Generate response packets
+    virtual int32_t runOnce() override;                         // Periodic task (returns next interval in ms)
+    virtual bool alterReceivedProtobuf(meshtastic_MeshPacket &mp, meshtastic_MyMessage *msg); // Modify in-flight
+    virtual bool wantUIFrame();                                 // Request a UI display frame
+};
+```
+
+Modules are registered in `src/modules/Modules.cpp` guarded by `MESHTASTIC_EXCLUDE_*` flags.
+
+#### Observer/Observable Pattern
+
+Event-driven communication between subsystems uses `src/Observer.h`:
+
+```cpp
+// Observable emits events
+Observable<const meshtastic::Status *> newStatus;
+newStatus.notifyObservers(&status);
+
+// Observer receives events via callback
+CallbackObserver<MyClass, const meshtastic::Status *> statusObserver =
+    CallbackObserver<MyClass, const meshtastic::Status *>(this, &MyClass::handleStatusUpdate);
+```
+
+#### Configuration Access
+
+- `config.*` - Device configuration (LoRa, position, power, etc.)
+- `moduleConfig.*` - Module-specific configuration
+- `channels.*` - Channel configuration and management
+- `owner` - Device owner info
+- `myNodeInfo` - Local node info
+
+#### Default Values
+
+Use the `Default` class helpers in `src/mesh/Default.h`:
+
+- `Default::getConfiguredOrDefaultMs(configured, default)` - Returns ms, using default if configured is 0
+- `Default::getConfiguredOrDefault(configured, default)` - Generic configured/default getter
+- `Default::getConfiguredOrMinimumValue(configured, min)` - Enforces minimum values
+- `Default::getConfiguredOrDefaultMsScaled(configured, default, numNodes)` - Scales based on network size
+
+#### Thread Safety
+
+- Use `concurrency::Lock` and `concurrency::LockGuard` for mutex protection
+- Radio SPI access uses `SPILock`
+- Prefer `OSThread` for background tasks
+
+### Hardware Detection
+
+`src/detect/ScanI2C` automatically enumerates 80+ I2C device types at boot including displays, sensors, RTCs, keyboards, PMUs, and touch controllers. This drives automatic initialization of the correct drivers.
+
+### Graphics/UI System
+
+Multiple display driver families in `src/graphics/`:
+
+- **OLED**: SSD1306, SH1106, ST7567
+- **TFT**: TFTDisplay (LovyanGFX-based)
+- **E-Ink**: EInkDisplay2, EInkDynamicDisplay, EInkParallelDisplay
+
+**InkHUD** (`src/graphics/niche/InkHUD/`) is an event-driven e-ink UI framework:
+
+- Applet-based architecture — modular display tiles
+- Read-only, static display optimized for minimal refreshes and low power
+- Configured per-variant via `nicheGraphics.h`
+- Separate PlatformIO config: `src/graphics/niche/InkHUD/PlatformioConfig.ini`
+
+### Input System
+
+`src/input/InputBroker` is the centralized input event dispatcher. Supports multiple input sources: buttons, keyboards (BBQ10, Cardputer, TCA8418), touch screens, rotary encoders, and matrix keyboards.
+
+### Power Management
+
+`src/PowerFSM.*` implements a finite state machine with states: `stateON`, `statePOWER`, `stateSERIAL`, `stateDARK`. Key events: `EVENT_PRESS`, `EVENT_WAKE_TIMER`, `EVENT_LOW_BATTERY`, `EVENT_RECEIVED_MSG`, `EVENT_SHUTDOWN`. Conditionally excluded with `MESHTASTIC_EXCLUDE_POWER_FSM` (falls back to `FakeFsm`).
+
+### Motion Sensors
+
+`src/motion/AccelerometerThread` provides background motion monitoring with automatic screen wake and double-tap button press detection. Supports 10+ accelerometer/gyroscope chips (BMA423, BMI270, MPU6050, LIS3DH, LSM6DS3, STK8XXX, QMA6100P, ICM20948, BMX160).
+
+### Telemetry Sensor Library
+
+`src/modules/Telemetry/Sensor/` contains 50+ I2C sensor drivers organized by category:
+
+- **Power monitoring**: INA219/226/260/3221, MAX17048
+- **Environmental**: BME280/680, SCD4X (CO₂), SEN5X (particulate)
+- **Humidity/Temperature**: SHT3X/4X, AHT10, MCP9808, MLX90614
+- **Light**: BH1750, TSL2561/2591, VEML7700, LTR390UV, OPT3001
+- **Air quality**: PMSA003I, SFA30
+- **Specialized**: CGRadSens (radiation), NAU7802 (weight scale)
+
+### API/Networking
+
+`src/mesh/api/` provides a template-based `ServerAPI` for client communication over WiFi (`WiFiServerAPI`) and Ethernet (`ethServerAPI`). Default port: **4403**. HTTP server in `src/mesh/http/`. JSON serialization in `src/serialization/MeshPacketSerializer`.
+
+### Hardware Variants
+
+Each hardware variant has:
+
+- `variant.h` - Pin definitions and hardware capabilities
+- `platformio.ini` - Build configuration
+- Optional: `pins_arduino.h`, `rfswitch.h`, `nicheGraphics.h` (for InkHUD variants)
+
+Key defines in variant.h:
+
+```cpp
+#define USE_SX1262          // Radio chip selection
+#define HAS_GPS 1           // Hardware capabilities
+#define HAS_SCREEN 1        // Display present
+#define LORA_CS 36          // Pin assignments
+#define SX126X_DIO1 14      // Radio-specific pins
+```
+
+### Protobuf Messages
+
+- Defined in `protobufs/meshtastic/*.proto` (~32 proto files)
+- Generated code in `src/mesh/generated/meshtastic/`
+- Regenerate with `bin/regen-protos.sh`
+- Message types prefixed with `meshtastic_`
+- Nanopb `.options` files control field sizes and encoding
+
+### Conditional Compilation
+
+```cpp
+#if !MESHTASTIC_EXCLUDE_GPS        // Feature exclusion
+#if !MESHTASTIC_EXCLUDE_WIFI       // Network feature exclusion
+#if !MESHTASTIC_EXCLUDE_BLUETOOTH  // BLE exclusion
+#if !MESHTASTIC_EXCLUDE_POWER_FSM  // Power FSM exclusion
+#ifdef ARCH_ESP32                   // Architecture-specific
+#ifdef ARCH_NRF52                   // Nordic platform
+#ifdef ARCH_RP2040                  // Raspberry Pi Pico
+#ifdef ARCH_PORTDUINO               // Linux native
+#if defined(USE_SX1262)            // Radio-specific
+#ifdef HAS_SCREEN                   // Hardware capability
+#if USERPREFS_EVENT_MODE           // User preferences
+```
+
+## Build System
+
+## Agent Tooling Baseline
+
+Mirror counterpart: `AGENTS.md` under **Agent Tooling Baseline**.
+
+To reduce avoidable agent mistakes, assume these tools are available (or install them before significant repo work):
+
+- **Required CLI basics**: `bash`, `git`, `find`, `grep`, `sed`, `awk`, `xargs`
+- **Strongly recommended**: `rg` (ripgrep) for fast file/text search, `jq` for JSON processing
+- **Build/test tools**: `python3`, `pip`, virtualenv (`python3 -m venv`), `platformio` (`pio`)
+- **Containerized native testing**: `docker` (fallback for non-Linux hosts; macOS can also build natively via `pio run -e native-macos`)
+
+Fallback expectations for agents:
+
+- If `rg` is unavailable, use `find` + `grep` instead of failing.
+- For native tests on hosts without Linux deps, prefer `./bin/test-native-docker.sh`.
+- The simulator helper script is `./bin/test-simulator.sh`.
+
+Uses **PlatformIO** with custom scripts:
+
+- `bin/platformio-pre.py` - Pre-build script
+- `bin/platformio-custom.py` - Custom build logic, manifest generation
+
+Build commands:
+
+```bash
+pio run -e tbeam              # Build specific target
+pio run -e tbeam -t upload    # Build and upload
+pio run -e native             # Build native/Linux version
+pio run -e native-macos       # Build headless macOS meshtasticd (Homebrew prereqs in variants/native/portduino/platformio.ini)
+```
+
+### Build Manifest
+
+`bin/platformio-custom.py` emits a build manifest with metadata:
+
+- `hasMui`, `hasInkHud` - UI capability flags (overridable via `custom_meshtastic_has_mui`, `custom_meshtastic_has_ink_hud`)
+- Architecture normalization (e.g., `esp32s3` → `esp32-s3` for API compatibility)
+
+## Common Tasks
+
+### Adding a New Module
+
+1. Create `src/modules/MyModule.cpp` and `.h`
+2. Inherit from appropriate base class (`MeshModule`, `SinglePortModule`, or `ProtobufModule<T>`)
+3. Mix in `concurrency::OSThread` if periodic work is needed
+4. Register in `src/modules/Modules.cpp` guarded by `#if !MESHTASTIC_EXCLUDE_MYMODULE`
+5. Add protobuf messages if needed in `protobufs/meshtastic/`
+6. Add test suite in `test/test_mymodule/` if applicable
+
+### Adding a New Hardware Variant
+
+1. Create directory under `variants/<arch>/<name>/`
+2. Add `variant.h` with pin definitions and hardware capability defines
+3. Add `platformio.ini` with build config — use `extends` to reference common base (e.g., `esp32s3_base`)
+4. Set `custom_meshtastic_support_level = 1` (PR builds) or `2` (merge builds)
+5. For e-ink displays, add `nicheGraphics.h` for InkHUD configuration
+
+### Adding a New Telemetry Sensor
+
+1. Create driver in `src/modules/Telemetry/Sensor/` following existing sensor pattern
+2. Register I2C address in `src/detect/ScanI2C` for auto-detection
+3. Integrate with the appropriate telemetry module (Environment, Health, Power, AirQuality)
+4. Add proto fields in `protobufs/meshtastic/telemetry.proto` if new data types are needed
+
+### Modifying Configuration Defaults
+
+- Check `src/mesh/Default.h` for default value defines
+- Check `src/mesh/NodeDB.cpp` for initialization logic
+- Consider `isDefaultChannel()` checks for public channel restrictions
+
+## Important Considerations
+
+### Traffic Management
+
+The mesh network has limited bandwidth. When modifying broadcast intervals:
+
+- Respect minimum intervals on default/public channels
+- Use `Default::getConfiguredOrMinimumValue()` to enforce minimums
+- Consider `numOnlineNodes` scaling for congestion control
+
+### Power Management
+
+Many devices are battery-powered:
+
+- Use `IF_ROUTER(routerVal, normalVal)` for role-based defaults
+- Check `config.power.is_power_saving` for power-saving modes
+- Implement proper `sleep()` methods in radio interfaces
+
+### Channel Security
+
+- `channels.isDefaultChannel(index)` - Check if using default/public settings
+- Default channels get stricter rate limits to prevent abuse
+- Private channels may have relaxed limits
+
+## GitHub Actions CI/CD
+
+The project uses GitHub Actions extensively for CI/CD. Key workflows are in `.github/workflows/`:
+
+### Core CI Workflows
+
+- **`main_matrix.yml`** - Main CI pipeline, runs on push to `master`/`develop` and PRs
+  - Uses `bin/generate_ci_matrix.py` to dynamically generate build targets
+  - Builds all supported hardware variants
+  - PRs build a subset (`--level pr`) for faster feedback
+
+- **`trunk_check.yml`** - Code quality checks on PRs
+  - Runs Trunk.io for linting and formatting
+  - Must pass before merge
+
+- **`tests.yml`** - End-to-end and hardware tests
+  - Runs daily on schedule
+  - Includes native tests and hardware-in-the-loop testing
+
+- **`test_native.yml`** - Native platform unit tests
+  - Runs `pio test -e native`
+
+### Release Workflows
+
+- **`release_channels.yml`** - Triggered on GitHub release publish
+  - Builds Docker images
+  - Packages for PPA (Ubuntu), OBS (openSUSE), and COPR (Fedora)
+  - Handles Alpha/Beta/Stable release channels
+
+- **`nightly.yml`** - Nightly builds from develop branch
+
+- **`docker_build.yml`** / **`docker_manifest.yml`** - Docker image builds
+
+### Build Matrix Generation
+
+The CI uses `bin/generate_ci_matrix.py` to dynamically select which targets to build:
+
+```bash
+# Generate full build matrix
+./bin/generate_ci_matrix.py all
+
+# Generate PR-level matrix (subset for faster builds)
+./bin/generate_ci_matrix.py all --level pr
+```
+
+Variants can specify their support level in `platformio.ini`:
+
+- `custom_meshtastic_support_level = 1` - Actively supported, built on every PR
+- `custom_meshtastic_support_level = 2` - Supported, built on merge to main branches
+- `board_level = extra` - Extra builds, only on full releases
+
+### Running Workflows Locally
+
+Most workflows can be triggered manually via `workflow_dispatch` for testing.
+
+## Testing
+
+### Native unit tests (C++)
+
+Unit tests in `test/` directory with 12 test suites:
+
+- `test_crypto/` - Cryptography
+- `test_mqtt/` - MQTT integration
+- `test_radio/` - Radio interface
+- `test_mesh_module/` - Module framework
+- `test_meshpacket_serializer/` - Packet serialization
+- `test_transmit_history/` - Retransmission tracking
+- `test_atak/` - ATAK integration
+- `test_default/` - Default configuration
+- `test_http_content_handler/` - HTTP handling
+- `test_serial/` - Serial communication
+
+Run with: `pio test -e native`
+
+Simulation testing: `bin/test-simulator.sh`
+
+Quick entry point for new test modules: `test/README.md` (native unit-test authoring guide, skeleton, pitfalls, and setup checklist).
+
+### Hardware-in-the-loop tests (`mcp-server/tests/`)
+
+Separate pytest suite that exercises real USB-connected Meshtastic devices. See the **MCP Server & Hardware Test Harness** section below for invocation, tier layout, and agent usage rules.
+
+## MCP Server & Hardware Test Harness
+
+The `mcp-server/` directory houses a firmware-aware [MCP](https://modelcontextprotocol.io/) server plus a pytest-based integration suite. AI agents that speak MCP get a well-defined tool surface for flashing, configuring, and inspecting physical Meshtastic devices — use it instead of hand-rolling `pio` or `meshtastic --port` calls where possible. `mcp-server/README.md` is the operator-facing setup doc; this section is the agent-facing usage contract.
+
+The repo registers the server via `.mcp.json` at the repo root — Claude Code picks it up automatically once `mcp-server/.venv/` is built (`cd mcp-server && python3 -m venv .venv && .venv/bin/pip install -e '.[test]'`).
+
+### When to use which surface
+
+| Goal                                              | Tool                                                                                                             |
+| ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
+| Find a connected device                           | `mcp__meshtastic__list_devices`                                                                                  |
+| Read a live node's config/state                   | `mcp__meshtastic__device_info`, `list_nodes`, `get_config`                                                       |
+| Mutate a device (owner, region, channels, reboot) | `set_owner`, `set_config`, `set_channel_url`, `reboot`, `shutdown`, `factory_reset` — all require `confirm=True` |
+| Flash firmware to a variant                       | `pio_flash` (any arch) or `erase_and_flash` (ESP32 factory install)                                              |
+| Stream serial logs while debugging                | `serial_open` → `serial_read` loop → `serial_close`                                                              |
+| Administer `userPrefs.jsonc` build-time constants | `userprefs_get`, `userprefs_set`, `userprefs_reset`, `userprefs_manifest`                                        |
+| Run the regression suite                          | `./mcp-server/run-tests.sh` (or `/test` slash command)                                                           |
+| Diagnose a specific device                        | `/diagnose [role]` slash command (read-only)                                                                     |
+| Triage a flaky test                               | `/repro <node-id> [count]` slash command                                                                         |
+
+**One MCP call per port at a time.** `SerialInterface` holds an exclusive OS-level lock on the serial port for its lifetime. If a `serial_*` session is open on `/dev/cu.usbmodem101`, calling `device_info` on the same port will fail fast pointing at the active session. Sequence calls: open → read/mutate → close, then next device. Never parallelize tool calls on the same port.
+
+### MCP tool surface (43 tools)
+
+Grouped by purpose. Full argument shapes in `mcp-server/README.md`; a few high-value signatures are called out here.
+
+- **Discovery & metadata**: `list_devices`, `list_boards`, `get_board`
+- **Build & flash**: `build`, `clean`, `pio_flash`, `erase_and_flash` (ESP32 only), `update_flash` (ESP32 OTA), `touch_1200bps`
+- **Serial sessions** (long-running, 10k-line ring buffer): `serial_open`, `serial_read`, `serial_list`, `serial_close`
+- **Device reads**: `device_info`, `list_nodes`
+- **Device writes**: `set_owner`, `get_config`, `set_config`, `get_channel_url`, `set_channel_url`, `send_text`, `send_input_event` (inject a button/key press via the firmware's InputBroker), `set_debug_log_api`; destructive/power-state writes require `confirm=True`: `reboot`, `shutdown`, `factory_reset`
+- **userPrefs admin** (build-time constants, not runtime config): `userprefs_get`, `userprefs_set`, `userprefs_reset`, `userprefs_manifest`, `userprefs_testing_profile`
+- **Vendor escape hatches**: `esptool_chip_info`, `esptool_erase_flash`, `esptool_raw`, `nrfutil_dfu`, `nrfutil_raw`, `picotool_info`, `picotool_load`, `picotool_raw`
+- **USB power control** (via `uhubctl`, per-port PPPS toggle): `uhubctl_list` (read-only), `uhubctl_power(action='on'|'off', confirm=True)`, `uhubctl_cycle(delay_s, confirm=True)`. Target by raw `(location, port)` or by `role` (`"nrf52"`, `"esp32s3"`); role lookup checks `MESHTASTIC_UHUBCTL_LOCATION_<ROLE>` + `_PORT_<ROLE>` env vars first, falls back to VID auto-detection.
+- **Observability** (UI tier + operator ad-hoc): `capture_screen(role, ocr=True)` — grabs a USB-webcam frame of the device OLED and optionally OCRs it. Requires `mcp-server[ui]` extras (`opencv-python-headless`, `easyocr`) and `MESHTASTIC_UI_CAMERA_DEVICE_<ROLE>` env var; falls through to a 1×1 black PNG `NullBackend` when unconfigured.
+
+`confirm=True` is a tool-level gate on top of whatever permission prompt your MCP host shows. **Don't bypass it** by asking the host to auto-approve — it exists specifically because MCP hosts sometimes remember "always allow this tool" and that's dangerous for `factory_reset`, `erase_and_flash`, `uhubctl_power(action='off')`, and `uhubctl_cycle`.
+
+**TCP / native-host nodes.** Setting `MESHTASTIC_MCP_TCP_HOST=<host[:port]>` makes `list_devices` surface a `meshtasticd` daemon (e.g. the `native-macos` build) as a synthetic `tcp://host:port` entry, and `connect()` routes through `meshtastic.tcp_interface.TCPInterface` instead of `SerialInterface`. Every read/write/admin tool that flows through `connect()` works against the daemon transparently. USB-only tools (`pio_flash`, `erase_and_flash`, `update_flash`, `touch_1200bps`, `serial_open`, `esptool_*`, `nrfutil_*`, `picotool_*`) raise a clear `ConnectionError` when handed a `tcp://` port; `pio_flash` against a `native*` env raises a `FlashError` (no upload step — use `build` and run the binary directly). The pytest harness still assumes USB-attached devices per role; TCP-aware fixtures are deferred. See `mcp-server/README.md` § "TCP / native-host nodes".
+
+### Hardware test suite (`mcp-server/run-tests.sh`)
+
+The wrapper auto-detects connected devices (VID → role map: `0x239A` → `nrf52`, `0x303A`/`0x10C4` → `esp32s3`), maps each role to a PlatformIO env (`nrf52` → `rak4631`, `esp32s3` → `heltec-v3`, overridable via `MESHTASTIC_MCP_ENV_<ROLE>`), then invokes pytest. Zero pre-flight config needed from the operator.
+
+Suite tiers (collected + run in this order via `pytest_collection_modifyitems`):
+
+1. `tests/unit/` — pure Python (boards parse, pio wrapper, userPrefs parse, testing profile, uhubctl parser). No hardware.
+2. `tests/test_00_bake.py` — flashes each detected device with current `userPrefs.jsonc` merged with the session's test profile. Has its own skip-if-already-baked check comparing region + primary channel to the session profile; skips cheaply on warm devices.
+3. `tests/mesh/` — multi-device mesh: bidirectional send, broadcast delivery, direct-with-ACK, mesh formation within 60s. Parametrized `[nrf52->esp32s3]` and `[esp32s3->nrf52]`. Includes `test_peer_offline_recovery` which uses uhubctl to physically power off one peer mid-conversation (requires uhubctl; skips without).
+4. `tests/telemetry/` — `DEVICE_METRICS_APP` broadcast timing.
+5. `tests/monitor/` — boot-log panic check.
+6. `tests/recovery/` — `uhubctl` power-cycle round-trip + NVS persistence across hard reset. Requires `uhubctl` installed and a PPPS-capable hub; entire tier auto-skips otherwise.
+7. `tests/ui/` — input-broker-driven screen navigation with camera + OCR evidence.
+8. `tests/fleet/` — PSK seed session isolation.
+9. `tests/admin/` — channel URL roundtrip, owner persistence across reboot.
+10. `tests/provisioning/` — region + modem + slot bake, admin key presence, `UNSET` region blocks TX, userPrefs survive factory reset.
+
+Invocation patterns:
+
+```bash
+./mcp-server/run-tests.sh                                        # full suite (auto-bake-if-needed)
+./mcp-server/run-tests.sh --force-bake                           # reflash before testing
+./mcp-server/run-tests.sh --assume-baked                         # skip bake (caller vouches for device state)
+./mcp-server/run-tests.sh tests/mesh                             # one tier
+./mcp-server/run-tests.sh tests/mesh/test_direct_with_ack.py     # one file
+./mcp-server/run-tests.sh -k telemetry                           # name filter
+```
+
+**No hardware detected?** The wrapper auto-narrows to `tests/unit/` only and prints `detected hub : (none)` in the pre-flight header. Agents interpreting the output should call this out explicitly — a 52-test green run without hardware is qualitatively different from a 12-unit-test green run.
+
+**Artifacts every run produces:**
+
+- `mcp-server/tests/report.html` — self-contained pytest-html. Each test gets a `Meshtastic debug` section with the tail of firmware log + device state dump. **Open this first** on failures; it's the canonical evidence source.
+- `mcp-server/tests/junit.xml` — CI-parseable.
+- `mcp-server/tests/reportlog.jsonl` — pytest-reportlog stream (`$report_type` keyed JSONL). Consumed by the live TUI.
+- `mcp-server/tests/fwlog.jsonl` — firmware log mirror from the `meshtastic.log.line` pubsub topic. Populated by the `_firmware_log_stream` autouse session fixture.
+
+### Live TUI (`meshtastic-mcp-test-tui`)
+
+A Textual-based live view that wraps `run-tests.sh`. Tails reportlog for per-test state, streams firmware logs, polls device state at startup + post-run (gated out of the active run because `hub_devices` holds exclusive port locks). Key bindings:
+
+| Key | Action                                                                                                       |
+| --- | ------------------------------------------------------------------------------------------------------------ |
+| `r` | re-run focused test (leaf → that node id; internal node → directory or `-k`)                                 |
+| `f` | filter tree by substring                                                                                     |
+| `d` | failure detail modal (pulls `longrepr` + captured stdout from the reportlog)                                 |
+| `g` | export reproducer bundle (tar.gz with README, test_report.json, time-filtered fwlog, devices.json, env.json) |
+| `l` | toggle firmware log pane                                                                                     |
+| `x` | tool coverage modal                                                                                          |
+| `c` | cross-run history sparkline                                                                                  |
+| `q` | quit (SIGINT → SIGTERM → SIGKILL escalation, 5-s windows each)                                               |
+
+Launch:
+
+```bash
+cd mcp-server
+.venv/bin/meshtastic-mcp-test-tui                 # full suite
+.venv/bin/meshtastic-mcp-test-tui tests/mesh      # args pass through to pytest
+```
+
+The plain CLI stays primary; the TUI is for operators who want a live dashboard. Both consume the same `run-tests.sh`.
+
+### Slash commands (Claude Code + Copilot)
+
+Three AI-assisted workflows wrap the test harness. Claude Code operators get `/test`, `/diagnose`, `/repro`; Copilot operators get `/mcp-test`, `/mcp-diagnose`, `/mcp-repro`. Bodies:
+
+- `.claude/commands/{test,diagnose,repro}.md`
+- `.github/prompts/mcp-{test,diagnose,repro}.prompt.md`
+
+`.claude/commands/README.md` is the index.
+
+House rules for agents running these prompts:
+
+- **Interpret failures, don't just echo them.** Pull firmware log tails from `report.html` and classify each failure as transient / environmental / regression. Use the exact format in `.claude/commands/test.md`.
+- **No destructive writes without operator approval.** Any skill that could reflash, factory-reset, or reboot a device must describe the action and stop. The operator authorizes.
+- **Sequential MCP calls per port.** See above.
+- **"Unknown" is a valid classification.** If evidence doesn't support a root cause, say so and list what would disambiguate. Do not invent.
+
+### Key fixtures (test authors + agents debugging)
+
+`mcp-server/tests/conftest.py` provides:
+
+- **`_session_userprefs`** (autouse session) — snapshots `userPrefs.jsonc` at session start, merges the session test profile via `userprefs.merge_active(test_profile)`, restores at teardown. Four layers of safety: pytest teardown + `atexit` + sidecar file (`userPrefs.jsonc.mcp-session-bak`) + startup self-heal in `run-tests.sh`. **Do not edit `userPrefs.jsonc` from inside a test.**
+- **`_firmware_log_stream`** (autouse session) — subscribes to `meshtastic.log.line` pubsub on every connected `SerialInterface` and mirrors lines to `tests/fwlog.jsonl`. Drives the TUI firmware-log pane.
+- **`_debug_log_buffer`** (autouse per-test) — captures last 200 firmware log lines + device state for attachment to the pytest-html `Meshtastic debug` section on failure.
+- **`hub_devices`** (session) — `dict[role, SerialInterface]` with session-long exclusive port locks. Reason the TUI's device poller is gated to startup + post-run only.
+- **`baked_mesh`** — parametrized mesh-pair fixture; depends on `test_00_bake`. `pytest_generate_tests` in `conftest.py` auto-generates `[nrf52->esp32s3]` and `[esp32s3->nrf52]` variants.
+- **`test_profile`** — session-scoped dict: region, primary channel, admin key, PSK seed. Derived from `MESHTASTIC_MCP_SEED` (defaults to `mcp-<user>-<host>`).
+
+### Firmware integration points tied to the test harness
+
+Two firmware changes exist specifically so the test harness works reliably. **Keep these in mind when touching related code.**
+
+- **`src/mesh/StreamAPI.cpp` + `StreamAPI.h`** — `emitLogRecord` uses a dedicated `fromRadioScratchLog` + `txBufLog` pair and a `concurrency::Lock streamLock`. Before this fix, `debug_log_api_enabled=true` would tear `FromRadio` protobufs on the serial transport because `emitTxBuffer` and `emitLogRecord` shared a single scratch buffer. The conftest enables the log stream session-wide; without this fix the device would corrupt its own FromRadio replies mid-session.
+- **`src/mesh/PhoneAPI.cpp`** — `ToRadio` `Heartbeat(nonce=1)` triggers `nodeInfoModule->sendOurNodeInfo(NODENUM_BROADCAST, true, 0, true)` for serial clients, mirroring the pre-existing behavior for TCP/UDP clients in `PacketAPI.cpp`. The mesh tests rely on this to force a NodeInfo broadcast right after connect so the peer discovers them before the test's first assertion.
+
+If you're modifying `StreamAPI`, `PhoneAPI`, `NodeInfoModule`, or `userPrefs` flow, run `./mcp-server/run-tests.sh` at minimum before asking for review.
+
+### Recovery playbooks
+
+| Symptom                                                                           | First check                                                   | Fix                                                                                                                                                                                                                              |
+| --------------------------------------------------------------------------------- | ------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `userPrefs.jsonc` dirty after test run                                            | `git status --porcelain userPrefs.jsonc`                      | If non-empty, re-run `./mcp-server/run-tests.sh` once — the pre-flight self-heal restores from sidecar. If still dirty, `git checkout userPrefs.jsonc`.                                                                          |
+| Port busy / wedged CP2102 on macOS                                                | `lsof /dev/cu.usbserial-0001`                                 | Kill the holder. USB replug if the kernel still reports busy. Often a stale `pio device monitor` or zombie `meshtastic_mcp` process.                                                                                             |
+| nRF52 appears unresponsive                                                        | `list_devices` shows VID `0x239A` but `device_info` times out | `touch_1200bps(port=...)` drops it into the DFU bootloader → `pio_flash` re-installs.                                                                                                                                            |
+| Device fully wedged (Guru Meditation, frozen CDC, no DFU)                         | `list_devices` shows the VID but every admin call times out   | `uhubctl_cycle(role="nrf52", confirm=True)` hard-power-cycles the port via USB hub PPPS. `baked_single`'s auto-recovery hook does this once automatically if uhubctl is installed. Falls back to physical replug if no PPPS hub. |
+| Multiple MCP server processes                                                     | `ps aux \| grep meshtastic_mcp` shows >1                      | Kill all but the one your MCP host spawned. Zombies hold ports and break tests.                                                                                                                                                  |
+| Mesh formation fails, one side sees peer but other doesn't                        | `/diagnose` (or `list_nodes` on both sides)                   | Asymmetric NodeInfo. `test_direct_with_ack` has a heal path; `/repro` it a few times. If persistent, both devices' clocks may be out of sync with their NodeInfo cooldown.                                                       |
+| "role not present on hub" in skip reasons                                         | `list_devices`                                                | Expected if a device is unplugged. Reconnect before re-running the tier.                                                                                                                                                         |
+| Entire `tests/recovery/` tier skipped                                             | `command -v uhubctl`                                          | Expected if `uhubctl` isn't on PATH. Install via `brew install uhubctl` (macOS) or `apt install uhubctl` (Debian/Ubuntu). Also skips if no hub advertises PPPS.                                                                  |
+| Entire `tests/ui/` tier skipped ("firmware not baked with USERPREFS_UI_TEST_LOG") | reportlog.jsonl for the skip reason                           | Re-run with `--force-bake` so the UI-log macro gets compiled into the fresh firmware. First run after the Round-3 landing always re-bakes.                                                                                       |
+| `tests/ui/` runs but captures are all 1×1 black PNGs                              | `MESHTASTIC_UI_CAMERA_DEVICE_ESP32S3`                         | Env var not set → `NullBackend`. Point a USB webcam at the heltec-v3 OLED and set the device index; `.venv/bin/python -c "import cv2; [print(i, cv2.VideoCapture(i).read()[0]) for i in range(5)]"` discovers it.                |
+| Tests fail only on first attempt then pass on rerun                               | —                                                             | State leak from a prior session. Run with `--force-bake` to reset to a known state.                                                                                                                                              |
+
+### Never do these without asking
+
+- `factory_reset` — wipes node identity; regenerates PKI keypair. Mesh peers will reject old DMs until re-exchange. Legitimate only when the operator explicitly wants it.
+- `erase_and_flash` — full chip erase; destroys all on-device state.
+- `esptool_erase_flash` / `esptool_raw` write/erase — bypasses pio's safety chain.
+- `set_config` on `lora.region` — changes regulatory domain; requires physical-location context the operator has and the agent doesn't.
+- `reboot` / `shutdown` mid-test — breaks fixture invariants.
+- `push -f`, `rebase -i`, `reset --hard`, or any history-rewriting git operation.
+- Clicking computer-use tools on web links in Mail/Messages/PDFs — open URLs via the claude-in-chrome MCP so the extension's link-safety checks apply.
+
+## Resources
+
+- [Documentation](https://meshtastic.org/docs/)
@@ -0,0 +1,3 @@
+---
+agent: hardware-support
+---
@@ -0,0 +1,64 @@
+---
+mode: agent
+description: Device health report via the meshtastic MCP tools (Copilot equivalent of the Claude Code /diagnose slash command)
+---
+
+# `/mcp-diagnose` — device health report
+
+Equivalent of `.claude/commands/diagnose.md`. Use when the operator asks to "check the devices", "what's the mesh looking like", "is nrf52 alive", etc.
+
+This prompt assumes the meshtastic MCP server is registered with your VS Code Copilot agent. If it isn't, fall back to running `./mcp-server/run-tests.sh tests/unit` plus a short `device_info` script via the terminal.
+
+## What to do
+
+1. **Enumerate hardware** via the `list_devices` MCP tool (with `include_unknown=True`). For each entry where `likely_meshtastic=True`, capture `port`, `vid`, `pid`, `description`.
+
+2. **Apply the operator's filter** (if any):
+   - No filter → every likely-meshtastic device.
+   - `nrf52` → `vid == 0x239a`
+   - `esp32s3` → `vid == 0x303a` or `vid == 0x10c4`
+   - A `/dev/cu.*` path → only that port.
+   - Anything else → substring match on port.
+
+3. **For each selected device, in sequence (don't parallelize — SerialInterface holds an exclusive port lock):**
+   - `device_info(port=<p>)` → `my_node_num`, `long_name`, `short_name`, `firmware_version`, `hw_model`, `region`, `num_nodes`, `primary_channel`
+   - `list_nodes(port=<p>)` → peer count, which peers have `publicKey`, SNR/RSSI distribution
+   - `get_config(section="lora", port=<p>)` → region, preset, channel_num, tx_power, hop_limit
+   - If anything looks off (can't connect, `num_nodes` wrong, missing `firmware_version`), open a short firmware-log window: `serial_open(port=<p>, env=<inferred>)`, wait 3 seconds, `serial_read(session_id, max_lines=100)`, `serial_close(session_id)`. Infer env from VID (0x239a → `rak4631`, 0x303a/0x10c4 → `heltec-v3`) unless an `MESHTASTIC_MCP_ENV_<ROLE>` env var overrides it.
+
+4. **Hub health** (call once, not per-device): `uhubctl_list()` — enumerates every USB hub the host sees. Cross-reference each Meshtastic device's VID to find which hub + port it's on. Flag in the report if:
+   - No hub advertises `ppps=true` → `tests/recovery/` can't run; hard-recovery via `uhubctl_cycle` isn't available.
+   - A Meshtastic device is on a non-PPPS hub → note it; moving to a PPPS hub unlocks auto-recovery.
+   - `uhubctl_list` raises `ConfigError: uhubctl not found` → report as "uhubctl not installed"; don't treat as a device fault.
+
+5. **Render per-device report** as a compact block:
+
+   ```text
+   [nrf52 @ /dev/cu.usbmodem1101]      fw=2.7.23.bce2825, hw=RAK4631
+     owner       : Meshtastic 40eb / 40eb
+     region/band : US, channel 88, LONG_FAST
+     tx_power    : 30 dBm, hop_limit=3
+     peers       : 1 (esp32s3 0x433c2428, pubkey ✓, SNR 6.0 / RSSI -24 dBm)
+     primary ch  : McpTest
+     hub         : 1-1.3 port 2 (PPPS, uhubctl-controllable)
+     firmware    : no panics in last 3s
+   ```
+
+   Flag abnormalities inline with `⚠︎ <short reason>` — missing pubkey on a known peer, region UNSET, mismatched channel name, device on non-PPPS hub, etc.
+
+6. **Cross-device correlation** (when >1 device selected):
+   - Do both see each other in `nodesByNum`?
+   - Do `region`, `channel_num`, `modem_preset` match across devices?
+   - Do the primary channel names match? (Different name → different PSK → no decode.)
+
+7. **Suggest next steps only for recognizable failure modes**, never speculatively:
+   - Stale PKI one-way → "`/mcp-test tests/mesh/test_direct_with_ack.py` — the test's retry+nodeinfo-ping heals this."
+   - Region mismatch → "re-bake one side via `./mcp-server/run-tests.sh --force-bake`."
+   - Device unreachable, DFU reachable → `touch_1200bps(port=...)` + `pio_flash`. If not even DFU responds and the device is on a PPPS hub, escalate to `uhubctl_cycle(role=..., confirm=True)`.
+   - CP2102-wedged-driver on macOS → see `run-tests.sh` notes.
+
+## Hard constraints
+
+- **Read-only.** No `set_config`, no `reboot`, no `factory_reset`, no `flash`. If the operator wants mutation, they'll escalate explicitly.
+- **Open/query/close per device.** Never hold multiple SerialInterfaces to the same port. The port lock is exclusive.
+- **Don't infer env beyond the VID map** — if the operator has an unusual board, ask them which env to use rather than guessing.
@@ -0,0 +1,68 @@
+---
+mode: agent
+description: Re-run a specific test N times to triage flakes; diff firmware logs between passes and failures (Copilot equivalent of the Claude Code /repro slash command)
+---
+
+# `/mcp-repro` — flakiness triage for one test
+
+Equivalent of `.claude/commands/repro.md`. Use when the operator says "that one test is flaky — dig in", "repro the direct_with_ack failure", "why does X sometimes fail?".
+
+## What to do
+
+1. **Parse the operator's input** into two pieces:
+   - **Test identifier** — either a pytest node id (has `::` or starts with `tests/`) or a `-k`-style filter (plain substring like `direct_with_ack`).
+   - **Count** — integer, default `5`, cap at `20`. If the operator asks for 50, negotiate down and explain (airtime + USB wear).
+
+2. **Sanity-check the hub** via the `list_devices` MCP tool. If the test name references `nrf52` or `esp32s3` and the matching VID isn't present, stop and report — re-running won't help.
+
+3. **Loop** N times. Each iteration:
+
+   ```bash
+   ./mcp-server/run-tests.sh <test-id> --tb=short -p no:cacheprovider
+   ```
+
+   `-p no:cacheprovider` keeps pytest from caching anything between iterations. Capture: exit code, duration, and (on failure) the `Meshtastic debug` firmware-log section from `mcp-server/tests/report.html`.
+
+4. **Tally** results as you go:
+
+   ```text
+   attempt 1: PASS (42s)
+   attempt 2: FAIL (128s)    ← fw log captured
+   attempt 3: PASS (39s)
+   attempt 4: FAIL (121s)
+   attempt 5: PASS (41s)
+   --------------------------------------------------
+   pass rate: 3/5 (60%)  |  mean duration: 74s
+   ```
+
+5. **On mixed outcomes, diff the firmware logs** between one representative pass and one representative fail. Focus on:
+   - Error-level lines present only in failures (`PKI_UNKNOWN_PUBKEY`, `Alloc an err=`, `Skip send`, `No suitable channel`, `NAK`)
+   - Timing around the assertion point (broadcast sent? ACK received? retry fired?)
+   - Device-state fields that changed between attempts
+
+   Surface the top 3 differences as a compact "passes when / fails when" table with uptime timestamps. Don't dump full logs.
+
+6. **Classify** the flake into one of:
+   - **LoRa airtime collision** — pass rate improves with fewer concurrent transmitters. Suggest a `time.sleep` gap or retry bump in the test body.
+   - **PKI key staleness** — first attempt fails, subsequent ones pass; existing retry-loop pattern in `test_direct_with_ack.py` is the fix.
+   - **NodeInfo cooldown** — `Skip send NodeInfo since we sent it <600s ago` in fail-only logs; needs a `broadcast_nodeinfo_ping()` warmup.
+   - **Hardware-specific** — one direction consistently fails, firmware versions differ, CP2102 driver wedged, etc. For a device wedged past `touch_1200bps`, recommend `uhubctl_cycle(role=..., confirm=True)` to hard-power-cycle its hub port (requires `uhubctl` installed).
+   - **Device went dark mid-run** — fails from some iteration onward and never recovers; firmware log stops arriving. Almost always a Guru crash with frozen CDC. Recommend `uhubctl_cycle` before the next iteration; escalate to replug if that also fails.
+   - **Unknown** — say so. Don't invent a root cause.
+
+7. **Report back** with:
+   - Pass rate + mean duration.
+   - Classification + the specific log evidence for it.
+   - A concrete next step (tighter assertion, more retries, open `/mcp-diagnose`, file a bug, nothing).
+
+## Examples
+
+- `tests/mesh/test_direct_with_ack.py::test_direct_with_ack_roundtrip[esp32s3->nrf52] 10` — 10 runs of that parametrized case.
+- `broadcast_delivers` — no `::`, no `tests/`; treat as `-k broadcast_delivers`; runs every match 5 times.
+- `tests/telemetry/test_device_telemetry_broadcast.py 3` — shorter count for a slow test.
+
+## Notes
+
+- If the FIRST attempt fails and the rest pass, that's a state-leak signature — suggest starting from `--force-bake` or a clean device state rather than chasing the first-failure firmware logs.
+- If ALL N fail, this isn't a flake — it's a regression. Say so, stop iterating, escalate to `/mcp-test` for full-suite context.
+- Don't rebuild firmware during triage. Flakes that only reproduce under different firmware belong in a separate session with a plan.
@@ -0,0 +1,57 @@
+---
+mode: agent
+description: Run the mcp-server test suite and interpret results (Copilot equivalent of the Claude Code /test slash command)
+---
+
+# `/mcp-test` — mcp-server test runner with interpretation
+
+Equivalent of the Claude Code `/test` slash command in `.claude/commands/test.md`. Use this when the operator asks you to "run the tests", "check the mcp test suite", "run the mesh tests", etc.
+
+## What to do
+
+1. **Invoke the wrapper** from the firmware repo root:
+
+   ```bash
+   ./mcp-server/run-tests.sh [pytest-args]
+   ```
+
+   If the operator specified a subset (e.g. "just the mesh tests"), pass it through as `tests/mesh` or a pytest `-k filter`. If they said nothing, use the wrapper's defaults (full suite with pytest-html report).
+
+   The wrapper auto-detects connected Meshtastic devices, maps each to its PlatformIO env, exports the required env vars, and invokes pytest. Zero pre-flight config needed from the operator.
+
+2. **Read the pre-flight header** (first few lines of wrapper output). The `detected hub :` line lists role → port → env mappings. If it reads `(none)`, the wrapper narrowed to `tests/unit` only — call that out explicitly so the operator knows hardware tiers were skipped.
+
+3. **On pass**: one-line summary like `N passed, M skipped in <duration>`. Don't enumerate test names. DO mention any non-placeholder SKIPs and name the cause:
+   - `"role not present on hub"` → device unplugged; operator should reconnect.
+   - `"firmware not baked with USERPREFS_UI_TEST_LOG"` → tests/ui skipped; the UI-log compile macro isn't in the baked firmware. Suggest `--force-bake`.
+   - `"uhubctl not installed"` → tests/recovery + `test_peer_offline_recovery` skipped. Suggest `brew install uhubctl` / `apt install uhubctl`.
+   - `"no PPPS-capable hubs detected"` → tests/recovery skipped because the attached hub doesn't support per-port power switching; won't run on that setup.
+   - `"opencv-python-headless is not installed"` → tests/ui auto-deselected by `run-tests.sh`. Suggest `pip install -e 'mcp-server/.[ui]'`.
+
+4. **On failure**: open `mcp-server/tests/report.html` (pytest-html output, self-contained) and extract the `Meshtastic debug` section for each failed test. That section includes a firmware log stream (last 200 lines) and device state dump. For each failure, summarise:
+   - test name
+   - one-line assertion message
+   - the specific firmware log lines that explain why (look for `PKI_UNKNOWN_PUBKEY`, `Skip send NodeInfo`, `Error=`, `Guru Meditation`, `assertion failed`, `No suitable channel`)
+   - for UI-tier failures also check `mcp-server/tests/ui_captures/<session>/<test>/transcript.md` (per-step frame + OCR)
+
+5. **Classify each failure** as one of:
+   - **Transient flake** — LoRa collision, first-attempt NAK with self-heal pattern, timing-sensitive assertion. Suggest `/mcp-repro <test-id>` to confirm.
+   - **Environmental** — device unreachable, port busy, CP2102 driver wedged on macOS. Suggest recovery in escalation order: (a) replug USB, (b) `touch_1200bps` + `pio_flash` for nRF52 DFU, (c) `uhubctl_cycle(role=..., confirm=True)` for a device wedged past DFU (needs `uhubctl` installed; `baked_single` does this once automatically when available). Also check `git status userPrefs.jsonc`.
+   - **Regression** — same assertion fails repeatedly on re-runs, firmware log shows novel errors. Identify the firmware module likely responsible.
+
+6. **Do NOT run destructive recovery automatically**. If a failure looks like it needs a reflash, factory*reset, `uhubctl_cycle`, or replug — \_describe the steps* and let the operator decide. Never burn airtime or flash cycles without approval.
+
+## Arguments convention
+
+Operators generally invoke this prompt either with no arguments (full suite) or with a specific subset. Examples:
+
+- `tests/mesh` — one tier
+- `tests/mesh/test_direct_with_ack.py::test_direct_with_ack_roundtrip` — one test
+- `--force-bake` — reflash devices first
+- `-k telemetry` — name-filter
+
+## Side-effects to confirm in your summary
+
+- `userPrefs.jsonc` should be clean after a successful run. The session fixture in `mcp-server/tests/conftest.py` (`_session_userprefs`) snapshots and restores. Check `git status --porcelain userPrefs.jsonc` and report if it's non-empty.
+- `mcp-server/tests/report.html` and `junit.xml` regenerate on every run.
+- The wrapper prints a warning if a `.mcp-session-bak` sidecar was left over from a crashed prior session and auto-restores from it — mention that if it happened.
@@ -0,0 +1,138 @@
+# New Meshtastic Module
+
+Guide for developing a new Meshtastic firmware module.
+
+## Module Hierarchy
+
+Choose the appropriate base class:
+
+1. **`MeshModule`** — Raw base class. Override `wantPacket()` and `handleReceived()`. Returns `ProcessMessage::STOP` or `ProcessMessage::CONTINUE`.
+2. **`SinglePortModule`** — Handles a single `meshtastic_PortNum`. Constructor takes `(name, portNum)`. Simplified `wantPacket()` checking `decoded.portnum`. Use `allocDataPacket()` to create outgoing packets.
+3. **`ProtobufModule<T>`** — Template for protobuf-encoded modules. Constructor takes `(name, portNum, fields)`. Override `handleReceivedProtobuf()`. Use `allocDataProtobuf(payload)` to create outgoing packets.
+
+Most modules also mix in `concurrency::OSThread` for periodic background tasks.
+
+## Implementation Pattern
+
+```cpp
+// src/modules/MyModule.h
+#pragma once
+#include "ProtobufModule.h"
+#include "concurrency/OSThread.h"
+
+class MyModule : public ProtobufModule<meshtastic_MyMessage>, private concurrency::OSThread
+{
+  public:
+    MyModule();
+
+  protected:
+    // Process incoming protobuf packet. Return true to stop further processing.
+    virtual bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_MyMessage *msg) override;
+
+    // Generate response packet (optional)
+    virtual meshtastic_MeshPacket *allocReply() override;
+
+    // Periodic task — return next run interval in ms, or disable()
+    virtual int32_t runOnce() override;
+
+    // Modify packet in-flight before delivery (optional)
+    virtual bool alterReceivedProtobuf(meshtastic_MeshPacket &mp, meshtastic_MyMessage *msg);
+
+    // Request a UI display frame (optional)
+    virtual bool wantUIFrame();
+};
+```
+
+## Registration
+
+Register in `src/modules/Modules.cpp` inside `setupModules()`:
+
+```cpp
+#if !MESHTASTIC_EXCLUDE_MYMODULE
+    new MyModule();
+#endif
+```
+
+If other code needs to reference the module instance:
+
+```cpp
+#if !MESHTASTIC_EXCLUDE_MYMODULE
+    myModule = new MyModule();
+#endif
+```
+
+And declare the global in the header:
+
+```cpp
+extern MyModule *myModule;
+```
+
+Some modules also conditionally instantiate based on `moduleConfig`:
+
+```cpp
+#if !MESHTASTIC_EXCLUDE_MYMODULE
+    if (moduleConfig.has_my_module && moduleConfig.my_module.enabled) {
+        new MyModule();
+    }
+#endif
+```
+
+## Conditional Compilation
+
+Add a `MESHTASTIC_EXCLUDE_MYMODULE` guard. This allows the module to be excluded from constrained builds. The flag name must follow the pattern: `MESHTASTIC_EXCLUDE_` + uppercase module name.
+
+## Protobuf Messages (if needed)
+
+1. Define messages in `protobufs/meshtastic/` (e.g., `mymodule.proto`)
+2. Add a `.options` file for nanopb field size constraints
+3. Regenerate with `bin/regen-protos.sh`
+4. Generated code appears in `src/mesh/generated/meshtastic/`
+5. Assign a `meshtastic_PortNum` if the module uses a new port number
+
+## Timing and Defaults
+
+Use `Default` class helpers for configurable intervals:
+
+```cpp
+int32_t MyModule::runOnce()
+{
+    uint32_t interval = Default::getConfiguredOrDefaultMs(moduleConfig.my_module.update_interval,
+                                                          default_my_module_interval);
+    // ... do work ...
+    return interval;
+}
+```
+
+On public/default channels, enforce minimums with `Default::getConfiguredOrMinimumValue()`.
+
+## Observer Pattern
+
+Subscribe to system events:
+
+```cpp
+CallbackObserver<MyModule, const meshtastic::Status *> statusObserver =
+    CallbackObserver<MyModule, const meshtastic::Status *>(this, &MyModule::handleStatusUpdate);
+```
+
+## Testing
+
+Add test suite in `test/test_mymodule/`:
+
+```text
+test/
+└── test_mymodule/
+    └── test_main.cpp
+```
+
+Run with: `pio test -e native`
+
+## Checklist
+
+- [ ] Header and implementation files in `src/modules/`
+- [ ] Inherit from appropriate base class (MeshModule / SinglePortModule / ProtobufModule)
+- [ ] Mix in OSThread if periodic work is needed
+- [ ] Register in `src/modules/Modules.cpp` with `MESHTASTIC_EXCLUDE_` guard
+- [ ] Add protobuf definitions if needed (`protobufs/meshtastic/`)
+- [ ] Use `Default::getConfiguredOrDefaultMs()` for timing
+- [ ] Respect bandwidth limits on public channels
+- [ ] Add test suite in `test/`
@@ -0,0 +1,149 @@
+# New Telemetry Sensor
+
+Guide for adding a new I2C telemetry sensor driver to Meshtastic firmware.
+
+## Overview
+
+Telemetry sensors live in `src/modules/Telemetry/Sensor/`. There are 50+ existing drivers organized by measurement type. Each sensor integrates with one of the telemetry modules:
+
+- **EnvironmentTelemetryModule** — Temperature, humidity, pressure, gas, light
+- **AirQualityTelemetryModule** — Particulate matter, VOCs
+- **PowerTelemetryModule** — Voltage, current, power monitoring
+- **HealthTelemetryModule** — Heart rate, SpO2, body temperature
+
+## Sensor Driver Pattern
+
+Each sensor has a `.h` and `.cpp` file pair following this pattern:
+
+```cpp
+// src/modules/Telemetry/Sensor/MySensor.h
+#pragma once
+#include "TelemetrySensor.h"
+#include <MySensorLibrary.h>  // Arduino/PlatformIO library
+
+class MySensor : virtual public TelemetrySensor
+{
+  private:
+    MySensorLibrary sensor;
+
+  public:
+    MySensor() : TelemetrySensor(meshtastic_TelemetrySensorType_MY_SENSOR, "MySensor") {}
+
+    // Initialize sensor hardware. Return true on success.
+    virtual void setup() override;
+
+    // Read sensor data into the telemetry protobuf. Return true on success.
+    virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+};
+```
+
+```cpp
+// src/modules/Telemetry/Sensor/MySensor.cpp
+#include "MySensor.h"
+#include "TelemetrySensor.h"
+
+void MySensor::setup()
+{
+    sensor.begin();
+    // Configure sensor parameters...
+}
+
+bool MySensor::getMetrics(meshtastic_Telemetry *measurement)
+{
+    // Read from hardware
+    float value = sensor.readValue();
+
+    // Populate the appropriate protobuf variant
+    measurement->variant.environment_metrics.temperature = value;
+    // ... other fields ...
+
+    return true;
+}
+```
+
+## I2C Address Registration
+
+Register the sensor's I2C address(es) in `src/detect/ScanI2C` so it's auto-detected at boot:
+
+1. Add a `DeviceType` enum entry in `src/detect/ScanI2C.h`
+2. Add the I2C address mapping in `src/detect/ScanI2CTwoWire.cpp`
+
+The scan runs at boot and populates a device map that telemetry modules use to decide which sensors to initialize.
+
+## Protobuf Fields
+
+If the sensor provides data not covered by existing telemetry fields:
+
+1. Add fields to the appropriate message in `protobufs/meshtastic/telemetry.proto`:
+   - `EnvironmentMetrics` — Environmental measurements
+   - `AirQualityMetrics` — Air quality data
+   - `PowerMetrics` — Power/energy data
+   - `HealthMetrics` — Health/biometric data
+2. Add a `.options` constraint if needed (field sizes for nanopb)
+3. Regenerate: `bin/regen-protos.sh`
+
+## Sensor Type Enum
+
+Add the sensor to `meshtastic_TelemetrySensorType` enum in `protobufs/meshtastic/telemetry.proto`:
+
+```protobuf
+enum TelemetrySensorType {
+    // ... existing entries ...
+    MY_SENSOR = XX;
+}
+```
+
+## Integration with Telemetry Module
+
+Wire the sensor into the appropriate telemetry module. For environment sensors, this is typically in `src/modules/Telemetry/EnvironmentTelemetry.cpp`:
+
+1. Include the sensor header
+2. Add initialization in `setupSensor()` guarded by detection results
+3. Call `getMetrics()` in the measurement collection path
+
+Example pattern from existing sensors:
+
+```cpp
+#include "Sensor/MySensor.h"
+
+MySensor mySensor;
+
+// In setup:
+if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_MY_SENSOR].first > 0) {
+    mySensor.setup();
+}
+
+// In measurement collection:
+if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_MY_SENSOR].first > 0) {
+    mySensor.getMetrics(&measurement);
+}
+```
+
+## Library Dependencies
+
+If the sensor needs an external library, add it to the `lib_deps` in the relevant base platformio.ini configs:
+
+```ini
+lib_deps =
+    ${env.lib_deps}
+    mysensorlibrary@^1.0.0
+```
+
+Or use a conditional dependency if it's platform-specific.
+
+## Unit Conversions
+
+If the sensor reports values in non-standard units, use `src/modules/Telemetry/UnitConversions.h` for conversion helpers (e.g., Celsius ↔ Fahrenheit, hPa ↔ inHg).
+
+## Checklist
+
+- [ ] Create `src/modules/Telemetry/Sensor/MySensor.h` and `.cpp`
+- [ ] Inherit from `TelemetrySensor` base class
+- [ ] Implement `setup()` and `getMetrics()` methods
+- [ ] Add `meshtastic_TelemetrySensorType` enum entry in `telemetry.proto`
+- [ ] Add I2C address to `src/detect/ScanI2C` for auto-detection
+- [ ] Add protobuf fields in `telemetry.proto` if new data types needed
+- [ ] Regenerate protos: `bin/regen-protos.sh`
+- [ ] Wire into the appropriate telemetry module (Environment/AirQuality/Power/Health)
+- [ ] Add library dependency if external library required
+- [ ] Test on hardware or native build
@@ -0,0 +1,178 @@
+# New Hardware Variant
+
+Guide for adding a new Meshtastic hardware variant to the firmware.
+
+## Directory Structure
+
+Create under `variants/<arch>/<name>/`:
+
+```text
+variants/
+├── esp32/          # ESP32
+├── esp32s3/        # ESP32-S3
+├── esp32c3/        # ESP32-C3
+├── esp32c6/        # ESP32-C6
+├── nrf52840/       # nRF52840
+├── rp2040/         # RP2040/RP2350
+├── stm32/          # STM32WL
+└── native/         # Linux/Portduino
+```
+
+Each variant needs at minimum:
+
+- `variant.h` — Pin definitions and hardware capabilities
+- `platformio.ini` — Build configuration
+
+Optional files:
+
+- `pins_arduino.h` — Arduino pin mapping overrides
+- `rfswitch.h` — RF switch control for multi-band radios
+- `nicheGraphics.h` — InkHUD e-ink configuration
+
+## variant.h Template
+
+```cpp
+// Pin definitions
+#define I2C_SDA 21
+#define I2C_SCL 22
+
+// LoRa radio
+#define USE_SX1262              // Radio chip: USE_SX1262, USE_SX1268, USE_SX1280, USE_RF95, USE_LLCC68, USE_LR1110, USE_LR1120, USE_LR1121
+#define LORA_CS   18
+#define LORA_SCK  5
+#define LORA_MOSI 27
+#define LORA_MISO 19
+#define LORA_DIO1 33            // SX126x: DIO1, SX128x: DIO1, RF95: IRQ
+#define LORA_RESET 23
+#define LORA_BUSY 32            // SX126x/SX128x only
+#define SX126X_DIO2_AS_RF_SWITCH // Common for SX1262 boards
+
+// GPS
+#define HAS_GPS 1
+#define GPS_RX_PIN 34
+#define GPS_TX_PIN 12
+// #define PIN_GPS_EN 47         // Optional GPS enable pin
+// #define GPS_BAUDRATE 9600     // Override default 9600
+
+// Display
+#define HAS_SCREEN 1
+// #define USE_SSD1306            // OLED type
+// #define USE_SH1106             // Alternative OLED
+// #define USE_ST7789             // TFT type
+// #define SCREEN_WIDTH 128
+// #define SCREEN_HEIGHT 64
+
+// LEDs
+#define LED_PIN 2               // Status LED (optional)
+// #define HAS_NEOPIXEL 1        // WS2812 support
+
+// Buttons
+#define BUTTON_PIN 38
+// #define BUTTON_PIN_ALT 0      // Secondary button
+
+// Power management
+// #define HAS_AXP192 1          // AXP192 PMU (T-Beam v1.0)
+// #define HAS_AXP2101 1         // AXP2101 PMU (T-Beam v1.2+)
+// #define BATTERY_PIN 35        // ADC battery voltage pin
+// #define ADC_MULTIPLIER 2.0    // Voltage divider ratio
+
+// Optional I2C devices
+// #define HAS_RTC 1             // Real-time clock
+// #define HAS_TELEMETRY 1       // Enable telemetry sensor support
+// #define HAS_SENSOR 1          // I2C sensors present
+```
+
+## platformio.ini Template
+
+```ini
+[env:my_variant]
+extends = esp32s3_base            ; Use architecture-specific base
+board = esp32-s3-devkitc-1        ; PlatformIO board definition (or custom in boards/)
+board_level = extra               ; Build level: extra, or omit for default
+custom_meshtastic_support_level = 1  ; 1 = PR builds, 2 = merge builds only
+
+build_flags =
+    ${esp32s3_base.build_flags}
+    -D MY_VARIANT_SPECIFIC_FLAG=1
+    -I variants/esp32s3/my_variant  ; Include path for variant.h
+
+upload_speed = 921600
+```
+
+### Common Base Configs
+
+- `esp32_base` / `esp32-common.ini` — ESP32
+- `esp32s3_base` — ESP32-S3
+- `esp32c3_base` — ESP32-C3
+- `esp32c6_base` — ESP32-C6
+- `nrf52840_base` / `nrf52.ini` — nRF52840
+- `rp2040_base` — RP2040/RP2350
+
+### Support Levels
+
+- `custom_meshtastic_support_level = 1` — Built on every PR (actively supported)
+- `custom_meshtastic_support_level = 2` — Built only on merge to main branches
+- `board_level = extra` — Only built on full releases
+
+## Build Manifest Metadata
+
+`bin/platformio-custom.py` emits UI capability flags in the build manifest:
+
+- `custom_meshtastic_has_mui = true/false` — Override MUI detection
+- `custom_meshtastic_has_ink_hud = true/false` — Override InkHUD detection
+- Architecture names are normalized (e.g., `esp32s3` → `esp32-s3`)
+
+## InkHUD E-Ink Variants
+
+For e-ink display variants using the InkHUD framework, add `nicheGraphics.h`:
+
+```cpp
+// nicheGraphics.h — InkHUD configuration for this variant
+#define INKHUD                     // Enable InkHUD
+// Configure display, applets, and refresh behavior per device
+```
+
+InkHUD has its own PlatformIO config: `src/graphics/niche/InkHUD/PlatformioConfig.ini`
+
+## I2C Device Detection
+
+If the variant has I2C devices, ensure `src/detect/ScanI2C` will detect them. The auto-detection system handles 80+ device types including displays, sensors, RTCs, keyboards, PMUs, and touch controllers at boot.
+
+## Custom Board Definitions
+
+If the PlatformIO board doesn't exist, create a custom board JSON in `boards/`:
+
+```json
+{
+  "build": {
+    "arduino": { "ldscript": "esp32s3_out.ld" },
+    "core": "esp32",
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "mcu": "esp32s3",
+    "variant": "esp32s3"
+  },
+  "connectivity": ["wifi", "bluetooth"],
+  "frameworks": ["arduino", "espidf"],
+  "name": "My Custom Board",
+  "upload": {
+    "flash_size": "8MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 8388608
+  },
+  "url": "https://example.com",
+  "vendor": "MyVendor"
+}
+```
+
+## Checklist
+
+- [ ] Create `variants/<arch>/<name>/variant.h` with pin definitions
+- [ ] Create `variants/<arch>/<name>/platformio.ini` extending correct base
+- [ ] Set `custom_meshtastic_support_level` (1 or 2)
+- [ ] Verify radio chip define matches hardware (`USE_SX1262`, etc.)
+- [ ] Set hardware capability flags (`HAS_GPS`, `HAS_SCREEN`, etc.)
+- [ ] Add custom board JSON in `boards/` if needed
+- [ ] Test build: `pio run -e my_variant`
+- [ ] For e-ink: add `nicheGraphics.h` with InkHUD config
@@ -0,0 +1,3 @@
+---
+agent: speckit.analyze
+---
@@ -0,0 +1,3 @@
+---
+agent: speckit.checklist
+---
@@ -0,0 +1,3 @@
+---
+agent: speckit.clarify
+---
@@ -0,0 +1,3 @@
+---
+agent: speckit.constitution
+---
@@ -0,0 +1,3 @@
+---
+agent: speckit.implement
+---
@@ -0,0 +1,3 @@
+---
+agent: speckit.plan
+---
@@ -0,0 +1,3 @@
+---
+agent: speckit.specify
+---
@@ -0,0 +1,3 @@
+---
+agent: speckit.tasks
+---
@@ -0,0 +1,3 @@
+---
+agent: speckit.taskstoissues
+---
@@ -4,16 +4,16 @@

 - Before starting on some new big chunk of code, it it is optional but highly recommended to open an issue first
  to say "Hey, I think this idea X should be implemented and I'm starting work on it. My general plan is Y, any feedback
-  is appreciated." This will allow other devs to potentially save you time by not accidentially duplicating work etc...
+  is appreciated." This will allow other devs to potentially save you time by not accidentally duplicating work etc...
 - Please do not check in files that don't have real changes
 - Please do not reformat lines that you didn't have to change the code on
- We recommend using the [Visual Studio Code](https://platformio.org/install/ide?install=vscode) editor along with the ['Trunk Check' extension](https://marketplace.visualstudio.com/items?itemName=trunk.io) (In beta for windows, WSL2 for the linux version),
+- We recommend using the [Visual Studio Code](https://platformio.org/install/ide?install=vscode) editor along with the ['Trunk Check' extension](https://marketplace.visualstudio.com/items?itemName=trunk.io) (In beta for windows, WSL2 for the Linux version),
  because it automatically follows our indentation rules and its auto reformatting will not cause spurious changes to lines.
 - If your PR fixes a bug, mention "fixes #bugnum" somewhere in your pull request description.
 - If your other co-developers have comments on your PR please tweak as needed.
 - Please also enable "Allow edits by maintainers".
 - Please do not submit untested code.
- If you do not have the affected hardware to test your code changes adequately against regressions, please indicate this, so that contributors and commnunity members can help test your changes.
+- If you do not have the affected hardware to test your code changes adequately against regressions, please indicate this, so that contributors and community members can help test your changes.
 - If your PR gets accepted you can request a "Contributor" role in the Meshtastic Discord

 ## 🤝 Attestations
@@ -16,8 +16,7 @@ on:
        type: string

 permissions:
-  contents: write
-  packages: write
+  contents: read

 jobs:
  build-debian-src:
@@ -28,21 +27,25 @@ jobs:
        with:
          submodules: recursive
          path: meshtasticd
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}

      - name: Install deps
        shell: bash
        working-directory: meshtasticd
        run: |
+          # Build-tools (notably platformio) come from the Meshtastic project
+          # on the OpenSUSE Build Service:
+          # https://build.opensuse.org/project/show/network:Meshtastic:build-tools
+          echo 'deb http://download.opensuse.org/repositories/network:/Meshtastic:/build-tools/xUbuntu_24.04/ /' \
+            | sudo tee /etc/apt/sources.list.d/network:Meshtastic:build-tools.list
+          curl -fsSL https://download.opensuse.org/repositories/network:Meshtastic:build-tools/xUbuntu_24.04/Release.key \
+            | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/network_Meshtastic_build-tools.gpg >/dev/null
          sudo apt-get update -y --fix-missing
-          sudo apt-get install -y software-properties-common build-essential devscripts equivs
-          sudo add-apt-repository ppa:meshtastic/build-tools -y
-          sudo apt-get update -y --fix-missing
+          sudo apt-get install -y build-essential devscripts equivs
          sudo mk-build-deps --install --remove --tool='apt-get -o Debug::pkgProblemResolver=yes --no-install-recommends --yes' debian/control

      - name: Import GPG key
-        uses: crazy-max/ghaction-import-gpg@v6
+        if: github.event_name != 'pull_request' && github.event_name != 'pull_request_target'
+        uses: crazy-max/ghaction-import-gpg@v7
        with:
          gpg_private_key: ${{ secrets.PPA_GPG_PRIVATE_KEY }}
        id: gpg
@@ -60,11 +63,11 @@ jobs:
        run: debian/ci_pack_sdeb.sh
        env:
          SERIES: ${{ inputs.series }}
-          GPG_KEY_ID: ${{ steps.gpg.outputs.keyid }}
+          GPG_KEY_ID: ${{ steps.gpg.outputs.keyid || '' }}
          PKG_VERSION: ${{ steps.version.outputs.deb }}

      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
        with:
          name: firmware-debian-${{ steps.version.outputs.deb }}~${{ inputs.series }}-src
          overwrite: true
@@ -21,30 +21,11 @@ jobs:
    # Use 'arctastic' self-hosted runner pool when building in the main repo
    runs-on: ${{ github.repository_owner == 'meshtastic' && 'arctastic' || 'ubuntu-latest' }}
    outputs:
-      artifact-id: ${{ steps.upload.outputs.artifact-id }}
+      artifact-id: ${{ steps.upload-firmware.outputs.artifact-id }}
    steps:
      - uses: actions/checkout@v6
        with:
          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Set OTA firmware source and target
-        if: startsWith(inputs.platform, 'esp32')
-        id: ota_dir
-        env:
-          PIO_PLATFORM: ${{ inputs.platform }}
-        run: |
-          if [ "$PIO_PLATFORM" = "esp32s3" ]; then
-            echo "src=firmware-s3.bin" >> $GITHUB_OUTPUT
-            echo "tgt=release/bleota-s3.bin" >> $GITHUB_OUTPUT
-          elif [ "$PIO_PLATFORM" = "esp32c3" ] || [ "$PIO_PLATFORM" = "esp32c6" ]; then
-            echo "src=firmware-c3.bin" >> $GITHUB_OUTPUT
-            echo "tgt=release/bleota-c3.bin" >> $GITHUB_OUTPUT
-          elif [ "$PIO_PLATFORM" = "esp32" ]; then
-            echo "src=firmware.bin" >> $GITHUB_OUTPUT
-            echo "tgt=release/bleota.bin" >> $GITHUB_OUTPUT
-          fi

      - name: Build ${{ inputs.platform }}
        id: build
@@ -53,23 +34,83 @@ jobs:
          pio_platform: ${{ inputs.platform }}
          pio_env: ${{ inputs.pio_env }}
          pio_target: build
-          ota_firmware_source: ${{ steps.ota_dir.outputs.src || '' }}
-          ota_firmware_target: ${{ steps.ota_dir.outputs.tgt || '' }}

-      - name: Echo manifest from release/firmware-*.mt.json to job summary
-        if: ${{ always() }}
+      - name: ESP32 - Download Unified OTA firmware
+        # Currently only esp32 and esp32s3 use the unified ota
+        if: inputs.platform == 'esp32' || inputs.platform == 'esp32s3'
+        id: dl-ota-unified
+        env:
+          PIO_PLATFORM: ${{ inputs.platform }}
+          PIO_ENV: ${{ inputs.pio_env }}
+          OTA_URL: https://github.com/meshtastic/esp32-unified-ota/releases/latest/download/mt-${{ inputs.platform }}-ota.bin
+        working-directory: release
+        run: |
+          curl -L -o "mt-$PIO_PLATFORM-ota.bin" $OTA_URL
+
+      - name: ESP32-C* - Download BLE-Only OTA firmware
+        if: inputs.platform == 'esp32c3' || inputs.platform == 'esp32c6'
+        id: dl-ota-ble
+        env:
+          PIO_ENV: ${{ inputs.pio_env }}
+          OTA_URL: https://github.com/meshtastic/firmware-ota/releases/latest/download/firmware-c3.bin
+        working-directory: release
+        run: |
+          curl -L -o bleota-c3.bin $OTA_URL
+
+      - name: Update manifest with OTA file
+        if: inputs.platform == 'esp32' || inputs.platform == 'esp32s3' || inputs.platform == 'esp32c3' || inputs.platform == 'esp32c6'
+        working-directory: release
+        env:
+          PIO_PLATFORM: ${{ inputs.platform }}
+        run: |
+          # Determine OTA filename based on platform
+          if [[ "$PIO_PLATFORM" == "esp32" || "$PIO_PLATFORM" == "esp32s3" ]]; then
+            OTA_FILE="mt-${PIO_PLATFORM}-ota.bin"
+          else
+            OTA_FILE="bleota-c3.bin"
+          fi
+
+          # Check if OTA file exists
+          if [[ ! -f "$OTA_FILE" ]]; then
+            echo "OTA file $OTA_FILE not found, skipping manifest update"
+            exit 0
+          fi
+
+          # Calculate MD5 and size
+          if command -v md5sum &> /dev/null; then
+            OTA_MD5=$(md5sum "$OTA_FILE" | cut -d' ' -f1)
+          else
+            OTA_MD5=$(md5 -q "$OTA_FILE")
+          fi
+          OTA_SIZE=$(stat -f%z "$OTA_FILE" 2>/dev/null || stat -c%s "$OTA_FILE")
+
+          # Find and update manifest file
+          for manifest in firmware-*.mt.json; do
+            if [[ -f "$manifest" ]]; then
+              echo "Updating $manifest with $OTA_FILE (md5: $OTA_MD5, size: $OTA_SIZE)"
+              # Add OTA entry to files array if not already present
+              jq --arg name "$OTA_FILE" --arg md5 "$OTA_MD5" --argjson bytes "$OTA_SIZE" --arg part "app1" \
+                'if .files | map(select(.name == $name)) | length == 0 then .files += [{"name": $name, "md5": $md5, "bytes": $bytes, "part_name": $part}] else . end' \
+                "$manifest" > "${manifest}.tmp" && mv "${manifest}.tmp" "$manifest"
+            fi
+          done
+
+      - name: Job summary
        env:
          PIO_ENV: ${{ inputs.pio_env }}
        run: |
-          echo "## Manifest: \`$PIO_ENV\`" >> $GITHUB_STEP_SUMMARY
+          echo "## $PIO_ENV" >> $GITHUB_STEP_SUMMARY
+          echo "<details><summary><strong>Manifest</strong></summary>" >> $GITHUB_STEP_SUMMARY
+          echo '' >> $GITHUB_STEP_SUMMARY
          echo '```json' >> $GITHUB_STEP_SUMMARY
          cat release/firmware-*.mt.json >> $GITHUB_STEP_SUMMARY
          echo '' >> $GITHUB_STEP_SUMMARY
          echo '```' >> $GITHUB_STEP_SUMMARY
+          echo "</details>" >> $GITHUB_STEP_SUMMARY

      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v5
-        id: upload
+        uses: actions/upload-artifact@v7
+        id: upload-firmware
        with:
          name: firmware-${{ inputs.platform }}-${{ inputs.pio_env }}-${{ inputs.version }}
          overwrite: true
@@ -82,3 +123,12 @@ jobs:
            release/*.zip
            release/device-*.sh
            release/device-*.bat
+
+      - name: Store manifests as an artifact
+        uses: actions/upload-artifact@v7
+        id: upload-manifest
+        with:
+          name: manifest-${{ inputs.platform }}-${{ inputs.pio_env }}-${{ inputs.version }}
+          overwrite: true
+          path: |
+            release/*.mt.json
@@ -0,0 +1,51 @@
+name: Build MacOS Binary
+
+on:
+  workflow_call:
+    inputs:
+      macos_ver:
+        required: false
+        default: "26" # ARM64
+        type: string
+
+permissions:
+  contents: read
+
+jobs:
+  build-MacOS:
+    runs-on: macos-${{ inputs.macos_ver }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+        with:
+          submodules: recursive
+
+      - name: Install deps
+        shell: bash
+        run: |
+          brew update
+          brew install platformio yaml-cpp libuv openssl@3 libusb argp-standalone pkg-config ulfius
+
+      - name: Get release version string
+        run: |
+          echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
+        id: version
+
+      - name: Build for MacOS
+        run: |
+          platformio run -e native-macos
+        env:
+          PKG_VERSION: ${{ steps.version.outputs.long }}
+        # Errors in this step should not fail the entire workflow while MacOS support is in development.
+        continue-on-error: true
+
+      - name: List output files
+        run: ls -lah .pio/build/native-macos/
+
+      - name: Store binaries as an artifact
+        uses: actions/upload-artifact@v7
+        with:
+          name: firmware-macos-${{ inputs.macos_ver }}-${{ steps.version.outputs.long }}
+          overwrite: true
+          path: |
+            .pio/build/native-macos/meshtasticd
@@ -87,7 +87,7 @@ jobs:

  gather-artifacts:
    permissions:
-      contents: write
+      contents: read
      pull-requests: write
    runs-on: ubuntu-latest
    needs: [version, build]
@@ -98,7 +98,7 @@ jobs:
          ref: ${{github.event.pull_request.head.ref}}
          repository: ${{github.event.pull_request.head.repo.full_name}}

-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v8
        with:
          path: ./
          pattern: firmware-*-*
@@ -111,7 +111,7 @@ jobs:
        run: mv -b -t ./ ./bin/device-*.sh ./bin/device-*.bat

      - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
        with:
          name: firmware-${{inputs.target}}-${{ needs.version.outputs.long }}
          overwrite: true
@@ -127,7 +127,7 @@ jobs:
            ./Meshtastic_nRF52_factory_erase*.uf2
          retention-days: 30

-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v8
        with:
          pattern: firmware-*-${{ needs.version.outputs.long }}
          merge-multiple: true
@@ -146,7 +146,7 @@ jobs:
        run: zip -j -9 -r ./firmware-${{inputs.target}}-${{ needs.version.outputs.long }}.zip ./output

      - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
        with:
          name: debug-elfs-${{inputs.target}}-${{ needs.version.outputs.long }}.zip
          overwrite: true
@@ -5,7 +5,7 @@ on:
  workflow_dispatch:
  push:
    branches:
-      - master
+      - develop # Default branch, same as 'cron' above
    paths:
      - debian/**
      - "*.rpkg"
@@ -16,7 +16,7 @@ on:
      - .github/workflows/hook_copr.yml

 permissions:
-  contents: write
+  contents: read
  packages: write

 jobs:
@@ -35,8 +35,8 @@ jobs:
        series:
          - jammy # 22.04 LTS
          - noble # 24.04 LTS
-          - plucky # 25.04
          - questing # 25.10
+          - resolute # 26.04 LTS
    uses: ./.github/workflows/package_ppa.yml
    with:
      ppa_repo: ppa:meshtastic/daily
@@ -37,7 +37,7 @@ on:
        value: ${{ jobs.docker-build.outputs.digest }}

 permissions:
-  contents: write
+  contents: read
  packages: write

 jobs:
@@ -50,35 +50,43 @@ jobs:
        uses: actions/checkout@v6
        with:
          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}

      - name: Get release version string
        run: |
          echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
        id: version

-      - name: Docker login
-        if: ${{ inputs.push }}
-        uses: docker/login-action@v3
-        with:
-          username: meshtastic
-          password: ${{ secrets.DOCKER_FIRMWARE_TOKEN }}
-
      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
+        uses: docker/setup-qemu-action@v4
+        with:
+          cache-image: true

      - name: Docker setup
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v4
+        with:
+          # Add Google/Amazon DockerHub mirrors to buildkit config
+          # https://docs.docker.com/build/ci/github-actions/configure-builder/#registry-mirror
+          buildkitd-config-inline: |
+            [registry."docker.io"]
+              mirrors = ["mirror.gcr.io", "public.ecr.aws"]

      - name: Sanitize platform string
        id: sanitize_platform
        # Replace slashes with underscores
-        run: echo "cleaned_platform=${{ inputs.platform }}" | sed 's/\//_/g' >> $GITHUB_OUTPUT
+        env:
+          plat: ${{ inputs.platform }}
+        run: echo "cleaned_platform=${plat}" | sed 's/\//_/g' >> $GITHUB_OUTPUT
+
+      - name: Docker login
+        if: ${{ inputs.push }}
+        uses: docker/login-action@v4
+        with:
+          username: meshtastic
+          password: ${{ secrets.DOCKER_FIRMWARE_TOKEN }}

      - name: Docker tag
        id: meta
-        uses: docker/metadata-action@v5
+        uses: docker/metadata-action@v6
        with:
          images: meshtastic/meshtasticd
          tags: |
@@ -86,7 +94,7 @@ jobs:
          flavor: latest=false

      - name: Docker build and push
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v7
        id: docker_variant
        with:
          context: .
@@ -97,3 +105,6 @@ jobs:
          platforms: ${{ inputs.platform }}
          build-args: |
            PIO_ENV=${{ inputs.pio_env }}
+          # Cache image layers in GitHub Actions cache to speed up subsequent builds.
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
@@ -12,7 +12,7 @@ on:
        type: string

 permissions:
-  contents: write
+  contents: read
  packages: write

 jobs:
@@ -43,6 +43,15 @@ jobs:
      push: true
    secrets: inherit

+  docker-debian-riscv64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: debian
+      platform: linux/riscv64
+      runs-on: ubuntu-24.04-arm
+      push: true
+    secrets: inherit
+
  docker-alpine-amd64:
    uses: ./.github/workflows/docker_build.yml
    with:
@@ -70,24 +79,33 @@ jobs:
      push: true
    secrets: inherit

+  docker-alpine-riscv64:
+    uses: ./.github/workflows/docker_build.yml
+    with:
+      distro: alpine
+      platform: linux/riscv64
+      runs-on: ubuntu-24.04-arm
+      push: true
+    secrets: inherit
+
  docker-manifest:
    needs:
      # Debian
      - docker-debian-amd64
      - docker-debian-arm64
      - docker-debian-armv7
+      - docker-debian-riscv64
      # Alpine
      - docker-alpine-amd64
      - docker-alpine-arm64
      - docker-alpine-armv7
+      - docker-alpine-riscv64
    runs-on: ubuntu-24.04
    steps:
      - name: Checkout code
        uses: actions/checkout@v6
        with:
          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}

      - name: Get release version string
        run: |
@@ -139,14 +157,14 @@ jobs:
        id: tags

      - name: Docker login
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
        with:
          username: meshtastic
          password: ${{ secrets.DOCKER_FIRMWARE_TOKEN }}

      - name: Docker meta (Debian)
        id: meta_debian
-        uses: docker/metadata-action@v5
+        uses: docker/metadata-action@v6
        with:
          images: meshtastic/meshtasticd
          tags: |
@@ -164,10 +182,11 @@ jobs:
            meshtastic/meshtasticd@${{ needs.docker-debian-amd64.outputs.digest }}
            meshtastic/meshtasticd@${{ needs.docker-debian-arm64.outputs.digest }}
            meshtastic/meshtasticd@${{ needs.docker-debian-armv7.outputs.digest }}
+            meshtastic/meshtasticd@${{ needs.docker-debian-riscv64.outputs.digest }}

      - name: Docker meta (Alpine)
        id: meta_alpine
-        uses: docker/metadata-action@v5
+        uses: docker/metadata-action@v6
        with:
          images: meshtastic/meshtasticd
          tags: |
@@ -184,3 +203,4 @@ jobs:
            meshtastic/meshtasticd@${{ needs.docker-alpine-amd64.outputs.digest }}
            meshtastic/meshtasticd@${{ needs.docker-alpine-arm64.outputs.digest }}
            meshtastic/meshtasticd@${{ needs.docker-alpine-armv7.outputs.digest }}
+            meshtastic/meshtasticd@${{ needs.docker-alpine-riscv64.outputs.digest }}
@@ -0,0 +1,47 @@
+name: Welcome First-Time Contributor
+
+on:
+  issues:
+    types: opened
+  pull_request_target:
+    types: opened
+
+permissions: {}
+
+jobs:
+  welcome:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write # Required to post comments and labels on issues
+      pull-requests: write # Required to post comments and labels on PRs
+    steps:
+      - uses: plbstl/first-contribution@v4
+        with:
+          labels: first-contribution
+          issue-opened-msg: |
+            ### @{fc-author}, Welcome to Meshtastic! :wave:
+
+            Thanks for opening your first issue. If it's helpful, an easy way
+            to get logs is the "Open Serial Monitor" button on the [Web Flasher](https://flasher.meshtastic.org).
+
+            If you have ideas for features, note that we often debate big ideas
+            in the [discussions tab](https://github.com/meshtastic/firmware/discussions/categories/ideas)
+            first. This tracker tends to be for ideas that have community
+            consensus and a clear implementation.
+
+            We're very active [on discord](https://discord.com/invite/meshtastic),
+            especially the \#firmware and \#alphanauts-testing channels. If you'll
+            be around for a while, we'd love to see you there!
+
+            Welcome to the community! :heart:
+
+          pr-opened-msg: |
+            ### @{fc-author}, Welcome to Meshtastic!
+
+            Thanks for opening your first pull request. We really appreciate it.
+
+            We discuss work as a team in discord, please join us in the [#firmware channel](https://discord.com/invite/meshtastic).
+            There's a big backlog of patches at the moment. If you have time,
+            please help us with some code review and testing of [other PRs](https://github.com/meshtastic/firmware/pulls)!
+
+            Welcome to the team :smile:
@@ -11,8 +11,7 @@ on:
        type: string

 permissions:
-  contents: write
-  packages: write
+  contents: read

 jobs:
  build-copr-hook:
@@ -22,8 +21,6 @@ jobs:
        uses: actions/checkout@v6
        with:
          submodules: recursive
-          ref: ${{ github.ref }}
-          repository: ${{ github.repository }}

      - name: Trigger COPR build
        uses: vidplace7/copr-build@main
@@ -8,23 +8,28 @@ on:
    branches:
      - master
      - develop
+      - pioarduino # Remove when merged // use `feature/` in the future.
      - event/*
+      - feature/*
    paths-ignore:
      - "**.md"
      - version.properties

-  # Note: This is different from "pull_request". Need to specify ref when doing checkouts.
-  pull_request_target:
+  pull_request:
    branches:
      - master
      - develop
+      - pioarduino # Remove when merged // use `feature/` in the future.
      - event/*
+      - feature/*
    paths-ignore:
      - "**.md"
      #- "**.yml"

  workflow_dispatch:

+permissions: read-all
+
 jobs:
  setup:
    strategy:
@@ -77,16 +82,19 @@ jobs:
      fail-fast: false
      matrix:
        check: ${{ fromJson(needs.setup.outputs.check) }}
-
-    runs-on: ubuntu-latest
+    # Use 'arctastic' self-hosted runner pool when checking in the main repo
+    runs-on: ${{ github.repository_owner == 'meshtastic' && 'arctastic' || 'ubuntu-latest' }}
    if: ${{ github.event_name != 'workflow_dispatch' && github.repository == 'meshtastic/firmware' }}
    steps:
      - uses: actions/checkout@v6
-      - name: Build base
-        id: base
-        uses: ./.github/actions/setup-base
+        with:
+          submodules: recursive
      - name: Check ${{ matrix.check.board }}
-        run: bin/check-all.sh ${{ matrix.check.board }}
+        uses: meshtastic/gh-action-firmware@main
+        with:
+          pio_platform: ${{ matrix.check.platform }}
+          pio_env: ${{ matrix.check.board }}
+          pio_target: check

  build:
    needs: [setup, version]
@@ -108,6 +116,20 @@ jobs:
      build_location: local
    secrets: inherit

+  MacOS:
+    strategy:
+      fail-fast: false
+      matrix:
+        macos_ver:
+          - "26" # ARM64
+          # - '26-intel' # x86_64
+          - "15" # ARM64
+          # - '15-intel' # x86_64
+    uses: ./.github/workflows/build_macos_bin.yml
+    with:
+      macos_ver: ${{ matrix.macos_ver }}
+    # secrets: inherit
+
  package-pio-deps-native-tft:
    if: ${{ github.repository == 'meshtastic/firmware' && github.event_name == 'workflow_dispatch' }}
    uses: ./.github/workflows/package_pio_deps.yml
@@ -117,9 +139,16 @@ jobs:

  test-native:
    if: ${{ !contains(github.ref_name, 'event/') && github.repository == 'meshtastic/firmware' }}
+    permissions: # Needed for dorny/test-reporter.
+      contents: read
+      actions: read
+      checks: write
    uses: ./.github/workflows/test_native.yml

  docker:
+    permissions: # Needed for pushing to GHCR.
+      contents: read
+      packages: write
    strategy:
      fail-fast: false
      matrix:
@@ -144,9 +173,6 @@ jobs:
  gather-artifacts:
    # trunk-ignore(checkov/CKV2_GHA_1)
    if: github.repository == 'meshtastic/firmware'
-    permissions:
-      contents: write
-      pull-requests: write
    strategy:
      fail-fast: false
      matrix:
@@ -164,11 +190,8 @@ jobs:
    steps:
      - name: Checkout code
        uses: actions/checkout@v6
-        with:
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}

-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v8
        with:
          path: ./
          pattern: firmware-${{matrix.arch}}-*
@@ -178,7 +201,7 @@ jobs:
        run: ls -R

      - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
        with:
          name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
          overwrite: true
@@ -192,10 +215,11 @@ jobs:
            ./device-*.bat
            ./littlefs-*.bin
            ./bleota*bin
+            ./mt-*-ota.bin
            ./Meshtastic_nRF52_factory_erase*.uf2
          retention-days: 30

-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v8
        with:
          name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
          merge-multiple: true
@@ -214,21 +238,58 @@ jobs:
        run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output

      - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
        with:
          name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}
          overwrite: true
          path: ./*.elf
          retention-days: 30

-      - uses: scruplelesswizard/comment-artifact@main
-        if: ${{ github.event_name == 'pull_request' }}
+  shame:
+    if: github.repository == 'meshtastic/firmware'
+    continue-on-error: true
+    runs-on: ubuntu-latest
+    needs: [build]
+    steps:
+      - uses: actions/checkout@v6
+        if: github.event_name == 'pull_request'
        with:
-          name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
-          description: "Download firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip. This artifact will be available for 90 days from creation"
-          github-token: ${{ secrets.GITHUB_TOKEN }}
+          filter: blob:none # means we download all the git history but none of the commit (except ones with checkout like the head)
+          fetch-depth: 0
+      - name: Download the current manifests
+        uses: actions/download-artifact@v8
+        with:
+          path: ./manifests-new/
+          pattern: manifest-*
+          merge-multiple: true
+      - name: Upload combined manifests for later commit and global stats crunching.
+        uses: actions/upload-artifact@v7
+        id: upload-manifest
+        with:
+          name: manifests-${{ github.sha }}
+          overwrite: true
+          path: manifests-new/*.mt.json
+      - name: Find the merge base
+        if: github.event_name == 'pull_request'
+        run: echo "MERGE_BASE=$(git merge-base "origin/$base" "$head")" >> $GITHUB_ENV
+        env:
+          base: ${{ github.base_ref }}
+          head: ${{ github.sha }}
+      # Currently broken (for-loop through EVERY artifact -- rate limiting)
+      # - name: Download the old manifests
+      #   if: github.event_name == 'pull_request'
+      #   run: gh run download -R "$repo" --name "manifests-$merge_base" --dir manifest-old/
+      #   env:
+      #     GH_TOKEN: ${{ github.token }}
+      #     merge_base: ${{ env.MERGE_BASE }}
+      #     repo: ${{ github.repository }}
+      # - name: Do scan and post comment
+      #   if: github.event_name == 'pull_request'
+      #   run: python3 bin/shame.py ${{ github.event.pull_request.number }} manifests-old/ manifests-new/

  release-artifacts:
+    permissions: # Needed for 'gh release upload'.
+      contents: write
    runs-on: ubuntu-latest
    if: ${{ github.event_name == 'workflow_dispatch' && github.repository == 'meshtastic/firmware' }}
    outputs:
@@ -239,30 +300,50 @@ jobs:
      - gather-artifacts
      - build-debian-src
      - package-pio-deps-native-tft
+      # - MacOS
    steps:
      - name: Checkout
        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: 3.x
+
+      - name: Generate release notes
+        id: release_notes
+        run: |
+          chmod +x ./bin/generate_release_notes.py
+          NOTES=$(./bin/generate_release_notes.py ${{ needs.version.outputs.long }} --compare-ref HEAD 2>release_notes.log)
+          echo "notes<<EOF" >> $GITHUB_OUTPUT
+          echo "$NOTES" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+          echo "### Release note range" >> $GITHUB_STEP_SUMMARY
+          cat release_notes.log >> $GITHUB_STEP_SUMMARY
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Create release
-        uses: softprops/action-gh-release@v2
+        uses: softprops/action-gh-release@v3
        id: create_release
        with:
          draft: true
          prerelease: true
          name: Meshtastic Firmware ${{ needs.version.outputs.long }} Alpha
          tag_name: v${{ needs.version.outputs.long }}
-          body: |
-            Autogenerated by github action, developer should edit as required before publishing...
+          body: ${{ steps.release_notes.outputs.notes }}

      - name: Download source deb
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v8
        with:
          pattern: firmware-debian-${{ needs.version.outputs.deb }}~UNRELEASED-src
          merge-multiple: true
          path: ./output/debian-src

      - name: Download `native-tft` pio deps
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v8
        with:
          pattern: platformio-deps-native-tft-${{ needs.version.outputs.long }}
          merge-multiple: true
@@ -286,7 +367,7 @@ jobs:
          }' > firmware-${{ needs.version.outputs.long }}.json

      - name: Save Release manifest artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
        with:
          name: manifest-${{ needs.version.outputs.long }}
          overwrite: true
@@ -303,6 +384,8 @@ jobs:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  release-firmware:
+    permissions: # Needed for 'gh release upload'.
+      contents: write
    strategy:
      fail-fast: false
      matrix:
@@ -327,7 +410,7 @@ jobs:
        with:
          python-version: 3.x

-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v8
        with:
          pattern: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
          merge-multiple: true
@@ -344,7 +427,7 @@ jobs:
      - name: Zip firmware
        run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output

-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v8
        with:
          name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}
          merge-multiple: true
@@ -376,6 +459,8 @@ jobs:
    steps:
      - name: Checkout
        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0

      - name: Setup Python
        uses: actions/setup-python@v6
@@ -383,18 +468,25 @@ jobs:
          python-version: 3.x

      - name: Get firmware artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v8
        with:
          pattern: firmware-{${{ env.targets }}}-${{ needs.version.outputs.long }}
          merge-multiple: true
          path: ./publish

      - name: Get manifest artifact
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v8
        with:
          pattern: manifest-${{ needs.version.outputs.long }}
          path: ./publish

+      - name: Generate release notes
+        run: |
+          chmod +x ./bin/generate_release_notes.py
+          ./bin/generate_release_notes.py ${{ needs.version.outputs.long }} --compare-ref HEAD > ./publish/release_notes.md
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
      - name: Publish firmware to meshtastic.github.io
        uses: peaceiris/actions-gh-pages@v4
        env:
@@ -1,371 +0,0 @@
-name: Merge Queue
-# Not sure how concurrency works in merge_queue, removing for now.
-# concurrency:
-#   group: merge-queue-${{ github.head_ref || github.run_id }}
-#   cancel-in-progress: true
-on:
-  # Merge group is a special trigger that is used to trigger the workflow when a merge group is created.
-  merge_group:
-
-jobs:
-  setup:
-    strategy:
-      fail-fast: true
-      matrix:
-        arch:
-          - all
-          - check
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-          cache: pip
-      - run: pip install -U platformio
-      - name: Generate matrix
-        id: jsonStep
-        run: |
-          if [[ "$GITHUB_HEAD_REF" == "" ]]; then
-            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}})
-          else  
-            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} --level pr)
-          fi
-          echo "Name: $GITHUB_REF_NAME Base: $GITHUB_BASE_REF Ref: $GITHUB_REF"
-          echo "${{matrix.arch}}=$TARGETS" >> $GITHUB_OUTPUT
-    outputs:
-      all: ${{ steps.jsonStep.outputs.all }}
-      check: ${{ steps.jsonStep.outputs.check }}
-
-  version:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - name: Get release version string
-        run: |
-          echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-          echo "deb=$(./bin/buildinfo.py deb)" >> $GITHUB_OUTPUT
-        id: version
-        env:
-          BUILD_LOCATION: local
-    outputs:
-      long: ${{ steps.version.outputs.long }}
-      deb: ${{ steps.version.outputs.deb }}
-
-  check:
-    needs: setup
-    strategy:
-      fail-fast: true
-      matrix:
-        check: ${{ fromJson(needs.setup.outputs.check) }}
-
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name != 'workflow_dispatch' }}
-    steps:
-      - uses: actions/checkout@v6
-      - name: Build base
-        id: base
-        uses: ./.github/actions/setup-base
-      - name: Check ${{ matrix.check.board }}
-        run: bin/check-all.sh ${{ matrix.check.board }}
-
-  build:
-    needs: [setup, version]
-    strategy:
-      matrix:
-        build: ${{ fromJson(needs.setup.outputs.all) }}
-    uses: ./.github/workflows/build_firmware.yml
-    with:
-      version: ${{ needs.version.outputs.long }}
-      pio_env: ${{ matrix.build.board }}
-      platform: ${{ matrix.build.platform }}
-
-  build-debian-src:
-    if: github.repository == 'meshtastic/firmware'
-    uses: ./.github/workflows/build_debian_src.yml
-    with:
-      series: UNRELEASED
-      build_location: local
-    secrets: inherit
-
-  package-pio-deps-native-tft:
-    if: ${{ github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/package_pio_deps.yml
-    with:
-      pio_env: native-tft
-    secrets: inherit
-
-  test-native:
-    if: ${{ !contains(github.ref_name, 'event/') }}
-    uses: ./.github/workflows/test_native.yml
-
-  docker:
-    strategy:
-      fail-fast: false
-      matrix:
-        distro: [debian, alpine]
-        platform: [linux/amd64, linux/arm64, linux/arm/v7]
-        pio_env: [native, native-tft]
-        exclude:
-          - distro: alpine
-            platform: linux/arm/v7
-          - pio_env: native-tft
-            platform: linux/arm64
-          - pio_env: native-tft
-            platform: linux/arm/v7
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: ${{ matrix.distro }}
-      platform: ${{ matrix.platform }}
-      runs-on: ${{ contains(matrix.platform, 'arm') && 'ubuntu-24.04-arm' || 'ubuntu-24.04' }}
-      pio_env: ${{ matrix.pio_env }}
-      push: false
-
-  gather-artifacts:
-    # trunk-ignore(checkov/CKV2_GHA_1)
-    permissions:
-      contents: write
-      pull-requests: write
-    strategy:
-      fail-fast: false
-      matrix:
-        arch:
-          - esp32
-          - esp32s3
-          - esp32c3
-          - esp32c6
-          - nrf52840
-          - rp2040
-          - rp2350
-          - stm32
-    runs-on: ubuntu-latest
-    needs: [version, build]
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - uses: actions/download-artifact@v6
-        with:
-          path: ./
-          pattern: firmware-${{matrix.arch}}-*
-          merge-multiple: true
-
-      - name: Display structure of downloaded files
-        run: ls -R
-
-      - name: Move files up
-        run: mv -b -t ./ ./bin/device-*.sh ./bin/device-*.bat
-
-      - name: Repackage in single firmware zip
-        uses: actions/upload-artifact@v5
-        with:
-          name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
-          overwrite: true
-          path: |
-            ./firmware-*.bin
-            ./firmware-*.uf2
-            ./firmware-*.hex
-            ./firmware-*.zip
-            ./device-*.sh
-            ./device-*.bat
-            ./littlefs-*.bin
-            ./bleota*bin
-            ./Meshtastic_nRF52_factory_erase*.uf2
-          retention-days: 30
-
-      - uses: actions/download-artifact@v6
-        with:
-          name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./output
-
-      # For diagnostics
-      - name: Show artifacts
-        run: ls -lR
-
-      - name: Device scripts permissions
-        run: |
-          chmod +x ./output/device-install.sh || true
-          chmod +x ./output/device-update.sh || true
-
-      - name: Zip firmware
-        run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output
-
-      - name: Repackage in single elfs zip
-        uses: actions/upload-artifact@v5
-        with:
-          name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}
-          overwrite: true
-          path: ./*.elf
-          retention-days: 30
-
-      - uses: scruplelesswizard/comment-artifact@main
-        if: ${{ github.event_name == 'pull_request' }}
-        with:
-          name: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
-          description: "Download firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip. This artifact will be available for 90 days from creation"
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-
-  release-artifacts:
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name == 'workflow_dispatch' }}
-    outputs:
-      upload_url: ${{ steps.create_release.outputs.upload_url }}
-    needs:
-      - version
-      - gather-artifacts
-      - build-debian-src
-      - package-pio-deps-native-tft
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Create release
-        uses: softprops/action-gh-release@v2
-        id: create_release
-        with:
-          draft: true
-          prerelease: true
-          name: Meshtastic Firmware ${{ needs.version.outputs.long }} Alpha
-          tag_name: v${{ needs.version.outputs.long }}
-          body: |
-            Autogenerated by github action, developer should edit as required before publishing...
-
-      - name: Download source deb
-        uses: actions/download-artifact@v6
-        with:
-          pattern: firmware-debian-${{ needs.version.outputs.deb }}~UNRELEASED-src
-          merge-multiple: true
-          path: ./output/debian-src
-
-      - name: Download `native-tft` pio deps
-        uses: actions/download-artifact@v6
-        with:
-          pattern: platformio-deps-native-tft-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./output/pio-deps-native-tft
-
-      - name: Zip Linux sources
-        working-directory: output
-        run: |
-          zip -j -9 -r ./meshtasticd-${{ needs.version.outputs.deb }}-src.zip ./debian-src
-          zip -9 -r ./platformio-deps-native-tft-${{ needs.version.outputs.long }}.zip ./pio-deps-native-tft
-
-      # For diagnostics
-      - name: Display structure of downloaded files
-        run: ls -lR
-
-      - name: Add Linux sources to GtiHub Release
-        # Only run when targeting master branch with workflow_dispatch
-        if: ${{ github.ref_name == 'master' }}
-        run: |
-          gh release upload v${{ needs.version.outputs.long }} ./output/meshtasticd-${{ needs.version.outputs.deb }}-src.zip
-          gh release upload v${{ needs.version.outputs.long }} ./output/platformio-deps-native-tft-${{ needs.version.outputs.long }}.zip
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  release-firmware:
-    strategy:
-      fail-fast: false
-      matrix:
-        arch:
-          - esp32
-          - esp32s3
-          - esp32c3
-          - esp32c6
-          - nrf52840
-          - rp2040
-          - rp2350
-          - stm32
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name == 'workflow_dispatch' }}
-    needs: [release-artifacts, version]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-
-      - uses: actions/download-artifact@v6
-        with:
-          pattern: firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./output
-
-      - name: Display structure of downloaded files
-        run: ls -lR
-
-      - name: Device scripts permissions
-        run: |
-          chmod +x ./output/device-install.sh || true
-          chmod +x ./output/device-update.sh || true
-
-      - name: Zip firmware
-        run: zip -j -9 -r ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./output
-
-      - uses: actions/download-artifact@v6
-        with:
-          name: debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./elfs
-
-      - name: Zip debug elfs
-        run: zip -j -9 -r ./debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip ./elfs
-
-      # For diagnostics
-      - name: Display structure of downloaded files
-        run: ls -lR
-
-      - name: Add bins and debug elfs to GitHub Release
-        # Only run when targeting master branch with workflow_dispatch
-        if: ${{ github.ref_name == 'master' }}
-        run: |
-          gh release upload v${{ needs.version.outputs.long }} ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
-          gh release upload v${{ needs.version.outputs.long }} ./debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  publish-firmware:
-    runs-on: ubuntu-24.04
-    if: ${{ github.event_name == 'workflow_dispatch' }}
-    needs: [release-firmware, version]
-    env:
-      targets: |-
-        esp32,esp32s3,esp32c3,esp32c6,nrf52840,rp2040,rp2350,stm32
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: 3.x
-
-      - uses: actions/download-artifact@v6
-        with:
-          pattern: firmware-{${{ env.targets }}}-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./publish
-
-      - name: Publish firmware to meshtastic.github.io
-        uses: peaceiris/actions-gh-pages@v4
-        env:
-          # On event/* branches, use the event name as the destination prefix
-          DEST_PREFIX: ${{ contains(github.ref_name, 'event/') && format('{0}/', github.ref_name) || '' }}
-        with:
-          deploy_key: ${{ secrets.DIST_PAGES_DEPLOY_KEY }}
-          external_repository: meshtastic/meshtastic.github.io
-          publish_branch: master
-          publish_dir: ./publish
-          destination_dir: ${{ env.DEST_PREFIX }}firmware-${{ needs.version.outputs.long }}
-          keep_files: true
-          user_name: github-actions[bot]
-          user_email: github-actions[bot]@users.noreply.github.com
-          commit_message: ${{ needs.version.outputs.long }}
-          enable_jekyll: true
@@ -0,0 +1,213 @@
+name: Issue Triage (Models)
+
+on:
+  issues:
+    types: [opened]
+
+permissions:
+  issues: write
+  models: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.issue.number }}
+  cancel-in-progress: true
+
+jobs:
+  triage:
+    if: ${{ github.repository == 'meshtastic/firmware' && github.event.issue.user.type != 'Bot' }}
+    runs-on: ubuntu-latest
+    steps:
+      # ─────────────────────────────────────────────────────────────────────────
+      # Step 1: Quality check (spam/AI-slop detection) - runs first, exits early if spam
+      # ─────────────────────────────────────────────────────────────────────────
+      - name: Detect spam or low-quality content
+        uses: actions/ai-inference@v2
+        id: quality
+        continue-on-error: true
+        with:
+          max-tokens: 20
+          prompt: |
+            Is this GitHub issue spam, AI-generated slop, or low quality?
+
+            Title: ${{ github.event.issue.title }}
+            Body: ${{ github.event.issue.body }}
+
+            Respond with exactly one of: spam, ai-generated, needs-review, ok
+          system-prompt: You detect spam and low-quality contributions. Be conservative - only flag obvious spam or AI slop.
+          model: openai/gpt-4o-mini
+
+      - name: Apply quality label if needed
+        if: steps.quality.outputs.response != '' && steps.quality.outputs.response != 'ok'
+        uses: actions/github-script@v9
+        env:
+          QUALITY_LABEL: ${{ steps.quality.outputs.response }}
+        with:
+          script: |
+            const label = (process.env.QUALITY_LABEL || '').trim().toLowerCase();
+            const labelMeta = {
+              'spam': { color: 'd73a4a', description: 'Possible spam' },
+              'ai-generated': { color: 'fbca04', description: 'Possible AI-generated low-quality content' },
+              'needs-review': { color: 'f9d0c4', description: 'Needs human review' },
+            };
+            const meta = labelMeta[label];
+            if (!meta) return;
+
+            // Ensure label exists
+            try {
+              await github.rest.issues.getLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label });
+            } catch (e) {
+              if (e.status !== 404) throw e;
+              await github.rest.issues.createLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label, color: meta.color, description: meta.description });
+            }
+
+            // Apply label
+            await github.rest.issues.addLabels({ owner: context.repo.owner, repo: context.repo.repo, issue_number: context.payload.issue.number, labels: [label] });
+
+            // Set output to skip remaining steps
+            core.setOutput('is_spam', 'true');
+
+      # ─────────────────────────────────────────────────────────────────────────
+      # Step 2: Duplicate detection - only if not spam
+      # ─────────────────────────────────────────────────────────────────────────
+      - name: Detect duplicate issues
+        if: steps.quality.outputs.response == 'ok' || steps.quality.outputs.response == ''
+        uses: pelikhan/action-genai-issue-dedup@bdb3b5d9451c1090ffcdf123d7447a5e7c7a2528 # v0.0.19
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+
+      # ─────────────────────────────────────────────────────────────────────────
+      # Step 3: Completeness check + auto-labeling (combined into one AI call)
+      # ─────────────────────────────────────────────────────────────────────────
+      - name: Determine if completeness check should be skipped
+        if: steps.quality.outputs.response == 'ok' || steps.quality.outputs.response == ''
+        uses: actions/github-script@v9
+        id: check-skip
+        with:
+          script: |
+            const title = (context.payload.issue.title || '').toLowerCase();
+            const labels = (context.payload.issue.labels || []).map(label => label.name);
+            const hasFeatureRequest = title.includes('feature request');
+            const hasEnhancement = labels.includes('enhancement');
+            const shouldSkip = hasFeatureRequest && hasEnhancement;
+            core.setOutput('should_skip', shouldSkip ? 'true' : 'false');
+
+      - name: Analyze issue completeness and determine labels
+        if: (steps.quality.outputs.response == 'ok' || steps.quality.outputs.response == '') && steps.check-skip.outputs.should_skip != 'true'
+        uses: actions/ai-inference@v2
+        id: analysis
+        continue-on-error: true
+        with:
+          prompt: |
+            Analyze this GitHub issue for completeness and determine if it needs labels.
+
+            IMPORTANT: Distinguish between:
+            - Device/firmware bugs (crashes, reboots, lockups, radio/GPS/display/power issues) - these need device logs
+            - Build/release/packaging issues (missing files, CI failures, download problems) - these do NOT need device logs
+            - Documentation or website issues - these do NOT need device logs
+
+            If this is a device/firmware bug, request device logs and explain how to get them:
+
+            Web Flasher logs:
+            - Go to https://flasher.meshtastic.org
+            - Connect the device via USB and click Connect
+            - Open the device console/log output, reproduce the problem, then copy/download and attach/paste the logs
+
+            Meshtastic CLI logs:
+            - Run: meshtastic --port <serial-port> --noproto
+            - Reproduce the problem, then copy/paste the terminal output
+
+            Also request key context if missing: device model/variant, firmware version, region, steps to reproduce, expected vs actual.
+
+            Respond ONLY with valid JSON (no markdown, no code fences):
+            {"complete": true, "comment": "", "label": "none"}
+            OR
+            {"complete": false, "comment": "Your helpful comment", "label": "needs-logs"}
+
+            Use "needs-logs" ONLY if this is a device/firmware bug AND no logs are attached.
+            Use "needs-info" if basic info like firmware version or steps to reproduce are missing.
+            Use "none" if the issue is complete, is a feature request, or is a build/CI/packaging issue.
+
+            Title: ${{ github.event.issue.title }}
+            Body: ${{ github.event.issue.body }}
+          system-prompt: You are a helpful assistant that triages GitHub issues. Be conservative with labels. Only request device logs for actual device/firmware bugs, not for build/release/CI issues.
+          model: openai/gpt-4o-mini
+
+      - name: Process analysis result
+        if: (steps.quality.outputs.response == 'ok' || steps.quality.outputs.response == '') && steps.check-skip.outputs.should_skip != 'true' && steps.analysis.outputs.response != ''
+        uses: actions/github-script@v9
+        id: process
+        env:
+          AI_RESPONSE: ${{ steps.analysis.outputs.response }}
+        with:
+          script: |
+            let raw = (process.env.AI_RESPONSE || '').trim();
+
+            // Strip markdown code fences if present
+            raw = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '').trim();
+
+            let complete = true;
+            let comment = '';
+            let label = 'none';
+
+            try {
+              const parsed = JSON.parse(raw);
+              complete = !!parsed.complete;
+              comment = (parsed.comment ?? '').toString().trim();
+              label = (parsed.label ?? 'none').toString().trim().toLowerCase();
+            } catch {
+              // If JSON parse fails, log warning and don't comment (avoid posting raw JSON)
+              console.log('Failed to parse AI response as JSON:', raw);
+              complete = true;
+              comment = '';
+              label = 'none';
+            }
+
+            // Validate label
+            const allowedLabels = new Set(['needs-logs', 'needs-info', 'none']);
+            if (!allowedLabels.has(label)) label = 'none';
+
+            // Only comment if we have a valid parsed comment (not raw JSON)
+            const shouldComment = !complete && comment.length > 0 && !comment.startsWith('{');
+            core.setOutput('should_comment', shouldComment ? 'true' : 'false');
+            core.setOutput('comment_body', comment);
+            core.setOutput('label', label);
+
+      - name: Apply triage label
+        if: steps.process.outputs.label != '' && steps.process.outputs.label != 'none'
+        uses: actions/github-script@v9
+        env:
+          LABEL_NAME: ${{ steps.process.outputs.label }}
+        with:
+          script: |
+            const label = process.env.LABEL_NAME;
+            const labelMeta = {
+              'needs-logs': { color: 'cfd3d7', description: 'Device logs requested for triage' },
+              'needs-info': { color: 'f9d0c4', description: 'More information requested for triage' },
+            };
+            const meta = labelMeta[label];
+            if (!meta) return;
+
+            // Ensure label exists
+            try {
+              await github.rest.issues.getLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label });
+            } catch (e) {
+              if (e.status !== 404) throw e;
+              await github.rest.issues.createLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label, color: meta.color, description: meta.description });
+            }
+
+            // Apply label
+            await github.rest.issues.addLabels({ owner: context.repo.owner, repo: context.repo.repo, issue_number: context.payload.issue.number, labels: [label] });
+
+      - name: Comment on issue
+        if: steps.process.outputs.should_comment == 'true'
+        uses: actions/github-script@v9
+        env:
+          COMMENT_BODY: ${{ steps.process.outputs.comment_body }}
+        with:
+          script: |
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.payload.issue.number,
+              body: process.env.COMMENT_BODY
+            });
@@ -0,0 +1,139 @@
+name: PR Triage (Models)
+
+on:
+  pull_request_target:
+    types: [opened]
+
+permissions:
+  pull-requests: write
+  issues: write
+  models: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  triage:
+    if: ${{ github.repository == 'meshtastic/firmware' && github.event.pull_request.user.type != 'Bot' }}
+    runs-on: ubuntu-latest
+    steps:
+      # ─────────────────────────────────────────────────────────────────────────
+      # Step 1: Check if PR already has automation/type labels (skip if so)
+      # ─────────────────────────────────────────────────────────────────────────
+      - name: Check existing labels
+        uses: actions/github-script@v9
+        id: check-labels
+        with:
+          script: |
+            const skipLabels = new Set(['automation']);
+            const typeLabels = new Set(['bugfix', 'hardware-support', 'enhancement', 'dependencies', 'submodules', 'github_actions', 'trunk', 'cleanup']);
+            const prLabels = context.payload.pull_request.labels.map(l => l.name);
+
+            const shouldSkipAll = prLabels.some(l => skipLabels.has(l));
+            const hasTypeLabel = prLabels.some(l => typeLabels.has(l));
+
+            core.setOutput('skip_all', shouldSkipAll ? 'true' : 'false');
+            core.setOutput('has_type_label', hasTypeLabel ? 'true' : 'false');
+
+      # ─────────────────────────────────────────────────────────────────────────
+      # Step 2: Quality check (spam/AI-slop detection)
+      # ─────────────────────────────────────────────────────────────────────────
+      - name: Detect spam or low-quality content
+        if: steps.check-labels.outputs.skip_all != 'true'
+        uses: actions/ai-inference@v2
+        id: quality
+        continue-on-error: true
+        with:
+          max-tokens: 20
+          prompt: |
+            Is this GitHub pull request spam, AI-generated slop, or low quality?
+
+            Title: ${{ github.event.pull_request.title }}
+            Body: ${{ github.event.pull_request.body }}
+
+            Respond with exactly one of: spam, ai-generated, needs-review, ok
+          system-prompt: You detect spam and low-quality contributions. Be conservative - only flag obvious spam or AI slop.
+          model: openai/gpt-4o-mini
+
+      - name: Apply quality label if needed
+        if: steps.check-labels.outputs.skip_all != 'true' && steps.quality.outputs.response != '' && steps.quality.outputs.response != 'ok'
+        uses: actions/github-script@v9
+        id: quality-label
+        env:
+          QUALITY_LABEL: ${{ steps.quality.outputs.response }}
+        with:
+          script: |
+            const label = (process.env.QUALITY_LABEL || '').trim().toLowerCase();
+            const labelMeta = {
+              'spam': { color: 'd73a4a', description: 'Possible spam' },
+              'ai-generated': { color: 'fbca04', description: 'Possible AI-generated low-quality content' },
+              'needs-review': { color: 'f9d0c4', description: 'Needs human review' },
+            };
+            const meta = labelMeta[label];
+            if (!meta) return;
+
+            // Ensure label exists
+            try {
+              await github.rest.issues.getLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label });
+            } catch (e) {
+              if (e.status !== 404) throw e;
+              await github.rest.issues.createLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label, color: meta.color, description: meta.description });
+            }
+
+            // Apply label
+            await github.rest.issues.addLabels({ owner: context.repo.owner, repo: context.repo.repo, issue_number: context.payload.pull_request.number, labels: [label] });
+
+            core.setOutput('is_spam', 'true');
+
+      # ─────────────────────────────────────────────────────────────────────────
+      # Step 3: Auto-label PR type (bugfix/hardware-support/enhancement)
+      # Only skip for spam/ai-generated; still classify needs-review PRs
+      # ─────────────────────────────────────────────────────────────────────────
+      - name: Classify PR for labeling
+        if: steps.check-labels.outputs.skip_all != 'true' && steps.check-labels.outputs.has_type_label != 'true' && steps.quality.outputs.response != 'spam' && steps.quality.outputs.response != 'ai-generated'
+        uses: actions/ai-inference@v2
+        id: classify
+        continue-on-error: true
+        with:
+          max-tokens: 30
+          prompt: |
+            Classify this pull request into exactly one category.
+
+            Return exactly one of: bugfix, hardware-support, enhancement
+
+            Use bugfix if it fixes a bug, crash, or incorrect behavior.
+            Use hardware-support if it adds or improves support for a specific hardware device/variant.
+            Use enhancement if it adds a new feature, improves performance, or refactors code.
+
+            Title: ${{ github.event.pull_request.title }}
+            Body: ${{ github.event.pull_request.body }}
+          system-prompt: You classify pull requests into categories. Be conservative and pick the most appropriate single label.
+          model: openai/gpt-4o-mini
+
+      - name: Apply type label
+        if: steps.check-labels.outputs.skip_all != 'true' && steps.check-labels.outputs.has_type_label != 'true' && steps.classify.outputs.response != ''
+        uses: actions/github-script@v9
+        env:
+          TYPE_LABEL: ${{ steps.classify.outputs.response }}
+        with:
+          script: |
+            const label = (process.env.TYPE_LABEL || '').trim().toLowerCase();
+            const labelMeta = {
+              'bugfix': { color: 'd73a4a', description: 'Bug fix' },
+              'hardware-support': { color: '0e8a16', description: 'Hardware support addition or improvement' },
+              'enhancement': { color: 'a2eeef', description: 'New feature or enhancement' },
+            };
+            const meta = labelMeta[label];
+            if (!meta) return;
+
+            // Ensure label exists
+            try {
+              await github.rest.issues.getLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label });
+            } catch (e) {
+              if (e.status !== 404) throw e;
+              await github.rest.issues.createLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label, color: meta.color, description: meta.description });
+            }
+
+            // Apply label
+            await github.rest.issues.addLabels({ owner: context.repo.owner, repo: context.repo.repo, issue_number: context.payload.pull_request.number, labels: [label] });
@@ -18,8 +18,7 @@ on:
        type: string

 permissions:
-  contents: write
-  packages: write
+  contents: read

 jobs:
  build-debian-src:
@@ -58,7 +57,7 @@ jobs:
        id: version

      - name: Download artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v8
        with:
          name: firmware-debian-${{ steps.version.outputs.deb }}~${{ inputs.series }}-src
          merge-multiple: true
@@ -16,8 +16,7 @@ on:
        type: string

 permissions:
-  contents: write
-  packages: write
+  contents: read

 jobs:
  pkg-pio-libdeps:
@@ -27,8 +26,6 @@ jobs:
        uses: actions/checkout@v6
        with:
          submodules: recursive
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}

      - name: Setup Python
        uses: actions/setup-python@v6
@@ -54,9 +51,19 @@ jobs:
          PLATFORMIO_LIBDEPS_DIR: pio/libdeps
          PLATFORMIO_PACKAGES_DIR: pio/packages
          PLATFORMIO_CORE_DIR: pio/core
+          PLATFORMIO_SETTING_ENABLE_TELEMETRY: 0
+          PLATFORMIO_SETTING_CHECK_PLATFORMIO_INTERVAL: 3650
+          PLATFORMIO_SETTING_CHECK_PRUNE_SYSTEM_THRESHOLD: 10240
+
+      - name: Mangle platformio cache
+        # Add "1" to epoch-timestamps of all downloads in the cache.
+        # This is a hack to prevent internet access at build-time.
+        run: |
+          cp pio/core/.cache/downloads/usage.db pio/core/.cache/downloads/usage.db.bak
+          jq -c 'with_entries(.value |= (. | tostring + "1" | tonumber))' pio/core/.cache/downloads/usage.db.bak > pio/core/.cache/downloads/usage.db

      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
        with:
          name: platformio-deps-${{ inputs.pio_env }}-${{ steps.version.outputs.long }}
          overwrite: true
@@ -5,6 +5,8 @@ on:
    secrets:
      PPA_GPG_PRIVATE_KEY:
        required: true
+      PPA_SFTP_PRIVATE_KEY:
+        required: true
    inputs:
      ppa_repo:
        description: Meshtastic PPA to target
@@ -16,8 +18,7 @@ on:
        type: string

 permissions:
-  contents: write
-  packages: write
+  contents: read

 jobs:
  build-debian-src:
@@ -28,6 +29,7 @@ jobs:
      build_location: ppa

  package-ppa:
+    if: ${{ github.event_name != 'pull_request_target' && github.event_name != 'pull_request' }}
    runs-on: ubuntu-24.04
    needs: build-debian-src
    steps:
@@ -36,17 +38,15 @@ jobs:
        with:
          submodules: recursive
          path: meshtasticd
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}

      - name: Install deps
        shell: bash
        run: |
          sudo apt-get update -y --fix-missing
-          sudo apt-get install -y dput
+          sudo apt-get install -y dput openssh-client

      - name: Import GPG key
-        uses: crazy-max/ghaction-import-gpg@v6
+        uses: crazy-max/ghaction-import-gpg@v7
        with:
          gpg_private_key: ${{ secrets.PPA_GPG_PRIVATE_KEY }}
        id: gpg
@@ -60,7 +60,7 @@ jobs:
        id: version

      - name: Download artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v8
        with:
          name: firmware-debian-${{ steps.version.outputs.deb }}~${{ inputs.series }}-src
          merge-multiple: true
@@ -68,7 +68,42 @@ jobs:
      - name: Display structure of downloaded files
        run: ls -lah

-      - name: Publish with dput
-        if: ${{ github.event_name != 'pull_request_target' && github.event_name != 'pull_request' }}
+      - name: Trust Launchpad's SSH key
        run: |
-          dput ${{ inputs.ppa_repo }} meshtasticd_${{ steps.version.outputs.deb }}~${{ inputs.series }}_source.changes
+          mkdir -p ~/.ssh
+          ssh-keyscan -H ppa.launchpad.net >> ~/.ssh/known_hosts
+
+      - name: Setup dput config
+        env:
+          ppa_login: meshtasticorg
+        run: |
+          sudo tee /etc/meshtastic-dput.cf >/dev/null <<EOF
+          [ppa]
+          fqdn                    = ppa.launchpad.net
+          method                  = ftp
+          incoming                = ~%(ppa)s
+          login                   = anonymous
+
+          [ssh-ppa]
+          fqdn                    = ppa.launchpad.net
+          method                  = sftp
+          incoming                = ~%(ssh-ppa)s
+          login                   = ${ppa_login}
+          EOF
+
+      - name: Import SSH key
+        uses: webfactory/ssh-agent@v0.10.0
+        with:
+          ssh-private-key: ${{ secrets.PPA_SFTP_PRIVATE_KEY }}
+        id: ssh
+
+      - name: Publish with dput (sftp)
+        timeout-minutes: 30 # dput is terrible, sometimes runs 'forever'
+        env:
+          up_ppa_repo: ${{ inputs.ppa_repo }}
+          up_series: ${{ inputs.series }}
+          up_version: ${{ steps.version.outputs.deb }}
+        run: >
+          dput -c /etc/meshtastic-dput.cf
+          ssh-${up_ppa_repo}
+          meshtasticd_${up_version}~${up_series}_source.changes
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Check for PR labels
-        uses: actions/github-script@v8
+        uses: actions/github-script@v9
        with:
          script: |
            const labels = context.payload.pull_request.labels.map(label => label.name);
@@ -50,7 +50,7 @@ jobs:

      - name: Download test artifacts
        if: needs.native-tests.result != 'skipped'
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v8
        with:
          name: platformio-test-report-${{ steps.version.outputs.long }}
          merge-multiple: true
@@ -177,7 +177,7 @@ jobs:

      - name: Comment test results on PR
        if: github.event_name == 'pull_request' && needs.native-tests.result != 'skipped'
-        uses: actions/github-script@v8
+        uses: actions/github-script@v9
        with:
          script: |
            const fs = require('fs');
@@ -23,8 +23,8 @@ jobs:
        series:
          - jammy # 22.04 LTS
          - noble # 24.04 LTS
-          - plucky # 25.04
          - questing # 25.10
+          - resolute # 26.04 LTS
    uses: ./.github/workflows/package_ppa.yml
    with:
      ppa_repo: |-
@@ -48,6 +48,37 @@ jobs:
        ${{ contains(github.event.release.name, 'Beta') && 'beta' || contains(github.event.release.name, 'Alpha') && 'alpha' }}
    secrets: inherit

+  publish-release-notes:
+    if: github.event.action == 'published'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get release version
+        id: version
+        run: |
+          # Extract version from tag (e.g., v2.7.15.567b8ea -> 2.7.15.567b8ea)
+          VERSION=${GITHUB_REF#refs/tags/v}
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+      - name: Get release notes
+        run: |
+          mkdir -p ./publish
+          gh release view ${{ github.event.release.tag_name }} --json body --jq '.body' > ./publish/release_notes.md
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Publish release notes to meshtastic.github.io
+        uses: peaceiris/actions-gh-pages@v4
+        with:
+          deploy_key: ${{ secrets.DIST_PAGES_DEPLOY_KEY }}
+          external_repository: meshtastic/meshtastic.github.io
+          publish_branch: master
+          publish_dir: ./publish
+          destination_dir: firmware-${{ steps.version.outputs.version }}
+          user_name: github-actions[bot]
+          user_email: github-actions[bot]@users.noreply.github.com
+          commit_message: Release notes for ${{ steps.version.outputs.version }}
+          enable_jekyll: true
+
  # Create a PR to bump version when a release is Published
  bump-version:
    if: github.event.action == 'published'
@@ -33,7 +33,7 @@ jobs:

      # step 3
      - name: save report as pipeline artifact
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
        with:
          name: report.sarif
          overwrite: true
@@ -17,7 +17,7 @@ jobs:

    steps:
      - name: Stale PR+Issues
-        uses: actions/stale@v10.1.1
+        uses: actions/stale@v10.2.0
        with:
          days-before-stale: 45
          stale-issue-message: This issue has not had any comment or update in the last month. If it is still relevant, please post update comments. If no comments are made, this issue will be closed automagically in 7 days.
@@ -16,8 +16,6 @@ jobs:
    steps:
      - uses: actions/checkout@v6
        with:
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
          submodules: recursive

      - name: Setup native build
@@ -59,7 +57,7 @@ jobs:
        id: version

      - name: Save coverage information
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
        if: always() # run this step even if previous step failed
        with:
          name: lcov-coverage-info-native-simulator-test-${{ steps.version.outputs.long }}
@@ -72,8 +70,6 @@ jobs:
    steps:
      - uses: actions/checkout@v6
        with:
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
          submodules: recursive

      - name: Setup native build
@@ -94,7 +90,7 @@ jobs:

      - name: Save test results
        if: always() # run this step even if previous step failed
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
        with:
          name: platformio-test-report-${{ steps.version.outputs.long }}
          overwrite: true
@@ -108,7 +104,7 @@ jobs:
          sed -i -e "s#${PWD}#.#" coverage_tests.info # Make paths relative.

      - name: Save coverage information
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
        if: always() # run this step even if previous step failed
        with:
          name: lcov-coverage-info-native-platformio-tests-${{ steps.version.outputs.long }}
@@ -128,29 +124,26 @@ jobs:
    if: always()
    steps:
      - uses: actions/checkout@v6
-        with:
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}

      - name: Get release version string
        run: echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
        id: version

      - name: Download test artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v8
        with:
          name: platformio-test-report-${{ steps.version.outputs.long }}
          merge-multiple: true

      - name: Test Report
-        uses: dorny/test-reporter@v2.3.0
+        uses: dorny/test-reporter@v3.0.0
        with:
          name: PlatformIO Tests
          path: testreport.xml
          reporter: java-junit

      - name: Download coverage artifacts
-        uses: actions/download-artifact@v6
+        uses: actions/download-artifact@v8
        with:
          pattern: lcov-coverage-info-native-*-${{ steps.version.outputs.long }}
          path: code-coverage-report
@@ -163,7 +156,7 @@ jobs:
          genhtml --quiet --legend --prefix "${PWD}" code-coverage-report/coverage_src.info --output-directory code-coverage-report

      - name: Save Code Coverage Report
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v7
        with:
          name: code-coverage-report-${{ steps.version.outputs.long }}
          path: code-coverage-report
@@ -52,7 +52,7 @@ jobs:
          node-version: 24

      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
+        uses: pnpm/action-setup@v6
        with:
          version: latest

@@ -1,51 +0,0 @@
-name: Run Trunk Fmt on PR Comment
-
-on:
-  issue_comment:
-    types: [created]
-
-permissions: read-all
-
-jobs:
-  trunk-fmt:
-    if: github.event.issue.pull_request != null && contains(github.event.comment.body, 'trunk fmt')
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-        with:
-          ref: ${{github.event.pull_request.head.ref}}
-          repository: ${{github.event.pull_request.head.repo.full_name}}
-
-      - name: Install trunk
-        run: curl https://get.trunk.io -fsSL | bash
-
-      - name: Run Trunk Fmt
-        run: trunk fmt
-
-      - name: Get release version string
-        run: echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-        id: version
-
-      - name: Commit and push changes
-        run: |
-          git config --global user.name "github-actions[bot]"
-          git config --global user.email "github-actions[bot]@users.noreply.github.com"
-          git add .
-          git commit -m "Add firmware version ${{ steps.version.outputs.long }}"
-          git push
-
-      - name: Comment on PR
-        uses: actions/github-script@v8
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            github.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: '`trunk fmt` has been run on this PR.'
-            })
@@ -6,7 +6,7 @@ permissions: read-all
 jobs:
  update-protobufs:
    runs-on: ubuntu-latest
-    permissions:
+    permissions: # Needed for peter-evans/create-pull-request.
      contents: write
      pull-requests: write
    steps:
@@ -16,7 +16,7 @@ jobs:
          submodules: true

      - name: Update submodule
-        if: ${{ github.ref == 'refs/heads/master' }}
+        if: ${{ github.ref == 'refs/heads/master' || github.ref == 'refs/heads/develop' }}
        run: |
          git submodule update --remote protobufs

@@ -33,6 +33,7 @@ __pycache__
 *~

 venv/
+.venv/
 release/
 .vscode/extensions.json
 /compile_commands.json
@@ -41,3 +42,17 @@ src/mesh/raspihttp/private_key.pem

 # Ignore logo (set at build time with platformio-custom.py)
 data/boot/logo.*
+
+# pioarduino platform
+managed_components/*
+arduino-lib-builder*
+dependencies.lock
+idf_component.yml
+CMakeLists.txt
+/sdkconfig.*
+.dummy/*
+
+# PYTHONPATH used by the Nix shell
+.python3
+.claude/scheduled_tasks.lock
+userPrefs.jsonc.mcp-session-bak
@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "meshtastic": {
+      "command": "./mcp-server/.venv/bin/python",
+      "args": ["-m", "meshtastic_mcp"],
+      "env": {
+        "MESHTASTIC_FIRMWARE_ROOT": "."
+      }
+    }
+  }
+}
@@ -0,0 +1,11 @@
+{
+  "ai": "copilot",
+  "ai_commands_dir": null,
+  "ai_skills": false,
+  "branch_numbering": "sequential",
+  "here": true,
+  "offline": false,
+  "preset": null,
+  "script": "sh",
+  "speckit_version": "0.4.2"
+}
@@ -0,0 +1,136 @@
+<!--
+Sync Impact Report
+Version change: template -> 1.0.0
+Modified principles:
+- [PRINCIPLE_1_NAME] -> I. Safety-Critical Mesh Behavior
+- [PRINCIPLE_2_NAME] -> II. Variant-Scoped Hardware Truth
+- [PRINCIPLE_3_NAME] -> III. Verification by Targeted Evidence
+- [PRINCIPLE_4_NAME] -> IV. Resource and Power Discipline
+- [PRINCIPLE_5_NAME] -> V. Minimal, Reviewable Change Sets
+Added sections:
+- Engineering Constraints
+- Delivery Workflow
+Removed sections:
+- None
+Templates requiring updates:
+- ✅ .specify/templates/plan-template.md
+- ✅ .specify/templates/spec-template.md
+- ✅ .specify/templates/tasks-template.md
+- ⚠ pending .specify/templates/checklist-template.md (not required for current constitution alignment)
+- ⚠ pending .specify/templates/agent-file-template.md (generic scaffold, no constitution-specific drift found)
+Follow-up TODOs:
+- None
+-->
+
+# Meshtastic Firmware Constitution
+
+## Core Principles
+
+### I. Safety-Critical Mesh Behavior
+
+All feature and bug-fix work MUST preserve safe, predictable behavior on live mesh networks.
+Changes that affect routing, airtime, broadcast intervals, MQTT bridging, channel handling,
+or packet processing MUST document the operational impact on shared bandwidth, public-channel
+abuse protections, and interoperability. Any relaxation of rate limits, encryption behavior,
+or default-channel safeguards MUST be treated as a breaking governance change unless explicitly
+approved and justified.
+
+Rationale: Meshtastic devices operate in constrained radio environments where seemingly small
+behavior changes can degrade network reliability, privacy, and fairness for other nodes.
+
+### II. Variant-Scoped Hardware Truth
+
+Board definitions, platform conditionals, and peripheral flags MUST reflect verified hardware
+truth and MUST remain scoped to the exact supported target. New capabilities in `variant.h`,
+`platformio.ini`, `pins_arduino.h`, or related board files MUST be backed by pin mappings,
+chip selection, and power assumptions that are consistent with the board design. Cross-board
+copying is prohibited unless every reused define is revalidated for the destination variant.
+
+Rationale: This firmware spans many architectures and board revisions; incorrect hardware
+declarations create silent regressions that are hard to detect until devices are flashed.
+
+### III. Verification by Targeted Evidence
+
+Every change MUST be validated by the smallest credible evidence that matches its risk.
+At minimum, contributors MUST run formatting or static validation for touched files and MUST
+run a targeted build, test, or simulation path for the affected platform when feasible.
+Changes to shared core logic, protobufs, routing, or configuration defaults SHOULD include a
+native test, simulator run, or equivalent cross-target evidence. If validation cannot be run,
+the gap MUST be stated explicitly in the plan, tasks, and final review.
+
+Rationale: The repository supports many targets, so quality depends on explicit validation
+rather than assumptions that one successful build implies system-wide safety.
+
+### IV. Resource and Power Discipline
+
+Implementations MUST respect embedded constraints for memory, flash, CPU, battery, and radio
+duty cycle. New dependencies, background tasks, logging, polling, display work, and peripheral
+power use MUST be justified against the target hardware footprint. Defaults MUST prefer safe
+operation on constrained devices, and network-facing behavior MUST account for scaling with
+node count where existing project patterns provide that mechanism.
+
+Rationale: Meshtastic firmware runs on low-power devices where unnecessary work directly harms
+battery life, responsiveness, thermal behavior, and mesh capacity.
+
+### V. Minimal, Reviewable Change Sets
+
+Changes MUST solve the root problem with the smallest coherent diff that fits the existing
+architecture and coding patterns. Unrelated refactors, opportunistic renames, and speculative
+abstractions are prohibited in the same change unless they are required to make the fix safe.
+Public behavior, configuration semantics, and generated artifacts MUST remain stable unless the
+specification and plan explicitly call out the intended change.
+
+Rationale: Small, scoped changes are easier to review across board variants and reduce the
+risk of hidden regressions in a large multi-platform firmware repository.
+
+## Engineering Constraints
+
+The authoritative implementation context for this repository is `.github/copilot-instructions.md`.
+Plans and tasks MUST align with the existing PlatformIO-based build system, generated protobuf
+workflow, architecture-specific source layout, and hardware-variant structure already used in
+the repository.
+
+Feature work MUST honor these constraints:
+
+- Code MUST follow existing logging, naming, threading, and configuration patterns.
+- Default values and user-facing configuration changes MUST use existing `Default` helpers and
+  public-channel safeguards where applicable.
+- Protobuf changes MUST include regeneration steps and identify downstream effects in generated
+  code and dependent modules.
+- Build and validation steps MUST prefer repository-standard commands such as targeted `pio run`,
+  `pio test -e native`, simulator tooling, and `trunk fmt` where applicable.
+- Platform-specific logic MUST be isolated to the narrowest valid architecture or variant scope.
+
+## Delivery Workflow
+
+Spec-driven work in this repository MUST produce artifacts that make operational risk visible
+before code is written.
+
+- Specifications MUST describe affected user or device behavior, impacted platforms, and edge
+  cases for unavailable peripherals, misconfigured variants, and constrained-network scenarios.
+- Plans MUST include a Constitution Check that names the exact validation evidence, target
+  environments, and any justified deviations from the constitution.
+- Tasks MUST be organized so that foundational hardware, protocol, or configuration work is
+  completed before feature-specific behavior that depends on it.
+- Review and implementation notes MUST call out any skipped validation, generated-file updates,
+  migration considerations, or behavior changes requiring maintainer scrutiny.
+
+## Governance
+
+This constitution supersedes ad hoc workflow preferences for spec-driven work in this repository.
+All plans, tasks, reviews, and implementation summaries MUST verify compliance with these
+principles.
+
+- Amendments MUST be documented in this file and reflected in dependent templates before new
+  work proceeds under the changed rule set.
+- Versioning policy for this constitution follows semantic versioning.
+  MAJOR versions indicate removed or materially redefined principles.
+  MINOR versions indicate new principles, sections, or materially expanded guidance.
+  PATCH versions indicate clarifications, wording improvements, or non-semantic refinements.
+- Compliance review is mandatory for every feature plan and code review. Any constitutional
+  violation MUST be listed in the plan's Complexity Tracking section or equivalent justification.
+- Repository guidance files remain authoritative for implementation detail. Where conflict is
+  discovered, this constitution governs process and quality gates, while `.github/copilot-instructions.md`
+  governs repository-specific coding practice until the conflict is resolved by amendment.
+
+**Version**: 1.0.0 | **Ratified**: 2026-03-25 | **Last Amended**: 2026-03-25
@@ -0,0 +1,193 @@
+#!/usr/bin/env bash
+
+# Consolidated prerequisite checking script
+#
+# This script provides unified prerequisite checking for Spec-Driven Development workflow.
+# It replaces the functionality previously spread across multiple scripts.
+#
+# Usage: ./check-prerequisites.sh [OPTIONS]
+#
+# OPTIONS:
+#   --json              Output in JSON format
+#   --require-tasks     Require tasks.md to exist (for implementation phase)
+#   --include-tasks     Include tasks.md in AVAILABLE_DOCS list
+#   --paths-only        Only output path variables (no validation)
+#   --help, -h          Show help message
+#
+# OUTPUTS:
+#   JSON mode: {"FEATURE_DIR":"...", "AVAILABLE_DOCS":["..."]}
+#   Text mode: FEATURE_DIR:... \n AVAILABLE_DOCS: \n ✓/✗ file.md
+#   Paths only: REPO_ROOT: ... \n BRANCH: ... \n FEATURE_DIR: ... etc.
+
+set -e
+
+# Parse command line arguments
+JSON_MODE=false
+REQUIRE_TASKS=false
+INCLUDE_TASKS=false
+PATHS_ONLY=false
+
+for arg in "$@"; do
+	case "$arg" in
+	--json)
+		JSON_MODE=true
+		;;
+	--require-tasks)
+		REQUIRE_TASKS=true
+		;;
+	--include-tasks)
+		INCLUDE_TASKS=true
+		;;
+	--paths-only)
+		PATHS_ONLY=true
+		;;
+	--help | -h)
+		cat <<'EOF'
+Usage: check-prerequisites.sh [OPTIONS]
+
+Consolidated prerequisite checking for Spec-Driven Development workflow.
+
+OPTIONS:
+  --json              Output in JSON format
+  --require-tasks     Require tasks.md to exist (for implementation phase)
+  --include-tasks     Include tasks.md in AVAILABLE_DOCS list
+  --paths-only        Only output path variables (no prerequisite validation)
+  --help, -h          Show this help message
+
+EXAMPLES:
+  # Check task prerequisites (plan.md required)
+  ./check-prerequisites.sh --json
+  
+  # Check implementation prerequisites (plan.md + tasks.md required)
+  ./check-prerequisites.sh --json --require-tasks --include-tasks
+  
+  # Get feature paths only (no validation)
+  ./check-prerequisites.sh --paths-only
+  
+EOF
+		exit 0
+		;;
+	*)
+		echo "ERROR: Unknown option '$arg'. Use --help for usage information." >&2
+		exit 1
+		;;
+	esac
+done
+
+# Source common functions
+SCRIPT_DIR="$(CDPATH="" cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/common.sh"
+
+# Get feature paths and validate branch
+_paths_output=$(get_feature_paths) || {
+	echo "ERROR: Failed to resolve feature paths" >&2
+	exit 1
+}
+eval "$_paths_output"
+unset _paths_output
+check_feature_branch "$CURRENT_BRANCH" "$HAS_GIT" || exit 1
+
+# If paths-only mode, output paths and exit (support JSON + paths-only combined)
+if $PATHS_ONLY; then
+	if $JSON_MODE; then
+		# Minimal JSON paths payload (no validation performed)
+		if has_jq; then
+			jq -cn \
+				--arg repo_root "$REPO_ROOT" \
+				--arg branch "$CURRENT_BRANCH" \
+				--arg feature_dir "$FEATURE_DIR" \
+				--arg feature_spec "$FEATURE_SPEC" \
+				--arg impl_plan "$IMPL_PLAN" \
+				--arg tasks "$TASKS" \
+				'{REPO_ROOT:$repo_root,BRANCH:$branch,FEATURE_DIR:$feature_dir,FEATURE_SPEC:$feature_spec,IMPL_PLAN:$impl_plan,TASKS:$tasks}'
+		else
+			printf '{"REPO_ROOT":"%s","BRANCH":"%s","FEATURE_DIR":"%s","FEATURE_SPEC":"%s","IMPL_PLAN":"%s","TASKS":"%s"}\n' \
+				"$(json_escape "$REPO_ROOT")" "$(json_escape "$CURRENT_BRANCH")" "$(json_escape "$FEATURE_DIR")" "$(json_escape "$FEATURE_SPEC")" "$(json_escape "$IMPL_PLAN")" "$(json_escape "$TASKS")"
+		fi
+	else
+		echo "REPO_ROOT: $REPO_ROOT"
+		echo "BRANCH: $CURRENT_BRANCH"
+		echo "FEATURE_DIR: $FEATURE_DIR"
+		echo "FEATURE_SPEC: $FEATURE_SPEC"
+		echo "IMPL_PLAN: $IMPL_PLAN"
+		echo "TASKS: $TASKS"
+	fi
+	exit 0
+fi
+
+# Validate required directories and files
+if [[ ! -d $FEATURE_DIR ]]; then
+	echo "ERROR: Feature directory not found: $FEATURE_DIR" >&2
+	echo "Run /speckit.specify first to create the feature structure." >&2
+	exit 1
+fi
+
+if [[ ! -f $IMPL_PLAN ]]; then
+	echo "ERROR: plan.md not found in $FEATURE_DIR" >&2
+	echo "Run /speckit.plan first to create the implementation plan." >&2
+	exit 1
+fi
+
+# Check for tasks.md if required
+if $REQUIRE_TASKS && [[ ! -f $TASKS ]]; then
+	echo "ERROR: tasks.md not found in $FEATURE_DIR" >&2
+	echo "Run /speckit.tasks first to create the task list." >&2
+	exit 1
+fi
+
+# Build list of available documents
+docs=()
+
+# Always check these optional docs
+[[ -f $RESEARCH ]] && docs+=("research.md")
+[[ -f $DATA_MODEL ]] && docs+=("data-model.md")
+
+# Check contracts directory (only if it exists and has files)
+if [[ -d $CONTRACTS_DIR ]] && [[ -n "$(ls -A "$CONTRACTS_DIR" 2>/dev/null)" ]]; then
+	docs+=("contracts/")
+fi
+
+[[ -f $QUICKSTART ]] && docs+=("quickstart.md")
+
+# Include tasks.md if requested and it exists
+if $INCLUDE_TASKS && [[ -f $TASKS ]]; then
+	docs+=("tasks.md")
+fi
+
+# Output results
+if $JSON_MODE; then
+	# Build JSON array of documents
+	if has_jq; then
+		if [[ ${#docs[@]} -eq 0 ]]; then
+			json_docs="[]"
+		else
+			json_docs=$(printf '%s\n' "${docs[@]}" | jq -R . | jq -s .)
+		fi
+		jq -cn \
+			--arg feature_dir "$FEATURE_DIR" \
+			--argjson docs "$json_docs" \
+			'{FEATURE_DIR:$feature_dir,AVAILABLE_DOCS:$docs}'
+	else
+		if [[ ${#docs[@]} -eq 0 ]]; then
+			json_docs="[]"
+		else
+			json_docs=$(for d in "${docs[@]}"; do printf '"%s",' "$(json_escape "$d")"; done)
+			json_docs="[${json_docs%,}]"
+		fi
+		printf '{"FEATURE_DIR":"%s","AVAILABLE_DOCS":%s}\n' "$(json_escape "$FEATURE_DIR")" "$json_docs"
+	fi
+else
+	# Text output
+	echo "FEATURE_DIR:$FEATURE_DIR"
+	echo "AVAILABLE_DOCS:"
+
+	# Show status of each potential document
+	check_file "$RESEARCH" "research.md"
+	check_file "$DATA_MODEL" "data-model.md"
+	check_dir "$CONTRACTS_DIR" "contracts/"
+	check_file "$QUICKSTART" "quickstart.md"
+
+	if $INCLUDE_TASKS; then
+		check_file "$TASKS" "tasks.md"
+	fi
+fi
@@ -0,0 +1,329 @@
+#!/usr/bin/env bash
+# Common functions and variables for all scripts
+
+# Find repository root by searching upward for .specify directory
+# This is the primary marker for spec-kit projects
+find_specify_root() {
+	local dir="${1:-$(pwd)}"
+	# Normalize to absolute path to prevent infinite loop with relative paths
+	# Use -- to handle paths starting with - (e.g., -P, -L)
+	dir="$(cd -- "$dir" 2>/dev/null && pwd)" || return 1
+	local prev_dir=""
+	while true; do
+		if [ -d "$dir/.specify" ]; then
+			echo "$dir"
+			return 0
+		fi
+		# Stop if we've reached filesystem root or dirname stops changing
+		if [ "$dir" = "/" ] || [ "$dir" = "$prev_dir" ]; then
+			break
+		fi
+		prev_dir="$dir"
+		dir="$(dirname "$dir")"
+	done
+	return 1
+}
+
+# Get repository root, prioritizing .specify directory over git
+# This prevents using a parent git repo when spec-kit is initialized in a subdirectory
+get_repo_root() {
+	# First, look for .specify directory (spec-kit's own marker)
+	local specify_root
+	if specify_root=$(find_specify_root); then
+		echo "$specify_root"
+		return
+	fi
+
+	# Fallback to git if no .specify found
+	if git rev-parse --show-toplevel >/dev/null 2>&1; then
+		git rev-parse --show-toplevel
+		return
+	fi
+
+	# Final fallback to script location for non-git repos
+	local script_dir="$(CDPATH="" cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+	(cd "$script_dir/../../.." && pwd)
+}
+
+# Get current branch, with fallback for non-git repositories
+get_current_branch() {
+	# First check if SPECIFY_FEATURE environment variable is set
+	if [[ -n ${SPECIFY_FEATURE-} ]]; then
+		echo "$SPECIFY_FEATURE"
+		return
+	fi
+
+	# Then check git if available at the spec-kit root (not parent)
+	local repo_root=$(get_repo_root)
+	if has_git; then
+		git -C "$repo_root" rev-parse --abbrev-ref HEAD
+		return
+	fi
+
+	# For non-git repos, try to find the latest feature directory
+	local specs_dir="$repo_root/specs"
+
+	if [[ -d $specs_dir ]]; then
+		local latest_feature=""
+		local highest=0
+		local latest_timestamp=""
+
+		for dir in "$specs_dir"/*; do
+			if [[ -d $dir ]]; then
+				local dirname=$(basename "$dir")
+				if [[ $dirname =~ ^([0-9]{8}-[0-9]{6})- ]]; then
+					# Timestamp-based branch: compare lexicographically
+					local ts="${BASH_REMATCH[1]}"
+					if [[ $ts > $latest_timestamp ]]; then
+						latest_timestamp="$ts"
+						latest_feature=$dirname
+					fi
+				elif [[ $dirname =~ ^([0-9]{3})- ]]; then
+					local number=${BASH_REMATCH[1]}
+					number=$((10#$number))
+					if [[ $number -gt $highest ]]; then
+						highest=$number
+						# Only update if no timestamp branch found yet
+						if [[ -z $latest_timestamp ]]; then
+							latest_feature=$dirname
+						fi
+					fi
+				fi
+			fi
+		done
+
+		if [[ -n $latest_feature ]]; then
+			echo "$latest_feature"
+			return
+		fi
+	fi
+
+	echo "main" # Final fallback
+}
+
+# Check if we have git available at the spec-kit root level
+# Returns true only if git is installed and the repo root is inside a git work tree
+# Handles both regular repos (.git directory) and worktrees/submodules (.git file)
+has_git() {
+	# First check if git command is available (before calling get_repo_root which may use git)
+	command -v git >/dev/null 2>&1 || return 1
+	local repo_root=$(get_repo_root)
+	# Check if .git exists (directory or file for worktrees/submodules)
+	[ -e "$repo_root/.git" ] || return 1
+	# Verify it's actually a valid git work tree
+	git -C "$repo_root" rev-parse --is-inside-work-tree >/dev/null 2>&1
+}
+
+check_feature_branch() {
+	local branch="$1"
+	local has_git_repo="$2"
+
+	# For non-git repos, we can't enforce branch naming but still provide output
+	if [[ $has_git_repo != "true" ]]; then
+		echo "[specify] Warning: Git repository not detected; skipped branch validation" >&2
+		return 0
+	fi
+
+	if [[ ! $branch =~ ^[0-9]{3}- ]] && [[ ! $branch =~ ^[0-9]{8}-[0-9]{6}- ]]; then
+		echo "ERROR: Not on a feature branch. Current branch: $branch" >&2
+		echo "Feature branches should be named like: 001-feature-name or 20260319-143022-feature-name" >&2
+		return 1
+	fi
+
+	return 0
+}
+
+get_feature_dir() { echo "$1/specs/$2"; }
+
+# Find feature directory by numeric prefix instead of exact branch match
+# This allows multiple branches to work on the same spec (e.g., 004-fix-bug, 004-add-feature)
+find_feature_dir_by_prefix() {
+	local repo_root="$1"
+	local branch_name="$2"
+	local specs_dir="$repo_root/specs"
+
+	# Extract prefix from branch (e.g., "004" from "004-whatever" or "20260319-143022" from timestamp branches)
+	local prefix=""
+	if [[ $branch_name =~ ^([0-9]{8}-[0-9]{6})- ]]; then
+		prefix="${BASH_REMATCH[1]}"
+	elif [[ $branch_name =~ ^([0-9]{3})- ]]; then
+		prefix="${BASH_REMATCH[1]}"
+	else
+		# If branch doesn't have a recognized prefix, fall back to exact match
+		echo "$specs_dir/$branch_name"
+		return
+	fi
+
+	# Search for directories in specs/ that start with this prefix
+	local matches=()
+	if [[ -d $specs_dir ]]; then
+		for dir in "$specs_dir"/"$prefix"-*; do
+			if [[ -d $dir ]]; then
+				matches+=("$(basename "$dir")")
+			fi
+		done
+	fi
+
+	# Handle results
+	if [[ ${#matches[@]} -eq 0 ]]; then
+		# No match found - return the branch name path (will fail later with clear error)
+		echo "$specs_dir/$branch_name"
+	elif [[ ${#matches[@]} -eq 1 ]]; then
+		# Exactly one match - perfect!
+		echo "$specs_dir/${matches[0]}"
+	else
+		# Multiple matches - this shouldn't happen with proper naming convention
+		echo "ERROR: Multiple spec directories found with prefix '$prefix': ${matches[*]}" >&2
+		echo "Please ensure only one spec directory exists per prefix." >&2
+		return 1
+	fi
+}
+
+get_feature_paths() {
+	local repo_root=$(get_repo_root)
+	local current_branch=$(get_current_branch)
+	local has_git_repo="false"
+
+	if has_git; then
+		has_git_repo="true"
+	fi
+
+	# Use prefix-based lookup to support multiple branches per spec
+	local feature_dir
+	if ! feature_dir=$(find_feature_dir_by_prefix "$repo_root" "$current_branch"); then
+		echo "ERROR: Failed to resolve feature directory" >&2
+		return 1
+	fi
+
+	# Use printf '%q' to safely quote values, preventing shell injection
+	# via crafted branch names or paths containing special characters
+	printf 'REPO_ROOT=%q\n' "$repo_root"
+	printf 'CURRENT_BRANCH=%q\n' "$current_branch"
+	printf 'HAS_GIT=%q\n' "$has_git_repo"
+	printf 'FEATURE_DIR=%q\n' "$feature_dir"
+	printf 'FEATURE_SPEC=%q\n' "$feature_dir/spec.md"
+	printf 'IMPL_PLAN=%q\n' "$feature_dir/plan.md"
+	printf 'TASKS=%q\n' "$feature_dir/tasks.md"
+	printf 'RESEARCH=%q\n' "$feature_dir/research.md"
+	printf 'DATA_MODEL=%q\n' "$feature_dir/data-model.md"
+	printf 'QUICKSTART=%q\n' "$feature_dir/quickstart.md"
+	printf 'CONTRACTS_DIR=%q\n' "$feature_dir/contracts"
+}
+
+# Check if jq is available for safe JSON construction
+has_jq() {
+	command -v jq >/dev/null 2>&1
+}
+
+# Escape a string for safe embedding in a JSON value (fallback when jq is unavailable).
+# Handles backslash, double-quote, and JSON-required control character escapes (RFC 8259).
+json_escape() {
+	local s="$1"
+	s="${s//\\/\\\\}"
+	s="${s//\"/\\\"}"
+	s="${s//$'\n'/\\n}"
+	s="${s//$'\t'/\\t}"
+	s="${s//$'\r'/\\r}"
+	s="${s//$'\b'/\\b}"
+	s="${s//$'\f'/\\f}"
+	# Escape any remaining U+0001-U+001F control characters as \uXXXX.
+	# (U+0000/NUL cannot appear in bash strings and is excluded.)
+	# LC_ALL=C ensures ${#s} counts bytes and ${s:$i:1} yields single bytes,
+	# so multi-byte UTF-8 sequences (first byte >= 0xC0) pass through intact.
+	local LC_ALL=C
+	local i char code
+	for ((i = 0; i < ${#s}; i++)); do
+		char="${s:i:1}"
+		printf -v code '%d' "'$char" 2>/dev/null || code=256
+		if ((code >= 1 && code <= 31)); then
+			printf '\\u%04x' "$code"
+		else
+			printf '%s' "$char"
+		fi
+	done
+}
+
+check_file() { [[ -f $1 ]] && echo "  ✓ $2" || echo "  ✗ $2"; }
+check_dir() { [[ -d $1 && -n $(ls -A "$1" 2>/dev/null) ]] && echo "  ✓ $2" || echo "  ✗ $2"; }
+
+# Resolve a template name to a file path using the priority stack:
+#   1. .specify/templates/overrides/
+#   2. .specify/presets/<preset-id>/templates/ (sorted by priority from .registry)
+#   3. .specify/extensions/<ext-id>/templates/
+#   4. .specify/templates/ (core)
+resolve_template() {
+	local template_name="$1"
+	local repo_root="$2"
+	local base="$repo_root/.specify/templates"
+
+	# Priority 1: Project overrides
+	local override="$base/overrides/${template_name}.md"
+	[ -f "$override" ] && echo "$override" && return 0
+
+	# Priority 2: Installed presets (sorted by priority from .registry)
+	local presets_dir="$repo_root/.specify/presets"
+	if [ -d "$presets_dir" ]; then
+		local registry_file="$presets_dir/.registry"
+		if [ -f "$registry_file" ] && command -v python3 >/dev/null 2>&1; then
+			# Read preset IDs sorted by priority (lower number = higher precedence).
+			# The python3 call is wrapped in an if-condition so that set -e does not
+			# abort the function when python3 exits non-zero (e.g. invalid JSON).
+			local sorted_presets=""
+			if sorted_presets=$(SPECKIT_REGISTRY="$registry_file" python3 -c "
+import json, sys, os
+try:
+    with open(os.environ['SPECKIT_REGISTRY']) as f:
+        data = json.load(f)
+    presets = data.get('presets', {})
+    for pid, meta in sorted(presets.items(), key=lambda x: x[1].get('priority', 10)):
+        print(pid)
+except Exception:
+    sys.exit(1)
+" 2>/dev/null); then
+				if [ -n "$sorted_presets" ]; then
+					# python3 succeeded and returned preset IDs — search in priority order
+					while IFS= read -r preset_id; do
+						local candidate="$presets_dir/$preset_id/templates/${template_name}.md"
+						[ -f "$candidate" ] && echo "$candidate" && return 0
+					done <<<"$sorted_presets"
+				fi
+				# python3 succeeded but registry has no presets — nothing to search
+			else
+				# python3 failed (missing, or registry parse error) — fall back to unordered directory scan
+				for preset in "$presets_dir"/*/; do
+					[ -d "$preset" ] || continue
+					local candidate="$preset/templates/${template_name}.md"
+					[ -f "$candidate" ] && echo "$candidate" && return 0
+				done
+			fi
+		else
+			# Fallback: alphabetical directory order (no python3 available)
+			for preset in "$presets_dir"/*/; do
+				[ -d "$preset" ] || continue
+				local candidate="$preset/templates/${template_name}.md"
+				[ -f "$candidate" ] && echo "$candidate" && return 0
+			done
+		fi
+	fi
+
+	# Priority 3: Extension-provided templates
+	local ext_dir="$repo_root/.specify/extensions"
+	if [ -d "$ext_dir" ]; then
+		for ext in "$ext_dir"/*/; do
+			[ -d "$ext" ] || continue
+			# Skip hidden directories (e.g. .backup, .cache)
+			case "$(basename "$ext")" in .*) continue ;; esac
+			local candidate="$ext/templates/${template_name}.md"
+			[ -f "$candidate" ] && echo "$candidate" && return 0
+		done
+	fi
+
+	# Priority 4: Core templates
+	local core="$base/${template_name}.md"
+	[ -f "$core" ] && echo "$core" && return 0
+
+	# Template not found in any location.
+	# Return 1 so callers can distinguish "not found" from "found".
+	# Callers running under set -e should use: TEMPLATE=$(resolve_template ...) || true
+	return 1
+}
@@ -0,0 +1,335 @@
+#!/usr/bin/env bash
+
+set -e
+
+JSON_MODE=false
+SHORT_NAME=""
+BRANCH_NUMBER=""
+USE_TIMESTAMP=false
+ARGS=()
+i=1
+while [ $i -le $# ]; do
+	arg="${!i}"
+	case "$arg" in
+	--json)
+		JSON_MODE=true
+		;;
+	--short-name)
+		if [ $((i + 1)) -gt $# ]; then
+			echo 'Error: --short-name requires a value' >&2
+			exit 1
+		fi
+		i=$((i + 1))
+		next_arg="${!i}"
+		# Check if the next argument is another option (starts with --)
+		if [[ $next_arg == --* ]]; then
+			echo 'Error: --short-name requires a value' >&2
+			exit 1
+		fi
+		SHORT_NAME="$next_arg"
+		;;
+	--number)
+		if [ $((i + 1)) -gt $# ]; then
+			echo 'Error: --number requires a value' >&2
+			exit 1
+		fi
+		i=$((i + 1))
+		next_arg="${!i}"
+		if [[ $next_arg == --* ]]; then
+			echo 'Error: --number requires a value' >&2
+			exit 1
+		fi
+		BRANCH_NUMBER="$next_arg"
+		;;
+	--timestamp)
+		USE_TIMESTAMP=true
+		;;
+	--help | -h)
+		echo "Usage: $0 [--json] [--short-name <name>] [--number N] [--timestamp] <feature_description>"
+		echo ""
+		echo "Options:"
+		echo "  --json              Output in JSON format"
+		echo "  --short-name <name> Provide a custom short name (2-4 words) for the branch"
+		echo "  --number N          Specify branch number manually (overrides auto-detection)"
+		echo "  --timestamp         Use timestamp prefix (YYYYMMDD-HHMMSS) instead of sequential numbering"
+		echo "  --help, -h          Show this help message"
+		echo ""
+		echo "Examples:"
+		echo "  $0 'Add user authentication system' --short-name 'user-auth'"
+		echo "  $0 'Implement OAuth2 integration for API' --number 5"
+		echo "  $0 --timestamp --short-name 'user-auth' 'Add user authentication'"
+		exit 0
+		;;
+	*)
+		ARGS+=("$arg")
+		;;
+	esac
+	i=$((i + 1))
+done
+
+FEATURE_DESCRIPTION="${ARGS[*]}"
+if [ -z "$FEATURE_DESCRIPTION" ]; then
+	echo "Usage: $0 [--json] [--short-name <name>] [--number N] [--timestamp] <feature_description>" >&2
+	exit 1
+fi
+
+# Trim whitespace and validate description is not empty (e.g., user passed only whitespace)
+FEATURE_DESCRIPTION=$(echo "$FEATURE_DESCRIPTION" | xargs)
+if [ -z "$FEATURE_DESCRIPTION" ]; then
+	echo "Error: Feature description cannot be empty or contain only whitespace" >&2
+	exit 1
+fi
+
+# Function to get highest number from specs directory
+get_highest_from_specs() {
+	local specs_dir="$1"
+	local highest=0
+
+	if [ -d "$specs_dir" ]; then
+		for dir in "$specs_dir"/*; do
+			[ -d "$dir" ] || continue
+			dirname=$(basename "$dir")
+			# Only match sequential prefixes (###-*), skip timestamp dirs
+			if echo "$dirname" | grep -q '^[0-9]\{3\}-'; then
+				number=$(echo "$dirname" | grep -o '^[0-9]\{3\}')
+				number=$((10#$number))
+				if [ "$number" -gt "$highest" ]; then
+					highest=$number
+				fi
+			fi
+		done
+	fi
+
+	echo "$highest"
+}
+
+# Function to get highest number from git branches
+get_highest_from_branches() {
+	local highest=0
+
+	# Get all branches (local and remote)
+	branches=$(git branch -a 2>/dev/null || echo "")
+
+	if [ -n "$branches" ]; then
+		while IFS= read -r branch; do
+			# Clean branch name: remove leading markers and remote prefixes
+			clean_branch=$(echo "$branch" | sed 's/^[* ]*//; s|^remotes/[^/]*/||')
+
+			# Extract feature number if branch matches pattern ###-*
+			if echo "$clean_branch" | grep -q '^[0-9]\{3\}-'; then
+				number=$(echo "$clean_branch" | grep -o '^[0-9]\{3\}' || echo "0")
+				number=$((10#$number))
+				if [ "$number" -gt "$highest" ]; then
+					highest=$number
+				fi
+			fi
+		done <<<"$branches"
+	fi
+
+	echo "$highest"
+}
+
+# Function to check existing branches (local and remote) and return next available number
+check_existing_branches() {
+	local specs_dir="$1"
+
+	# Fetch all remotes to get latest branch info (suppress errors if no remotes)
+	git fetch --all --prune >/dev/null 2>&1 || true
+
+	# Get highest number from ALL branches (not just matching short name)
+	local highest_branch=$(get_highest_from_branches)
+
+	# Get highest number from ALL specs (not just matching short name)
+	local highest_spec=$(get_highest_from_specs "$specs_dir")
+
+	# Take the maximum of both
+	local max_num=$highest_branch
+	if [ "$highest_spec" -gt "$max_num" ]; then
+		max_num=$highest_spec
+	fi
+
+	# Return next number
+	echo $((max_num + 1))
+}
+
+# Function to clean and format a branch name
+clean_branch_name() {
+	local name="$1"
+	echo "$name" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/-\+/-/g' | sed 's/^-//' | sed 's/-$//'
+}
+
+# Resolve repository root using common.sh functions which prioritize .specify over git
+SCRIPT_DIR="$(CDPATH="" cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/common.sh"
+
+REPO_ROOT=$(get_repo_root)
+
+# Check if git is available at this repo root (not a parent)
+if has_git; then
+	HAS_GIT=true
+else
+	HAS_GIT=false
+fi
+
+cd "$REPO_ROOT"
+
+SPECS_DIR="$REPO_ROOT/specs"
+mkdir -p "$SPECS_DIR"
+
+# Function to generate branch name with stop word filtering and length filtering
+generate_branch_name() {
+	local description="$1"
+
+	# Common stop words to filter out
+	local stop_words="^(i|a|an|the|to|for|of|in|on|at|by|with|from|is|are|was|were|be|been|being|have|has|had|do|does|did|will|would|should|could|can|may|might|must|shall|this|that|these|those|my|your|our|their|want|need|add|get|set)$"
+
+	# Convert to lowercase and split into words
+	local clean_name=$(echo "$description" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/ /g')
+
+	# Filter words: remove stop words and words shorter than 3 chars (unless they're uppercase acronyms in original)
+	local meaningful_words=()
+	for word in $clean_name; do
+		# Skip empty words
+		[ -z "$word" ] && continue
+
+		# Keep words that are NOT stop words AND (length >= 3 OR are potential acronyms)
+		if ! echo "$word" | grep -qiE "$stop_words"; then
+			if [ ${#word} -ge 3 ]; then
+				meaningful_words+=("$word")
+			elif echo "$description" | grep -q "\b${word^^}\b"; then
+				# Keep short words if they appear as uppercase in original (likely acronyms)
+				meaningful_words+=("$word")
+			fi
+		fi
+	done
+
+	# If we have meaningful words, use first 3-4 of them
+	if [ ${#meaningful_words[@]} -gt 0 ]; then
+		local max_words=3
+		if [ ${#meaningful_words[@]} -eq 4 ]; then max_words=4; fi
+
+		local result=""
+		local count=0
+		for word in "${meaningful_words[@]}"; do
+			if [ $count -ge $max_words ]; then break; fi
+			if [ -n "$result" ]; then result="$result-"; fi
+			result="$result$word"
+			count=$((count + 1))
+		done
+		echo "$result"
+	else
+		# Fallback to original logic if no meaningful words found
+		local cleaned=$(clean_branch_name "$description")
+		echo "$cleaned" | tr '-' '\n' | grep -v '^$' | head -3 | tr '\n' '-' | sed 's/-$//'
+	fi
+}
+
+# Generate branch name
+if [ -n "$SHORT_NAME" ]; then
+	# Use provided short name, just clean it up
+	BRANCH_SUFFIX=$(clean_branch_name "$SHORT_NAME")
+else
+	# Generate from description with smart filtering
+	BRANCH_SUFFIX=$(generate_branch_name "$FEATURE_DESCRIPTION")
+fi
+
+# Warn if --number and --timestamp are both specified
+if [ "$USE_TIMESTAMP" = true ] && [ -n "$BRANCH_NUMBER" ]; then
+	echo >&2 "[specify] Warning: --number is ignored when --timestamp is used"
+	BRANCH_NUMBER=""
+fi
+
+# Determine branch prefix
+if [ "$USE_TIMESTAMP" = true ]; then
+	FEATURE_NUM=$(date +%Y%m%d-%H%M%S)
+	BRANCH_NAME="${FEATURE_NUM}-${BRANCH_SUFFIX}"
+else
+	# Determine branch number
+	if [ -z "$BRANCH_NUMBER" ]; then
+		if [ "$HAS_GIT" = true ]; then
+			# Check existing branches on remotes
+			BRANCH_NUMBER=$(check_existing_branches "$SPECS_DIR")
+		else
+			# Fall back to local directory check
+			HIGHEST=$(get_highest_from_specs "$SPECS_DIR")
+			BRANCH_NUMBER=$((HIGHEST + 1))
+		fi
+	fi
+
+	# Force base-10 interpretation to prevent octal conversion (e.g., 010 → 8 in octal, but should be 10 in decimal)
+	FEATURE_NUM=$(printf "%03d" "$((10#$BRANCH_NUMBER))")
+	BRANCH_NAME="${FEATURE_NUM}-${BRANCH_SUFFIX}"
+fi
+
+# GitHub enforces a 244-byte limit on branch names
+# Validate and truncate if necessary
+MAX_BRANCH_LENGTH=244
+if [ ${#BRANCH_NAME} -gt $MAX_BRANCH_LENGTH ]; then
+	# Calculate how much we need to trim from suffix
+	# Account for prefix length: timestamp (15) + hyphen (1) = 16, or sequential (3) + hyphen (1) = 4
+	PREFIX_LENGTH=$((${#FEATURE_NUM} + 1))
+	MAX_SUFFIX_LENGTH=$((MAX_BRANCH_LENGTH - PREFIX_LENGTH))
+
+	# Truncate suffix at word boundary if possible
+	TRUNCATED_SUFFIX=$(echo "$BRANCH_SUFFIX" | cut -c1-$MAX_SUFFIX_LENGTH)
+	# Remove trailing hyphen if truncation created one
+	TRUNCATED_SUFFIX=$(echo "$TRUNCATED_SUFFIX" | sed 's/-$//')
+
+	ORIGINAL_BRANCH_NAME="$BRANCH_NAME"
+	BRANCH_NAME="${FEATURE_NUM}-${TRUNCATED_SUFFIX}"
+
+	echo >&2 "[specify] Warning: Branch name exceeded GitHub's 244-byte limit"
+	echo >&2 "[specify] Original: $ORIGINAL_BRANCH_NAME (${#ORIGINAL_BRANCH_NAME} bytes)"
+	echo >&2 "[specify] Truncated to: $BRANCH_NAME (${#BRANCH_NAME} bytes)"
+fi
+
+if [ "$HAS_GIT" = true ]; then
+	if ! git checkout -b "$BRANCH_NAME" 2>/dev/null; then
+		# Check if branch already exists
+		if git branch --list "$BRANCH_NAME" | grep -q .; then
+			if [ "$USE_TIMESTAMP" = true ]; then
+				echo >&2 "Error: Branch '$BRANCH_NAME' already exists. Rerun to get a new timestamp or use a different --short-name."
+			else
+				echo >&2 "Error: Branch '$BRANCH_NAME' already exists. Please use a different feature name or specify a different number with --number."
+			fi
+			exit 1
+		else
+			echo >&2 "Error: Failed to create git branch '$BRANCH_NAME'. Please check your git configuration and try again."
+			exit 1
+		fi
+	fi
+else
+	echo >&2 "[specify] Warning: Git repository not detected; skipped branch creation for $BRANCH_NAME"
+fi
+
+FEATURE_DIR="$SPECS_DIR/$BRANCH_NAME"
+mkdir -p "$FEATURE_DIR"
+
+TEMPLATE=$(resolve_template "spec-template" "$REPO_ROOT") || true
+SPEC_FILE="$FEATURE_DIR/spec.md"
+if [ -n "$TEMPLATE" ] && [ -f "$TEMPLATE" ]; then
+	cp "$TEMPLATE" "$SPEC_FILE"
+else
+	echo "Warning: Spec template not found; created empty spec file" >&2
+	touch "$SPEC_FILE"
+fi
+
+# Inform the user how to persist the feature variable in their own shell
+printf '# To persist: export SPECIFY_FEATURE=%q\n' "$BRANCH_NAME" >&2
+
+if $JSON_MODE; then
+	if command -v jq >/dev/null 2>&1; then
+		jq -cn \
+			--arg branch_name "$BRANCH_NAME" \
+			--arg spec_file "$SPEC_FILE" \
+			--arg feature_num "$FEATURE_NUM" \
+			'{BRANCH_NAME:$branch_name,SPEC_FILE:$spec_file,FEATURE_NUM:$feature_num}'
+	else
+		printf '{"BRANCH_NAME":"%s","SPEC_FILE":"%s","FEATURE_NUM":"%s"}\n' "$(json_escape "$BRANCH_NAME")" "$(json_escape "$SPEC_FILE")" "$(json_escape "$FEATURE_NUM")"
+	fi
+else
+	echo "BRANCH_NAME: $BRANCH_NAME"
+	echo "SPEC_FILE: $SPEC_FILE"
+	echo "FEATURE_NUM: $FEATURE_NUM"
+	printf '# To persist in your shell: export SPECIFY_FEATURE=%q\n' "$BRANCH_NAME"
+fi
@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+
+set -e
+
+# Parse command line arguments
+JSON_MODE=false
+ARGS=()
+
+for arg in "$@"; do
+	case "$arg" in
+	--json)
+		JSON_MODE=true
+		;;
+	--help | -h)
+		echo "Usage: $0 [--json]"
+		echo "  --json    Output results in JSON format"
+		echo "  --help    Show this help message"
+		exit 0
+		;;
+	*)
+		ARGS+=("$arg")
+		;;
+	esac
+done
+
+# Get script directory and load common functions
+SCRIPT_DIR="$(CDPATH="" cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/common.sh"
+
+# Get all paths and variables from common functions
+_paths_output=$(get_feature_paths) || {
+	echo "ERROR: Failed to resolve feature paths" >&2
+	exit 1
+}
+eval "$_paths_output"
+unset _paths_output
+
+# Check if we're on a proper feature branch (only for git repos)
+check_feature_branch "$CURRENT_BRANCH" "$HAS_GIT" || exit 1
+
+# Ensure the feature directory exists
+mkdir -p "$FEATURE_DIR"
+
+# Copy plan template if it exists
+TEMPLATE=$(resolve_template "plan-template" "$REPO_ROOT") || true
+if [[ -n $TEMPLATE ]] && [[ -f $TEMPLATE ]]; then
+	cp "$TEMPLATE" "$IMPL_PLAN"
+	echo "Copied plan template to $IMPL_PLAN"
+else
+	echo "Warning: Plan template not found"
+	# Create a basic plan file if template doesn't exist
+	touch "$IMPL_PLAN"
+fi
+
+# Output results
+if $JSON_MODE; then
+	if has_jq; then
+		jq -cn \
+			--arg feature_spec "$FEATURE_SPEC" \
+			--arg impl_plan "$IMPL_PLAN" \
+			--arg specs_dir "$FEATURE_DIR" \
+			--arg branch "$CURRENT_BRANCH" \
+			--arg has_git "$HAS_GIT" \
+			'{FEATURE_SPEC:$feature_spec,IMPL_PLAN:$impl_plan,SPECS_DIR:$specs_dir,BRANCH:$branch,HAS_GIT:$has_git}'
+	else
+		printf '{"FEATURE_SPEC":"%s","IMPL_PLAN":"%s","SPECS_DIR":"%s","BRANCH":"%s","HAS_GIT":"%s"}\n' \
+			"$(json_escape "$FEATURE_SPEC")" "$(json_escape "$IMPL_PLAN")" "$(json_escape "$FEATURE_DIR")" "$(json_escape "$CURRENT_BRANCH")" "$(json_escape "$HAS_GIT")"
+	fi
+else
+	echo "FEATURE_SPEC: $FEATURE_SPEC"
+	echo "IMPL_PLAN: $IMPL_PLAN"
+	echo "SPECS_DIR: $FEATURE_DIR"
+	echo "BRANCH: $CURRENT_BRANCH"
+	echo "HAS_GIT: $HAS_GIT"
+fi
@@ -0,0 +1,840 @@
+#!/usr/bin/env bash
+
+# Update agent context files with information from plan.md
+#
+# This script maintains AI agent context files by parsing feature specifications
+# and updating agent-specific configuration files with project information.
+#
+# MAIN FUNCTIONS:
+# 1. Environment Validation
+#    - Verifies git repository structure and branch information
+#    - Checks for required plan.md files and templates
+#    - Validates file permissions and accessibility
+#
+# 2. Plan Data Extraction
+#    - Parses plan.md files to extract project metadata
+#    - Identifies language/version, frameworks, databases, and project types
+#    - Handles missing or incomplete specification data gracefully
+#
+# 3. Agent File Management
+#    - Creates new agent context files from templates when needed
+#    - Updates existing agent files with new project information
+#    - Preserves manual additions and custom configurations
+#    - Supports multiple AI agent formats and directory structures
+#
+# 4. Content Generation
+#    - Generates language-specific build/test commands
+#    - Creates appropriate project directory structures
+#    - Updates technology stacks and recent changes sections
+#    - Maintains consistent formatting and timestamps
+#
+# 5. Multi-Agent Support
+#    - Handles agent-specific file paths and naming conventions
+#    - Supports: Claude, Gemini, Copilot, Cursor, Qwen, opencode, Codex, Windsurf, Junie, Kilo Code, Auggie CLI, Roo Code, CodeBuddy CLI, Qoder CLI, Amp, SHAI, Tabnine CLI, Kiro CLI, Mistral Vibe, Kimi Code, Pi Coding Agent, iFlow CLI, Antigravity or Generic
+#    - Can update single agents or all existing agent files
+#    - Creates default Claude file if no agent files exist
+#
+# Usage: ./update-agent-context.sh [agent_type]
+# Agent types: claude|gemini|copilot|cursor-agent|qwen|opencode|codex|windsurf|junie|kilocode|auggie|roo|codebuddy|amp|shai|tabnine|kiro-cli|agy|bob|vibe|qodercli|kimi|trae|pi|iflow|generic
+# Leave empty to update all existing agent files
+
+set -e
+
+# Enable strict error handling
+set -u
+set -o pipefail
+
+#==============================================================================
+# Configuration and Global Variables
+#==============================================================================
+
+# Get script directory and load common functions
+SCRIPT_DIR="$(CDPATH="" cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/common.sh"
+
+# Get all paths and variables from common functions
+_paths_output=$(get_feature_paths) || {
+	echo "ERROR: Failed to resolve feature paths" >&2
+	exit 1
+}
+eval "$_paths_output"
+unset _paths_output
+
+NEW_PLAN="$IMPL_PLAN" # Alias for compatibility with existing code
+AGENT_TYPE="${1-}"
+
+# Agent-specific file paths
+CLAUDE_FILE="$REPO_ROOT/CLAUDE.md"
+GEMINI_FILE="$REPO_ROOT/GEMINI.md"
+COPILOT_FILE="$REPO_ROOT/.github/agents/copilot-instructions.md"
+CURSOR_FILE="$REPO_ROOT/.cursor/rules/specify-rules.mdc"
+QWEN_FILE="$REPO_ROOT/QWEN.md"
+AGENTS_FILE="$REPO_ROOT/AGENTS.md"
+WINDSURF_FILE="$REPO_ROOT/.windsurf/rules/specify-rules.md"
+JUNIE_FILE="$REPO_ROOT/.junie/AGENTS.md"
+KILOCODE_FILE="$REPO_ROOT/.kilocode/rules/specify-rules.md"
+AUGGIE_FILE="$REPO_ROOT/.augment/rules/specify-rules.md"
+ROO_FILE="$REPO_ROOT/.roo/rules/specify-rules.md"
+CODEBUDDY_FILE="$REPO_ROOT/CODEBUDDY.md"
+QODER_FILE="$REPO_ROOT/QODER.md"
+# Amp, Kiro CLI, IBM Bob, and Pi all share AGENTS.md — use AGENTS_FILE to avoid
+# updating the same file multiple times.
+AMP_FILE="$AGENTS_FILE"
+SHAI_FILE="$REPO_ROOT/SHAI.md"
+TABNINE_FILE="$REPO_ROOT/TABNINE.md"
+KIRO_FILE="$AGENTS_FILE"
+AGY_FILE="$REPO_ROOT/.agent/rules/specify-rules.md"
+BOB_FILE="$AGENTS_FILE"
+VIBE_FILE="$REPO_ROOT/.vibe/agents/specify-agents.md"
+KIMI_FILE="$REPO_ROOT/KIMI.md"
+TRAE_FILE="$REPO_ROOT/.trae/rules/AGENTS.md"
+IFLOW_FILE="$REPO_ROOT/IFLOW.md"
+
+# Template file
+TEMPLATE_FILE="$REPO_ROOT/.specify/templates/agent-file-template.md"
+
+# Global variables for parsed plan data
+NEW_LANG=""
+NEW_FRAMEWORK=""
+NEW_DB=""
+NEW_PROJECT_TYPE=""
+
+#==============================================================================
+# Utility Functions
+#==============================================================================
+
+log_info() {
+	echo "INFO: $1"
+}
+
+log_success() {
+	echo "✓ $1"
+}
+
+log_error() {
+	echo "ERROR: $1" >&2
+}
+
+log_warning() {
+	echo "WARNING: $1" >&2
+}
+
+# Cleanup function for temporary files
+cleanup() {
+	local exit_code=$?
+	# Disarm traps to prevent re-entrant loop
+	trap - EXIT INT TERM
+	rm -f /tmp/agent_update_*_$$
+	rm -f /tmp/manual_additions_$$
+	exit $exit_code
+}
+
+# Set up cleanup trap
+trap cleanup EXIT INT TERM
+
+#==============================================================================
+# Validation Functions
+#==============================================================================
+
+validate_environment() {
+	# Check if we have a current branch/feature (git or non-git)
+	if [[ -z $CURRENT_BRANCH ]]; then
+		log_error "Unable to determine current feature"
+		if [[ $HAS_GIT == "true" ]]; then
+			log_info "Make sure you're on a feature branch"
+		else
+			log_info "Set SPECIFY_FEATURE environment variable or create a feature first"
+		fi
+		exit 1
+	fi
+
+	# Check if plan.md exists
+	if [[ ! -f $NEW_PLAN ]]; then
+		log_error "No plan.md found at $NEW_PLAN"
+		log_info "Make sure you're working on a feature with a corresponding spec directory"
+		if [[ $HAS_GIT != "true" ]]; then
+			log_info "Use: export SPECIFY_FEATURE=your-feature-name or create a new feature first"
+		fi
+		exit 1
+	fi
+
+	# Check if template exists (needed for new files)
+	if [[ ! -f $TEMPLATE_FILE ]]; then
+		log_warning "Template file not found at $TEMPLATE_FILE"
+		log_warning "Creating new agent files will fail"
+	fi
+}
+
+#==============================================================================
+# Plan Parsing Functions
+#==============================================================================
+
+extract_plan_field() {
+	local field_pattern="$1"
+	local plan_file="$2"
+
+	grep "^\*\*${field_pattern}\*\*: " "$plan_file" 2>/dev/null |
+		head -1 |
+		sed "s|^\*\*${field_pattern}\*\*: ||" |
+		sed 's/^[ \t]*//;s/[ \t]*$//' |
+		grep -v "NEEDS CLARIFICATION" |
+		grep -v "^N/A$" || echo ""
+}
+
+parse_plan_data() {
+	local plan_file="$1"
+
+	if [[ ! -f $plan_file ]]; then
+		log_error "Plan file not found: $plan_file"
+		return 1
+	fi
+
+	if [[ ! -r $plan_file ]]; then
+		log_error "Plan file is not readable: $plan_file"
+		return 1
+	fi
+
+	log_info "Parsing plan data from $plan_file"
+
+	NEW_LANG=$(extract_plan_field "Language/Version" "$plan_file")
+	NEW_FRAMEWORK=$(extract_plan_field "Primary Dependencies" "$plan_file")
+	NEW_DB=$(extract_plan_field "Storage" "$plan_file")
+	NEW_PROJECT_TYPE=$(extract_plan_field "Project Type" "$plan_file")
+
+	# Log what we found
+	if [[ -n $NEW_LANG ]]; then
+		log_info "Found language: $NEW_LANG"
+	else
+		log_warning "No language information found in plan"
+	fi
+
+	if [[ -n $NEW_FRAMEWORK ]]; then
+		log_info "Found framework: $NEW_FRAMEWORK"
+	fi
+
+	if [[ -n $NEW_DB ]] && [[ $NEW_DB != "N/A" ]]; then
+		log_info "Found database: $NEW_DB"
+	fi
+
+	if [[ -n $NEW_PROJECT_TYPE ]]; then
+		log_info "Found project type: $NEW_PROJECT_TYPE"
+	fi
+}
+
+format_technology_stack() {
+	local lang="$1"
+	local framework="$2"
+	local parts=()
+
+	# Add non-empty parts
+	[[ -n $lang && $lang != "NEEDS CLARIFICATION" ]] && parts+=("$lang")
+	[[ -n $framework && $framework != "NEEDS CLARIFICATION" && $framework != "N/A" ]] && parts+=("$framework")
+
+	# Join with proper formatting
+	if [[ ${#parts[@]} -eq 0 ]]; then
+		echo ""
+	elif [[ ${#parts[@]} -eq 1 ]]; then
+		echo "${parts[0]}"
+	else
+		# Join multiple parts with " + "
+		local result="${parts[0]}"
+		for ((i = 1; i < ${#parts[@]}; i++)); do
+			result="$result + ${parts[i]}"
+		done
+		echo "$result"
+	fi
+}
+
+#==============================================================================
+# Template and Content Generation Functions
+#==============================================================================
+
+get_project_structure() {
+	local project_type="$1"
+
+	if [[ $project_type == *"web"* ]]; then
+		echo 'backend/\nfrontend/\ntests/'
+	else
+		echo 'src/\ntests/'
+	fi
+}
+
+get_commands_for_language() {
+	local lang="$1"
+
+	case "$lang" in
+	*"Python"*)
+		echo "cd src && pytest && ruff check ."
+		;;
+	*"Rust"*)
+		echo "cargo test && cargo clippy"
+		;;
+	*"JavaScript"* | *"TypeScript"*)
+		echo 'npm test \&\& npm run lint'
+		;;
+	*)
+		echo "# Add commands for $lang"
+		;;
+	esac
+}
+
+get_language_conventions() {
+	local lang="$1"
+	echo "$lang: Follow standard conventions"
+}
+
+create_new_agent_file() {
+	local target_file="$1"
+	local temp_file="$2"
+	local project_name="$3"
+	local current_date="$4"
+
+	if [[ ! -f $TEMPLATE_FILE ]]; then
+		log_error "Template not found at $TEMPLATE_FILE"
+		return 1
+	fi
+
+	if [[ ! -r $TEMPLATE_FILE ]]; then
+		log_error "Template file is not readable: $TEMPLATE_FILE"
+		return 1
+	fi
+
+	log_info "Creating new agent context file from template..."
+
+	if ! cp "$TEMPLATE_FILE" "$temp_file"; then
+		log_error "Failed to copy template file"
+		return 1
+	fi
+
+	# Replace template placeholders
+	local project_structure
+	project_structure=$(get_project_structure "$NEW_PROJECT_TYPE")
+
+	local commands
+	commands=$(get_commands_for_language "$NEW_LANG")
+
+	local language_conventions
+	language_conventions=$(get_language_conventions "$NEW_LANG")
+
+	# Perform substitutions with error checking using safer approach
+	# Escape special characters for sed by using a different delimiter or escaping
+	local escaped_lang=$(printf '%s\n' "$NEW_LANG" | sed 's/[\[\.*^$()+{}|]/\\&/g')
+	local escaped_framework=$(printf '%s\n' "$NEW_FRAMEWORK" | sed 's/[\[\.*^$()+{}|]/\\&/g')
+	local escaped_branch=$(printf '%s\n' "$CURRENT_BRANCH" | sed 's/[\[\.*^$()+{}|]/\\&/g')
+
+	# Build technology stack and recent change strings conditionally
+	local tech_stack
+	if [[ -n $escaped_lang && -n $escaped_framework ]]; then
+		tech_stack="- $escaped_lang + $escaped_framework ($escaped_branch)"
+	elif [[ -n $escaped_lang ]]; then
+		tech_stack="- $escaped_lang ($escaped_branch)"
+	elif [[ -n $escaped_framework ]]; then
+		tech_stack="- $escaped_framework ($escaped_branch)"
+	else
+		tech_stack="- ($escaped_branch)"
+	fi
+
+	local recent_change
+	if [[ -n $escaped_lang && -n $escaped_framework ]]; then
+		recent_change="- $escaped_branch: Added $escaped_lang + $escaped_framework"
+	elif [[ -n $escaped_lang ]]; then
+		recent_change="- $escaped_branch: Added $escaped_lang"
+	elif [[ -n $escaped_framework ]]; then
+		recent_change="- $escaped_branch: Added $escaped_framework"
+	else
+		recent_change="- $escaped_branch: Added"
+	fi
+
+	local substitutions=(
+		"s|\[PROJECT NAME\]|$project_name|"
+		"s|\[DATE\]|$current_date|"
+		"s|\[EXTRACTED FROM ALL PLAN.MD FILES\]|$tech_stack|"
+		"s|\[ACTUAL STRUCTURE FROM PLANS\]|$project_structure|g"
+		"s|\[ONLY COMMANDS FOR ACTIVE TECHNOLOGIES\]|$commands|"
+		"s|\[LANGUAGE-SPECIFIC, ONLY FOR LANGUAGES IN USE\]|$language_conventions|"
+		"s|\[LAST 3 FEATURES AND WHAT THEY ADDED\]|$recent_change|"
+	)
+
+	for substitution in "${substitutions[@]}"; do
+		if ! sed -i.bak -e "$substitution" "$temp_file"; then
+			log_error "Failed to perform substitution: $substitution"
+			rm -f "$temp_file" "$temp_file.bak"
+			return 1
+		fi
+	done
+
+	# Convert \n sequences to actual newlines
+	newline=$(printf '\n')
+	sed -i.bak2 "s/\\\\n/${newline}/g" "$temp_file"
+
+	# Clean up backup files
+	rm -f "$temp_file.bak" "$temp_file.bak2"
+
+	# Prepend Cursor frontmatter for .mdc files so rules are auto-included
+	if [[ $target_file == *.mdc ]]; then
+		local frontmatter_file
+		frontmatter_file=$(mktemp) || return 1
+		printf '%s\n' "---" "description: Project Development Guidelines" 'globs: ["**/*"]' "alwaysApply: true" "---" "" >"$frontmatter_file"
+		cat "$temp_file" >>"$frontmatter_file"
+		mv "$frontmatter_file" "$temp_file"
+	fi
+
+	return 0
+}
+
+update_existing_agent_file() {
+	local target_file="$1"
+	local current_date="$2"
+
+	log_info "Updating existing agent context file..."
+
+	# Use a single temporary file for atomic update
+	local temp_file
+	temp_file=$(mktemp) || {
+		log_error "Failed to create temporary file"
+		return 1
+	}
+
+	# Process the file in one pass
+	local tech_stack=$(format_technology_stack "$NEW_LANG" "$NEW_FRAMEWORK")
+	local new_tech_entries=()
+	local new_change_entry=""
+
+	# Prepare new technology entries
+	if [[ -n $tech_stack ]] && ! grep -q "$tech_stack" "$target_file"; then
+		new_tech_entries+=("- $tech_stack ($CURRENT_BRANCH)")
+	fi
+
+	if [[ -n $NEW_DB ]] && [[ $NEW_DB != "N/A" ]] && [[ $NEW_DB != "NEEDS CLARIFICATION" ]] && ! grep -q "$NEW_DB" "$target_file"; then
+		new_tech_entries+=("- $NEW_DB ($CURRENT_BRANCH)")
+	fi
+
+	# Prepare new change entry
+	if [[ -n $tech_stack ]]; then
+		new_change_entry="- $CURRENT_BRANCH: Added $tech_stack"
+	elif [[ -n $NEW_DB ]] && [[ $NEW_DB != "N/A" ]] && [[ $NEW_DB != "NEEDS CLARIFICATION" ]]; then
+		new_change_entry="- $CURRENT_BRANCH: Added $NEW_DB"
+	fi
+
+	# Check if sections exist in the file
+	local has_active_technologies=0
+	local has_recent_changes=0
+
+	if grep -q "^## Active Technologies" "$target_file" 2>/dev/null; then
+		has_active_technologies=1
+	fi
+
+	if grep -q "^## Recent Changes" "$target_file" 2>/dev/null; then
+		has_recent_changes=1
+	fi
+
+	# Process file line by line
+	local in_tech_section=false
+	local in_changes_section=false
+	local tech_entries_added=false
+	local changes_entries_added=false
+	local existing_changes_count=0
+	local file_ended=false
+
+	while IFS= read -r line || [[ -n $line ]]; do
+		# Handle Active Technologies section
+		if [[ $line == "## Active Technologies" ]]; then
+			echo "$line" >>"$temp_file"
+			in_tech_section=true
+			continue
+		elif [[ $in_tech_section == true ]] && [[ $line =~ ^##[[:space:]] ]]; then
+			# Add new tech entries before closing the section
+			if [[ $tech_entries_added == false ]] && [[ ${#new_tech_entries[@]} -gt 0 ]]; then
+				printf '%s\n' "${new_tech_entries[@]}" >>"$temp_file"
+				tech_entries_added=true
+			fi
+			echo "$line" >>"$temp_file"
+			in_tech_section=false
+			continue
+		elif [[ $in_tech_section == true ]] && [[ -z $line ]]; then
+			# Add new tech entries before empty line in tech section
+			if [[ $tech_entries_added == false ]] && [[ ${#new_tech_entries[@]} -gt 0 ]]; then
+				printf '%s\n' "${new_tech_entries[@]}" >>"$temp_file"
+				tech_entries_added=true
+			fi
+			echo "$line" >>"$temp_file"
+			continue
+		fi
+
+		# Handle Recent Changes section
+		if [[ $line == "## Recent Changes" ]]; then
+			echo "$line" >>"$temp_file"
+			# Add new change entry right after the heading
+			if [[ -n $new_change_entry ]]; then
+				echo "$new_change_entry" >>"$temp_file"
+			fi
+			in_changes_section=true
+			changes_entries_added=true
+			continue
+		elif [[ $in_changes_section == true ]] && [[ $line =~ ^##[[:space:]] ]]; then
+			echo "$line" >>"$temp_file"
+			in_changes_section=false
+			continue
+		elif [[ $in_changes_section == true ]] && [[ $line == "- "* ]]; then
+			# Keep only first 2 existing changes
+			if [[ $existing_changes_count -lt 2 ]]; then
+				echo "$line" >>"$temp_file"
+				((existing_changes_count++))
+			fi
+			continue
+		fi
+
+		# Update timestamp
+		if [[ $line =~ (\*\*)?Last\ updated(\*\*)?:.*[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] ]]; then
+			echo "$line" | sed "s/[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]/$current_date/" >>"$temp_file"
+		else
+			echo "$line" >>"$temp_file"
+		fi
+	done <"$target_file"
+
+	# Post-loop check: if we're still in the Active Technologies section and haven't added new entries
+	if [[ $in_tech_section == true ]] && [[ $tech_entries_added == false ]] && [[ ${#new_tech_entries[@]} -gt 0 ]]; then
+		printf '%s\n' "${new_tech_entries[@]}" >>"$temp_file"
+		tech_entries_added=true
+	fi
+
+	# If sections don't exist, add them at the end of the file
+	if [[ $has_active_technologies -eq 0 ]] && [[ ${#new_tech_entries[@]} -gt 0 ]]; then
+		echo "" >>"$temp_file"
+		echo "## Active Technologies" >>"$temp_file"
+		printf '%s\n' "${new_tech_entries[@]}" >>"$temp_file"
+		tech_entries_added=true
+	fi
+
+	if [[ $has_recent_changes -eq 0 ]] && [[ -n $new_change_entry ]]; then
+		echo "" >>"$temp_file"
+		echo "## Recent Changes" >>"$temp_file"
+		echo "$new_change_entry" >>"$temp_file"
+		changes_entries_added=true
+	fi
+
+	# Ensure Cursor .mdc files have YAML frontmatter for auto-inclusion
+	if [[ $target_file == *.mdc ]]; then
+		if ! head -1 "$temp_file" | grep -q '^---'; then
+			local frontmatter_file
+			frontmatter_file=$(mktemp) || {
+				rm -f "$temp_file"
+				return 1
+			}
+			printf '%s\n' "---" "description: Project Development Guidelines" 'globs: ["**/*"]' "alwaysApply: true" "---" "" >"$frontmatter_file"
+			cat "$temp_file" >>"$frontmatter_file"
+			mv "$frontmatter_file" "$temp_file"
+		fi
+	fi
+
+	# Move temp file to target atomically
+	if ! mv "$temp_file" "$target_file"; then
+		log_error "Failed to update target file"
+		rm -f "$temp_file"
+		return 1
+	fi
+
+	return 0
+}
+#==============================================================================
+# Main Agent File Update Function
+#==============================================================================
+
+update_agent_file() {
+	local target_file="$1"
+	local agent_name="$2"
+
+	if [[ -z $target_file ]] || [[ -z $agent_name ]]; then
+		log_error "update_agent_file requires target_file and agent_name parameters"
+		return 1
+	fi
+
+	log_info "Updating $agent_name context file: $target_file"
+
+	local project_name
+	project_name=$(basename "$REPO_ROOT")
+	local current_date
+	current_date=$(date +%Y-%m-%d)
+
+	# Create directory if it doesn't exist
+	local target_dir
+	target_dir=$(dirname "$target_file")
+	if [[ ! -d $target_dir ]]; then
+		if ! mkdir -p "$target_dir"; then
+			log_error "Failed to create directory: $target_dir"
+			return 1
+		fi
+	fi
+
+	if [[ ! -f $target_file ]]; then
+		# Create new file from template
+		local temp_file
+		temp_file=$(mktemp) || {
+			log_error "Failed to create temporary file"
+			return 1
+		}
+
+		if create_new_agent_file "$target_file" "$temp_file" "$project_name" "$current_date"; then
+			if mv "$temp_file" "$target_file"; then
+				log_success "Created new $agent_name context file"
+			else
+				log_error "Failed to move temporary file to $target_file"
+				rm -f "$temp_file"
+				return 1
+			fi
+		else
+			log_error "Failed to create new agent file"
+			rm -f "$temp_file"
+			return 1
+		fi
+	else
+		# Update existing file
+		if [[ ! -r $target_file ]]; then
+			log_error "Cannot read existing file: $target_file"
+			return 1
+		fi
+
+		if [[ ! -w $target_file ]]; then
+			log_error "Cannot write to existing file: $target_file"
+			return 1
+		fi
+
+		if update_existing_agent_file "$target_file" "$current_date"; then
+			log_success "Updated existing $agent_name context file"
+		else
+			log_error "Failed to update existing agent file"
+			return 1
+		fi
+	fi
+
+	return 0
+}
+
+#==============================================================================
+# Agent Selection and Processing
+#==============================================================================
+
+update_specific_agent() {
+	local agent_type="$1"
+
+	case "$agent_type" in
+	claude)
+		update_agent_file "$CLAUDE_FILE" "Claude Code" || return 1
+		;;
+	gemini)
+		update_agent_file "$GEMINI_FILE" "Gemini CLI" || return 1
+		;;
+	copilot)
+		update_agent_file "$COPILOT_FILE" "GitHub Copilot" || return 1
+		;;
+	cursor-agent)
+		update_agent_file "$CURSOR_FILE" "Cursor IDE" || return 1
+		;;
+	qwen)
+		update_agent_file "$QWEN_FILE" "Qwen Code" || return 1
+		;;
+	opencode)
+		update_agent_file "$AGENTS_FILE" "opencode" || return 1
+		;;
+	codex)
+		update_agent_file "$AGENTS_FILE" "Codex CLI" || return 1
+		;;
+	windsurf)
+		update_agent_file "$WINDSURF_FILE" "Windsurf" || return 1
+		;;
+	junie)
+		update_agent_file "$JUNIE_FILE" "Junie" || return 1
+		;;
+	kilocode)
+		update_agent_file "$KILOCODE_FILE" "Kilo Code" || return 1
+		;;
+	auggie)
+		update_agent_file "$AUGGIE_FILE" "Auggie CLI" || return 1
+		;;
+	roo)
+		update_agent_file "$ROO_FILE" "Roo Code" || return 1
+		;;
+	codebuddy)
+		update_agent_file "$CODEBUDDY_FILE" "CodeBuddy CLI" || return 1
+		;;
+	qodercli)
+		update_agent_file "$QODER_FILE" "Qoder CLI" || return 1
+		;;
+	amp)
+		update_agent_file "$AMP_FILE" "Amp" || return 1
+		;;
+	shai)
+		update_agent_file "$SHAI_FILE" "SHAI" || return 1
+		;;
+	tabnine)
+		update_agent_file "$TABNINE_FILE" "Tabnine CLI" || return 1
+		;;
+	kiro-cli)
+		update_agent_file "$KIRO_FILE" "Kiro CLI" || return 1
+		;;
+	agy)
+		update_agent_file "$AGY_FILE" "Antigravity" || return 1
+		;;
+	bob)
+		update_agent_file "$BOB_FILE" "IBM Bob" || return 1
+		;;
+	vibe)
+		update_agent_file "$VIBE_FILE" "Mistral Vibe" || return 1
+		;;
+	kimi)
+		update_agent_file "$KIMI_FILE" "Kimi Code" || return 1
+		;;
+	trae)
+		update_agent_file "$TRAE_FILE" "Trae" || return 1
+		;;
+	pi)
+		update_agent_file "$AGENTS_FILE" "Pi Coding Agent" || return 1
+		;;
+	iflow)
+		update_agent_file "$IFLOW_FILE" "iFlow CLI" || return 1
+		;;
+	generic)
+		log_info "Generic agent: no predefined context file. Use the agent-specific update script for your agent."
+		;;
+	*)
+		log_error "Unknown agent type '$agent_type'"
+		log_error "Expected: claude|gemini|copilot|cursor-agent|qwen|opencode|codex|windsurf|junie|kilocode|auggie|roo|codebuddy|amp|shai|tabnine|kiro-cli|agy|bob|vibe|qodercli|kimi|trae|pi|iflow|generic"
+		exit 1
+		;;
+	esac
+}
+
+# Helper: skip non-existent files and files already updated (dedup by
+# realpath so that variables pointing to the same file — e.g. AMP_FILE,
+# KIRO_FILE, BOB_FILE all resolving to AGENTS_FILE — are only written once).
+# Uses a linear array instead of associative array for bash 3.2 compatibility.
+# Note: defined at top level because bash 3.2 does not support true
+# nested/local functions. _updated_paths, _found_agent, and _all_ok are
+# initialised exclusively inside update_all_existing_agents so that
+# sourcing this script has no side effects on the caller's environment.
+
+_update_if_new() {
+	local file="$1" name="$2"
+	[[ -f $file ]] || return 0
+	local real_path
+	real_path=$(realpath "$file" 2>/dev/null || echo "$file")
+	local p
+	if [[ ${#_updated_paths[@]} -gt 0 ]]; then
+		for p in "${_updated_paths[@]}"; do
+			[[ $p == "$real_path" ]] && return 0
+		done
+	fi
+	# Record the file as seen before attempting the update so that:
+	# (a) aliases pointing to the same path are not retried on failure
+	# (b) _found_agent reflects file existence, not update success
+	_updated_paths+=("$real_path")
+	_found_agent=true
+	update_agent_file "$file" "$name"
+}
+
+update_all_existing_agents() {
+	_found_agent=false
+	_updated_paths=()
+	local _all_ok=true
+
+	_update_if_new "$CLAUDE_FILE" "Claude Code" || _all_ok=false
+	_update_if_new "$GEMINI_FILE" "Gemini CLI" || _all_ok=false
+	_update_if_new "$COPILOT_FILE" "GitHub Copilot" || _all_ok=false
+	_update_if_new "$CURSOR_FILE" "Cursor IDE" || _all_ok=false
+	_update_if_new "$QWEN_FILE" "Qwen Code" || _all_ok=false
+	_update_if_new "$AGENTS_FILE" "Codex/opencode" || _all_ok=false
+	_update_if_new "$AMP_FILE" "Amp" || _all_ok=false
+	_update_if_new "$KIRO_FILE" "Kiro CLI" || _all_ok=false
+	_update_if_new "$BOB_FILE" "IBM Bob" || _all_ok=false
+	_update_if_new "$WINDSURF_FILE" "Windsurf" || _all_ok=false
+	_update_if_new "$JUNIE_FILE" "Junie" || _all_ok=false
+	_update_if_new "$KILOCODE_FILE" "Kilo Code" || _all_ok=false
+	_update_if_new "$AUGGIE_FILE" "Auggie CLI" || _all_ok=false
+	_update_if_new "$ROO_FILE" "Roo Code" || _all_ok=false
+	_update_if_new "$CODEBUDDY_FILE" "CodeBuddy CLI" || _all_ok=false
+	_update_if_new "$SHAI_FILE" "SHAI" || _all_ok=false
+	_update_if_new "$TABNINE_FILE" "Tabnine CLI" || _all_ok=false
+	_update_if_new "$QODER_FILE" "Qoder CLI" || _all_ok=false
+	_update_if_new "$AGY_FILE" "Antigravity" || _all_ok=false
+	_update_if_new "$VIBE_FILE" "Mistral Vibe" || _all_ok=false
+	_update_if_new "$KIMI_FILE" "Kimi Code" || _all_ok=false
+	_update_if_new "$TRAE_FILE" "Trae" || _all_ok=false
+	_update_if_new "$IFLOW_FILE" "iFlow CLI" || _all_ok=false
+
+	# If no agent files exist, create a default Claude file
+	if [[ $_found_agent == false ]]; then
+		log_info "No existing agent files found, creating default Claude file..."
+		update_agent_file "$CLAUDE_FILE" "Claude Code" || return 1
+	fi
+
+	[[ $_all_ok == true ]]
+}
+print_summary() {
+	echo
+	log_info "Summary of changes:"
+
+	if [[ -n $NEW_LANG ]]; then
+		echo "  - Added language: $NEW_LANG"
+	fi
+
+	if [[ -n $NEW_FRAMEWORK ]]; then
+		echo "  - Added framework: $NEW_FRAMEWORK"
+	fi
+
+	if [[ -n $NEW_DB ]] && [[ $NEW_DB != "N/A" ]]; then
+		echo "  - Added database: $NEW_DB"
+	fi
+
+	echo
+	log_info "Usage: $0 [claude|gemini|copilot|cursor-agent|qwen|opencode|codex|windsurf|junie|kilocode|auggie|roo|codebuddy|amp|shai|tabnine|kiro-cli|agy|bob|vibe|qodercli|kimi|trae|pi|iflow|generic]"
+}
+
+#==============================================================================
+# Main Execution
+#==============================================================================
+
+main() {
+	# Validate environment before proceeding
+	validate_environment
+
+	log_info "=== Updating agent context files for feature $CURRENT_BRANCH ==="
+
+	# Parse the plan file to extract project information
+	if ! parse_plan_data "$NEW_PLAN"; then
+		log_error "Failed to parse plan data"
+		exit 1
+	fi
+
+	# Process based on agent type argument
+	local success=true
+
+	if [[ -z $AGENT_TYPE ]]; then
+		# No specific agent provided - update all existing agent files
+		log_info "No agent specified, updating all existing agent files..."
+		if ! update_all_existing_agents; then
+			success=false
+		fi
+	else
+		# Specific agent provided - update only that agent
+		log_info "Updating specific agent: $AGENT_TYPE"
+		if ! update_specific_agent "$AGENT_TYPE"; then
+			success=false
+		fi
+	fi
+
+	# Print summary
+	print_summary
+
+	if [[ $success == true ]]; then
+		log_success "Agent context update completed successfully"
+		exit 0
+	else
+		log_error "Agent context update completed with errors"
+		exit 1
+	fi
+}
+
+# Execute main function if script is run directly
+if [[ ${BASH_SOURCE[0]} == "${0}" ]]; then
+	main "$@"
+fi
@@ -0,0 +1,28 @@
+# [PROJECT NAME] Development Guidelines
+
+Auto-generated from all feature plans. Last updated: [DATE]
+
+## Active Technologies
+
+[EXTRACTED FROM ALL PLAN.MD FILES]
+
+## Project Structure
+
+```text
+[ACTUAL STRUCTURE FROM PLANS]
+```
+
+## Commands
+
+[ONLY COMMANDS FOR ACTIVE TECHNOLOGIES]
+
+## Code Style
+
+[LANGUAGE-SPECIFIC, ONLY FOR LANGUAGES IN USE]
+
+## Recent Changes
+
+[LAST 3 FEATURES AND WHAT THEY ADDED]
+
+<!-- MANUAL ADDITIONS START -->
+<!-- MANUAL ADDITIONS END -->
@@ -0,0 +1,40 @@
+# [CHECKLIST TYPE] Checklist: [FEATURE NAME]
+
+**Purpose**: [Brief description of what this checklist covers]
+**Created**: [DATE]
+**Feature**: [Link to spec.md or relevant documentation]
+
+**Note**: This checklist is generated by the `/speckit.checklist` command based on feature context and requirements.
+
+<!--
+  ============================================================================
+  IMPORTANT: The checklist items below are SAMPLE ITEMS for illustration only.
+
+  The /speckit.checklist command MUST replace these with actual items based on:
+  - User's specific checklist request
+  - Feature requirements from spec.md
+  - Technical context from plan.md
+  - Implementation details from tasks.md
+
+  DO NOT keep these sample items in the generated checklist file.
+  ============================================================================
+-->
+
+## [Category 1]
+
+- [ ] CHK001 First checklist item with clear action
+- [ ] CHK002 Second checklist item
+- [ ] CHK003 Third checklist item
+
+## [Category 2]
+
+- [ ] CHK004 Another category item
+- [ ] CHK005 Item with specific criteria
+- [ ] CHK006 Final item in this category
+
+## Notes
+
+- Check items off as completed: `[x]`
+- Add comments or findings inline
+- Link to relevant resources or documentation
+- Items are numbered sequentially for easy reference
@@ -0,0 +1,73 @@
+# [PROJECT_NAME] Constitution
+
+<!-- Example: Spec Constitution, TaskFlow Constitution, etc. -->
+
+## Core Principles
+
+### [PRINCIPLE_1_NAME]
+
+<!-- Example: I. Library-First -->
+
+[PRINCIPLE_1_DESCRIPTION]
+
+<!-- Example: Every feature starts as a standalone library; Libraries must be self-contained, independently testable, documented; Clear purpose required - no organizational-only libraries -->
+
+### [PRINCIPLE_2_NAME]
+
+<!-- Example: II. CLI Interface -->
+
+[PRINCIPLE_2_DESCRIPTION]
+
+<!-- Example: Every library exposes functionality via CLI; Text in/out protocol: stdin/args → stdout, errors → stderr; Support JSON + human-readable formats -->
+
+### [PRINCIPLE_3_NAME]
+
+<!-- Example: III. Test-First (NON-NEGOTIABLE) -->
+
+[PRINCIPLE_3_DESCRIPTION]
+
+<!-- Example: TDD mandatory: Tests written → User approved → Tests fail → Then implement; Red-Green-Refactor cycle strictly enforced -->
+
+### [PRINCIPLE_4_NAME]
+
+<!-- Example: IV. Integration Testing -->
+
+[PRINCIPLE_4_DESCRIPTION]
+
+<!-- Example: Focus areas requiring integration tests: New library contract tests, Contract changes, Inter-service communication, Shared schemas -->
+
+### [PRINCIPLE_5_NAME]
+
+<!-- Example: V. Observability, VI. Versioning & Breaking Changes, VII. Simplicity -->
+
+[PRINCIPLE_5_DESCRIPTION]
+
+<!-- Example: Text I/O ensures debuggability; Structured logging required; Or: MAJOR.MINOR.BUILD format; Or: Start simple, YAGNI principles -->
+
+## [SECTION_2_NAME]
+
+<!-- Example: Additional Constraints, Security Requirements, Performance Standards, etc. -->
+
+[SECTION_2_CONTENT]
+
+<!-- Example: Technology stack requirements, compliance standards, deployment policies, etc. -->
+
+## [SECTION_3_NAME]
+
+<!-- Example: Development Workflow, Review Process, Quality Gates, etc. -->
+
+[SECTION_3_CONTENT]
+
+<!-- Example: Code review requirements, testing gates, deployment approval process, etc. -->
+
+## Governance
+
+<!-- Example: Constitution supersedes all other practices; Amendments require documentation, approval, migration plan -->
+
+[GOVERNANCE_RULES]
+
+<!-- Example: All PRs/reviews must verify compliance; Complexity must be justified; Use [GUIDANCE_FILE] for runtime development guidance -->
+
+**Version**: [CONSTITUTION_VERSION] | **Ratified**: [RATIFICATION_DATE] | **Last Amended**: [LAST_AMENDED_DATE]
+
+<!-- Example: Version: 2.1.1 | Ratified: 2025-06-13 | Last Amended: 2025-07-16 -->
@@ -0,0 +1,109 @@
+# Implementation Plan: [FEATURE]
+
+**Branch**: `[###-feature-name]` | **Date**: [DATE] | **Spec**: [link]
+**Input**: Feature specification from `/specs/[###-feature-name]/spec.md`
+
+**Note**: This template is filled in by the `/speckit.plan` command. See `.specify/templates/plan-template.md` for the execution workflow.
+
+## Summary
+
+[Extract from feature spec: primary requirement + technical approach from research]
+
+## Technical Context
+
+<!--
+  ACTION REQUIRED: Replace the content in this section with the technical details
+  for the project. The structure here is presented in advisory capacity to guide
+  the iteration process.
+-->
+
+**Language/Version**: [e.g., Python 3.11, Swift 5.9, Rust 1.75 or NEEDS CLARIFICATION]  
+**Primary Dependencies**: [e.g., FastAPI, UIKit, LLVM or NEEDS CLARIFICATION]  
+**Storage**: [if applicable, e.g., PostgreSQL, CoreData, files or N/A]  
+**Testing**: [e.g., pytest, XCTest, cargo test or NEEDS CLARIFICATION]  
+**Target Platform**: [e.g., Linux server, iOS 15+, WASM or NEEDS CLARIFICATION]
+**Project Type**: [e.g., library/cli/web-service/mobile-app/compiler/desktop-app or NEEDS CLARIFICATION]  
+**Performance Goals**: [domain-specific, e.g., 1000 req/s, 10k lines/sec, 60 fps or NEEDS CLARIFICATION]  
+**Constraints**: [domain-specific, e.g., <200ms p95, <100MB memory, offline-capable or NEEDS CLARIFICATION]  
+**Scale/Scope**: [domain-specific, e.g., 10k users, 1M LOC, 50 screens or NEEDS CLARIFICATION]
+
+## Constitution Check
+
+_GATE: Must pass before Phase 0 research. Re-check after Phase 1 design._
+
+- Safety-critical mesh impact is identified for any routing, airtime, MQTT, channel, or packet-path change.
+- Variant and platform scope are explicit, and all hardware flags or pin mappings are verified against the target board.
+- Validation evidence is defined, including the exact `pio`, native test, simulator, formatting, or static checks to run.
+- Resource, power, memory, and dependency impact are assessed for the affected targets.
+- Any constitutional violation or validation gap is documented with justification in Complexity Tracking.
+
+## Project Structure
+
+### Documentation (this feature)
+
+```text
+specs/[###-feature]/
+├── plan.md              # This file (/speckit.plan command output)
+├── research.md          # Phase 0 output (/speckit.plan command)
+├── data-model.md        # Phase 1 output (/speckit.plan command)
+├── quickstart.md        # Phase 1 output (/speckit.plan command)
+├── contracts/           # Phase 1 output (/speckit.plan command)
+└── tasks.md             # Phase 2 output (/speckit.tasks command - NOT created by /speckit.plan)
+```
+
+### Source Code (repository root)
+
+<!--
+  ACTION REQUIRED: Replace the placeholder tree below with the concrete layout
+  for this feature. Delete unused options and expand the chosen structure with
+  real paths (e.g., apps/admin, packages/something). The delivered plan must
+  not include Option labels.
+-->
+
+```text
+# [REMOVE IF UNUSED] Option 1: Single project (DEFAULT)
+src/
+├── models/
+├── services/
+├── cli/
+└── lib/
+
+tests/
+├── contract/
+├── integration/
+└── unit/
+
+# [REMOVE IF UNUSED] Option 2: Web application (when "frontend" + "backend" detected)
+backend/
+├── src/
+│   ├── models/
+│   ├── services/
+│   └── api/
+└── tests/
+
+frontend/
+├── src/
+│   ├── components/
+│   ├── pages/
+│   └── services/
+└── tests/
+
+# [REMOVE IF UNUSED] Option 3: Mobile + API (when "iOS/Android" detected)
+api/
+└── [same as backend above]
+
+ios/ or android/
+└── [platform-specific structure: feature modules, UI flows, platform tests]
+```
+
+**Structure Decision**: [Document the selected structure and reference the real
+directories captured above]
+
+## Complexity Tracking
+
+> **Fill ONLY if Constitution Check has violations that must be justified**
+
+| Violation                  | Why Needed         | Simpler Alternative Rejected Because |
+| -------------------------- | ------------------ | ------------------------------------ |
+| [e.g., 4th project]        | [current need]     | [why 3 projects insufficient]        |
+| [e.g., Repository pattern] | [specific problem] | [why direct DB access insufficient]  |
@@ -0,0 +1,140 @@
+# Feature Specification: [FEATURE NAME]
+
+**Feature Branch**: `[###-feature-name]`  
+**Created**: [DATE]  
+**Status**: Draft  
+**Input**: User description: "$ARGUMENTS"
+
+## User Scenarios & Testing _(mandatory)_
+
+<!--
+  IMPORTANT: User stories should be PRIORITIZED as user journeys ordered by importance.
+  Each user story/journey must be INDEPENDENTLY TESTABLE - meaning if you implement just ONE of them,
+  you should still have a viable MVP (Minimum Viable Product) that delivers value.
+
+  Assign priorities (P1, P2, P3, etc.) to each story, where P1 is the most critical.
+  Think of each story as a standalone slice of functionality that can be:
+  - Developed independently
+  - Tested independently
+  - Deployed independently
+  - Demonstrated to users independently
+-->
+
+### User Story 1 - [Brief Title] (Priority: P1)
+
+[Describe this user journey in plain language]
+
+**Why this priority**: [Explain the value and why it has this priority level]
+
+**Independent Test**: [Describe how this can be tested independently - e.g., "Can be fully tested by [specific action] and delivers [specific value]"]
+
+**Acceptance Scenarios**:
+
+1. **Given** [initial state], **When** [action], **Then** [expected outcome]
+2. **Given** [initial state], **When** [action], **Then** [expected outcome]
+
+---
+
+### User Story 2 - [Brief Title] (Priority: P2)
+
+[Describe this user journey in plain language]
+
+**Why this priority**: [Explain the value and why it has this priority level]
+
+**Independent Test**: [Describe how this can be tested independently]
+
+**Acceptance Scenarios**:
+
+1. **Given** [initial state], **When** [action], **Then** [expected outcome]
+
+---
+
+### User Story 3 - [Brief Title] (Priority: P3)
+
+[Describe this user journey in plain language]
+
+**Why this priority**: [Explain the value and why it has this priority level]
+
+**Independent Test**: [Describe how this can be tested independently]
+
+**Acceptance Scenarios**:
+
+1. **Given** [initial state], **When** [action], **Then** [expected outcome]
+
+---
+
+[Add more user stories as needed, each with an assigned priority]
+
+For firmware and hardware-facing work, each story MUST identify affected platforms or variants
+and describe how the behavior is validated on its own.
+
+### Edge Cases
+
+<!--
+  ACTION REQUIRED: The content in this section represents placeholders.
+  Fill them out with the right edge cases.
+-->
+
+- What happens when [boundary condition]?
+- How does system handle [error scenario]?
+- What happens when the target hardware capability is absent, misdeclared, or only present on some variants?
+- How does the system behave when radio, power, timing, or memory constraints are tighter than expected?
+
+## Requirements _(mandatory)_
+
+<!--
+  ACTION REQUIRED: The content in this section represents placeholders.
+  Fill them out with the right functional requirements.
+-->
+
+### Functional Requirements
+
+- **FR-001**: System MUST [specific capability, e.g., "allow users to create accounts"]
+- **FR-002**: System MUST [specific capability, e.g., "validate email addresses"]
+- **FR-003**: Users MUST be able to [key interaction, e.g., "reset their password"]
+- **FR-004**: System MUST [data requirement, e.g., "persist user preferences"]
+- **FR-005**: System MUST [behavior, e.g., "log all security events"]
+
+_Example of marking unclear requirements:_
+
+- **FR-006**: System MUST authenticate users via [NEEDS CLARIFICATION: auth method not specified - email/password, SSO, OAuth?]
+- **FR-007**: System MUST retain user data for [NEEDS CLARIFICATION: retention period not specified]
+
+Where relevant, requirements MUST also state:
+
+- affected architectures, boards, or modules
+- whether behavior changes public defaults, protocol compatibility, or generated artifacts
+- any required validation evidence for high-risk mesh, hardware, or power behavior
+
+### Key Entities _(include if feature involves data)_
+
+- **[Entity 1]**: [What it represents, key attributes without implementation]
+- **[Entity 2]**: [What it represents, relationships to other entities]
+
+## Success Criteria _(mandatory)_
+
+<!--
+  ACTION REQUIRED: Define measurable success criteria.
+  These must be technology-agnostic and measurable.
+-->
+
+### Measurable Outcomes
+
+- **SC-001**: [Measurable metric, e.g., "Users can complete account creation in under 2 minutes"]
+- **SC-002**: [Measurable metric, e.g., "System handles 1000 concurrent users without degradation"]
+- **SC-003**: [User satisfaction metric, e.g., "90% of users successfully complete primary task on first attempt"]
+- **SC-004**: [Business metric, e.g., "Reduce support tickets related to [X] by 50%"]
+
+## Assumptions
+
+<!--
+  ACTION REQUIRED: The content in this section represents placeholders.
+  Fill them out with the right assumptions based on reasonable defaults
+  chosen when the feature description did not specify certain details.
+-->
+
+- [Assumption about target users, e.g., "Users have stable internet connectivity"]
+- [Assumption about scope boundaries, e.g., "Mobile support is out of scope for v1"]
+- [Assumption about data/environment, e.g., "Existing authentication system will be reused"]
+- [Dependency on existing system/service, e.g., "Requires access to the existing user profile API"]
+- [Assumption about available hardware capabilities, board revisions, or build targets]
@@ -0,0 +1,259 @@
+---
+description: "Task list template for feature implementation"
+---
+
+# Tasks: [FEATURE NAME]
+
+**Input**: Design documents from `/specs/[###-feature-name]/`
+**Prerequisites**: plan.md (required), spec.md (required for user stories), research.md, data-model.md, contracts/
+
+**Tests**: Validation tasks are REQUIRED whenever the constitution or feature risk profile demands evidence. Include targeted builds, native tests, simulator runs, protobuf regeneration checks, formatting, or other repository-standard validation appropriate to the change.
+
+**Organization**: Tasks are grouped by user story to enable independent implementation and testing of each story.
+
+## Format: `[ID] [P?] [Story] Description`
+
+- **[P]**: Can run in parallel (different files, no dependencies)
+- **[Story]**: Which user story this task belongs to (e.g., US1, US2, US3)
+- Include exact file paths in descriptions
+
+## Path Conventions
+
+- **Single project**: `src/`, `tests/` at repository root
+- **Web app**: `backend/src/`, `frontend/src/`
+- **Mobile**: `api/src/`, `ios/src/` or `android/src/`
+- Paths shown below assume single project - adjust based on plan.md structure
+
+<!--
+  ============================================================================
+  IMPORTANT: The tasks below are SAMPLE TASKS for illustration purposes only.
+
+  The /speckit.tasks command MUST replace these with actual tasks based on:
+  - User stories from spec.md (with their priorities P1, P2, P3...)
+  - Feature requirements from plan.md
+  - Entities from data-model.md
+  - Endpoints from contracts/
+
+  Tasks MUST be organized by user story so each story can be:
+  - Implemented independently
+  - Tested independently
+  - Delivered as an MVP increment
+
+  DO NOT keep these sample tasks in the generated tasks.md file.
+  ============================================================================
+-->
+
+## Phase 1: Setup (Shared Infrastructure)
+
+**Purpose**: Project initialization and basic structure
+
+- [ ] T001 Create project structure per implementation plan
+- [ ] T002 Initialize [language] project with [framework] dependencies
+- [ ] T003 [P] Configure linting and formatting tools
+- [ ] T00X Identify affected targets, variants, and validation commands
+
+---
+
+## Phase 2: Foundational (Blocking Prerequisites)
+
+**Purpose**: Core infrastructure that MUST be complete before ANY user story can be implemented
+
+**⚠️ CRITICAL**: No user story work can begin until this phase is complete
+
+Examples of foundational tasks (adjust based on your project):
+
+- [ ] T004 Setup database schema and migrations framework
+- [ ] T005 [P] Implement authentication/authorization framework
+- [ ] T006 [P] Setup API routing and middleware structure
+- [ ] T007 Create base models/entities that all stories depend on
+- [ ] T008 Configure error handling and logging infrastructure
+- [ ] T009 Setup environment configuration management
+- [ ] T00X Verify board-specific flags, pins, generated assets, or protocol prerequisites needed by all stories
+
+**Checkpoint**: Foundation ready - user story implementation can now begin in parallel
+
+---
+
+## Phase 3: User Story 1 - [Title] (Priority: P1) 🎯 MVP
+
+**Goal**: [Brief description of what this story delivers]
+
+**Independent Test**: [How to verify this story works on its own]
+
+### Validation for User Story 1 ⚠️
+
+> **NOTE: Add the smallest credible validation for the story's risk level before declaring it complete**
+
+- [ ] T010 [P] [US1] Contract test for [endpoint] in tests/contract/test\_[name].py
+- [ ] T011 [P] [US1] Integration test for [user journey] in tests/integration/test\_[name].py
+- [ ] T01X [P] [US1] Run targeted build or simulation for affected platform(s)
+
+### Implementation for User Story 1
+
+- [ ] T012 [P] [US1] Create [Entity1] model in src/models/[entity1].py
+- [ ] T013 [P] [US1] Create [Entity2] model in src/models/[entity2].py
+- [ ] T014 [US1] Implement [Service] in src/services/[service].py (depends on T012, T013)
+- [ ] T015 [US1] Implement [endpoint/feature] in src/[location]/[file].py
+- [ ] T016 [US1] Add validation and error handling
+- [ ] T017 [US1] Add logging for user story 1 operations
+- [ ] T01Y [US1] Confirm variant-scoped behavior and configuration defaults remain correct
+
+**Checkpoint**: At this point, User Story 1 should be fully functional and testable independently
+
+---
+
+## Phase 4: User Story 2 - [Title] (Priority: P2)
+
+**Goal**: [Brief description of what this story delivers]
+
+**Independent Test**: [How to verify this story works on its own]
+
+### Validation for User Story 2 ⚠️
+
+- [ ] T018 [P] [US2] Contract test for [endpoint] in tests/contract/test\_[name].py
+- [ ] T019 [P] [US2] Integration test for [user journey] in tests/integration/test\_[name].py
+- [ ] T02X [P] [US2] Run targeted build or simulation for affected platform(s)
+
+### Implementation for User Story 2
+
+- [ ] T020 [P] [US2] Create [Entity] model in src/models/[entity].py
+- [ ] T021 [US2] Implement [Service] in src/services/[service].py
+- [ ] T022 [US2] Implement [endpoint/feature] in src/[location]/[file].py
+- [ ] T023 [US2] Integrate with User Story 1 components (if needed)
+- [ ] T02Y [US2] Confirm resource, power, and compatibility impacts stay within plan constraints
+
+**Checkpoint**: At this point, User Stories 1 AND 2 should both work independently
+
+---
+
+## Phase 5: User Story 3 - [Title] (Priority: P3)
+
+**Goal**: [Brief description of what this story delivers]
+
+**Independent Test**: [How to verify this story works on its own]
+
+### Validation for User Story 3 ⚠️
+
+- [ ] T024 [P] [US3] Contract test for [endpoint] in tests/contract/test\_[name].py
+- [ ] T025 [P] [US3] Integration test for [user journey] in tests/integration/test\_[name].py
+- [ ] T03X [P] [US3] Run targeted build or simulation for affected platform(s)
+
+### Implementation for User Story 3
+
+- [ ] T026 [P] [US3] Create [Entity] model in src/models/[entity].py
+- [ ] T027 [US3] Implement [Service] in src/services/[service].py
+- [ ] T028 [US3] Implement [endpoint/feature] in src/[location]/[file].py
+- [ ] T03Y [US3] Confirm backward compatibility or explicitly document intentional behavior changes
+
+**Checkpoint**: All user stories should now be independently functional
+
+---
+
+[Add more user story phases as needed, following the same pattern]
+
+---
+
+## Phase N: Polish & Cross-Cutting Concerns
+
+**Purpose**: Improvements that affect multiple user stories
+
+- [ ] TXXX [P] Documentation updates in docs/
+- [ ] TXXX Code cleanup and refactoring
+- [ ] TXXX Performance optimization across all stories
+- [ ] TXXX [P] Additional unit tests (if requested) in tests/unit/
+- [ ] TXXX Security hardening
+- [ ] TXXX Run quickstart.md validation
+- [ ] TXXX Summarize skipped validations, migration notes, and generated-file updates for review
+
+---
+
+## Dependencies & Execution Order
+
+### Phase Dependencies
+
+- **Setup (Phase 1)**: No dependencies - can start immediately
+- **Foundational (Phase 2)**: Depends on Setup completion - BLOCKS all user stories
+- **User Stories (Phase 3+)**: All depend on Foundational phase completion
+  - User stories can then proceed in parallel (if staffed)
+  - Or sequentially in priority order (P1 → P2 → P3)
+- **Polish (Final Phase)**: Depends on all desired user stories being complete
+
+### User Story Dependencies
+
+- **User Story 1 (P1)**: Can start after Foundational (Phase 2) - No dependencies on other stories
+- **User Story 2 (P2)**: Can start after Foundational (Phase 2) - May integrate with US1 but should be independently testable
+- **User Story 3 (P3)**: Can start after Foundational (Phase 2) - May integrate with US1/US2 but should be independently testable
+
+### Within Each User Story
+
+- Tests (if included) MUST be written and FAIL before implementation
+- Models before services
+- Services before endpoints
+- Core implementation before integration
+- Story complete before moving to next priority
+
+### Parallel Opportunities
+
+- All Setup tasks marked [P] can run in parallel
+- All Foundational tasks marked [P] can run in parallel (within Phase 2)
+- Once Foundational phase completes, all user stories can start in parallel (if team capacity allows)
+- All tests for a user story marked [P] can run in parallel
+- Models within a story marked [P] can run in parallel
+- Different user stories can be worked on in parallel by different team members
+
+---
+
+## Parallel Example: User Story 1
+
+```bash
+# Launch all tests for User Story 1 together (if tests requested):
+Task: "Contract test for [endpoint] in tests/contract/test_[name].py"
+Task: "Integration test for [user journey] in tests/integration/test_[name].py"
+
+# Launch all models for User Story 1 together:
+Task: "Create [Entity1] model in src/models/[entity1].py"
+Task: "Create [Entity2] model in src/models/[entity2].py"
+```
+
+---
+
+## Implementation Strategy
+
+### MVP First (User Story 1 Only)
+
+1. Complete Phase 1: Setup
+2. Complete Phase 2: Foundational (CRITICAL - blocks all stories)
+3. Complete Phase 3: User Story 1
+4. **STOP and VALIDATE**: Test User Story 1 independently
+5. Deploy/demo if ready
+
+### Incremental Delivery
+
+1. Complete Setup + Foundational → Foundation ready
+2. Add User Story 1 → Test independently → Deploy/Demo (MVP!)
+3. Add User Story 2 → Test independently → Deploy/Demo
+4. Add User Story 3 → Test independently → Deploy/Demo
+5. Each story adds value without breaking previous stories
+
+### Parallel Team Strategy
+
+With multiple developers:
+
+1. Team completes Setup + Foundational together
+2. Once Foundational is done:
+   - Developer A: User Story 1
+   - Developer B: User Story 2
+   - Developer C: User Story 3
+3. Stories complete and integrate independently
+
+---
+
+## Notes
+
+- [P] tasks = different files, no dependencies
+- [Story] label maps task to specific user story for traceability
+- Each user story should be independently completable and testable
+- Verify tests fail before implementing
+- Commit after each task or logical group
+- Stop at any checkpoint to validate story independently
+- Avoid: vague tasks, same file conflicts, cross-story dependencies that break independence
@@ -1,2 +1,28 @@
 [bandit]
-skips = B101
+# Rule IDs: https://bandit.readthedocs.io/en/latest/plugins/index.html
+#
+# B101 assert_used
+#   pytest assertions + internal invariants; required for pytest.
+# B110 try_except_pass
+#   best-effort cleanup paths (atexit handlers, pubsub unsubscribe,
+#   session-end file close, socket shutdown). Logging inside the
+#   except block would be worse than the silent pass — teardown is
+#   already at end-of-session and the surrounding caller has context.
+# B112 try_except_continue
+#   defensive loops over flaky sources (pubsub handlers, device
+#   re-enumeration polls). One failed iteration shouldn't abort the loop.
+# B404 import_subprocess
+#   mcp-server wraps PlatformIO, esptool, nrfutil, picotool, and the
+#   pytest test-runner — subprocess is a load-bearing import here, not
+#   a smell. The "consider possible security implications" advisory is
+#   redundant given the file-level review already applied.
+# B603 subprocess_without_shell_equals_true
+#   all subprocess calls use a static argv list; `shell=False` is the
+#   default and we never string-interpolate user input into the command.
+# B606 start_process_with_no_shell
+#   same invariant as B603 — running a binary via argv list (not
+#   `shell=True`) is the safe pattern bandit is asking for.
+#
+# Higher-severity checks (B102 exec_used, B301 pickle, B307 eval,
+# B602 shell=True, etc.) remain enabled.
+skips = B101,B110,B112,B404,B603,B606
@@ -4,31 +4,31 @@ cli:
 plugins:
  sources:
    - id: trunk
-      ref: v1.7.4
+      ref: v1.8.0
      uri: https://github.com/trunk-io/plugins
 lint:
  enabled:
-    - checkov@3.2.495
-    - renovate@42.44.0
-    - prettier@3.7.4
-    - trufflehog@3.92.2
-    - yamllint@1.37.1
-    - bandit@1.9.2
-    - trivy@0.68.1
+    - checkov@3.2.526
+    - renovate@43.150.0
+    - prettier@3.8.3
+    - trufflehog@3.95.2
+    - yamllint@1.38.0
+    - bandit@1.9.4
+    - trivy@0.70.0
    - taplo@0.10.0
-    - ruff@0.14.8
-    - isort@7.0.0
-    - markdownlint@0.47.0
-    - oxipng@10.0.0
-    - svgo@4.0.0
-    - actionlint@1.7.9
+    - ruff@0.15.12
+    - isort@8.0.1
+    - markdownlint@0.48.0
+    - oxipng@10.1.1
+    - svgo@4.0.1
+    - actionlint@1.7.12
    - flake8@7.3.0
    - hadolint@2.14.0
    - shfmt@3.6.0
    - shellcheck@0.11.0
-    - black@25.12.0
+    - black@26.3.1
    - git-diff-check
-    - gitleaks@8.30.0
+    - gitleaks@8.30.1
    - clang-format@16.0.3
  ignore:
    - linters: [ALL]
@@ -36,7 +36,7 @@ lint:
        - bin/**
 runtimes:
  enabled:
-    - python@3.10.8
+    - python@3.14.4
    - go@1.21.0
    - node@22.16.0
 actions:
@@ -10,5 +10,16 @@
  },
  "[powershell]": {
    "editor.defaultFormatter": "ms-vscode.powershell"
+  },
+  "chat.promptFilesRecommendations": {
+    "speckit.constitution": true,
+    "speckit.specify": true,
+    "speckit.plan": true,
+    "speckit.tasks": true,
+    "speckit.implement": true
+  },
+  "chat.tools.terminal.autoApprove": {
+    ".specify/scripts/bash/": true,
+    ".specify/scripts/powershell/": true
  }
 }
@@ -0,0 +1,142 @@
+# Agent instructions
+
+This repository is the [Meshtastic](https://meshtastic.org) firmware — a C++17 embedded codebase targeting ESP32 / nRF52 / RP2040 / STM32WL / Linux-Portduino LoRa mesh radios — plus a Python MCP server in `mcp-server/` that AI agents use to flash, configure, and test connected devices.
+
+## Primary instruction file
+
+**Read `.github/copilot-instructions.md` first.** That file is the canonical agent-facing document for this repo. It covers project layout, coding conventions (naming, module framework, Observer pattern, thread safety), the build system, CI/CD, the native C++ test suite, and — most importantly for automation work — the **MCP Server & Hardware Test Harness** section. Read it top-to-bottom before starting any non-trivial change.
+
+This file (`AGENTS.md`) is a short pointer + quick reference for agents that don't read `.github/copilot-instructions.md` by default.
+
+## Quick command reference
+
+| Action                           | Command                                                                                                       |
+| -------------------------------- | ------------------------------------------------------------------------------------------------------------- |
+| Build a firmware variant         | `pio run -e <env>` (e.g. `pio run -e rak4631`, `pio run -e heltec-v3`)                                        |
+| Build native macOS host binary   | `pio run -e native-macos` (Homebrew prereqs + CH341 LoRa setup in `variants/native/portduino/platformio.ini`) |
+| Clean + rebuild                  | `pio run -e <env> -t clean && pio run -e <env>`                                                               |
+| Flash a device                   | `pio run -e <env> -t upload --upload-port <port>` (or use the `pio_flash` MCP tool)                           |
+| Run firmware unit tests (native) | `pio test -e native`                                                                                          |
+| Run MCP hardware tests           | `./mcp-server/run-tests.sh`                                                                                   |
+| Live TUI test runner             | `mcp-server/.venv/bin/meshtastic-mcp-test-tui`                                                                |
+| Format before commit             | `trunk fmt`                                                                                                   |
+| Regenerate protobuf bindings     | `bin/regen-protos.sh`                                                                                         |
+| Generate CI matrix               | `./bin/generate_ci_matrix.py all [--level pr]`                                                                |
+
+## MCP server (device + test automation)
+
+The `mcp-server/` package exposes ~32 MCP tools for device discovery, building, flashing, serial monitoring, and live-node administration. Tools are grouped as:
+
+- **Discovery**: `list_devices`, `list_boards`, `get_board`
+- **Build & flash**: `build`, `clean`, `pio_flash`, `erase_and_flash` (ESP32 factory), `update_flash` (ESP32 OTA), `touch_1200bps`
+- **Serial sessions**: `serial_open`, `serial_read`, `serial_list`, `serial_close`
+- **Device reads**: `device_info`, `list_nodes`
+- **Device writes** (require `confirm=True`): `set_owner`, `get_config`, `set_config`, `get_channel_url`, `set_channel_url`, `send_text`, `reboot`, `shutdown`, `factory_reset`, `set_debug_log_api`
+- **userPrefs admin**: `userprefs_get`, `userprefs_set`, `userprefs_reset`, `userprefs_manifest`, `userprefs_testing_profile`
+- **Vendor escape hatches**: `esptool_*`, `nrfutil_*`, `picotool_*`
+
+Setup: `cd mcp-server && python3 -m venv .venv && .venv/bin/pip install -e '.[test]'`. The repo registers the server via `.mcp.json` — Claude Code picks it up automatically.
+
+See `mcp-server/README.md` for argument shapes and the **MCP Server & Hardware Test Harness** section of `.github/copilot-instructions.md` for agent usage rules (tool surface, fixture contract, firmware integration points, recovery playbooks).
+
+## Slash commands (AI-assisted workflows)
+
+Three test-and-diagnose workflows exist as slash commands:
+
+- **`/test` (Claude Code) / `/mcp-test` (Copilot)** — run the hardware test suite and interpret failures
+- **`/diagnose` / `/mcp-diagnose`** — read-only device health report
+- **`/repro` / `/mcp-repro`** — flakiness triage: re-run one test N times, diff firmware logs between passes and failures
+
+Bodies live in `.claude/commands/` and `.github/prompts/` respectively. `.claude/commands/README.md` is the index.
+
+## Encryption at a glance
+
+Two layers, both in `src/mesh/CryptoEngine.cpp`:
+
+- **Channel (symmetric)** — **AES-CTR** with a channel-wide PSK (AES-128 or AES-256). Nonce = packet_id ‖ from_node ‖ block_counter. No AEAD; integrity is soft (channel-hash filter). The well-known default PSK lives in `src/mesh/Channels.h`; a 1-byte PSK is a short-form index into it.
+- **Per-peer PKI** — **X25519 ECDH** (Curve25519, 32-byte keys) → SHA-256 → **AES-256-CCM** with an 8-byte MAC. Fresh 32-bit `extraNonce` per packet, sent in the clear alongside the MAC. 12-byte wire overhead (`MESHTASTIC_PKC_OVERHEAD`). Used for DMs. Also used for remote admin (`src/modules/AdminModule.cpp`), where AdminMessage authorization is gated by `config.security.admin_key[0..2]`. Disabled entirely in Ham mode (`user.is_licensed=true`).
+
+Key rotation to never trigger casually: only the **full** factory reset (`factory_reset_device`, `eraseBleBonds=true`) wipes `security.private_key` and regenerates the keypair — every peer holds the old public key, so DMs silently fail PKI decrypt until NodeInfo re-exchanges. The **partial** config reset (`factory_reset_config`) preserves the private key and doesn't invalidate peer relationships. Explicitly blanking `security.private_key` via admin also triggers regen. See the **Encryption & Key Management** section of `.github/copilot-instructions.md` for the full spec (nonce layout, send/receive selection logic including infrastructure-portnum exceptions, admin-key + session-passkey authorization, `is_managed` scope, key-rotation hazards).
+
+## House rules
+
+- **No destructive device operations without operator approval.** `factory_reset`, `erase_and_flash`, `reboot`, `shutdown`, history-rewriting git ops — describe the action and stop. Operator authorizes.
+- **One MCP call per serial port at a time.** The port lock is exclusive; concurrent calls deadlock. Sequence: open → read/mutate → close, then next device.
+- **`userPrefs.jsonc` is session state during tests.** The `_session_userprefs` fixture snapshots + restores it; never edit it from inside a test.
+- **Don't speculate about firmware root causes.** When evidence doesn't support a classification, say "unknown" and list what would disambiguate.
+- **Run `trunk fmt` before proposing a commit.** The `trunk_check` CI gate will reject unformatted code.
+- **`confirm=True` on destructive MCP tools is a real gate, not a formality.** Don't bypass it via auto-approve settings.
+
+## Typical agent workflows
+
+### Flashing a device
+
+1. `list_devices` → find the port + likely VID
+2. `list_boards` → confirm the env, or use the known default for the hardware
+3. `pio_flash(env=..., port=..., confirm=True)` for any arch, or `erase_and_flash(env=..., port=..., confirm=True)` for an ESP32 factory install
+
+### Inspecting live node state
+
+1. `device_info(port=...)` — short summary (node num, firmware version, region, peer count)
+2. `list_nodes(port=...)` — full peer table (SNR, RSSI, pubkey presence, last_heard)
+3. `get_config(section="lora", port=...)` — LoRa settings for cross-device comparison
+
+Sequence these; don't parallelize on the same port.
+
+### Testing a firmware change
+
+1. Build locally: `pio run -e <env>`
+2. Flash the test device: `pio_flash(env=..., port=..., confirm=True)`
+3. Run the suite: `./mcp-server/run-tests.sh tests/<tier>` or `/test tests/<tier>`
+4. On failure, open `mcp-server/tests/report.html` → `Meshtastic debug` section for the firmware log tail + device state dump
+5. Iterate
+
+### Debugging a flaky test
+
+1. `/repro <test-node-id> [count]` — re-runs the test N times, diffs firmware logs between passes and failures
+2. If the first attempt always fails and the rest pass, that's a state-leak pattern → suggest `--force-bake` or a clean device state, don't chase the first failure
+3. If all N fail, this isn't a flake — it's a regression. Stop iterating and escalate to `/test` for full-suite context.
+
+## Where to look
+
+| Path                              | What's there                                                                                                             |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
+| `src/`                            | Firmware C++ source (`mesh/`, `modules/`, `platform/`, `graphics/`, `gps/`, `motion/`, `mqtt/`, …)                       |
+| `src/mesh/`                       | Core: NodeDB, Router, Channels, CryptoEngine, radio interfaces, StreamAPI, PhoneAPI                                      |
+| `src/modules/`                    | Feature modules; `Telemetry/Sensor/` has 50+ I2C sensor drivers                                                          |
+| `variants/`                       | 200+ hardware variant definitions (`variant.h` + `platformio.ini` per board)                                             |
+| `protobufs/`                      | `.proto` definitions; regenerate with `bin/regen-protos.sh`                                                              |
+| `test/`                           | Firmware unit tests (12 suites; `pio test -e native`)                                                                    |
+| `mcp-server/`                     | Python MCP server + pytest hardware integration tests                                                                    |
+| `mcp-server/tests/`               | Tiered pytest suite: `unit/`, `mesh/`, `telemetry/`, `monitor/`, `recovery/`, `ui/`, `fleet/`, `admin/`, `provisioning/` |
+| `.claude/commands/`               | Claude Code slash command bodies                                                                                         |
+| `.github/prompts/`                | Copilot prompt bodies (mirrors of the Claude Code ones)                                                                  |
+| `.github/copilot-instructions.md` | **Primary agent instructions — read this**                                                                               |
+| `.github/workflows/`              | CI pipelines                                                                                                             |
+| `.mcp.json`                       | MCP server registration for Claude Code                                                                                  |
+
+## Recovery one-liners
+
+- **`userPrefs.jsonc` dirty after a test run?** Re-run `./mcp-server/run-tests.sh` once (pre-flight self-heals from the sidecar). If still dirty: `git checkout userPrefs.jsonc`.
+- **nRF52 not responding?** `mcp__meshtastic__touch_1200bps(port=...)` drops it into the DFU bootloader, then `pio_flash` re-installs.
+- **Device fully wedged (no DFU)?** `mcp__meshtastic__uhubctl_cycle(role="nrf52", confirm=True)` hard-power-cycles it via USB hub PPPS. Needs `uhubctl` installed (`brew install uhubctl` / `apt install uhubctl`); on Linux without udev rules, permission errors fail fast, so use `sudo uhubctl` yourself or configure udev access.
+- **Port busy?** `lsof <port>` to find the holder. Usually a stale `pio device monitor` or zombie `meshtastic_mcp` process. Kill it.
+- **Multiple MCP servers running?** `ps aux | grep meshtastic_mcp` — zombies hold ports. Kill all but the one your host spawned.
+- **macOS: `LIBUSB_ERROR_BUSY` on a CH341 LoRa adapter?** A third-party WCH `CH34xVCPDriver` is claiming interface 0. Find the bundle ID with `ioreg -p IOUSB -l -w 0 | grep -B2 -A30 0x5512`, then `sudo kmutil unload -b <bundleID>`. Apple's bundled CH34x kext targets the CH340 UART (PID 0x7523), not the SPI bridge — it's never the culprit.
+
+## Environment variables (test harness)
+
+| Var                                  | Purpose                                                                                                                                                                                                    |
+| ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `MESHTASTIC_MCP_ENV_<ROLE>`          | Override PlatformIO env for a role (e.g. `MESHTASTIC_MCP_ENV_NRF52=rak4631-dap`). Default map: `nrf52→rak4631`, `esp32s3→heltec-v3`.                                                                       |
+| `MESHTASTIC_MCP_SEED`                | PSK seed for the session test profile. Defaults to `mcp-<user>-<host>`.                                                                                                                                    |
+| `MESHTASTIC_MCP_FLASH_LOG`           | File path to tee pio/esptool/nrfutil/picotool output. `run-tests.sh` sets this to `tests/flash.log` so the TUI can stream live flash progress.                                                             |
+| `MESHTASTIC_MCP_TCP_HOST`            | `host` or `host:port` of a `meshtasticd` daemon (e.g. the `native-macos` build). Surfaces it in `list_devices` as `tcp://host:port` so `connect()`-based tools target it transparently. Default port 4403. |
+| `MESHTASTIC_UHUBCTL_BIN`             | Absolute path to `uhubctl` binary. Default: PATH lookup.                                                                                                                                                   |
+| `MESHTASTIC_UHUBCTL_LOCATION_<ROLE>` | Pin a role to a specific uhubctl hub location (e.g. `1-1.3`). Wins over VID auto-detection — use when multiple devices share a VID.                                                                        |
+| `MESHTASTIC_UHUBCTL_PORT_<ROLE>`     | Pin a role to a specific hub port number. Required alongside `LOCATION_<ROLE>`.                                                                                                                            |
+| `MESHTASTIC_UI_CAMERA_BACKEND`       | Camera backend for UI tier + `capture_screen` tool: `opencv` / `ffmpeg` / `null` / `auto` (default).                                                                                                       |
+| `MESHTASTIC_UI_CAMERA_DEVICE`        | Generic camera device (index or path). Used by the UI tier when no per-role var is set.                                                                                                                    |
+| `MESHTASTIC_UI_CAMERA_DEVICE_<ROLE>` | Per-role camera pinning (e.g. `MESHTASTIC_UI_CAMERA_DEVICE_ESP32S3=0` for the OLED-bearing heltec-v3).                                                                                                     |
+| `MESHTASTIC_UI_OCR_BACKEND`          | OCR engine selection: `easyocr` / `pytesseract` / `null` / `auto` (default).                                                                                                                               |
+| `MESHTASTIC_UI_TUI_CAMERA`           | Set to `1` to mount the live camera-feed panel in `meshtastic-mcp-test-tui`.                                                                                                                               |
@@ -3,18 +3,20 @@
 # trunk-ignore-all(hadolint/DL3008): Do not pin apt package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions

-FROM python:3.14-slim-trixie AS builder
+FROM debian:trixie AS builder
 ARG PIO_ENV=native
 ENV DEBIAN_FRONTEND=noninteractive
 ENV TZ=Etc/UTC

 # Install Dependencies
 ENV PIP_ROOT_USER_ACTION=ignore
+ENV PIP_BREAK_SYSTEM_PACKAGES=1
 RUN apt-get update && apt-get install --no-install-recommends -y \
        curl wget g++ zip git ca-certificates pkg-config \
+        python3-pip python3-grpc-tools \
        libgpiod-dev libyaml-cpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
        libusb-1.0-0-dev libulfius-dev liborcania-dev libssl-dev \
-        libx11-dev libinput-dev libxkbcommon-x11-dev \
+        libx11-dev libinput-dev libxkbcommon-x11-dev libsqlite3-dev libsdl2-dev \
    && apt-get clean && rm -rf /var/lib/apt/lists/* \
    && pip install --no-cache-dir -U platformio \
    && mkdir /tmp/firmware
@@ -53,7 +55,7 @@ USER root
 RUN apt-get update && apt-get --no-install-recommends -y install \
        libc-bin libc6 libgpiod3 libyaml-cpp0.8 libi2c0 libuv1t64 libusb-1.0-0-dev \
        liborcania2.3 libulfius2.7t64 libssl3t64 \
-        libx11-6 libinput10 libxkbcommon-x11-0 \
+        libx11-6 libinput10 libxkbcommon-x11-0 libsdl2-2.0-0 \
    && apt-get clean && rm -rf /var/lib/apt/lists/* \
    && mkdir -p /var/lib/meshtasticd \
    && mkdir -p /etc/meshtasticd/config.d \
@@ -0,0 +1,26 @@
+# Lightweight container for running native PlatformIO tests on non-Linux hosts
+FROM python:3.14-slim-trixie
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PIP_ROOT_USER_ACTION=ignore
+
+# hadolint ignore=DL3008
+RUN apt-get update && apt-get install --no-install-recommends -y \
+        g++ git ca-certificates pkg-config \
+        libgpiod-dev libyaml-cpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
+        libusb-1.0-0-dev libulfius-dev liborcania-dev libssl-dev \
+        libx11-dev libinput-dev libxkbcommon-x11-dev libsqlite3-dev libsdl2-dev \
+    && apt-get clean && rm -rf /var/lib/apt/lists/* \
+    && pip install --no-cache-dir platformio==6.1.19 \
+        && useradd --create-home --shell /usr/sbin/nologin meshtastic
+
+WORKDIR /firmware
+RUN chown -R meshtastic:meshtastic /firmware
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+    CMD platformio --version || exit 1
+
+USER meshtastic
+
+# Run tests by default; override with docker run args for specific filters
+CMD ["platformio", "test", "-e", "coverage", "-v"]
@@ -4,8 +4,8 @@

 | Firmware Version | Supported          |
 | ---------------- | ------------------ |
-| 2.6.x            | :white_check_mark: |
-| <= 2.5.x         | :x:                |
+| 2.7.x            | :white_check_mark: |
+| <= 2.6.x         | :x:                |

 ## Reporting a Vulnerability

@@ -3,15 +3,22 @@
 # trunk-ignore-all(hadolint/DL3018): Do not pin apk package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions

-FROM python:3.14-alpine3.22 AS builder
+# Ensure the Alpine version is updated in both stages of the container!
+FROM alpine:3.23 AS builder
 ARG PIO_ENV=native
-ENV PIP_ROOT_USER_ACTION=ignore

+# Enable Alpine community repository (for 'py3-grpcio-tools')
+RUN echo "https://dl-cdn.alpinelinux.org/alpine/v$(cut -d. -f1,2 /etc/alpine-release)/community" >> /etc/apk/repositories
+
+# Install Dependencies
+ENV PIP_ROOT_USER_ACTION=ignore
+ENV PIP_BREAK_SYSTEM_PACKAGES=1
 RUN apk --no-cache add \
        bash g++ libstdc++-dev linux-headers zip git ca-certificates libbsd-dev \
+        py3-pip py3-grpcio-tools \
        libgpiod-dev yaml-cpp-dev bluez-dev \
        libusb-dev i2c-tools-dev libuv-dev openssl-dev pkgconf argp-standalone \
-        libx11-dev libinput-dev libxkbcommon-dev \
+        libx11-dev libinput-dev libxkbcommon-dev sqlite-dev sdl2-dev \
    && rm -rf /var/cache/apk/* \
    && pip install --no-cache-dir -U platformio \
    && mkdir /tmp/firmware
@@ -42,7 +49,7 @@ USER root

 RUN apk --no-cache add \
        shadow libstdc++ libbsd libgpiod yaml-cpp libusb \
-        i2c-tools libuv libx11 libinput libxkbcommon \
+        i2c-tools libuv libx11 libinput libxkbcommon sdl2 \
    && rm -rf /var/cache/apk/* \
    && mkdir -p /var/lib/meshtasticd \
    && mkdir -p /etc/meshtasticd/config.d \
@@ -60,4 +67,4 @@ EXPOSE 4403

 CMD [ "sh",  "-cx", "meshtasticd --fsdir=/var/lib/meshtasticd" ]

-HEALTHCHECK NONE
+HEALTHCHECK NONE
@@ -0,0 +1,628 @@
+#!/usr/bin/env python3
+"""Board intake assessment for new Meshtastic hardware support.
+
+Validates a board intake request against the repository hardware context,
+identifies evidence gaps, and produces a structured readiness report.
+
+Usage:
+    python3 bin/board_intake.py <intake.json>
+    python3 bin/board_intake.py <intake.json> --output report.md
+    python3 bin/board_intake.py <intake.json> --validate   # gaps check only, exit 1 if not scaffold_ready
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_CONTEXT_PATH = ROOT / "docs" / "hardware-support-context.md"
+
+# Metadata keys every new PlatformIO environment should declare.
+REQUIRED_METADATA_KEYS = [
+    "custom_meshtastic_hw_model",
+    "custom_meshtastic_hw_model_slug",
+    "custom_meshtastic_architecture",
+    "custom_meshtastic_actively_supported",
+    "custom_meshtastic_support_level",
+    "custom_meshtastic_display_name",
+]
+
+RECOMMENDED_METADATA_KEYS = [
+    "custom_meshtastic_images",
+    "custom_meshtastic_tags",
+    "custom_meshtastic_requires_dfu",
+    "custom_meshtastic_partition_scheme",
+]
+
+# Pin groups that should be backed by evidence before scaffolding.
+EVIDENCE_CATEGORIES = ["radio", "display", "input", "GPS", "power"]
+
+# Architecture families that rely on BSP defaults for many pin defines.
+BSP_DEFAULT_FAMILIES = {"nrf52840", "rp2040", "stm32", "native"}
+
+# Known valid architectures from the repository.
+KNOWN_ARCHITECTURES = {
+    "esp32",
+    "esp32-s3",
+    "esp32-c3",
+    "esp32-c6",
+    "esp32s2",
+    "nrf52840",
+    "rp2040",
+    "rp2350",
+    "stm32",
+    "native",
+}
+
+
+# ---------------------------------------------------------------------------
+# T004 – BoardIntakeRequest dataclass
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class BoardIntakeRequest:
+    """Maintainer-supplied description of a proposed new board."""
+
+    # Required
+    environment_name: str
+    hardware_model: str
+    display_name: str
+    architecture: str
+
+    # Recommended
+    hardware_model_slug: str = ""
+    actively_supported: bool | None = None
+    support_level: str = ""
+    source_materials: list[str] = field(default_factory=list)
+    board_notes: str = ""
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "BoardIntakeRequest":
+        return cls(
+            environment_name=data.get("environment_name", ""),
+            hardware_model=str(data.get("hardware_model", "")),
+            display_name=data.get("display_name", ""),
+            architecture=data.get("architecture", ""),
+            hardware_model_slug=data.get("hardware_model_slug", ""),
+            actively_supported=data.get("actively_supported"),
+            support_level=str(data.get("support_level", "")),
+            source_materials=list(data.get("source_materials", [])),
+            board_notes=data.get("board_notes", ""),
+        )
+
+    @classmethod
+    def from_json(cls, path: Path) -> "BoardIntakeRequest":
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return cls.from_dict(data)
+
+
+# ---------------------------------------------------------------------------
+# T005 – EvidenceGap dataclass
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class EvidenceGap:
+    """A specific missing, conflicting, or ambiguous hardware fact."""
+
+    category: str  # metadata | radio | display | input | GPS | power | storage | connectivity | revision-scope
+    description: str
+    affected_artifact: str
+    required_evidence: str
+    blocking: bool
+
+
+# ---------------------------------------------------------------------------
+# T006 – IntakeAssessment dataclass
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class IntakeAssessment:
+    """Structured result of evaluating a BoardIntakeRequest."""
+
+    request: BoardIntakeRequest
+    expected_artifacts: list[str]
+    required_metadata: list[str]
+    matched_patterns: list[dict]
+    evidence_gaps: list[EvidenceGap]
+    risk_flags: list[str]
+    next_actions: list[str]
+    scaffold_ready: bool
+
+
+# ---------------------------------------------------------------------------
+# T007 – load_hardware_context
+# ---------------------------------------------------------------------------
+
+
+def load_hardware_context(path: Path = DEFAULT_CONTEXT_PATH) -> dict:
+    """Parse the generated hardware-support-context.md into a usable dict.
+
+    Returns:
+        {
+            "architecture_names": list[str],  # families present in the inventory
+            "metadata_keys": list[str],       # custom_meshtastic_* keys observed
+            "environments": dict[str, dict],  # env_name -> {display, hw_model, hw_slug, variant_dir, arch}
+        }
+    """
+    if not path.exists():
+        raise FileNotFoundError(
+            f"Hardware context not found at {path}. "
+            "Run: python3 bin/generate_hardware_support_context.py"
+        )
+
+    text = path.read_text(encoding="utf-8")
+
+    # Extract metadata keys from the "## Repository Metadata Inputs" section.
+    metadata_keys: list[str] = re.findall(r"`(custom_meshtastic_[^`]+)`", text)
+    metadata_keys = list(dict.fromkeys(metadata_keys))  # deduplicate, preserve order
+
+    # Extract architecture families from the "## Architecture and Environment Inventory" section.
+    arch_names: list[str] = re.findall(r"^### ([a-z0-9\-]+)\s*$", text, re.MULTILINE)
+    # Filter out sub-headings that are architecture names (exclude e.g. "nrf52840" inside examples)
+    # The inventory section has short arch names; filter to known set plus any that look like archs.
+    arch_names = [a for a in dict.fromkeys(arch_names) if not a[0].isupper()]
+
+    # Extract environments from inventory table rows.
+    environments: dict[str, dict] = {}
+    current_arch = ""
+    for line in text.splitlines():
+        arch_match = re.match(r"^### ([a-z0-9\-]+)\s*$", line)
+        if arch_match:
+            current_arch = arch_match.group(1)
+            continue
+        # Table row: | env | display | hw_model | hw_slug | variant_dir | categories |
+        row = re.match(
+            r"^\|\s*([^|]+?)\s*\|\s*([^|]*?)\s*\|\s*([^|]*?)\s*\|\s*([^|]*?)\s*\|\s*([^|]*?)\s*\|",
+            line,
+        )
+        if (
+            row
+            and not row.group(1).startswith("Environment")
+            and not row.group(1).startswith("---")
+        ):
+            env_name = row.group(1).strip()
+            if env_name:
+                environments[env_name] = {
+                    "display_name": row.group(2).strip(),
+                    "hw_model": row.group(3).strip(),
+                    "hw_slug": row.group(4).strip(),
+                    "variant_dir": row.group(5).strip(),
+                    "architecture": current_arch,
+                }
+
+    return {
+        "architecture_names": arch_names,
+        "metadata_keys": metadata_keys,
+        "environments": environments,
+    }
+
+
+# ---------------------------------------------------------------------------
+# T018 – validate_intake
+# ---------------------------------------------------------------------------
+
+
+def validate_intake(request: BoardIntakeRequest, context: dict) -> list[str]:
+    """Check required fields and detect conflicts with existing environments/models.
+
+    Returns a list of validation error strings (empty = valid).
+    """
+    errors: list[str] = []
+
+    if not request.environment_name:
+        errors.append("environment_name is required.")
+    if not request.hardware_model:
+        errors.append("hardware_model is required.")
+    if not request.display_name:
+        errors.append("display_name is required.")
+    if not request.architecture:
+        errors.append("architecture is required.")
+
+    if request.architecture and request.architecture not in KNOWN_ARCHITECTURES:
+        errors.append(
+            f"architecture '{request.architecture}' is not a known repository architecture. "
+            f"Known: {', '.join(sorted(KNOWN_ARCHITECTURES))}"
+        )
+
+    # Conflict: environment name already exists
+    if request.environment_name and request.environment_name in context.get(
+        "environments", {}
+    ):
+        errors.append(
+            f"environment_name '{request.environment_name}' already exists in the repository. "
+            "Choose a unique name or confirm this is an intentional update."
+        )
+
+    # Conflict: hardware model already assigned to a different environment
+    if request.hardware_model:
+        for env_name, env_data in context.get("environments", {}).items():
+            if (
+                env_data.get("hw_model") == request.hardware_model
+                and env_name != request.environment_name
+            ):
+                errors.append(
+                    f"hardware_model '{request.hardware_model}' is already assigned to "
+                    f"environment '{env_name}' ({env_data.get('display_name', '')!r}). "
+                    "Verify this is a new model number or confirm the shared-model intent."
+                )
+                break  # report once
+
+    return errors
+
+
+# ---------------------------------------------------------------------------
+# T019 – find_matched_patterns
+# ---------------------------------------------------------------------------
+
+
+def find_matched_patterns(request: BoardIntakeRequest, context: dict) -> list[dict]:
+    """Return up to 3 existing environments closest to the request by architecture."""
+    envs = context.get("environments", {})
+    arch = request.architecture
+
+    # Prefer exact architecture match, then partial (e.g., "esp32" matches "esp32-s3").
+    exact: list[dict] = []
+    partial: list[dict] = []
+    for env_name, env_data in envs.items():
+        entry = {**env_data, "environment": env_name}
+        env_arch = env_data.get("architecture", "")
+        if env_arch == arch:
+            exact.append(entry)
+        elif arch and (env_arch.startswith(arch) or arch.startswith(env_arch)):
+            partial.append(entry)
+
+    candidates = exact + partial
+    # Prefer boards that have a display_name and hw_model (more complete entries).
+    candidates.sort(key=lambda e: (not e.get("display_name"), not e.get("hw_model")))
+    return candidates[:3]
+
+
+# ---------------------------------------------------------------------------
+# T020 – build_evidence_gaps
+# ---------------------------------------------------------------------------
+
+
+def build_evidence_gaps(request: BoardIntakeRequest) -> list[EvidenceGap]:
+    """Identify missing pin-group evidence and metadata gaps."""
+    gaps: list[EvidenceGap] = []
+    has_sources = bool(request.source_materials)
+
+    if not has_sources:
+        # Every pin category is unresolvable without sources.
+        for cat in EVIDENCE_CATEGORIES:
+            gaps.append(
+                EvidenceGap(
+                    category=cat,
+                    description=(
+                        f"No source materials supplied. {cat.capitalize()} pin mappings cannot be "
+                        "verified without a schematic, pinout diagram, or vendor datasheet."
+                    ),
+                    affected_artifact="variant.h",
+                    required_evidence="Schematic, pinout image, or vendor board page",
+                    blocking=True,
+                )
+            )
+    else:
+        # Sources exist but may still be incomplete; flag as non-blocking advisory.
+        for cat in EVIDENCE_CATEGORIES:
+            gaps.append(
+                EvidenceGap(
+                    category=cat,
+                    description=(
+                        f"Source materials are present but {cat} pin assignments have not been "
+                        "extracted and cross-checked against repository macro conventions."
+                    ),
+                    affected_artifact="variant.h",
+                    required_evidence=f"Explicit {cat} pin listing matched to repository #define names",
+                    blocking=False,
+                )
+            )
+
+    # Metadata gaps
+    if not request.hardware_model_slug:
+        gaps.append(
+            EvidenceGap(
+                category="metadata",
+                description="hardware_model_slug is not set. The repository requires an UPPER_SNAKE_CASE slug for PlatformIO metadata.",
+                affected_artifact="platformio.ini (custom_meshtastic_hw_model_slug)",
+                required_evidence="Agreed slug from the project maintainers",
+                blocking=True,
+            )
+        )
+
+    if request.actively_supported is None:
+        gaps.append(
+            EvidenceGap(
+                category="metadata",
+                description="actively_supported is not specified. This controls CI matrix inclusion.",
+                affected_artifact="platformio.ini (custom_meshtastic_actively_supported)",
+                required_evidence="Maintainer decision on support status",
+                blocking=False,
+            )
+        )
+
+    if not request.support_level:
+        gaps.append(
+            EvidenceGap(
+                category="metadata",
+                description="support_level is not specified (expected: 1 = active, 2 = supported, 3 = extra).",
+                affected_artifact="platformio.ini (custom_meshtastic_support_level)",
+                required_evidence="Maintainer decision on support tier",
+                blocking=False,
+            )
+        )
+
+    # Revision-scope: multiple display/radio options without disambiguation.
+    # Match whole-word choice language rather than raw substrings so normal text
+    # like "radio" does not trigger the ambiguity gate.
+    note_text = request.board_notes.lower()
+    revision_scope_patterns = (
+        r"\brevision\b",
+        r"\bvariant\b",
+        r"\bvariants\b",
+        r"\boption\b",
+        r"\boptions\b",
+        r"\balternative\b",
+        r"\balternatives\b",
+        r"\bmulti\b",
+        r"\btwo\b",
+        r"\beither\b",
+        r"\bor\b",
+    )
+    if note_text and any(re.search(pattern, note_text) for pattern in revision_scope_patterns):
+        gaps.append(
+            EvidenceGap(
+                category="revision-scope",
+                description=(
+                    "Board notes mention multiple variants, revisions, or options. "
+                    "The intake must be scoped to a single hardware revision before scaffolding can proceed."
+                ),
+                affected_artifact="variant.h, platformio.ini",
+                required_evidence="Explicit decision on which revision this intake covers",
+                blocking=True,
+            )
+        )
+
+    return gaps
+
+
+# ---------------------------------------------------------------------------
+# T021 – assess_intake
+# ---------------------------------------------------------------------------
+
+
+def assess_intake(request: BoardIntakeRequest, context: dict) -> IntakeAssessment:
+    """Produce a full structured assessment from intake request and context."""
+    validation_errors = validate_intake(request, context)
+    matched = find_matched_patterns(request, context)
+    gaps = build_evidence_gaps(request)
+
+    expected_artifacts = [
+        f"variants/{request.architecture or '<architecture>'}/<variant-dir>/variant.h",
+        f"variants/{request.architecture or '<architecture>'}/<variant-dir>/platformio.ini (env:{request.environment_name or '<env>'})",
+    ]
+    if request.architecture in {"esp32", "esp32-s3", "esp32-c3", "esp32-c6"}:
+        expected_artifacts.append(
+            "(optional) variants/.../variant.cpp — only if board requires custom init hooks"
+        )
+    expected_artifacts += [
+        "PlatformIO metadata: all required custom_meshtastic_* keys (see required_metadata below)",
+        "(optional) board image under branding/ or images/ if custom_meshtastic_images is set",
+    ]
+
+    required_metadata = list(REQUIRED_METADATA_KEYS)
+    if request.architecture in BSP_DEFAULT_FAMILIES:
+        required_metadata.append(
+            f"(BSP note) {request.architecture} boards may inherit some pin defines from BSP headers — "
+            "check the Inherited Defaults section of docs/hardware-support-context.md before assuming a missing define is an error."
+        )
+
+    risk_flags: list[str] = []
+    for err in validation_errors:
+        risk_flags.append(f"Validation error: {err}")
+    if request.architecture in BSP_DEFAULT_FAMILIES:
+        risk_flags.append(
+            f"Architecture '{request.architecture}' uses BSP defaults for some pin defines. "
+            "Verify which macros are inherited before declaring them explicitly in variant.h."
+        )
+    if not matched:
+        risk_flags.append(
+            "No closely matched existing board found for this architecture. "
+            "Manual review of variant structure is required."
+        )
+
+    next_actions: list[str] = []
+    if validation_errors:
+        next_actions.append("Resolve validation errors before proceeding.")
+    blocking_gaps = [g for g in gaps if g.blocking]
+    non_blocking_gaps = [g for g in gaps if not g.blocking]
+    for gap in blocking_gaps:
+        next_actions.append(
+            f"Provide {gap.required_evidence} for {gap.category} ({gap.affected_artifact})."
+        )
+    if non_blocking_gaps:
+        next_actions.append(
+            f"Review {len(non_blocking_gaps)} non-blocking gap(s) before merging scaffold output."
+        )
+    if not next_actions:
+        next_actions.append(
+            "All required evidence is present. Proceed to scaffold generation."
+        )
+
+    scaffold_ready = len(validation_errors) == 0 and all(not g.blocking for g in gaps)
+
+    return IntakeAssessment(
+        request=request,
+        expected_artifacts=expected_artifacts,
+        required_metadata=required_metadata,
+        matched_patterns=matched,
+        evidence_gaps=gaps,
+        risk_flags=risk_flags,
+        next_actions=next_actions,
+        scaffold_ready=scaffold_ready,
+    )
+
+
+# ---------------------------------------------------------------------------
+# T022 – render_assessment_markdown
+# ---------------------------------------------------------------------------
+
+
+def render_assessment_markdown(assessment: IntakeAssessment) -> str:
+    req = assessment.request
+    lines: list[str] = []
+
+    lines.append(f"# Board Intake Assessment: `{req.environment_name or '(unnamed)'}`")
+    lines.append("")
+    lines.append(
+        f"**Scaffold ready**: {'✅ Yes' if assessment.scaffold_ready else '❌ No — see blocking gaps below'}"
+    )
+    lines.append("")
+
+    lines.append("## Request Summary")
+    lines.append("")
+    lines.append(f"- **Environment name**: `{req.environment_name}`")
+    lines.append(f"- **Hardware model**: `{req.hardware_model}`")
+    lines.append(
+        f"- **Hardware model slug**: `{req.hardware_model_slug or '(not set)'}`"
+    )
+    lines.append(f"- **Display name**: {req.display_name}")
+    lines.append(f"- **Architecture**: `{req.architecture}`")
+    if req.actively_supported is not None:
+        lines.append(f"- **Actively supported**: {req.actively_supported}")
+    if req.support_level:
+        lines.append(f"- **Support level**: {req.support_level}")
+    if req.source_materials:
+        lines.append("- **Source materials**:")
+        for src in req.source_materials:
+            lines.append(f"  - {src}")
+    if req.board_notes:
+        lines.append(f"- **Board notes**: {req.board_notes}")
+    lines.append("")
+
+    lines.append("## Expected Artifacts")
+    lines.append("")
+    for artifact in assessment.expected_artifacts:
+        lines.append(f"- {artifact}")
+    lines.append("")
+
+    lines.append("## Required Metadata")
+    lines.append("")
+    for key in assessment.required_metadata:
+        lines.append(
+            f"- `{key}`" if key.startswith("custom_meshtastic") else f"- {key}"
+        )
+    lines.append("")
+
+    lines.append("## Matched Repository Patterns")
+    lines.append("")
+    if assessment.matched_patterns:
+        for pattern in assessment.matched_patterns:
+            name = pattern.get("display_name") or pattern.get("environment", "")
+            env = pattern.get("environment", "")
+            arch = pattern.get("architecture", "")
+            vdir = pattern.get("variant_dir", "")
+            lines.append(f"- **{name}** (`{env}`, {arch}) — `{vdir}`")
+    else:
+        lines.append("- No closely matched patterns found for this architecture.")
+    lines.append("")
+
+    blocking = [g for g in assessment.evidence_gaps if g.blocking]
+    non_blocking = [g for g in assessment.evidence_gaps if not g.blocking]
+
+    lines.append("## Evidence Gaps")
+    lines.append("")
+    if blocking:
+        lines.append("### Blocking")
+        lines.append("")
+        for gap in blocking:
+            lines.append(f"- **[{gap.category}]** {gap.description}")
+            lines.append(f"  - Affected: `{gap.affected_artifact}`")
+            lines.append(f"  - Required evidence: {gap.required_evidence}")
+    else:
+        lines.append("*No blocking evidence gaps.*")
+    lines.append("")
+    if non_blocking:
+        lines.append("### Non-blocking (review before merge)")
+        lines.append("")
+        for gap in non_blocking:
+            lines.append(f"- **[{gap.category}]** {gap.description}")
+            lines.append(f"  - Affected: `{gap.affected_artifact}`")
+            lines.append(f"  - Required evidence: {gap.required_evidence}")
+        lines.append("")
+
+    if assessment.risk_flags:
+        lines.append("## Risk Flags")
+        lines.append("")
+        for flag in assessment.risk_flags:
+            lines.append(f"- {flag}")
+        lines.append("")
+
+    lines.append("## Next Actions")
+    lines.append("")
+    for i, action in enumerate(assessment.next_actions, 1):
+        lines.append(f"{i}. {action}")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# T023 – CLI entry point
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Evaluate a board intake request against the repository hardware context."
+    )
+    parser.add_argument("intake", help="Path to the intake JSON file")
+    parser.add_argument(
+        "--output",
+        default="-",
+        help="Output path for the assessment markdown (default: stdout)",
+    )
+    parser.add_argument(
+        "--validate",
+        action="store_true",
+        help="Exit with code 1 if scaffold_ready is false (useful for CI gate checks)",
+    )
+    parser.add_argument(
+        "--context",
+        default=str(DEFAULT_CONTEXT_PATH),
+        help="Path to docs/hardware-support-context.md (default: auto-detected)",
+    )
+    args = parser.parse_args()
+
+    intake_path = Path(args.intake)
+    if not intake_path.exists():
+        print(f"Error: intake file not found: {intake_path}", file=sys.stderr)
+        sys.exit(2)
+
+    request = BoardIntakeRequest.from_json(intake_path)
+    context = load_hardware_context(Path(args.context))
+    assessment = assess_intake(request, context)
+    report = render_assessment_markdown(assessment)
+
+    if args.output == "-":
+        print(report)
+    else:
+        output_path = Path(args.output)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(report, encoding="utf-8")
+        print(f"Assessment written to {output_path}")
+
+    if args.validate and not assessment.scaffold_ready:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,392 @@
+#!/usr/bin/env python3
+"""Scaffold board-support files from a validated intake assessment."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+from board_intake import (
+    BoardIntakeRequest,
+    EvidenceGap,
+    IntakeAssessment,
+    assess_intake,
+    load_hardware_context,
+    render_assessment_markdown,
+)
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_OUTPUT_ROOT = ROOT / "generated" / "hardware-support"
+
+ARCH_BASE_ENV = {
+    "esp32": "esp32_base",
+    "esp32-s3": "esp32s3_base",
+    "esp32-c3": "esp32c3_base",
+    "esp32-c6": "esp32c6_base",
+    "esp32s2": "esp32s2_base",
+    "nrf52840": "nrf52_base",
+    "rp2040": "rp2040_base",
+    "rp2350": "rp2350_base",
+    "stm32": "stm32_base",
+    "native": "native_base",
+}
+
+ARCH_VARIANT_ROOT = {
+    "esp32": "esp32",
+    "esp32-s3": "esp32s3",
+    "esp32-c3": "esp32c3",
+    "esp32-c6": "esp32c6",
+    "esp32s2": "esp32s2",
+    "nrf52840": "nrf52840",
+    "rp2040": "rp2040",
+    "rp2350": "rp2350",
+    "stm32": "stm32",
+    "native": "native",
+}
+
+PLACEHOLDER_DEFINES = {
+    "status": [
+        "#define LED_PIN  // TODO: verify status LED pin if present",
+    ],
+    "input": [
+        "#define BUTTON_PIN  // TODO: verify user button pin",
+    ],
+    "display": [
+        "#define HAS_SCREEN 1",
+        "#define USE_SSD1306 // TODO: verify display controller",
+        "#define I2C_SCL  // TODO: verify display I2C clock pin",
+        "#define I2C_SDA  // TODO: verify display I2C data pin",
+    ],
+    "GPS": [
+        "#define GPS_RX_PIN  // TODO: verify GPS RX pin or remove if GPS absent",
+        "#define GPS_TX_PIN  // TODO: verify GPS TX pin or remove if GPS absent",
+    ],
+    "power": [
+        "#define BATTERY_PIN  // TODO: verify battery sense pin",
+        "#define ADC_MULTIPLIER  // TODO: verify voltage divider ratio",
+    ],
+    "radio": [
+        "#define USE_SX1262 // TODO: verify radio chip selection from schematic",
+        "#define SX126X_CS  // TODO: verify radio chip-select pin",
+        "#define SX126X_BUSY  // TODO: verify radio busy pin",
+        "#define SX126X_DIO1  // TODO: verify radio IRQ pin",
+        "#define SX126X_RESET  // TODO: verify radio reset pin",
+        "#define LORA_SCK  // TODO: verify radio SPI clock pin",
+        "#define LORA_MISO  // TODO: verify radio SPI MISO pin",
+        "#define LORA_MOSI  // TODO: verify radio SPI MOSI pin",
+    ],
+}
+
+DEFINE_PATTERN = re.compile(r"^#define\s+([A-Za-z0-9_]+)(?:\s+(.*?))?\s*(?://.*)?$")
+
+CATEGORY_MACROS = {
+    "status": ["LED_POWER", "LED_PIN", "LED_STATE_ON", "VEXT_ENABLE"],
+    "input": ["BUTTON_PIN", "BUTTON_NEED_PULLUP", "ROTARY_A", "ROTARY_B"],
+    "display": [
+        "HAS_SCREEN",
+        "USE_SSD1306",
+        "USE_SH1106",
+        "USE_TFTDISPLAY",
+        "USE_ST7789",
+        "I2C_SCL",
+        "I2C_SDA",
+        "I2C_SCL1",
+        "I2C_SDA1",
+        "TFT_HEIGHT",
+        "TFT_WIDTH",
+        "TFT_OFFSET_X",
+        "TFT_OFFSET_Y",
+        "SCREEN_ROTATE",
+        "SCREEN_TRANSITION_FRAMERATE",
+    ],
+    "GPS": [
+        "HAS_GPS",
+        "GPS_RX_PIN",
+        "GPS_TX_PIN",
+        "GPS_BAUDRATE",
+        "PIN_GPS_PPS",
+        "GPS_THREAD_INTERVAL",
+    ],
+    "power": [
+        "ADC_CTRL",
+        "ADC_CTRL_ENABLED",
+        "BATTERY_PIN",
+        "ADC_CHANNEL",
+        "ADC_ATTENUATION",
+        "ADC_MULTIPLIER",
+        "USE_POWERSAVE",
+        "SLEEP_TIME",
+    ],
+    "radio": [
+        "USE_SX1262",
+        "USE_SX1268",
+        "USE_LR1121",
+        "USE_SX1280",
+        "LORA_DIO0",
+        "LORA_RESET",
+        "LORA_DIO1",
+        "LORA_DIO2",
+        "LORA_SCK",
+        "LORA_MISO",
+        "LORA_MOSI",
+        "LORA_CS",
+        "SX126X_CS",
+        "SX126X_DIO1",
+        "SX126X_BUSY",
+        "SX126X_RESET",
+        "SX126X_DIO2_AS_RF_SWITCH",
+        "SX126X_DIO3_TCXO_VOLTAGE",
+        "LR1121_IRQ_PIN",
+        "LR1121_NRESET_PIN",
+        "LR1121_BUSY_PIN",
+        "LR1121_SPI_NSS_PIN",
+        "LR1121_SPI_SCK_PIN",
+        "LR1121_SPI_MOSI_PIN",
+        "LR1121_SPI_MISO_PIN",
+        "LR11X0_DIO3_TCXO_VOLTAGE",
+        "LR11X0_DIO_AS_RF_SWITCH",
+    ],
+}
+
+
+def slugify_variant_dir(req: BoardIntakeRequest) -> str:
+    return req.environment_name.replace("_", "-").lower()
+
+
+def target_variant_dir(req: BoardIntakeRequest) -> Path:
+    arch_root = ARCH_VARIANT_ROOT.get(req.architecture, req.architecture)
+    return Path("variants") / arch_root / slugify_variant_dir(req)
+
+
+def pick_pattern(assessment: IntakeAssessment) -> dict | None:
+    return assessment.matched_patterns[0] if assessment.matched_patterns else None
+
+
+def source_basis_lines(assessment: IntakeAssessment, context: dict) -> list[str]:
+    lines = [
+        f"// Intake environment: {assessment.request.environment_name}",
+        f"// Intake architecture: {assessment.request.architecture}",
+    ]
+    pattern = pick_pattern(assessment)
+    if pattern:
+        lines.append(
+            "// Repository pattern basis: "
+            f"{pattern.get('environment', '')} -> {pattern.get('variant_dir', '')}"
+        )
+    lines.append(
+        f"// Context source: {context.get('context_path', 'docs/hardware-support-context.md')}"
+    )
+    return lines
+
+
+def parse_variant_defines(variant_path: Path) -> dict[str, str]:
+    defines: dict[str, str] = {}
+    if not variant_path.exists():
+        return defines
+
+    for raw_line in variant_path.read_text(encoding="utf-8").splitlines():
+        match = DEFINE_PATTERN.match(raw_line.strip())
+        if not match:
+            continue
+        name = match.group(1)
+        value = (match.group(2) or "1").strip()
+        defines[name] = value
+    return defines
+
+
+def infer_category_lines(pattern_variant_path: Path, category: str) -> list[str]:
+    defines = parse_variant_defines(pattern_variant_path)
+    lines: list[str] = []
+    for macro_name in CATEGORY_MACROS[category]:
+        value = defines.get(macro_name)
+        if value is None:
+            continue
+        if value == "1":
+            lines.append(f"#define {macro_name}")
+        else:
+            lines.append(f"#define {macro_name} {value}")
+
+    if lines:
+        return lines
+    return PLACEHOLDER_DEFINES[category]
+
+
+# T028
+
+
+def generate_variant_h(assessment: IntakeAssessment, context: dict) -> str:
+    req = assessment.request
+    lines: list[str] = []
+    lines.extend(source_basis_lines(assessment, context))
+    lines.append("")
+    lines.append("#pragma once")
+    lines.append("")
+
+    pattern = pick_pattern(assessment)
+    pattern_variant_path = None
+    if pattern and pattern.get("variant_dir"):
+        pattern_variant_path = (ROOT / str(pattern["variant_dir"]) / "variant.h").resolve()
+
+    for category in ("status", "input", "display", "GPS", "power", "radio"):
+        lines.append(f"// {category}")
+        if pattern_variant_path is not None:
+            lines.extend(infer_category_lines(pattern_variant_path, category))
+        else:
+            lines.extend(PLACEHOLDER_DEFINES[category])
+        lines.append("")
+
+    lines.append("// Board identity")
+    macro_name = req.hardware_model_slug or req.environment_name.upper().replace(
+        "-", "_"
+    )
+    lines.append(f"#define {macro_name} 1")
+    lines.append("")
+
+    return "\n".join(lines).rstrip() + "\n"
+
+
+# T029
+
+
+def generate_platformio_env(assessment: IntakeAssessment) -> str:
+    req = assessment.request
+    extends = ARCH_BASE_ENV.get(req.architecture, f"{req.architecture}_base")
+    variant_dir = target_variant_dir(req)
+    build_define = (
+        req.hardware_model_slug or req.environment_name.upper().replace("-", "_")
+    ).replace(" ", "_")
+
+    lines = [
+        f"[env:{req.environment_name}]",
+        f"custom_meshtastic_hw_model = {req.hardware_model}",
+        f"custom_meshtastic_hw_model_slug = {req.hardware_model_slug or 'TODO_SET_HW_MODEL_SLUG'}",
+        f"custom_meshtastic_architecture = {req.architecture}",
+        f"custom_meshtastic_actively_supported = {str(req.actively_supported).lower() if req.actively_supported is not None else 'TODO_SET_ACTIVELY_SUPPORTED'}",
+        f"custom_meshtastic_support_level = {req.support_level or 'TODO_SET_SUPPORT_LEVEL'}",
+        f"custom_meshtastic_display_name = {req.display_name}",
+        "custom_meshtastic_images = TODO_SET_IMAGES",
+        "custom_meshtastic_tags = TODO_SET_TAGS",
+        "custom_meshtastic_requires_dfu = TODO_SET_REQUIRES_DFU",
+        "custom_meshtastic_partition_scheme = TODO_SET_PARTITION_SCHEME",
+        "",
+        "board = TODO_SET_PLATFORMIO_BOARD",
+        f"extends = {extends}",
+        "build_flags =",
+        f"  ${{{extends}.build_flags}}",
+        f"  -D {build_define}",
+        f"  -I {variant_dir.as_posix()}",
+    ]
+    return "\n".join(lines).rstrip() + "\n"
+
+
+# T030
+
+
+def annotate_unresolved(content: str, gaps: list[EvidenceGap], is_ini: bool = False) -> str:
+    annotations = [
+        gap
+        for gap in gaps
+        if not gap.blocking
+        and gap.category in {"radio", "display", "input", "GPS", "power", "metadata"}
+    ]
+    if not annotations:
+        return content
+
+    lines = content.splitlines()
+    todo_lines = [f"; TODO: verify — {gap.description}" for gap in annotations]
+    
+    if is_ini:
+        # For INI files, insert TODOs after the first section header
+        if lines and lines[0].startswith("["):
+            return "\n".join(lines[:1] + todo_lines + [""] + lines[1:]) + "\n"
+    else:
+        # For .h files, prepend TODOs with C++ comment syntax
+        todo_lines = [f"// TODO: verify — {gap.description}" for gap in annotations]
+        return "\n".join(todo_lines + [""] + lines) + "\n"
+    
+    return content
+
+
+# T031
+
+
+def scaffold_board(
+    assessment: IntakeAssessment, context: dict, output_dir: Path
+) -> dict[str, Path]:
+    req = assessment.request
+    variant_dir = output_dir / target_variant_dir(req)
+    variant_dir.mkdir(parents=True, exist_ok=True)
+
+    variant_h_path = variant_dir / "variant.h"
+    platformio_path = variant_dir / "platformio.ini"
+
+    variant_h_content = annotate_unresolved(
+        generate_variant_h(assessment, context), assessment.evidence_gaps, is_ini=False
+    )
+    platformio_content = annotate_unresolved(
+        generate_platformio_env(assessment), assessment.evidence_gaps, is_ini=True
+    )
+
+    variant_h_path.write_text(variant_h_content, encoding="utf-8")
+    platformio_path.write_text(platformio_content, encoding="utf-8")
+
+    generated = {
+        "variant_h": variant_h_path,
+        "platformio": platformio_path,
+    }
+
+    if req.architecture in {"esp32", "esp32-s3", "esp32-c3", "esp32-c6"}:
+        variant_cpp_path = variant_dir / "variant.cpp"
+        variant_cpp_content = annotate_unresolved(
+            "\n".join(
+                [
+                    '#include "variant.h"',
+                    "",
+                    "// Optional board-specific initialization hooks go here.",
+                    "// Leave this file out if the board does not need custom startup behavior.",
+                ]
+            )
+            + "\n",
+            assessment.evidence_gaps,
+        )
+        variant_cpp_path.write_text(variant_cpp_content, encoding="utf-8")
+        generated["variant_cpp"] = variant_cpp_path
+
+    return generated
+
+
+# T032 + T033
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Generate board-support scaffold files from an intake JSON file."
+    )
+    parser.add_argument("intake", help="Path to intake JSON")
+    parser.add_argument(
+        "--output-dir",
+        default=str(DEFAULT_OUTPUT_ROOT),
+        help="Directory where scaffold files will be written",
+    )
+    args = parser.parse_args()
+
+    intake_path = Path(args.intake)
+    request = BoardIntakeRequest.from_json(intake_path)
+    context = load_hardware_context()
+    context["context_path"] = "docs/hardware-support-context.md"
+    assessment = assess_intake(request, context)
+
+    if not assessment.scaffold_ready:
+        print(render_assessment_markdown(assessment))
+        sys.exit(1)
+
+    generated = scaffold_board(assessment, context, Path(args.output_dir))
+    print("Generated scaffold files:")
+    for name, path in generated.items():
+        print(f"- {name}: {path}")
+
+
+if __name__ == "__main__":
+    main()
@@ -22,7 +22,7 @@ export APP_VERSION=$VERSION

 basename=firmware-$1-$VERSION

-pio run --environment $1 # -v
+pio run --environment $1 -t mtjson # -v

 cp $BUILDDIR/$basename.elf $OUTDIR/$basename.elf

@@ -32,20 +32,10 @@ cp $BUILDDIR/$basename.factory.bin $OUTDIR/$basename.factory.bin
 echo "Copying ESP32 update bin file"
 cp $BUILDDIR/$basename.bin $OUTDIR/$basename.bin

-echo "Building Filesystem for ESP32 targets"
-# If you want to build the webui, uncomment the following lines
-# pio run --environment $1 -t buildfs
-# cp .pio/build/$1/littlefs.bin $OUTDIR/littlefswebui-$1-$VERSION.bin
-# # Remove webserver files from the filesystem and rebuild
-# ls -l data/static # Diagnostic list of files
-# rm -rf data/static
-pio run --environment $1 -t buildfs --disable-auto-clean
+echo "Copying Filesystem for ESP32 targets"
 cp $BUILDDIR/littlefs-$1-$VERSION.bin $OUTDIR/littlefs-$1-$VERSION.bin
 cp bin/device-install.* $OUTDIR/
 cp bin/device-update.* $OUTDIR/

-# Generate the manifest file
-echo "Generating Meshtastic manifest"
-TIMEFORMAT="Generated manifest in %E seconds"
-time pio run --environment $1 -t mtjson --silent --disable-auto-clean
-cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json
+echo "Copying manifest"
+cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json || true
@@ -31,5 +31,6 @@ basename=meshtasticd-$1-$VERSION
 pio pkg install --environment "$PIO_ENV" || platformioFailed
 pio run --environment "$PIO_ENV" || platformioFailed

-cp "$BUILDDIR/meshtasticd" "$OUTDIR/meshtasticd_linux_$(uname -m)"
+os_name=$(uname -s | tr '[:upper:]' '[:lower:]')
+cp "$BUILDDIR/meshtasticd" "$OUTDIR/meshtasticd_${os_name}_$(uname -m)"
 cp bin/native-install.* $OUTDIR/
@@ -21,13 +21,14 @@ rm -f $BUILDDIR/firmware*
 export APP_VERSION=$VERSION

 basename=firmware-$1-$VERSION
+ota_basename=${basename}-ota

-pio run --environment $1 # -v
+pio run --environment $1 -t mtjson # -v

 cp $BUILDDIR/$basename.elf $OUTDIR/$basename.elf

 echo "Copying NRF52 dfu (OTA) file"
-cp $BUILDDIR/$basename.zip $OUTDIR/$basename.zip
+cp $BUILDDIR/$basename.zip $OUTDIR/$ota_basename.zip

 echo "Copying NRF52 UF2 file"
 cp $BUILDDIR/$basename.uf2 $OUTDIR/$basename.uf2
@@ -47,8 +48,5 @@ if (echo $1 | grep -q "rak4631"); then
 	cp $SRCHEX $OUTDIR/
 fi

-# Generate the manifest file
-echo "Generating Meshtastic manifest"
-TIMEFORMAT="Generated manifest in %E seconds"
-time pio run --environment $1 -t mtjson --silent --disable-auto-clean
-cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json
+echo "Copying manifest"
+cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json || true
@@ -22,15 +22,12 @@ export APP_VERSION=$VERSION

 basename=firmware-$1-$VERSION

-pio run --environment $1 # -v
+pio run --environment $1 -t mtjson # -v

 cp $BUILDDIR/$basename.elf $OUTDIR/$basename.elf

 echo "Copying uf2 file"
 cp $BUILDDIR/$basename.uf2 $OUTDIR/$basename.uf2

-# Generate the manifest file
-echo "Generating Meshtastic manifest"
-TIMEFORMAT="Generated manifest in %E seconds"
-time pio run --environment $1 -t mtjson --silent --disable-auto-clean
-cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json
+echo "Copying manifest"
+cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json || true
@@ -22,15 +22,12 @@ export APP_VERSION=$VERSION

 basename=firmware-$1-$VERSION

-pio run --environment $1 # -v
+pio run --environment $1 -t mtjson # -v

 cp $BUILDDIR/$basename.elf $OUTDIR/$basename.elf

 echo "Copying STM32 bin file"
 cp $BUILDDIR/$basename.bin $OUTDIR/$basename.bin

-# Generate the manifest file
-echo "Generating Meshtastic manifest"
-TIMEFORMAT="Generated manifest in %E seconds"
-time pio run --environment $1 -t mtjson --silent --disable-auto-clean
-cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json
+echo "Copying manifest"
+cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json || true
@@ -23,4 +23,4 @@ for BOARD in $BOARDS; do
 	CHECK="${CHECK} -e ${BOARD}"
 done

-pio check --flags "-DAPP_VERSION=${APP_VERSION} --suppressions-list=suppressions.txt --inline-suppr" $CHECK --skip-packages --pattern="src/" --fail-on-defect=medium --fail-on-defect=high
+pio check --flags "-DAPP_VERSION=${APP_VERSION} --suppressions-list=suppressions.txt --inline-suppr" $CHECK --skip-packages --pattern="src/" --fail-on-defect=low --fail-on-defect=medium --fail-on-defect=high
@@ -105,6 +105,8 @@ Lora:

 GPS:
 #  SerialPath: /dev/ttyS0
+#  ExtraPins:
+#    - 22

 ### Specify I2C device, or leave blank for none

@@ -184,6 +186,9 @@ Input:
 Logging:
  LogLevel: info # debug, info, warn, error
 #  TraceFile: /var/log/meshtasticd.json
+#  JSONFile: /packets.json # File location for JSON output of decoded packets
+#  JSONFileRotate: 60 # Rotate JSON file every N minutes, or 0 for no rotation
+#  JSONFilter: position # filter for packets to save to JSON file
 #  AsciiLogs: true     # default if not specified is !isatty() on stdout

 Webserver:
@@ -210,3 +215,4 @@ General:
  AvailableDirectory: /etc/meshtasticd/available.d/
 #  MACAddress: AA:BB:CC:DD:EE:FF
 #  MACAddressSource: eth0
+#  APIPort: 4403
@@ -1,3 +1,9 @@
+Meta:
+  name: BananaPi-BPI-R4-sx1262
+  support: community
+  compatible:
+    - bananapi_bpi-r4 # OpenWrt target
+
 Lora:
  Module: sx1262  # BananaPi-BPI-R4 SPI via 26p GPIO Header
 ##  CS: 28
@@ -1,4 +1,10 @@
 ##  https://www.mikroe.com/lr-iot-click
+Meta:
+  name: OpenWRT One mikroBUS LR-IOT-CLICK
+  support: community
+  compatible:
+    - openwrt_one # OpenWrt target
+
 Lora:
  Module: lr1110  # OpenWRT ONE mikroBUS with LR-IOT-CLICK
 #  CS: 25
@@ -1,3 +1,9 @@
+Meta:
+  name: OpenWRT One mikroBUS sx1262
+  support: community
+  compatible:
+    - openwrt_one # OpenWrt target
+
 Lora:
  Module: sx1262
  IRQ: 10
@@ -0,0 +1,28 @@
+# meshtasticd configuration files
+
+This directory contains YAML configuration files for meshtasticd. Each file describes a specific hardware configuration, including the LoRa module and pin assignments. These configurations are used by meshtasticd to correctly interface with the hardware.
+
+## Metadata structure
+
+Each configuration file includes a `Meta` section that provides information about the configuration.
+This configuration is consumed by configuration-selection tools.
+
+```yaml
+Meta:
+  name: MeshAdv-Pi E22-900M30S # A unique identifier for this configuration.
+  support: community # community, official, or deprecated; determined by Meshtastic Leads.
+  compatible: # A list of compatible products or platforms.
+    - raspberry-pi
+```
+`name`: A unique identifier for the configuration, typically reflecting the hardware it supports.
+
+`support`: Indicates the level of support for this configuration. It can be one of the following:
+
+- `community`: Supported by the Meshtastic community. Meshtastic Members may not possess, or have not tested this configuration.
+- `official`: Fully supported by Meshtastic. Meshtastic Members have tested and verified this configuration.
+- `deprecated`: No longer recommended for deployment by Meshtastic.
+
+`compatible`: A list of compatible products or platforms that can use this configuration.
+This will vary depending on the intended use case / platform.
+Multiple compatible entries can be included. E.g. Armbian `BOARD` value or OpenWrt `TARGET` value.
+These tags can be consumed by different configuration-selection tools, filtering based upon their platform/etc.
@@ -1,3 +1,9 @@
+Meta:
+  name: Waveshare 1.44inch LCD HAT
+  support: community
+  compatible:
+    - raspberry-pi
+
 ### Waveshare 1.44inch LCD HAT
 Display:
  Panel: ST7735S
--- a/Show More
+++ b/Show More