@qwen-code/qwen-code 0.19.12 → 0.20.0-nightly.20260721.cda0e0348

package/bundled/qc-helper/docs/configuration/settings.md

@@ -748,7 +748,7 @@ For sandbox image selection, precedence is:
 | `--extensions`               | `-e`  | Specifies a list of extensions to use for the session.                                                                                                                                                                                       | Extension names                                | If not provided, all available extensions are used. Use the special term `qwen -e none` to disable all extensions. Example: `qwen -e my-extension -e my-other-extension`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `--list-extensions`          | `-l`  | Lists all available extensions and exits.                                                                                                                                                                                                    |                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `--proxy`                    |       | Sets the proxy for the CLI.                                                                                                                                                                                                                  | Proxy URL                                      | Example: `--proxy http://localhost:7890`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `--include-directories`      |       | Includes additional directories in the workspace for multi-directory support.                                                                                                                                                                | Directory paths                                | Can be specified multiple times or as comma-separated values. 5 directories can be added at maximum. Example: `--include-directories /path/to/project1,/path/to/project2` or `--include-directories /path/to/project1 --include-directories /path/to/project2`                                                                                                                                                                                                                                                                                                                                                                                                |
+| `--include-directories`      |       | Includes additional directories in the workspace for multi-directory support.                                                                                                                                                                | Directory paths                                | Can be specified multiple times or as comma-separated values. Example: `--include-directories /path/to/project1,/path/to/project2` or `--include-directories /path/to/project1 --include-directories /path/to/project2`                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `--screen-reader`            |       | Enables screen reader mode, which adjusts the TUI for better compatibility with screen readers.                                                                                                                                              |                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `--version`                  |       | Displays the version of the CLI.                                                                                                                                                                                                             |                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `--openai-logging`           |       | Enables logging of OpenAI API calls for debugging and analysis.                                                                                                                                                                              |                                                | This flag overrides the `enableOpenAILogging` setting in `settings.json`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |

package/bundled/qc-helper/docs/features/commands.md

@@ -49,6 +49,7 @@ Commands for adjusting interface appearance and work environment.
 | → `detail`           | Show per-item context usage breakdown                                                                                                                                             | `/context detail`                                                                 |
 | `/history`           | Control history display preferences and visibility                                                                                                                                | `/history collapse-on-resume`, `/history expand-on-resume`, `/history expand-now` |
 | `/diff`              | Open an interactive diff viewer showing uncommitted changes and per-turn diffs. Use ←/→ to switch between current git diff and individual conversation turns, ↑/↓ to browse files | `/diff`                                                                           |
+| `/log`               | Open a commit history viewer for the workspace (Web Shell only)                                                                                                                   | `/log`                                                                            |
 | `/theme`             | Change Qwen Code visual theme                                                                                                                                                     | `/theme`                                                                          |
 | `/vim`               | Turn input area Vim editing mode on/off                                                                                                                                           | `/vim`                                                                            |
 | `/voice`             | Toggle voice dictation input                                                                                                                                                      | `/voice`, `/voice hold`, `/voice tap`, `/voice off`, `/voice status`              |
@@ -310,6 +311,59 @@ In headless (`--prompt`) or non-interactive contexts, `/diff` prints a plain-tex
    +3  -2  README.md
 ```
 
+**Web Shell:** In the Web Shell UI (`qwen serve`), `/diff` opens a graphical diff dialog. A tab bar at the top lets you switch between the **Changes** view and the **History** view (`/log`).
+
+#### History Viewer (`/log`) — Web Shell only
+
+The `/log` command opens a commit history browser for the current workspace. It is available only in the Web Shell UI; the CLI/TUI does not have this command.
+
+**How it works:**
+
+`/log` opens a dialog listing commits in reverse chronological order (newest first). Each row shows:
+
+- Short SHA (monospace, with a copy button for the full SHA)
+- Commit subject (single line)
+- Author name and relative time (e.g. "2h ago")
+- Branch/tag ref labels, when present
+- A merge icon (⎇) for merge commits
+
+Click a commit row to expand its details on demand:
+
+- Full commit message body
+- File change statistics (files changed, lines added/removed, per-file breakdown)
+
+Use **Load more** at the bottom to fetch the next page of commits (50 per page).
+
+**Example:**
+
+```
+┌─ History ──────────────────────────── 50 commits ─ ✕ ┐
+│                                                       │
+│  a1b2c3d  feat(cli): add --json flag        2h ago   │
+│           wenshao                                    │
+│                                                       │
+│  e4f5g6h  fix(core): handle null config     5h ago   │
+│           dev · main  v1.2.0                         │
+│                                                       │
+│ ▼ 789abcd  refactor: simplify parser        1d ago   │
+│   ┌─────────────────────────────────────────────┐    │
+│   │  Broke the monolithic parse() into smaller  │    │
+│   │  functions for readability.                 │    │
+│   │                                             │    │
+│   │  3 files · +45 −12                          │    │
+│   │   +30 −8   src/parser.ts                    │    │
+│   │   +10 −2   src/utils.ts                     │    │
+│   │   +5  −2   test/parser.test.ts              │    │
+│   └─────────────────────────────────────────────┘    │
+│                                                       │
+│              [ Load more ]                            │
+└───────────────────────────────────────────────────────┘
+```
+
+> [!note]
+>
+> `/log` requires a git repository workspace. If the workspace is not a git repository or has no commits, the dialog shows a placeholder message.
+
 ### 1.9 Information, Settings, and Help
 
 Commands for obtaining information and performing system settings.

package/bundled/qc-helper/docs/integration-github-action.md

@@ -96,7 +96,7 @@ This workflow acts as a central dispatcher for Qwen Code CLI, routing requests t
 
 ### Issue Triage
 
-This action can be used to triage GitHub Issues automatically or on a schedule. For a working issue triage setup, see the [automated issue triage workflow](https://github.com/QwenLM/qwen-code/blob/main/.github/workflows/qwen-automated-issue-triage.yml).
+This action can be used to triage GitHub Issues automatically or on demand. For a working issue triage setup, see the [Qwen triage workflow](https://github.com/QwenLM/qwen-code/blob/main/.github/workflows/qwen-triage.yml).
 
 ### Pull Request Review
 

package/bundled/qc-helper/docs/qwen-serve.md

@@ -66,7 +66,7 @@ qwen serve
 
 The default bind is `127.0.0.1:4170`. Bearer auth is **off** on loopback so local development "just works". The daemon registers the current working directory as its primary workspace; use an absolute `--workspace /path/to/dir` to override it, and repeat the flag to register additional isolated runtimes.
 
-**Open the Web Shell UI.** Browse to `http://127.0.0.1:4170/` (or start the daemon with `qwen serve --open` to launch it automatically) for the full browser terminal — chat, diffs, tool calls, and permission prompts. The UI is served at the daemon root on the same origin as the API. The rest of this guide uses raw HTTP so you can script against the API directly.
+**Open the Web Shell UI.** Browse to `http://127.0.0.1:4170/` (or start the daemon with `qwen serve --open` to launch it automatically) for the full browser terminal — chat, diffs, commit history, tool calls, and permission prompts. The UI is served at the daemon root on the same origin as the API. The rest of this guide uses raw HTTP so you can script against the API directly.
 
 ### 2. Sanity-check it
 
@@ -397,6 +397,7 @@ Notes:
 | `--mcp-client-budget <n>`               | —               | Positive integer cap on live MCP clients. When `mcp_workspace_pool` is advertised, the cap and transports are shared per workspace runtime; when the tag is absent, the legacy per-session manager enforces it. Combine with `--mcp-budget-mode`. When unset, no accounting-driven enforcement (but `GET /workspace/mcp` still reports `clientCount`). Distinct from claude-code's `MCP_SERVER_CONNECTION_BATCH_SIZE`, which gates startup concurrency rather than total live clients. Pre-flight `caps.features.mcp_guardrails` and `caps.features.mcp_workspace_pool`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `--mcp-budget-mode <m>`                 | `warn` / `off`  | How `--mcp-client-budget` is enforced. `warn` (default when budget set): no refusal, snapshot's `budgets[0].status` flips to `warning` at ≥75% of budget. `enforce`: connects past the cap are refused, per-server cell shows `disabledReason: 'budget'`, deterministic by `mcpServers` declaration order. `off` (default when budget unset): pure observability. Boot rejects `enforce` without a budget.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `--http-bridge`                         | `true`          | Stage 1 mode: production attempts to preheat one primary `qwen --acp` child for compatibility and retries on first use after failure, while each trusted secondary can start one child on demand. Sessions targeting a runtime multiplex onto its child via ACP `newSession()`; untrusted secondaries cannot start ACP. Stage 2 native in-process becomes available later.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `--initialize-timeout-ms <n>`           | `10000`         | ACP child request timeout, including the `initialize` handshake (ms). Must be a positive integer up to `2147483647`. Values above the JS timer ceiling (`2^31-1`) are rejected at boot because Node silently compresses them to 1 ms. Cold-container deployments that need extra headroom for child startup can raise this; the same value governs `newSession`, workspace-status polls, and other ACP ext-method deadlines.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | `--allow-origin <pat>`                  | —               | T2.4 ([#4514](https://github.com/QwenLM/qwen-code/issues/4514)). Cross-origin allowlist for browser webui clients. Repeatable. Each value is `*` (any origin — boot refuses if no bearer token is configured; `--require-auth` on loopback is recommended so `/health` and `/demo` are also bearer-gated, since both are pre-auth on loopback by default) or a canonical URL origin (`<scheme>://<host>[:<port>]`, no trailing slash / path / userinfo / query). **Subdomain wildcards (`https://*.example.com`) are intentionally unsupported** — list each subdomain explicitly, or use `*` with a configured token (and `--require-auth` for full hardening). Matched origins receive CORS response headers (`Access-Control-Allow-Origin`, `Vary: Origin`, methods, headers, max-age, and exposed `Retry-After`); unmatched origins still get a 403 with the same envelope as today's wall. `Origin: null` (sandboxed iframes, file:// docs) is always rejected, even under `*`. Pre-flight via `caps.features.allow_origin`. Loopback self-origin hits are unaffected. |
 | `--web` / `--no-web`                    | `true`          | Serve the built Web Shell SPA at the daemon root (`GET /`, `/assets/*`, and SPA deep-link fallback). The static shell is registered **before** the bearer-auth gate — a browser can't attach a token to a `<script>` subresource or an address-bar navigation, the shell carries no secrets, and every API route stays token-gated regardless. On non-loopback binds a one-line stderr warning notes the UI is reachable without auth. Use `--no-web` for an API-only daemon. No effect when the build omits the Web Shell assets (the daemon logs a breadcrumb and runs API-only).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `--open`                                | `false`         | After the listener is up, open the Web Shell in your default browser at the daemon URL (with `#token=` appended as a URL fragment when a token is configured — a fragment is never sent to the server, keeping the token out of access logs and Referer headers). No-op with `--no-web`, or in headless / CI / SSH environments where no browser is available.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
@@ -712,16 +713,48 @@ const result = await flow.awaitCompletion({ signal: abortCtrl.signal });
 
 ## Daemon log file
 
-`qwen serve` writes a per-process diagnostic log to:
+`qwen serve` appends diagnostic records across normal restarts at the stable
+active path:
 
 ```
-${QWEN_RUNTIME_DIR or ~/.qwen}/debug/daemon/serve-<pid>-<workspaceHash>.log
+${QWEN_RUNTIME_DIR or ~/.qwen}/debug/daemon/daemon.log
 ```
 
-A `latest` symlink in the same directory always points at the current process's log, so `tail -f ~/.qwen/debug/daemon/latest` will follow whichever daemon is running.
+Every file record includes a random per-start `runId` and the daemon PID. A
+successful stable owner also updates `debug/daemon/latest` to `daemon.log` on
+platforms that support symlinks. On macOS/Linux, follow rotation with:
+
+```bash
+tail -F ~/.qwen/debug/daemon/daemon.log
+```
+
+On other platforms, configure the viewer to reopen the pathname after it is
+replaced. A viewer that keeps only the old file handle will remain on the
+archive after rotation.
 
 The log captures lifecycle messages, route errors (with `route=` and `sessionId=` context), ACP child stderr, and — when `QWEN_SERVE_DEBUG=1` is set — extra bridge breadcrumbs. Lines that go to stderr today still go to stderr; the file log is **additive**, not a replacement.
 
+The active file rotates before it would exceed 10 MiB. Each family retains
+four archives under `archive/`, and each file record is capped at 256 KiB. The
+in-memory queue accepts at most 4 MiB of unsettled file payload. Queue pressure,
+rotation failures, or filesystem failures can therefore drop file copies;
+`GET /daemon/status?detail=full` exposes logger health, issues, and dropped
+record/byte counters.
+
+Only one daemon may own the stable family in a log namespace. A concurrent
+daemon writes to `debug/daemon/runs/run-<runId>/daemon.log`; the startup banner
+and full status contain the authoritative path. `runs/recent-fallback` is a
+best-effort locator for a recent fallback family and may point to one that is
+still live. A healthy namespace converges to roughly 100 MiB: about 50 MiB for
+stable plus one inactive fallback family. Live or not-yet-stale fallback
+families are retained, so concurrent daemons or crash/restart storms can
+temporarily use more.
+
+One runtime directory is one ownership and retention namespace. Use distinct
+`QWEN_RUNTIME_DIR` values when daemons need independent history. New daemon log
+directories are private to the user (`0700`) and new files use `0600` on POSIX.
+There is no age-based expiry.
+
 ### Disabling
 
 Set `QWEN_DAEMON_LOG_FILE=0` (or `false`/`off`/`no`) to skip file logging entirely. Stderr output is unaffected.
@@ -730,9 +763,14 @@ Set `QWEN_DAEMON_LOG_FILE=0` (or `false`/`off`/`no`) to skip file logging entire
 
 Session-scoped debug logs (`~/.qwen/debug/<sessionId>.txt` and the `~/.qwen/debug/latest` symlink) are independent. The daemon log lives in a sibling `daemon/` subdirectory; per-session debug semantics are unchanged by this feature.
 
-### No rotation
+### External rotation
 
-The daemon log appends indefinitely. Rotate manually if it grows large. A future enhancement may add automatic rotation; track via [#4548](https://github.com/QwenLM/qwen-code/issues/4548) follow-ups.
+Do not point an external logrotate rule at the active `daemon.log`. The daemon
+is the sole supported writer and rotator; external rename, deletion, or
+truncation invalidates its size model. Copying or shipping records without
+mutating the family is safe. Older `serve-<pid>.log` and
+`serve-<pid>-<workspaceHash>.log` files are left untouched and are not counted
+by the new retention policy.
 
 ## Runtime MCP server management (issue [#4514](https://github.com/QwenLM/qwen-code/issues/4514))
 

package/bundled/review/DESIGN.md

@@ -301,7 +301,7 @@ Seven rounds of review-the-review on this PR converged on one diagnosis: the ski
 The resolution is the same one this document already records for presubmit and cleanup: judgment stays in the prompt, bookkeeping moves to tested subcommands that version together with the skill.
 
 - **`parse-args`** owns the grammar. Every previously-shipped parsing bug is a named row in its table-driven tests. The raw string travels **on stdin** (`--stdin` with a quoted heredoc), never as a positional: a flag-first raw string (`/review --effort low`) is consumed by the CLI's own strict parser before the handler runs, and a positional also breaks on quotes and shell metacharacters. Pure-function tests could not see that class — the documented invocation failed only when run against the built binary — so the suite includes yargs-level wiring tests alongside the table.
-- **`compose-review`** owns event selection and body composition — the C/S table (counting body Criticals and discarded Suggestions), the event caps (cannot-tell existing Criticals, uncoverable chunks, unreviewed dimensions, context-unavailable), the downgrade carve-outs, and the clause composition. Its truth-table tests pin each shipped bug; writing them immediately caught one more instance of the class (all Suggestions discarded → S=0 → APPROVE). The input is validated at the boundary: the producer is a model writing JSON that omits inapplicable fields, so absent counts default to zero and malformed values throw typed errors — before that, an omitted count meant `undefined + 1 = NaN`, which fails every event comparison and would have returned APPROVE over a body-only blocker. 422 recovery stops being a hand-derived recomposition: it is the same call with updated counts, so the "recompute may never upgrade the verdict" guarantee holds by construction.
+- **`compose-review`** owns event selection and body composition — the C/S table (counting body Criticals and discarded Suggestions), the event caps (cannot-tell existing Criticals, uncoverable chunks, unreviewed dimensions, context-unavailable), the downgrade carve-outs, and the clause composition. Its truth-table tests pin each shipped bug; writing them immediately caught one more instance of the class (all Suggestions discarded → S=0 → APPROVE). The input is validated at the boundary: the producer is a model writing JSON that omits inapplicable fields, so absent counts default to zero and malformed values throw typed errors — before that, an omitted count meant `undefined + 1 = NaN`, which fails every event comparison and would have returned APPROVE over a body-only blocker. 422 recovery stops being a hand-derived recomposition: it is the same call with the updated `--comments` file (the inline counts are counted from the drafted comments, never typed — a dogfooded report-only run dropped the typed count while moving its one Critical inline, and the verdict line read Approve over it), so the "recompute may never upgrade the verdict" guarantee holds by construction.
 - **`pr-context`** ends the fetch-prose chain at its root: review bodies **and every blocker-bearing body** render **in full** (a body-only blocker lives only there; a capped body names its review or comment id so the tail stays fetchable one object at a time, and reply snippets name their comment id when cut), and blocker-bearing threads are quarantined into a "Blockers to re-check" section instead of settling into "Already discussed" — a reply alone never retires a blocker. The `gh` wrapper's `maxBuffer` rises to 64 MiB, closing the ENOBUFS that killed two subcommands mid-review on a comment-heavy PR.
 
 What deliberately stays prose: everything judgment-shaped — what counts as a Critical, verification, the posting gate's authorization semantics, the angles. A truth table cannot decide whether a finding is real; it can guarantee that a real finding is never mislabeled, dropped by a downgrade, or approved past.
@@ -384,7 +384,7 @@ No new `compose-review` input was needed: `cannot tell` already caps the event.
 
 Six concurrent real-PR runs (batch 3) produced three targeted changes, each fixing something the batch measured rather than predicted:
 
-- **Overlap disposal is deterministic.** presubmit's overlap report used to end in "ask the user whether to proceed" — 2 of 6 runs stalled on an improvised interactive question (fatal for a headless run) while the other 4 proceeded, the signature of an under-specified decision point. An overlap is a duplicate by the Exclusion Criteria; the rule is now drop, note in the terminal, continue — and the counts handed to `compose-review` shrink accordingly, so a dropped finding can never flip the verdict.
+- **Overlap disposal is deterministic.** presubmit's overlap report used to end in "ask the user whether to proceed" — 2 of 6 runs stalled on an improvised interactive question (fatal for a headless run) while the other 4 proceeded, the signature of an under-specified decision point. An overlap is a duplicate by the Exclusion Criteria; the rule is now drop, note in the terminal, continue — and the comments file `compose-review` counts from shrinks accordingly, so a dropped finding can never flip the verdict.
 - **Host routing is a flag, not prose.** The GH_HOST-by-prefix instruction survived exactly one review round before a reviewer noted the model must remember it per call. `--host` on `fetch-pr` / `pr-context` / `presubmit` routes every wrapped `gh` call in code (`lib/gh.ts` `setGhHost`/`ghEnv`), leaving the prose rule only for the handful of `gh` commands the orchestrating model runs directly.
 - **A fixed completion line.** Three different completion phrasings across one batch each needed their own detection regex in the batch driver. Step 9 now ends every run with `Review complete: <target> — <disposition>`, greppable by `^Review complete: `.
 

package/bundled/review/SKILL.md

@@ -382,7 +382,7 @@ A check you perform silently is a check you skip, and this one has been skipped:
 
 **Every agent MUST return inline: set `subagent_type: "general-purpose"` and `run_in_background: false` on every `agent` call.** Do NOT fork them — never set `subagent_type: "fork"`. A fork runs fire-and-forget and its findings never come back to you, so the review would stall in Step 4 with nothing to aggregate. You need every agent's findings returned to you inline.
 
-**For same-repo PR reviews (worktree mode), every `agent` call MUST also set `working_dir: "<worktreePath>"`** — the `worktreePath` from the Step 1 fetch report (a repo-relative path like `.qwen/tmp/review-pr-<n>`; pass it through as-is). This sets each agent's working directory to the PR worktree, so its `git diff`, `grep_search`, file reads, and Agent 7's build/test **resolve against the PR's code, not the user's main checkout**. It is a deterministic, harness-level cwd pin — it does NOT depend on the agent remembering to `cd`, and it is what makes reviewing multiple PRs concurrently safe. (It pins the working directory; it is not a hard filesystem sandbox — an absolute path could still reach elsewhere — but normal review operations stay inside the worktree.) This rule applies to **every** agent the review workflow launches — not just the Step 3 dimension agents, but also the Step 4 verification agent and the Step 5 reverse-audit agents (both restated below). Do NOT set `working_dir` for **local-diff, file-path, or cross-repo lightweight** reviews — those have no worktree, so the agents run in the main project directory.
+**For same-repo PR reviews (worktree mode), every `agent` call MUST also set `working_dir: "<worktreePath>"`** — the `worktreePath` from the Step 1 fetch report (a repo-relative path like `.qwen/tmp/review-pr-<n>`; pass it through as-is). This sets each agent's working directory to the PR worktree, so its `git diff`, `grep_search`, file reads, and Agent 7's build/test **resolve against the PR's code, not the user's main checkout**. It is a deterministic, harness-level cwd pin — it does NOT depend on the agent remembering to `cd`, and it is what makes reviewing multiple PRs concurrently safe. (It pins the working directory; it is not a hard filesystem sandbox — an absolute path could still reach elsewhere — but normal review operations stay inside the worktree.) This rule applies to **every** agent the review workflow launches — not just the Step 3 dimension agents, but also the Step 4 verification agent and the Step 5 reverse-audit agents (both restated below). Do NOT set `working_dir` for **local-diff, file-path, or cross-repo lightweight** reviews — those have no worktree, so the agents run in the main project directory. **Do NOT set `isolation` on review agents.** `isolation: "worktree"` creates a brand-new worktree copy of the repo; the review worktree already exists at `worktreePath`, and `isolation` is mutually exclusive with `working_dir` — passing both fails every agent call with a parameter error and the review produces nothing.
 
 **You no longer compose these prompts. `qwen review agent-prompt` does** — one `--roster` call builds every one of them, and each block it prints goes to its agent unedited. It already contains everything the list below used to ask you to remember: `diffPathAbsolute` and the exact `read_file` ranges for that role (its own `offset`/`limit` for a chunk agent; every chunk for a whole-diff or 3A agent; the post-change file plus `addedRanges[]` and its own `diffRange` for an invariant agent), the agent's focus areas, the severity definitions verbatim, the finding format, and the project rules. **Never give an agent a `git diff` command** — see "Diff capture and the review topology" in Step 1 for why. In worktree-mode PR reviews the agent's `working_dir` is the PR worktree, so `grep_search` and source-file reads resolve against the PR's code automatically — the agent must NOT `cd` into the worktree or prefix absolute paths for those.
 
@@ -481,10 +481,11 @@ Write this shard's findings to a file — each with its file, line, issue and fa
 ```bash
 "${QWEN_CODE_CLI:-qwen}" review agent-prompt --plan <the plan report from Step 1> --role verify \
   --findings <the file of this shard's findings> \
-  [--rules <the rules file from Step 2, if the project has any>]
+  [--rules <the rules file from Step 2, if the project has any>] \
+  [--round <k> — on a repeat verification round (new findings arriving from Step 5), so the label and the record key are the CLI's, not yours]
 ```
 
-**`--findings` is required for this role — the command refuses without it**, because a bare block is a block you would assemble by hand, and hand-assembly is the one step this skill measured drifting. **Paste what it prints verbatim — the whole block, findings and all. Do not prepend, append, reword, or add a shard number.** Dogfooded twice: the step that used to have you prepend the list by hand is where the prompt got paraphrased — a summary inserted, the "nothing replaces the brief" line truncated — and Step 6's check caught it and capped the verdict. The command records the exact block it prints — findings included, keyed per findings digest — so a launch that drops or rewrites the findings matches no record. In worktree mode the verifier's `working_dir` is the PR worktree (same rule as Step 3), so its reads and re-checks resolve against the PR's code.
+**`--findings` is required for this role — the command refuses without it**, because a bare block is a block you would assemble by hand, and hand-assembly is the one step this skill measured drifting. **Paste what it prints verbatim — the whole block, findings and all. Do not prepend, append, reword, or add a shard number** (a repeat round passes `--round <k>` and the CLI bakes the label in). Dogfooded twice: the step that used to have you prepend the list by hand is where the prompt got paraphrased — a summary inserted, the "nothing replaces the brief" line truncated — and Step 6's check caught it and capped the verdict. The command records the exact block it prints — findings included, keyed per findings digest — so a launch that drops or rewrites the findings matches no record. In worktree mode the verifier's `working_dir` is the PR worktree (same rule as Step 3), so its reads and re-checks resolve against the PR's code.
 
 The brief holds the method the orchestrator used to spell out here and that a paraphrase kept dropping: trace the failure scenario through the real code rather than voting on the finding's prose; engage the diff's own documented intent before calling a documented change a regression (the rule a run skipped when it auto-posted a false "leaks tokens" Critical); and the one-way, quote-the-contradiction bar on **rejecting a Critical**. Read the brief to know what a verdict means; do not re-derive it here.
 
@@ -530,18 +531,20 @@ Write **the cumulative list of every confirmed finding so far** (Steps 3-4 plus
 # Step 3A (small diff): one auditor per round, the whole diff.
 "${QWEN_CODE_CLI:-qwen}" review agent-prompt --plan <the plan report from Step 1> --role reverse-audit \
   --findings <the cumulative findings file> \
+  --round <k> \
   [--rules <the rules file from Step 2>]
 
 # Step 3B (large diff): one auditor PER CHUNK per round — ONE call builds them all.
 "${QWEN_CODE_CLI:-qwen}" review agent-prompt --plan <the plan report from Step 1> --role reverse-audit --all-chunks \
   --findings <the cumulative findings file> \
+  --round <k> \
   [--rules <the rules file from Step 2>] \
   > .qwen/tmp/qwen-review-{target}-ra-round<k>.txt
 ```
 
-Redirect and `read_file` it paged, exactly as with `--roster`: one labelled block per chunk, numbered `auditor k of N`, closed by an `end of round` line — launch one agent per block, verbatim. **Never sample the builder's output** (`| head`, `| tail`, a truncated read): the text IS the deliverable, and a real run that sampled each build with `| head -5` never possessed the prompts, hand-reconstructed all ten launches, and had every one flagged rewritten — a full repair round spent recovering from a shortcut that saved nothing. To rebuild a single auditor after a gap: `--chunk <id>` in place of `--all-chunks`.
+Redirect and `read_file` it paged, exactly as with `--roster`: one labelled block per chunk, numbered `auditor k of N`, closed by an `end of round` line — launch one agent per block, verbatim. **Never sample the builder's output** (`| head`, `| tail`, a truncated read): the text IS the deliverable, and a real run that sampled each build with `| head -5` never possessed the prompts, hand-reconstructed all ten launches, and had every one flagged rewritten — a full repair round spent recovering from a shortcut that saved nothing. To rebuild a single auditor after a gap: `--chunk <id>` in place of `--all-chunks`, keeping the same `--findings`, `--rules` and `--round` — a rebuild that drops one of them is keyed as a different launch and matches no requirement.
 
-**`--findings` is required for this role — the command refuses without it** (an early round with nothing confirmed yet passes an empty file; the command tells the auditor so). **Paste what it prints verbatim — the whole block. Do not prepend, append, reword, or add a round number** (track the round in your own notes, not in the prompt). A real run skipped `--findings`, hand-wrote the auditor's launch keeping only the brief pointer, and Step 6's check capped the verdict — the auditors had run and read their brief, but not one of them got the prompt the CLI built. The command records the exact block it prints — findings included, keyed per round's findings digest — so a launch that drops the confirmed list matches no record. It also gives each auditor its diff reads — the whole plan in 3A, one chunk's range in 3B (a Step 3B auditor handed the whole 5 800-line diff is the most context-starved agent in the pipeline, on exactly the PRs where the reverse audit matters most). In worktree mode its `working_dir` is the PR worktree.
+**`--findings` is required for this role — the command refuses without it** (an early round with nothing confirmed yet passes an empty file; the command tells the auditor so). **Pass the round as `--round <k>`** — the CLI bakes it into the identity line and the record key, so two rounds are two receipts even when the findings list has not changed between them. **Paste what it prints verbatim — the whole block. Do not write a round label yourself**: dogfooded, two same-findings rounds shared one record, the orchestrator appended `(round N)` to the identity line to tell its own launches apart, and both rounds were flagged rewritten — a repair round paid for a label the CLI now prints. A real run skipped `--findings`, hand-wrote the auditor's launch keeping only the brief pointer, and Step 6's check capped the verdict — the auditors had run and read their brief, but not one of them got the prompt the CLI built. The command records the exact block it prints — findings included, keyed per round's findings digest — so a launch that drops the confirmed list matches no record. It also gives each auditor its diff reads — the whole plan in 3A, one chunk's range in 3B (a Step 3B auditor handed the whole 5 800-line diff is the most context-starved agent in the pipeline, on exactly the PRs where the reverse audit matters most). In worktree mode its `working_dir` is the PR worktree.
 
 The brief holds what the auditor is for: hunt only the **gaps** no prior agent caught, report only Critical or Suggestion, apply the Exclusion Criteria, and end with a substantive receipt (`No issues found — <what it re-examined>`) — a bare "No issues found." fails the substantive-return check below and triggers the one relaunch.
 
@@ -627,10 +630,11 @@ Two failure modes this closes, both observed in this repo's own dogfood: reporti
 
 ```bash
 "${QWEN_CODE_CLI:-qwen}" review compose-review --input .qwen/tmp/qwen-review-{target}-compose.json \
+  --comments .qwen/tmp/qwen-review-{target}-comments.json \
   --out .qwen/tmp/qwen-review-{target}-composed.json
 ```
 
-It prints a `Verdict:` line to stderr. **That line is the verdict — print it, and nothing else.** It writes nothing, posts nothing, and needs no authorisation, so run it on every high-effort review, whether or not you are going to post. The state file is the same one Step 7 uses (see there for every field): your findings and the states you established — the body Criticals, the discarded suggestions, the `cannot tell` blockers, the unreviewed dimensions, the `planPath`, the presubmit flags, the model id. It does **not** take the coverage or the inline counts. It derives coverage from the harness's transcripts, and Step 7 derives the inline counts from the comments you actually attach.
+It prints a `Verdict:` line to stderr. **That line is the verdict — print it, and nothing else.** It writes nothing, posts nothing, and needs no authorisation, so run it on every high-effort review, whether or not you are going to post. The state file is the same one Step 7 uses (see there for every field): your findings and the states you established — the body Criticals, the discarded suggestions, the `cannot tell` blockers, the unreviewed dimensions, the `planPath`, the presubmit flags, the model id. It does **not** take the coverage or the inline counts, and it **refuses** a state JSON carrying `criticalsInline`/`suggestionsInline`. It derives coverage from the harness's transcripts, and it **counts** the inline findings from `--comments`: write the drafted inline comments to that file first — the same `[{path, line, body, …}]` array the Step 7 payload will carry, each body opening with its `**[Critical]**`/`**[Suggestion]**` marker; a review with nothing anchored inline passes a file containing `[]`. Dogfooded, a report-only run — where no later step recounts — moved its one Critical from `bodyCriticals` to an inline comment, and the verdict line read Approve over a blocker the same report listed; counted from the draft, that finding cannot fall out of the computation. **If the comment set changes after composing** — an anchor fails to resolve, a finding relocates to the body, a comment is dropped — update the comments file (and the state), and run `compose-review` again: the verdict must be computed from the set you actually post, and Step 7's `submit` recounts from the payload to hold you to it.
 
 **It also proves Step 4 and Step 5 ran — the way `check-coverage` proves Step 3.** `check-coverage` runs at Step 3D, before verify and reverse audit exist, so its roster cannot reach them; and their count is not in the plan (verify shards on the finding count, the reverse audit loops until it goes dry), so there is no exact roster to check. What there is is a floor, and `compose-review` — which runs only at high effort, where both steps are part of the contract — checks it from the same transcripts: at least one **reverse auditor** ran and opened its brief (on every high-effort review), and at least one **verifier** did (whenever the review posts findings). A step skipped wholesale, or run with agents that never opened their brief, is named in `unreviewedDimensions` and caps the verdict, exactly like a dimension nobody reviewed. You do not pass a flag for this and cannot turn it off: the proof is the intersection of the prompt the CLI recorded building (`--role verify` / `--role reverse-audit`) and the harness's transcript of an agent that ran it. So a run cannot approve a diff by skipping the pass that looks for what Step 3 missed — the highest-value catch here is a clean, zero-finding review that never ran its reverse audit.
 
@@ -638,8 +642,8 @@ The rules it applies — so you can read the line it gives you, not so you can a
 
 - Only **high-confidence** findings count. Low-confidence ones are terminal-only, under "Needs Human Review".
 - **Approve** — no high-confidence Critical, and no cap state.
-- **Request changes** — one or more high-confidence Criticals, anchored or in the body.
-- **Comment** — suggestions but no blockers, **or** an Approve that a cap took away: an uncoverable chunk, a chunk nobody read, a dimension nobody reviewed, a **reverse audit that never ran** (or a **verifier** that never ran on a review with findings), an existing blocker you could not rule on, a PR whose discussion you could not read. A review that did not read part of the diff — or never looked for what it missed — cannot certify it.
+- **Request changes** — one or more high-confidence Criticals, anchored or in the body, **whose verification is on record** (a deterministic `[build]`/`[test]` finding is pre-confirmed and needs none).
+- **Comment** — suggestions but no blockers, **or** an Approve that a cap took away: an uncoverable chunk, a chunk nobody read, a dimension nobody reviewed, a **reverse audit that never ran**, an existing blocker you could not rule on, a PR whose discussion you could not read. A review that did not read part of the diff — or never looked for what it missed — cannot certify it. **Or a Request changes whose blockers were never verified**: the findings still post, disclosed as unverified, but an unverified finding must not become a public blocker — a run whose verifier never launched posted a CHANGES_REQUESTED onto an external contributor's PR over a Critical its own body disclosed as unverified, and this row is what stops the next one.
 
 **Why this is a command and not a paragraph.** It was a paragraph, and the paragraph was skipped. Dogfooded, a run read the coverage check's refusal, concluded that "the agents clearly did their job", never called `compose-review` at all, and printed **`Review complete — Approve`** — a verdict it had composed itself, from prose, on a review whose gate had just refused. There is now one place a verdict exists. Skipping the command does not get you a different one; it gets you none.
 
@@ -819,7 +823,7 @@ Rationale: an inline comment is the only place GitHub renders a ` ```suggestion
 - `presubmit` — `downgradeApprove` / `downgradeRequestChanges` / `downgradeReasons` from the presubmit report. Do not apply a downgrade by hand; hand it over and let `submit` own the semantics (a Suggestion-only review is already `COMMENT`, so nothing is downgraded and no "downgraded from Approve" sentence is emitted).
 - `modelId` — for the footer.
 
-The verdict is a computed fact and this is the second place it must not be re-derived: Step 6 printed it from this same `state`, and `submit` will post it from this same `state`. What the machine guarantees (its tests pin all of it): `REQUEST_CHANGES` whenever any Critical is confirmed, inline or body-only; `COMMENT` for a Suggestion-only run and for every capped or downgraded outcome; `APPROVE` only for a clean, uncapped, undowngraded, zero-finding run whose coverage the transcripts confirm. A cap state forbids `APPROVE` but never softens a `REQUEST_CHANGES`; body Criticals count toward `C`; the "no blockers" opener appears only when the review can certify it. Two live failures this replaces: a review that filed three Suggestions and then publicly `APPROVE`d the PR (#6584), and a Suggestion that would not anchor becoming a second paragraph of the public body (#6631) — both impossible now, because the caller no longer writes the event or the body.
+The verdict is a computed fact and this is the second place it must not be re-derived: Step 6 printed it from this same `state`, and `submit` will post it from this same `state`. What the machine guarantees (its tests pin all of it): `REQUEST_CHANGES` whenever any Critical is confirmed, inline or body-only; `COMMENT` for a Suggestion-only run and for every capped or downgraded outcome; `APPROVE` only for a clean, uncapped, undowngraded, zero-finding run whose coverage the transcripts confirm. A **coverage** cap forbids `APPROVE` but never softens a `REQUEST_CHANGES`; the one exception is the unverified-blockers cap, which softens it to `COMMENT` (findings still posted, disclosed as unverified); body Criticals count toward `C`; the "no blockers" opener appears only when the review can certify it. Two live failures this replaces: a review that filed three Suggestions and then publicly `APPROVE`d the PR (#6584), and a Suggestion that would not anchor becoming a second paragraph of the public body (#6631) — both impossible now, because the caller no longer writes the event or the body.
 
 - `comments`: high-confidence **Critical and Suggestion** findings. Skip Nice to have and low-confidence. Each must reference a line in the diff — the `line` `resolve-anchors` computed, never one you derived.
 - **Multi-line anchors get a `start_line` — and both `side` fields with it.** When a finding's resolution has `startLine !== line`, GitHub can highlight the whole construct instead of just its last line — the `if` and its condition, the three lines of a broken guard — which is something a bare line number could not express, and it is free: the resolver already computed both ends. But GitHub requires **`side` and `start_side` on any multi-line comment**, and rejects the whole review with a 422 without them. Emit all four together, or none:

package/chunks/{MaxSizedBox-QOXLJGAF.js → MaxSizedBox-EE76OHAP.js}

@@ -4,58 +4,61 @@ import {
   MINIMUM_MAX_HEIGHT,
   MaxSizedBox,
   setMaxSizedBoxDebugging
-} from "./chunk-NUHSLBJZ.js";
-import "./chunk-GEHSF7MS.js";
-import "./chunk-XAAEDML2.js";
+} from "./chunk-JNWZQ27S.js";
+import "./chunk-GMGDLUC7.js";
+import "./chunk-SV5PQVQE.js";
+import "./chunk-AYCDXHZB.js";
+import "./chunk-NEEB7UEN.js";
+import "./chunk-5QWWOFGG.js";
 import "./chunk-NHDKSOEY.js";
-import "./chunk-J6NT5YTN.js";
+import "./chunk-RS7MT2QG.js";
+import "./chunk-H2XVO6NE.js";
 import "./chunk-QHTIBUWB.js";
-import "./chunk-HTHUX2T5.js";
 import "./chunk-RKUWKYED.js";
-import "./chunk-GCY7QTCE.js";
+import "./chunk-NO6XTCYT.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-T4TZQJ7W.js";
 import "./chunk-H6XPXXMH.js";
-import "./chunk-LKR7QQ63.js";
-import "./chunk-4XCVGEEX.js";
-import "./chunk-XSPFQQRE.js";
-import "./chunk-4RPARQ5D.js";
+import "./chunk-EAUYY7SS.js";
+import "./chunk-FSL5W5TI.js";
+import "./chunk-OONJNQ42.js";
+import "./chunk-D2VIDMVM.js";
 import "./chunk-E2UVIFI2.js";
 import "./chunk-XU457J4V.js";
 import "./chunk-VDDGDZMA.js";
-import "./chunk-J2MKYJKZ.js";
+import "./chunk-EIAK6Q2B.js";
 import "./chunk-SZRN75WQ.js";
 import "./chunk-HTO4JFDZ.js";
 import "./chunk-CPBF7KYF.js";
-import "./chunk-UOA2IHRI.js";
+import "./chunk-CPCVCKKF.js";
 import "./chunk-6AM5D4ME.js";
-import "./chunk-OSSDHJDU.js";
-import "./chunk-SGPFJMRP.js";
-import "./chunk-335ECZTA.js";
-import "./chunk-JCJPZMJV.js";
-import "./chunk-2CCDMJM7.js";
-import "./chunk-6ETOSWAO.js";
+import "./chunk-G45X5TRN.js";
+import "./chunk-PBATSWUQ.js";
+import "./chunk-ZEOZL37W.js";
+import "./chunk-OOCI5VVU.js";
+import "./chunk-25Y6JSH2.js";
+import "./chunk-246TW4IX.js";
 import "./chunk-JESCGQM3.js";
-import "./chunk-CPU6I5YV.js";
+import "./chunk-P64HXIC5.js";
 import "./chunk-4WKAA4KS.js";
 import "./chunk-CR3C7WXL.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-LPHGXXZX.js";
-import "./chunk-4CA4WUMS.js";
-import "./chunk-VAJS2E2D.js";
-import "./chunk-WEPXQKGP.js";
-import "./chunk-ANRANWVE.js";
+import "./chunk-JD3MKVKL.js";
+import "./chunk-UEY4AYUL.js";
+import "./chunk-BDBMYST4.js";
+import "./chunk-EZVDJFZ7.js";
+import "./chunk-OP4MOGXF.js";
 import "./chunk-XVNQMZ2I.js";
 import "./chunk-FEOZBUMT.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-4CHDYDG3.js";
-import "./chunk-V4PCIS25.js";
+import "./chunk-6EFTQYW7.js";
+import "./chunk-FZVSFBNW.js";
 import "./chunk-A4UCTEB5.js";
 import "./chunk-XWRJCPHC.js";
 import "./chunk-TYQMGACW.js";
 import "./chunk-TYAMGABM.js";
 import "./chunk-FCMNKVXT.js";
-import "./chunk-UE5TZ55T.js";
+import "./chunk-C27BYUX6.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";

package/chunks/{StandaloneSessionPicker-FLV6CGYJ.js → StandaloneSessionPicker-WZH4PC3K.js}

@@ -2,45 +2,50 @@
 "use strict";
 import {
   ConfigContext,
-  SessionPicker
-} from "./chunk-N47VAEAJ.js";
-import "./chunk-GFYFLDEG.js";
-import {
+  SessionPicker,
   SettingsContext
-} from "./chunk-EDFD7VOX.js";
+} from "./chunk-XZOBDSDG.js";
+import "./chunk-2ITGJJE2.js";
 import {
   KeypressProvider
-} from "./chunk-MRE77ST5.js";
+} from "./chunk-R5N7NF5D.js";
+import "./chunk-7KGXAXF7.js";
+import "./chunk-2GOPPEHK.js";
+import "./chunk-QKYTTBYW.js";
 import "./chunk-4WGODMVR.js";
 import "./chunk-KW7NOTN6.js";
-import "./chunk-NUHSLBJZ.js";
+import "./chunk-JNWZQ27S.js";
+import "./chunk-GMGDLUC7.js";
+import {
+  require_jsx_runtime
+} from "./chunk-SV5PQVQE.js";
+import "./chunk-AYCDXHZB.js";
 import {
   Box_default,
   render_default,
-  require_jsx_runtime,
   use_app_default
-} from "./chunk-GEHSF7MS.js";
-import "./chunk-XAAEDML2.js";
-import "./chunk-NHDKSOEY.js";
-import "./chunk-VEFR4XJQ.js";
-import "./chunk-HZ4M2UQD.js";
-import "./chunk-J6NT5YTN.js";
-import "./chunk-QHTIBUWB.js";
-import "./chunk-76BFY7AF.js";
+} from "./chunk-NEEB7UEN.js";
 import {
   require_react
-} from "./chunk-HTHUX2T5.js";
+} from "./chunk-5QWWOFGG.js";
+import "./chunk-NHDKSOEY.js";
+import "./chunk-W3BKN3LO.js";
+import "./chunk-6RVJRVQR.js";
+import "./chunk-RS7MT2QG.js";
+import "./chunk-H2XVO6NE.js";
+import "./chunk-QHTIBUWB.js";
+import "./chunk-QTERJVPZ.js";
 import "./chunk-E5Z2AVNV.js";
 import "./chunk-57OAHC2Y.js";
-import "./chunk-42VIHAYT.js";
-import "./chunk-6IITZE7O.js";
+import "./chunk-B452RETY.js";
+import "./chunk-5JX5EWR5.js";
 import "./chunk-RKUWKYED.js";
 import "./chunk-GOXKNSDZ.js";
 import "./chunk-IDS7MSUP.js";
-import "./chunk-TKASNYDS.js";
-import "./chunk-PR5XQ73G.js";
+import "./chunk-6DHWO5ZF.js";
+import "./chunk-KTNIZG2C.js";
 import "./chunk-QRUIS3DN.js";
-import "./chunk-GMUPIMHF.js";
+import "./chunk-4RA7PWIY.js";
 import "./chunk-ALGGS7UH.js";
 import "./chunk-MR3PXB6E.js";
 import {
@@ -49,51 +54,51 @@ import {
 import {
   SessionService,
   getGitBranch
-} from "./chunk-GCY7QTCE.js";
+} from "./chunk-NO6XTCYT.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-T4TZQJ7W.js";
 import "./chunk-H6XPXXMH.js";
-import "./chunk-LKR7QQ63.js";
-import "./chunk-4XCVGEEX.js";
-import "./chunk-XSPFQQRE.js";
-import "./chunk-4RPARQ5D.js";
+import "./chunk-EAUYY7SS.js";
+import "./chunk-FSL5W5TI.js";
+import "./chunk-OONJNQ42.js";
+import "./chunk-D2VIDMVM.js";
 import "./chunk-E2UVIFI2.js";
 import "./chunk-XU457J4V.js";
 import "./chunk-VDDGDZMA.js";
-import "./chunk-J2MKYJKZ.js";
+import "./chunk-EIAK6Q2B.js";
 import "./chunk-SZRN75WQ.js";
 import "./chunk-HTO4JFDZ.js";
 import "./chunk-CPBF7KYF.js";
-import "./chunk-UOA2IHRI.js";
+import "./chunk-CPCVCKKF.js";
 import "./chunk-6AM5D4ME.js";
-import "./chunk-OSSDHJDU.js";
-import "./chunk-SGPFJMRP.js";
-import "./chunk-335ECZTA.js";
-import "./chunk-JCJPZMJV.js";
-import "./chunk-2CCDMJM7.js";
-import "./chunk-6ETOSWAO.js";
+import "./chunk-G45X5TRN.js";
+import "./chunk-PBATSWUQ.js";
+import "./chunk-ZEOZL37W.js";
+import "./chunk-OOCI5VVU.js";
+import "./chunk-25Y6JSH2.js";
+import "./chunk-246TW4IX.js";
 import "./chunk-JESCGQM3.js";
-import "./chunk-CPU6I5YV.js";
+import "./chunk-P64HXIC5.js";
 import "./chunk-4WKAA4KS.js";
 import "./chunk-CR3C7WXL.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-LPHGXXZX.js";
-import "./chunk-4CA4WUMS.js";
-import "./chunk-VAJS2E2D.js";
-import "./chunk-WEPXQKGP.js";
-import "./chunk-ANRANWVE.js";
+import "./chunk-JD3MKVKL.js";
+import "./chunk-UEY4AYUL.js";
+import "./chunk-BDBMYST4.js";
+import "./chunk-EZVDJFZ7.js";
+import "./chunk-OP4MOGXF.js";
 import "./chunk-XVNQMZ2I.js";
 import "./chunk-FEOZBUMT.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-4CHDYDG3.js";
-import "./chunk-V4PCIS25.js";
+import "./chunk-6EFTQYW7.js";
+import "./chunk-FZVSFBNW.js";
 import "./chunk-A4UCTEB5.js";
 import "./chunk-XWRJCPHC.js";
 import "./chunk-TYQMGACW.js";
 import "./chunk-TYAMGABM.js";
 import "./chunk-FCMNKVXT.js";
-import "./chunk-UE5TZ55T.js";
-import "./chunk-KMJOMWHE.js";
+import "./chunk-C27BYUX6.js";
+import "./chunk-WRRF6TEQ.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";