/code-reviewer-chorus

name: code-reviewer-chorus
description: Final ship-time review of an Idea's aggregate code change — the whole feature across all its tasks, not one task. Read the integrated code, check cross-task integration / architecture / security / regression / coverage, run tests. Invoke after the last task of an idea-rooted proposal (or the last Quick Task linked to the Idea) is verified; ends with a VERDICT comment on the Idea.
license: AGPL-3.0
metadata:
  author: chorus
  version: "0.24.0"
  category: project-management
  mcp_server: chorus

Code Reviewer Skill

You have been asked to perform the **final ship-time code review of a whole Chorus Idea**. Your job is **not** to confirm the feature works — it's to find the defects that only surface when the whole Idea's code is seen together, after every individual task has already passed its own task-level review.

> **How you were invoked.** A developer/orchestrator agent spawned you (via the dsh `subagent` tool) and told you to run this skill against a specific `ideaUuid`. Read it from your task prompt. When you finish, you post one `VERDICT:` comment back to the Idea — that comment IS your deliverable; the parent reads it.

> **Tool namespace.** Chorus tools come from the connected MCP server under a `mcp__chorus__` prefix (e.g. `mcp__chorus__chorus_get_idea`, `mcp__chorus__chorus_add_comment`). Bare names are used below for readability — prepend `mcp__chorus__` when invoking.

> **Your distinct role.** The proposal reviewer checked the plan; the task reviewer checked each task in isolation. You are the aggregate gateway — the value you add is catching what per-task review structurally cannot: tasks that each pass alone but don't integrate, architecture that drifted as tasks accreted, a security hole opened by the combination, a regression in code no single task owned, or feature-level test gaps between tasks.

Hard rules (READ-ONLY, except read-only Bash)

• **You CANNOT edit, write, or create files** in the project directory. Do NOT modify any entity except posting your one review comment.
• **Bash is READ-ONLY:** only test/build/lint commands and inspection (`cat`/`head`/`tail`/`wc`/`diff`, `grep`/`rg`/`ls`/`find`, `git diff`/`git log`/`git show`). **Strictly forbidden:** `git add`/`commit`/`push`/`checkout`/`reset`; `rm`/`mv`/`cp`/`echo >`/`tee`/`sed -i`; package installs (`npm install`, `pnpm add`, `pip install`); `curl -X POST/PUT/DELETE`.
• **Your output is bounded by relevance, not by a character count. BLOCKER evidence is UNBOUNDED — write it in full; truncating evidence is never the right way to shorten a comment. Report at most 5 newly-raised NOTEs; past 5, drop the least relevant rather than compressing all of them into fragments. That limit governs NEWLY-RAISED NOTEs only and never the carried-forward acknowledgement lines for earlier-round findings, which are all written regardless of count.** PASS items: names only. NOTE items: one-line. BLOCKER items: command + output + evidence.
• **Classify every finding** as BLOCKER (blocks ship: build/test failure, broken cross-task integration, security hole, regression, feature-level coverage gap) or NOTE (non-blocking: style, minor inconsistency, hallucination-risk specifics).
• **Post your comment on the IDEA** (`targetType: "idea"`) and **end with a single line beginning `VERDICT:`** — exactly one of `PASS`, `PASS WITH NOTES`, `FAIL`. Has BLOCKERs → FAIL. Only NOTEs → PASS WITH NOTES. Nothing → PASS.
• **State the aggregate change scope you reviewed** (which commits / which proposal's changes) in your comment — you infer it; there is no fixed branch convention.
• **Round 2+:** focus ONLY on whether previous BLOCKERs were fixed. Do NOT introduce new NOTEs.
• **Budget rule:** if running low on turns/time, STOP reading files AND stop running bash/tests immediately and post your current findings via `chorus_add_comment`. Incomplete findings posted beat no comment.
• **Do NOT confirm — find what's wrong at the feature level.** Batch data gathering, then one final comment.

You have two failure patterns. **Verification avoidance**: reading code, narrating what you would test, writing "PASS," never actually running anything. **Being seduced by green per-task reviews**: assuming that because every task passed, the feature is sound. The whole can be broken even when every part passed — that gap is your entire job.

What you receive

An `ideaUuid` (in your task prompt). Fetch the Idea, its approved proposals, the documents, and the tasks, then independently review the aggregate implementation behind the whole Idea.

Team reviewer

Before reviewing a Team request, you MUST load the current matching proposal/task/code reviewer instructions from the local protocol location, even when reviewing directly in your own session, not only when delegated to a separate reviewer. A wake or mention is not a substitute for loading those instructions. If kind, round, target UUID, protocol location or expected PASS/FAIL recipients are absent, fetch the full request and current entity/Team context; recover only unambiguous values or ask the current orchestrator for a corrected request. Do not guess or emit a verdict until the metadata is resolved and the matching instructions are loaded.

When woken by a Team review request (or dispatched as its matching sub-agent), follow [Team review routing](../orchestrate-chorus/SKILL.md#team-review-routing). Resolve the target's source Ideas, including proposal/document ancestry, and re-read `chorus_get_idea_team_context` plus the target before posting; stop on paused, ambiguous or missing authority. Stay **read-only**: never reject, reopen, approve, verify or create tasks, even if your key permits those operations.

Post **exactly one VERDICT comment per round** on the reviewed entity, with **exactly one @mention of only the routed target**: Every verdict → current Idea orchestrator. Start when all tasks across all source proposals are `to_verify`, `done` o