Thanks for the PR!

Template looks good ✓

On direction: this solves a genuine UX gap — when the self-hosted ecs-qwen runner is busy, there's zero feedback in the PR conversation, which looks broken. A fast acknowledgement on ubuntu-latest before the heavy review job starts is the right architecture. The linked issue #4846 confirms this is a real pain point.

On approach: the scope is tight — one job, one step, 42 lines added. The if conditions correctly mirror the review-pr job's explicit-trigger branches (issue_comment, pull_request_review_comment, pull_request_review) while intentionally omitting pull_request_target and workflow_dispatch (those don't need an ack). Permissions (pull-requests: read + issues: write) are appropriate for posting a PR comment via gh pr comment.

One minor observation: the ack-review-request job has no concurrency group, so rapid repeated /review comments would each post a separate ack. Low-risk since the review job's own concurrency group with cancel-in-progress handles dedup on the heavy side. Not a blocker.

Moving on to code review. 🔍

— Qwen Code · qwen3.7-max

Code Review

The diff is 42 lines added to a single workflow file, and it's clean:

• Trigger conditions correctly mirror the three explicit-trigger branches from review-pr (issue_comment, pull_request_review_comment, pull_request_review). The pull_request_target and workflow_dispatch events are intentionally excluded — those don't need an ack since they either auto-fire or are manually triggered with visible UI.
• Permissions are properly scoped: pull-requests: read for reading PR data, issues: write for posting the comment via gh pr comment. No unnecessary permissions.
• runs-on: ubuntu-latest is the right choice — this job needs to start fast to give immediate feedback, which is the whole point. The self-hosted runner is reserved for the actual review.
• Environment variables are properly quoted with ${{ }} expressions. The PR_NUMBER and RUN_URL are derived from GitHub context (not user input), so no injection risk.
• YAML formatting passes Prettier. YAML syntax is valid.

No correctness bugs, security issues, or AGENTS.md violations found.

Testing

This is a GitHub Actions workflow file change — there's no user-facing CLI behavior to drive via tmux. The change can only be verified end-to-end when GitHub Actions executes it on a real /review trigger.

Verification performed:

$ npx prettier --check .github/workflows/qwen-code-pr-review.yml
Checking formatting...
All matched files use Prettier code style!

$ python3 -c "import yaml; yaml.safe_load(open('.github/workflows/qwen-code-pr-review.yml')); print('YAML syntax valid')"
YAML syntax valid

$ gh pr checks 4847
CodeQL                     pass    4m31s
Lint                       pass    4m4s
Classify PR                pass    4s
Test (ubuntu-latest)       pending
Test (macos-latest)        pending
Test (windows-latest)      pending
review-pr                  pending

Lint and CodeQL pass. Tests are pending (not affected by this workflow-only change). actionlint was not available in this environment — the workflow should be verified by a maintainer with actionlint access or by observing the first live execution.

— Qwen Code · qwen3.7-max

Straightforward, well-scoped change. The ack job is the simplest possible solution — one step on a fast runner, posting one comment. The trigger conditions are correctly mirrored from the review job, permissions are tight, and there's no user-input injection surface.

The only thing we can't verify locally is the live GitHub Actions execution (will the ack actually appear before the review job picks up?). But the risk is minimal — worst case, an extra PR comment appears slightly after the review starts, which is no worse than the current state.

Approved. ✅

— Qwen Code · qwen3.7-max

✅ Local verification — queued-review acknowledgement workflow

Verified .github/workflows/qwen-code-pr-review.yml as a merge reference. The PR is rebased on current main (origin/main is an ancestor), so the branch head already is the post-merge state and main hasn't touched this file. Since this is a GitHub Actions change, "real testing" here = lint the workflow + exercise the gating expression and the shell step directly. act/actionlint weren't available in this environment (no Docker), so I used shellcheck, prettier, a faithful evaluator of the exact if, and real execution of the extracted shell step.

1. Lint & format — clean

• prettier --check → ✅ All matched files use Prettier code style!
• shellcheck on the extracted ack run: script → ✅ clean
• YAML parses; on: already includes issue_comment, pull_request_review_comment, and pull_request_review (the events the new job keys on).

2. Structure & consistency

• The new ack-review-request job is purely additive (+52/−0; every existing job is byte-unchanged).
• Runs on ubuntu-latest, not the self-hosted ecs-qwen runner — so the acknowledgement is independent of the busy review runner, which is exactly the problem this PR targets.
• Permissions are correct & minimal: pull-requests: read (for gh pr view) + issues: write (a PR conversation comment is an issue comment, which is what gh pr comment posts). It posts via GITHUB_TOKEN, which by design does not recursively re-trigger the workflow.
• PR-scoped concurrency with cancel-in-progress (repeated /review comments collapse to the latest ack).
• Gating consistency (the key check): the ack job's three event branches (issue_comment / pull_request_review_comment / pull_request_review) are verbatim-identical to the matching comment/review-trigger branches of the existing review-pr job. So the ack fires under exactly the conditions that start a real comment/review-triggered review, and it correctly omits the pull_request_target (automatic-review) branch.

3. Gating truth-table — 18 / 18 (faithful evaluation of the exact if)

4. Shell step — real execution (mocked gh)

Ran the extracted run: script end-to-end:

• non-fork PR → posts exactly _Qwen Code review request accepted. Review is queued in [workflow run](<run-url>)._ ✅
• fork PR (isCrossRepository=true) → skips, posts nothing, exits 0 with Skipping ack… on stderr ✅

Observations (minor, non-blocking; both pre-existing / shared with review-pr)

• Fork-skip premise. The ack skips forks because "review-pr skips forks", but that skip is enforced by the qwen /review tooling at runtime, not by this workflow's if/steps (review-pr has no isCrossRepository gate). Skipping the ack on forks is the safe direction either way — it can't make a false "queued" promise, and it's no worse than today's no-ack behavior.
• format(..., '\n') newline sub-condition. startsWith(body, format('@qwen-code /review{0}', '\n')) is copied verbatim from review-pr. GitHub expression string literals don't process \n as a newline, so this sub-condition likely matches a literal \n rather than a real newline (effectively inert). Impact is nil — the exact-match and space-prefix conditions cover the real cases — and the ack stays identical to review-pr regardless. Worth a separate look if multi-line trigger comments matter, but out of scope for this PR.

Verdict

✅ Verified. The new job is additive, correctly gated (identical to the real review trigger), correctly scoped to ubuntu-latest with minimal permissions, lint/format-clean, and the shell step behaves correctly for both fork and non-fork PRs. No blockers found.

_{Scope: static lint + faithful gating-expression evaluation + real shell-step execution. The live GitHub event delivery itself can only be exercised by the workflow on an actual comment.}

✅ Local re-verification (updated) — queued-review acknowledgement

Re-verified against current head 57bb9ea. This supersedes my earlier note above — the PR has changed since: it is now +74/−0 across two files and is no longer purely additive (it also tightens the existing review-pr trigger and ships a test-file fix).

No Docker here, so act/actionlint can't run. "Real test" = trial 3-way merge against current main + lint + faithful evaluation of the exact if + actual execution of the extracted shell step in tmux with a mocked gh.

What the PR changes (head 57bb9ea)

• .github/workflows/qwen-code-pr-review.yml (+71/−0): new ack-review-request job; plus one added AND‑clause github.event.review.state == 'commented' inside the existing review-pr.if; plus two KEEP IN SYNC comments.
• packages/core/src/utils/environmentContext.test.ts (+3/−0): adds the missing }); }); closing braces.

1. Merge‑correctness — clean ✅ (the test fix also independently landed on main)

The test‑file fix duplicates #4863 (36dd4be0b — the single commit main has that this branch lacks). Both add the identical closing braces over a genuinely‑broken merge‑base, so the risk was a double‑close → syntax error. Checked with a non‑destructive 3‑way merge (git merge-tree):

• No conflict (merged tree 0766ebd).
• The merged environmentContext.test.ts is byte‑identical to main's #4863 version (already CI‑green) — single set of braces, no doubling.
• esbuild parses it (no syntax error), braces balance (148/148, 453/453, 97/97), prettier‑clean.

2. Lint & format — clean ✅

• prettier --check on the merged workflow and test file → All matched files use Prettier code style!
• shellcheck -s bash on the extracted ack run: block → clean.

3. Gating — ack fires iff a real explicit‑trigger review fires ✅

Both if expressions were whitespace‑normalized and compared:

• All three ack branches (issue_comment / pull_request_review_comment / pull_request_review) are verbatim substrings of review-pr.if.
• review-pr.if ends with exactly ‹ack‑expression› + ')' → the explicit‑trigger branches are byte‑identical between the two jobs (matching the KEEP IN SYNC comments).
• Faithful truth‑table over 20 payloads → 20/20 (exact / space‑arg → ack; /reviewers, /review-now, mid‑comment mention, NONE/CONTRIBUTOR/FIRST_TIME_CONTRIBUTOR, closed PR, plain issue, pull_request_target, workflow_dispatch → skip).

4. Shell step — real execution in tmux (mocked gh), every path ✅

Ran the extracted run: end‑to‑end with a mock gh driven by canned PR state / existing‑comment id:

5. Structure & security ✅

• runs-on: ubuntu-latest — decoupled from the busy self‑hosted ecs-qwen runner (the whole point: the ack posts immediately even while the review is queued).
• concurrency: qwen-pr-ack-‹PR#›, cancel-in-progress: false — serializes ack runs per‑PR so the read‑then‑update is race‑free; repeated /review updates the same comment instead of stacking.
• Author‑association gate (OWNER/MEMBER/COLLABORATOR) limits triggering to trusted users; the ack is posted by GITHUB_TOKEN and its body doesn't match @qwen-code /review, so there's no self‑retrigger loop.
• on: includes all three events the if keys on (no dead job); timeout-minutes: 5.
• Dropping the old fork‑skip is actually a fix: the ack now fires exactly when the explicit review fires (byte‑identical if), so a collaborator‑triggered review on a fork PR now correctly gets an ack too.

Observations (non‑blocking; for reviewer awareness)

1. Behavioral change to review-pr not mentioned in the description. Adding review.state == 'commented' means a review submitted as Approve or Request changes whose body contains @qwen-code /review will no longer trigger a review (it did before). The common issue_comment path is unaffected. It keeps ack/review consistent and is defensible — but please confirm it's intended.
   • pull_request_review old → new: approved: trigger→skip · changes_requested: trigger→skip · commented: trigger (unchanged).
2. permissions: pull-requests: write is broader than needed. The step only does gh pr view --json state (read); every comment write goes through the issues endpoint (issues: write). pull-requests: read would suffice (least‑privilege).
3. Inert '\n' sub‑condition (pre‑existing, copied verbatim from review-pr): format('@qwen-code /review{0}', '\n') is a literal backslash‑n in GitHub expressions (single‑quoted literals don't escape), not a newline — so a command on its own line followed by a real newline won't match via that clause. Not introduced here; now shared by both jobs.

Verdict

✅ Verified — merge‑ready, no blockers. Clean 3‑way merge with main (the test fix de‑duplicates with #4863, no conflict, merged file == main's CI‑green version), lint/format‑clean, gating provably in sync (20/20), and the shell step — including the new idempotent update path — behaves correctly under real execution. One thing to confirm before merge: the undocumented review-pr tightening (obs. 1); minor least‑privilege nit (obs. 2).

_{Scope: trial 3‑way merge + static lint + faithful gating evaluation + real tmux shell‑step execution with mocked gh. Live GitHub event delivery itself can only be exercised by the workflow on an actual comment. Head 57bb9ea.}