Claude Skill

hex-review

Tiered adversarial review orchestrator for a working tree, branch diff, pull request, or plan/markdown artifact before it lands on main — a staged reviewer panel (spec, quality, security, performance, docs), root-cause analysis, and a cross-model adversarial pass (codex, medium a

LLM Mart · 0 points · 1 views 0 listing impressions 0 install-command copies
Download grimoire-rs-grimoire-.agents_skills_hex-review-dddf811.zip · 29 KB

Install

skills CLI npx skills add https://github.com/grimoire-rs/grimoire/tree/main/.agents/skills/hex-review
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install grimoire-rs-grimoire@llmmart
Git git clone https://github.com/grimoire-rs/grimoire.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole grimoire-rs/grimoire collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

hex-review — Adversarial Reviewer

Thin dispatcher. It resolves the review target and baseline, classifies the diff's tier, resolves overlays, runs the single meta-plan approval gate, announces the resolved config, and hands off to the matching tier file. hex-review never edits its own output or loops on it — the reviewer panel runs once per invocation and reports; applying the findings is /hex-execute's job. The phase plans live in the five tier-<tier>.md files; the shared vocabulary (tiers, worker roles, model classes, the memory file) lives in the hex-core reference library and is linked here, never copied.

Loop mode — the caller is /hex-execute or /hex-loop, not a human. It runs autonomously: no gate prompt, no question, ever (step 5). The report and the findings go back to the caller.

Shared contracts: protocol.md · workers.md · models.md · memory.md. If hex-core is not installed: grim add ghcr.io/michael-herwig/arcana/hex-core:latest.

Argument syntax

/hex-review [tier] <target> [flags]
  • tier (optional): low | medium | high | xhigh | max | auto. Default auto — the classifier picks low … xhigh from diff metrics. max is explicit only — --tier=max, or a plan whose Status block says Tier: max; the classifier never emits it (protocol.md).
  • target (one of):
    • empty — in loop mode, anchor..HEAD (the plan's Reviewed: anchor when valid, else the resolved baseline; step 2). Otherwise the working tree: uncommitted changes (staged + unstaged) against HEAD. If the working tree is clean, fall back to the current branch's diff against the resolved baseline and say so in the announce block.
    • a branch name — diffed against the resolved baseline.
    • <N> / #<N> / PR <N> / pull/<N> / a full GitHub PR URL — an explicit pull request.
    • a path to a markdown plan, ADR, or spec artifact — review the file directly, not a code diff. Diff metrics do not apply; see classify.md.
  • flags (before the target, by convention):
    • --base=<git-ref> — the diff baseline. Pipeline input, not an overlay axis: everything downstream (metrics, tier, review scope, adversary scope) reads from it. Default resolution in step 2.
    • --breadth=minimal|full|adversarial — override the Stage 2 panel breadth (see overlays.md).
    • --rca=on|off — override root-cause (Five Whys) analysis.
    • --adversary / --no-adversary — force the cross-model pass on or off.
    • --dry-run — make the meta-plan gate block for explicit approval and stop there (preview only, no workers launched).

Dispatch

The outer loop every hex orchestrator shares (protocol.md):

1. Parse arguments and resolve memory

Parse the tier, target, and flags. Locate .agents/memory/hex.md by searching upward from the working directory; a missing file is normal (memory.md) — fall back to shipped defaults and note that /hex-init can create one. When present, read the whole file: hex.md › Pointers for where verification and review conventions are documented, and for the constitution pointer when present (activates the constitution gate); hex.md › Preferences for the instantiated model matrix, the adversary skill name, limits, and always-on perspectives or path-triggered escalations; the project's product knowledge (located via hex.md › Pointers) when present (it grounds the user-feedback perspective); and hex.md › Memory for any active plan this review might trace back to.

If the resolved hex.md carries a Federation lead: bullet, halt per memory.md § Location and resolution — this repo is a federation satellite and its memory is not the plan's.

2. Resolve the target and baseline

Detect the target (order above). For a GitHub reference, fetch title, body, labels, base ref, and file list in this order of preference:

  1. the client's GitHub MCP tools (PR read) when it exposes them;
  2. the gh CLI (gh pr view --json baseRefName,title,body,labels,files) as fallback;
  3. neither available — treat the input as a branch name or free text and continue.

Resolve the baseline: user --base=<ref> wins; else, where the traced plan carries a valid Reviewed: anchor and the invocation is a review round continuing that plan's loop, the anchor is the baseline — validity per loop.md, which resolves the fallback below first and validates the anchor against it; else a PR target uses its fetched base ref; else main. Fast-fail when the baseline doesn't resolve (git rev-parse --verify <base> fails) — print remediation and stop. An empty baseline-to-HEAD diff reports "nothing to review" and exits clean where no converged pass is outstanding; an empty anchor..HEAD delta proceeds to that pass instead (loop.md). A markdown-artifact target skips baseline resolution entirely.

Federation refusal (C-323). A run is federated only if its own resolved hex.md carries Federation: bullets; if the resolved plan (or the branch's traced plan) carries a Repo column but this run's does not, halt per memory.md § Location and resolution — it cannot reach every participating repo and must not review a silently narrower union. Every Repo value must resolve to a declared Federation key, or halt the same way.

Federation pre-flight (C-320). For a federated target — one tracing to a plan that carries a Repo column — resolve nothing about the union scope until every participating repo is proven reachable. Run C-303's pre-flight in its read-only form for every distinct Repo value the plan uses — clauses (i) --show-toplevel and (ii) --git-common-dir, plus a status --porcelain read check — and halt with the same Error:/Fix: --add-dir relaunch line on any failure. A satellite unreachable from this session would otherwise resolve a silently narrower union — full coverage reported over a partial diff, the exact failure C-303 exists to stop. The write probe does not apply: /hex-review never writes in a satellite — every write it makes is lead-scoped, including the Fold-Back write (the lead's resolved spec file and fold receipt, C-415 clause 5; see the Review-only contract), so satellite writability is never checked.

3. Classify (only when tier is auto)

Read classify.md. For a diff target, compute file count, lines changed, and areas touched once, then apply its tier signals, structural markers, and overlay triggers. It emits the lowest tier whose limits all hold (only low, medium, high, or xhigh), a confidence flag, and an overlay set. Low confidence forces the gate in step 5 (not in loop mode). Never ask a mid-flow question during classification — ambiguity is resolved at the single gate.

4. Resolve overlays

Final config = the tier's baseline from overlays.md + classifier-inferred overlays + hex.md › Preferences hints + user flags. Later wins; user flags always override (see protocol.md).

5. Meta-plan gate (the single approval point)

Exactly one gate, before any worker launches (protocol.md). Loop mode never blocks here: announce the resolved config (step 6) and proceed at every tier, low confidence included. Otherwise its weight scales:

  • Confident low / medium / high (an explicit user tier always counts as confident — the classifier never ran) — announce the resolved config (step 6) and proceed; the user can still abort.
  • xhigh or max tier, low-confidence classification, or --dry-run — block for explicit approval.

On a client with a native plan-approval mechanism, use it. Otherwise present the announce block as one structured question (approve / adjust / cancel). The gate is also where the user can add or drop perspectives and adjust the breadth axis. On adjust, re-resolve and re-present once. Never split this into sequential questions.

6. Announce the resolved config

Print the resolved config with per-axis source attribution before loading the tier file:

hex-review
  Tier:      high                          (auto — 6 files, 180 lines, 1 area)
  Baseline:  main                             (default)
  Target:    HEAD (branch: feature/export)
  Overlays:  breadth=full                     (tier baseline)
             rca=on                           (tier baseline)
             adversary=on                     (tier baseline)
  Spawn set:
    reviewer: spec (post-implementation)      (tier baseline, per pipeline)
    reviewer: quality (test-coverage)         (tier baseline, per pipeline)
    reviewer: spec (seams)                    (tier baseline, 2+ pipelines)
    reviewer: quality                         (tier baseline)
    reviewer: security                        (classifier: auth path touched)
    doc-reviewer                              (classifier: CLI flag doc trigger)
  Models:    standard, all seats                (models.md)
  Adversary: codex-adversary, code-diff scope  (hex.md preference)
  Degraded:  no — subagent spawning available

The announce block prints one config-disclosure line per change a hex.md › Preferences block makes; the full trigger set is defined once in protocol.md § the meta-plan approval gate. For this skill, for example:

  [project-redefined: Stage 2.reviewer:performance 1→2 (hex.md tiers)]
  [reviewer:security dropped — phase ceiling 6 reached]
  [Stage 2 batched 3+3 — concurrency cap 3 (hex.md)]
  Error: never [reviewer:security] refused (hex.md preference)
  Fix:   see config.md#merge-rules for the attestation requirement

Every spawn line carries its source (tier baseline / classifier / hex.md preference / user flag) per spawn-selection precedence. Model names above are class placeholders — shipped files never hardcode literals; the running orchestrator resolves and prints each spawn's literal model per the Models line contract. On a client that cannot spawn subagents, announce Degraded: inline workers and run each worker prompt inline and sequentially (protocol.md).

7. Dispatch to the tier file

Read workflows.hex-review.<tier> from the resolved config first. When set and the named file passes the seven validation checks (config.md § Workflows), Read that forked file in place of the shipped one; on validation failure or when unset, Read the matching tier-{low,medium,high,xhigh,max}.md — config.md owns the check list and the on-failure fallback. Announce which ran: Workflow: shipped tier-<tier>.md, or for a fork, Workflow: <path> (forked from <shipped tier file> @ <stamped version>). Execute the loaded file's phase plan; no phase content is duplicated in this file.

Worker assignment (shared across tiers)

Roles are indexed in workers.md; the orchestrator loads a full persona (spawn-prompt template, output contract) only for roles in the resolved spawn set (spawn-selection precedence). This table maps roles to review stages; the tier files set the actual counts and firing conditions.

Seats.

  • Class. Every seat is standard (models.md) at every tier. Tier scales the seat count only. deep seats run only when the user asks for them.
  • Split. A target made of pipelines (a plan's, one worktree each) gets its Stage 1 seats once per pipeline, scoped to that pipeline's paths, plus one reviewer (focus spec) seat for the seams — the contract-wave files and where pipelines meet. One pipeline, or no plan: one slice, no seams seat. Stage 2 seats cover the whole range.
  • Evidence. Seats consume the integration gate's evidence from the brief. A seat runs at most one targeted test of its own, never the suite.
Stage Role Count Purpose
Stage 1 — Correctness reviewer (focus spec, phase post-implementation) 1 per pipeline design ↔ implementation traceability; also runs the convergence check when the target traces to a plan
Stage 1 — Correctness reviewer (focus quality, test-coverage emphasis) 0–1 per pipeline Specify-phase test adequacy (high and above)
Stage 1 — Correctness reviewer (focus spec, seams) 0–1 contract-wave files and cross-pipeline boundaries (2+ pipelines)
Stage 2 — Panel reviewer (focus quality) 1 naming, style, pattern compliance
Stage 2 — Panel reviewer (focus security) 0–1 fires on security-sensitive paths
Stage 2 — Panel reviewer (focus performance) 0–1 fires on hot-path / async changes
Stage 2 — Panel doc-reviewer 0–1 fires on a doc-trigger match
Stage 2 — Panel (high and above) architect 0–1 boundary / dependency-direction review
Stage 2 — Panel (high and above) researcher 0–1 SOTA / known-pitfall gap check
Adversary configured adversary skill (code-diff or plan-artifact) 1 at medium+ (every configured entry at max) cross-model review
Stage 2 — Panel (max) simulator 0 (4+ at max only) one user pattern each against the target; reported, never fixed

A project's tiers.hex-review.<tier>.counts can override any Count cell above against the baseline this table sets (config.md § Merge rules).

Concurrency cap and degraded mode: protocol.md. The adversary skill name comes from hex.md › Preferences (adversary contract); codex-adversary is only an example value. The adversary runs in every call at medium and up; when it is unavailable, log the skip line and continue — never wait for it. A markdown-artifact target uses the plan-artifact scope; every other target uses code-diff.

Project rules and conventions

hex never carries a hardcoded rule or area table. Every phase that needs the project's invariants, quality rules, or verification command discovers them from project context (the client's ambient instructions / project rules) and the pointers in the Pointers section of .agents/memory/hex.md (memory.md). Reviewers never run the project's verification; they read the gate evidence (§ Worker assignment). Path hints from hex.md › Preferences (e.g. "security review mandatory under src/auth/**") fold into perspective selection at classification time (classify.md).

The review report

Where it goes. The report is presented inline as the response to this invocation — it is not a persisted plan artifact. hex-review's writes land only here, on the plan artifact itself, never on the code or diff under review. When the target traces to an active plan (the hex.md › Memory active-plan pointer, or a ## Status block found in a referenced markdown file — see memory.md), mutate that block: on round entry, flip State to review; on verdict, set State to done with Next cleared (Approve — or State: landing, not done, for a plan carrying a Repo column, whose Next names the landing enumeration, C-324), or leave State: executing and set Next to /hex-execute <plan path> (Needs Work / Request Changes). Skip silently when no active plan is found — never invent one. An Approve never writes the terminal review state — done, or landing for a plan carrying a Repo column — where the run ended with a non-empty stranded set (decompose.md). This skill runs when invoked, by the user or in loop mode, and remains the sole writer of the terminal review state. Writing the Reviewed: anchor is a Status-block write, the class of write hex-review already performs — a branch-scope pass only (loop.md).

Federated diff scope (C-309). When the target traces to a plan carrying a Repo column, the resolved review scope is not one repo's diff but the union over the lead (.) plus every distinct Repo value — each computed as git -C <repo> diff <base>...hex/<plan-slug> and presented to the panel as one diff set with each hunk labelled by its repo. <base> is the frozen per-repo base SHA read from the plan's Repos: ledger (worktree.md C-317/C-324), never re-resolved from a trunk ref that may have moved since execution started. The C-320 pre-flight (step 2) has already proven every participating repo reachable, so the union is never silently narrower than the plan. Absent a Repo column the scope is step 2's single diff, byte-identical. Only the scope's construction generalizes — the never-edits and stay-in-scope contracts below are unchanged.

When the target traces to a plan artifact, also run the convergence check: the orchestrator — never a worker — appends any gap as new pipeline rows at the end of the plan's Parallelization table (their wave derives as the next topological level); the plan stays byte-identical when nothing is outstanding ("Converged").

Fold-Back phase. After the convergence check and before Upkeep, the Fold-Back phase folds the plan's ## Spec Deltas into the project's documented spec home. It runs only when all four preconditions hold and the plan carries a ## Spec Deltas block (the archive.md conditional-load trigger, S-410); otherwise it does not run and the Fold-Back block below says so in one line (not performed — <reason>):

  1. the target traces to a plan artifact (as above);
  2. the verdict is Approve;
  3. the convergence check reported Converged;
  4. this run is about to write the plan's terminal review state — done, or landing for a plan carrying a Repo column (a federated plan, whose Approve writes landing, never done — so keying on done alone would strand it, never folding).

Order is not cosmetic: convergence is the mirror of this phase and runs first, always (loop.md), because folding an incompletely delivered plan would write aspiration into truth. Every mechanic is defined in archive.md and is not restated here — the delta grammar, destination resolution and containment, the safety envelope and its four pasted-command checks, halt semantics, idempotence, the fold receipt, and revert. The phase's only writes are the one resolved spec file and the fold receipt it appends to the plan's ## Spec Deltas block; both land uncommitted, and every run emits the mandatory Fold-Back block in the report skeleton below.

Synthesis self-check. Before emitting the report, the orchestrator confirms on its own draft:

  • every duplicate file:line finding resolved max-wins, never averaged;
  • every doc-reviewer grade mapped onto the severity ladder;
  • every cross-model escalation is noted in the Cross-Model Adversarial section;
  • every empty findings bucket printed (none).

Required skeleton (tier files add or drop sections per the breadth they run — absence of a section is a tier contract, not a bug):

## Code Review: <target>
### Summary
- Verdict: Approve | Needs Work | Request Changes
- Tier / Baseline / Diff: N files, +L / -L lines, S areas
### Stage 1 — Correctness
### Stage 2 — <perspectives run at this tier>
### Convergence   <!-- when the target traces to a plan artifact -->
### Fold-Back     <!-- mandatory when the target traces to a plan; `not performed — <reason>` if a precondition fails -->
### Cross-Model Adversarial               <!-- if adversary=on fired -->
### Root-Cause Analysis                   <!-- if rca=on -->
### Deferred Findings (human judgment required)

The Convergence section holds one line per unmet requirement ID (missing | partial | contradicts | unrequested), or the single word Converged — see the convergence contract.

The Fold-Back section is mandatory whenever the target traces to a plan, and prints not performed — <reason> when any precondition fails (verdict not Approve; unconverged; not the terminal review state; the target does not trace to a plan; or the plan carries no ## Spec Deltas block). When the phase runs, every line is pasted command output, never narration — see archive.md § evidence:

  • target and how it resolved (Related Spec: / carries the IDs / plan slug);
  • the ID-marker convention and its source (default / hex.md › Preferences);
  • the census — live (pasted grep transcript) and incoming (the delta block's IDs);
  • per-ID disposition (C-002 modified, C-003 removed, C-004 added);
  • a per-touched-ID content excerpt — the live body's first line and its pasted non-blank line count beside the incoming body's, so prose loss shows in the report;
  • a per-MODIFIED sub-ID census — the live body's sub-ID set and the incoming body's, both as pasted command output (C-405), beside that line-count pair, so a dropped inline sub-clause shows in the report;
  • the containment verdict with the resolved path and its pasted git ls-files transcript — printed on every run, not only on failure;
  • destination cleanliness as pasted git status --porcelain output at step 4 and again at step 6;
  • targets: 1 with prepared-then-written;
  • the fold receipt it appended to the plan (Folded: …);
  • the revert command, git checkout -- <target>.

An absent Fold-Back block, or a prose assertion standing where a command transcript belongs, is a spec violation.

Verdict rules (tier files refine thresholds):

  • Request Changes — any unresolved Block-tier finding, a security vulnerability, a breaking change without a migration note, new behavior without tests, or an unjustified constitution violation (a violation with no adequate Constitution Deviations row is automatic Request Changes — see the constitution gate).
  • Needs Work — High- or Warn-tier findings remain, the cross-model pass surfaced actionable findings not yet addressed, or the convergence check found unconverged gaps — unconverged gaps cap the verdict at Needs Work, never Approve, with Next: /hex-execute <plan path>.
  • Approve — otherwise.

Review-only contract. hex-review never edits the code or diff under review, and never commits. Its writes are the plan-artifact mutations above — the Status block, including the Reviewed: anchor line on a branch-scope pass, and the append-only convergence rows — plus, under the Fold-Back phase's four preconditions only, the one resolved spec file and the fold receipt appended to the plan's ## Spec Deltas block; a fold is never inferred from silence, and every write lands uncommitted (revert is git checkout -- <file>, see archive.md). Every finding is reported, not applied; the fix loop belongs to /hex-execute. Fix rounds are the caller's: cap 2, each re-review covers the fix delta only (loop.md); what remains after round 2 goes to the user.

Constraints

  • Never edits the code or diff under review, and never commits — its writes are the plan-artifact Status block, including the Reviewed: anchor line on a branch-scope pass, and the append-only convergence rows, and — under the Fold-Back phase's four preconditions only — the one resolved spec file and the fold receipt (see archive.md).
  • No approving with an unresolved Block-tier finding — the verdict rules above are binding.
  • A federated plan's Approve writes State: landing, not done (C-324) — a plan carrying a Repo column stops at landing so the satellite locks outlive the broken-integration window (removed only on done, per protocol.md § Upkeep); single-repo plans keep review → done byte-identically. landing is the terminal review state the Fold-Back phase already keys on.
  • No mid-flow questions — ambiguity is resolved at the single gate; in loop mode there is no gate and no question.
  • Never exceed the concurrency cap (protocol.md).
  • Always cite specific files and lines; always pair a finding with a remediation, not just a problem.
  • Always classify every finding actionable or deferred — nothing reaches the report unclassified.
  • Always stay within the resolved diff scope (<base>...<target>), and across every participating repo for a federated plan — the C-309 union, not one repo's slice. A regression the diff introduces in an unchanged file is in scope; pre-existing issues in unrelated code are not.
  • Don't nitpick style the project's own formatter or linter already enforces (discovered from project context).
  • Upkeep (protocol.md): as the final phase, update any hex.md › Pointers entry this run revealed as drifted. When this run wrote the plan's terminal review state (done, or landing for a plan carrying a Repo column), also clear the hex.md › Memory active-plan pointer — the first clear in the bundle — and record the plan plus its fold target in the artifact index (archive.md § Plan archive).

Handoff

The handoff contract applies: this block is the run's required final message; one optional proceed question may follow it.

## Review Complete: <target>

### Classification
- Scope: small | medium | large
- Tier: low | medium | high | xhigh | max
- Baseline: <ref>
- Overlays: breadth=<minimal|full|adversarial>, rca=<on|off>, adversary=<on|off>

### Verdict
- Approve | Needs Work | Request Changes

### Findings   <!-- [severity] prefix absent below tier high -->
- Actionable:
  - [severity] file:line — issue — remediation      <!-- one line per finding; `(none)` if the bucket is empty -->
- Deferred:
  - [severity] file:line — issue — why human input is needed   <!-- same; `(none)` if empty -->

### Cross-model review
- ran — <n> actionable, <n> deferred, <n> dropped   |   skipped: <reason>

### Fold-Back   <!-- mandatory when the target traces to a plan; full block per § The review report -->
- target: <file> · marker: <default | hex.md › Preferences> · targets: 1
- census / disposition / line-counts / containment / cleanliness: pasted transcripts (see report)
- receipt: <the `Folded: …` lines appended to the plan>   |   not performed — <reason>
- revert: git checkout -- <file>

### Next step
    /hex-execute <plan path> "apply review findings"    <!-- actionable findings exist -->
    /hex-finalize                                       <!-- clean Approve, branch or PR target -->
    (none — approved)                                   <!-- clean verdict, plan-artifact or working-tree target -->

Consumers: /hex-execute (actionable findings, the Review-Fix Loop); the human (verdict and deferred findings).

$ARGUMENTS

Files (grimoire)
  • classify.md 8.1 KB
    Loading…
  • overlays.md 6 KB
    Loading…
  • SKILL.md 30 KB
    ---
    name: hex-review
    description: Tiered adversarial review orchestrator for a working tree, branch diff, pull request, or plan/markdown artifact before it lands on main — a staged reviewer panel (spec, quality, security, performance, docs), root-cause analysis, and a cross-model adversarial pass (codex, medium and up) scale with diff size via tier (low|medium|high|xhigh|max, auto by default). Use for pre-merge checks, code review, branch or PR review, diff review, plan or ADR review, adversarial review, root-cause analysis, or any "review this before I merge" request. Never edits the code or diff under review, and never commits — its writes are the plan's Status block, an append-only convergence check, and — on an approved, converged fold — the resolved spec file and a fold receipt; the fix loop is /hex-execute's job.
    license: Apache-2.0
    metadata:
      summary: Tiered swarm review — diff or artifact to verdict via adversarial reviewer panel
      keywords: review,swarm,multi-agent,adversarial,rca,pre-merge,verdict
      repository: https://github.com/michael-herwig/arcana
    ---
    
    # hex-review — Adversarial Reviewer
    
    Thin dispatcher. It resolves the review target and baseline, classifies the
    diff's tier, resolves overlays, runs the single meta-plan approval gate,
    announces the resolved config, and hands off to the matching tier file.
    hex-review never edits its own output or loops on it — the reviewer panel
    runs **once** per invocation and reports; applying the findings is
    [`/hex-execute`'s job](../hex-core/references/loop.md#the-review-fix-loop).
    The phase plans live in the five `tier-<tier>.md` files; the shared vocabulary (tiers, worker roles, model classes,
    the memory file) lives in the `hex-core` reference library and is **linked
    here, never copied**.
    
    **Loop mode** — the caller is `/hex-execute` or `/hex-loop`, not a human.
    It runs autonomously: no gate prompt, no question, ever (step 5). The report
    and the findings go back to the caller.
    
    Shared contracts:
    [`protocol.md`](../hex-core/references/protocol.md) ·
    [`workers.md`](../hex-core/references/workers.md) ·
    [`models.md`](../hex-core/references/models.md) ·
    [`memory.md`](../hex-core/references/memory.md).
    If `hex-core` is not installed: `grim add ghcr.io/michael-herwig/arcana/hex-core:latest`.
    
    ## Argument syntax
    
    ```
    /hex-review [tier] <target> [flags]
    ```
    
    - **tier** (optional): `low | medium | high | xhigh | max | auto`. Default
      `auto` — the classifier picks `low` … `xhigh` from diff metrics. **`max` is explicit
      only** — `--tier=max`, or a plan whose Status block says `Tier: max`; the
      classifier never emits it
      ([`protocol.md`](../hex-core/references/protocol.md#tier-grammar)).
    - **target** (one of):
      - empty — in loop mode, `anchor..HEAD` (the plan's `Reviewed:` anchor when
        valid, else the resolved baseline; step 2). Otherwise the **working
        tree**: uncommitted changes (staged + unstaged) against `HEAD`. If the
        working tree is clean, fall back to the current branch's diff against the
        resolved baseline and say so in the announce block.
      - a **branch name** — diffed against the resolved baseline.
      - `<N>` / `#<N>` / `PR <N>` / `pull/<N>` / a full GitHub PR URL — an
        explicit pull request.
      - a path to a **markdown plan, ADR, or spec artifact** — review the file
        directly, not a code diff. Diff metrics do not apply; see
        [`classify.md`](classify.md#plan-and-artifact-targets).
    - **flags** (before the target, by convention):
      - `--base=<git-ref>` — the diff baseline. Pipeline input, not an
        overlay axis: everything downstream (metrics, tier, review scope,
        adversary scope) reads from it. Default resolution in step 2.
      - `--breadth=minimal|full|adversarial` — override the Stage 2 panel
        breadth (see [`overlays.md`](overlays.md)).
      - `--rca=on|off` — override root-cause (Five Whys) analysis.
      - `--adversary` / `--no-adversary` — force the cross-model pass on or
        off.
      - `--dry-run` — make the meta-plan gate block for explicit approval and
        stop there (preview only, no workers launched).
    
    ## Dispatch
    
    The outer loop every hex orchestrator shares
    ([`protocol.md`](../hex-core/references/protocol.md#shared-shape)):
    
    ### 1. Parse arguments and resolve memory
    
    Parse the tier, target, and flags. Locate `.agents/memory/hex.md` by
    searching upward from the working directory; a missing file is normal
    ([`memory.md`](../hex-core/references/memory.md#location-and-resolution)) —
    fall back to shipped defaults and note that `/hex-init` can create one. When
    present, read the whole file: `hex.md › Pointers` for where verification and
    review conventions are documented, and for the constitution pointer when
    present (activates the
    [constitution gate](../hex-core/references/protocol.md#constitution-gate));
    `hex.md › Preferences` for the instantiated model matrix, the adversary skill
    name, limits, and always-on perspectives or path-triggered escalations; the
    project's product knowledge (located via `hex.md › Pointers`) when present (it
    grounds the `user-feedback` perspective); and `hex.md › Memory` for any active
    plan this review might trace back to.
    
    If the resolved `hex.md` carries a `Federation lead:` bullet, **halt** per
    [`memory.md` § Location and resolution](../hex-core/references/memory.md#location-and-resolution)
    — this repo is a federation satellite and its memory is not the plan's.
    
    ### 2. Resolve the target and baseline
    
    Detect the target (order above). For a GitHub reference, fetch title, body,
    labels, base ref, and file list in this order of preference:
    
    1. the client's **GitHub MCP tools** (PR read) when it exposes them;
    2. the **`gh` CLI** (`gh pr view --json baseRefName,title,body,labels,files`)
       as fallback;
    3. neither available — treat the input as a branch name or free text and
       continue.
    
    Resolve the baseline: user `--base=<ref>` wins; else, where the traced plan
    carries a valid `Reviewed:` anchor and the invocation is a review round
    continuing that plan's loop, the anchor is the baseline — validity per
    [`loop.md`](../hex-core/references/loop.md#anchor-validation), which
    resolves the fallback below *first* and validates the anchor against it; else
    a PR target uses its fetched base ref; else `main`. Fast-fail when the
    baseline doesn't resolve (`git rev-parse --verify <base>` fails) — print
    remediation and stop. An empty baseline-to-HEAD diff reports
    "nothing to review" and exits clean where no converged pass is outstanding;
    an empty `anchor..HEAD` delta proceeds to that pass instead
    ([`loop.md`](../hex-core/references/loop.md#delta-round-scope)).
    A markdown-artifact target skips baseline resolution entirely.
    
    **Federation refusal (C-323).** A run is federated only if its own resolved
    `hex.md` carries `Federation:` bullets; if the resolved plan (or the branch's
    traced plan) carries a `Repo` column but this run's does not, **halt** per
    [`memory.md` § Location and resolution](../hex-core/references/memory.md#location-and-resolution)
    — it cannot reach every participating repo and must not review a silently
    narrower union. Every `Repo` value must resolve to a declared Federation key,
    or halt the same way.
    
    **Federation pre-flight (C-320).** For a federated target — one tracing to a
    plan that carries a `Repo` column — resolve nothing about the union scope until
    every participating repo is proven reachable. Run
    [C-303's pre-flight](../hex-core/references/worktree.md#pipeline-worktree-mechanics)
    in its **read-only** form for **every distinct `Repo` value the plan uses** —
    clauses (i) `--show-toplevel` and (ii) `--git-common-dir`, plus a
    `status --porcelain` read check — and **halt** with the same `Error:`/`Fix:`
    `--add-dir` relaunch line on any failure. A satellite unreachable from this
    session would otherwise resolve a **silently narrower** union — full coverage
    reported over a partial diff, the exact failure C-303 exists to stop. The
    **write probe does not apply**: `/hex-review` never writes in a satellite —
    every write it makes is lead-scoped, including the Fold-Back write (the lead's
    resolved spec file and fold receipt, C-415 clause 5; see the
    [Review-only contract](#constraints)), so satellite writability is never
    checked.
    
    ### 3. Classify (only when tier is `auto`)
    
    Read [`classify.md`](classify.md). For a diff target, compute file count,
    lines changed, and areas touched once, then apply its tier signals,
    structural markers, and overlay triggers. It emits the lowest tier whose
    limits all hold (**only** `low`, `medium`, `high`, or `xhigh`), a confidence
    flag, and an overlay set. Low confidence forces the gate in step 5 (not in
    loop mode). Never ask a mid-flow question during classification —
    ambiguity is resolved at the single gate.
    
    ### 4. Resolve overlays
    
    Final config = the tier's baseline from [`overlays.md`](overlays.md) +
    classifier-inferred overlays + `hex.md › Preferences` hints + user
    flags. Later wins; **user flags always override** (see
    [`protocol.md`](../hex-core/references/protocol.md#spawn-selection-precedence)).
    
    ### 5. Meta-plan gate (the single approval point)
    
    Exactly one gate, before any worker launches
    ([`protocol.md`](../hex-core/references/protocol.md#the-meta-plan-approval-gate)).
    **Loop mode never blocks here:** announce the resolved config (step 6) and
    proceed at every tier, low confidence included. Otherwise its weight scales:
    
    - **Confident `low` / `medium` / `high`** (an explicit user tier always counts as
      confident — the classifier never ran) — announce the resolved config (step 6)
      and proceed; the user can still abort.
    - **`xhigh` or `max` tier, low-confidence classification, or `--dry-run`** — block
      for explicit approval.
    
    On a client with a **native plan-approval mechanism**, use it. Otherwise
    present the announce block as **one structured question** (approve / adjust
    / cancel). The gate is also where the user can add or drop perspectives and
    adjust the breadth axis. On adjust, re-resolve and re-present once. Never
    split this into sequential questions.
    
    ### 6. Announce the resolved config
    
    Print the resolved config with per-axis source attribution before loading
    the tier file:
    
    ```
    hex-review
      Tier:      high                          (auto — 6 files, 180 lines, 1 area)
      Baseline:  main                             (default)
      Target:    HEAD (branch: feature/export)
      Overlays:  breadth=full                     (tier baseline)
                 rca=on                           (tier baseline)
                 adversary=on                     (tier baseline)
      Spawn set:
        reviewer: spec (post-implementation)      (tier baseline, per pipeline)
        reviewer: quality (test-coverage)         (tier baseline, per pipeline)
        reviewer: spec (seams)                    (tier baseline, 2+ pipelines)
        reviewer: quality                         (tier baseline)
        reviewer: security                        (classifier: auth path touched)
        doc-reviewer                              (classifier: CLI flag doc trigger)
      Models:    standard, all seats                (models.md)
      Adversary: codex-adversary, code-diff scope  (hex.md preference)
      Degraded:  no — subagent spawning available
    ```
    
    The announce block prints one config-disclosure line per change a
    `hex.md › Preferences` block makes; the full trigger set is defined once in
    [`protocol.md` § the meta-plan approval gate](../hex-core/references/protocol.md#the-meta-plan-approval-gate).
    For this skill, for example:
    
    ```
      [project-redefined: Stage 2.reviewer:performance 1→2 (hex.md tiers)]
      [reviewer:security dropped — phase ceiling 6 reached]
      [Stage 2 batched 3+3 — concurrency cap 3 (hex.md)]
      Error: never [reviewer:security] refused (hex.md preference)
      Fix:   see config.md#merge-rules for the attestation requirement
    ```
    
    Every spawn line carries its source (`tier baseline` / `classifier` /
    `hex.md preference` / `user flag`) per
    [spawn-selection precedence](../hex-core/references/protocol.md#spawn-selection-precedence).
    Model names above are class placeholders — shipped files never hardcode
    literals; the running orchestrator resolves and prints each spawn's
    literal model per the
    [Models line contract](../hex-core/references/protocol.md#the-meta-plan-approval-gate). On a client that cannot spawn subagents, announce
    `Degraded: inline workers` and run each worker prompt inline and
    sequentially
    ([`protocol.md`](../hex-core/references/protocol.md#worker-coordination)).
    
    ### 7. Dispatch to the tier file
    
    Read `workflows.hex-review.<tier>` from the resolved config first. When set
    and the named file passes the seven validation checks
    ([`config.md` § Workflows](../hex-core/references/config.md#workflows)), `Read`
    that forked file in place of the shipped one; on validation failure or when
    unset, `Read` the matching `tier-{low,medium,high,xhigh,max}.md` — config.md owns the
    check list and the on-failure fallback. Announce which ran: `Workflow: shipped
    tier-<tier>.md`, or for a fork, `Workflow: <path> (forked from <shipped tier
    file> @ <stamped version>)`. Execute the loaded file's phase plan; no phase
    content is duplicated in this file.
    
    ## Worker assignment (shared across tiers)
    
    Roles are indexed in [`workers.md`](../hex-core/references/workers.md);
    the orchestrator loads a full persona (spawn-prompt template, output
    contract) only for roles in the resolved spawn set
    ([spawn-selection precedence](../hex-core/references/protocol.md#spawn-selection-precedence)).
    This table maps roles to review stages; the tier files set the actual counts
    and firing conditions.
    
    **Seats.**
    
    - **Class.** Every seat is `standard`
      ([`models.md`](../hex-core/references/models.md)) at every tier. Tier scales
      the seat count only. `deep` seats run only when the user asks for them.
    - **Split.** A target made of pipelines (a plan's, one worktree each) gets its
      Stage 1 seats once per pipeline, scoped to that pipeline's paths, plus one
      `reviewer` (focus `spec`) seat for the seams — the contract-wave files and
      where pipelines meet. One pipeline, or no plan: one slice, no seams seat.
      Stage 2 seats cover the whole range.
    - **Evidence.** Seats consume the integration gate's evidence from the brief.
      A seat runs at most one targeted test of its own, never the suite.
    
    | Stage | Role | Count | Purpose |
    |---|---|---|---|
    | Stage 1 — Correctness | `reviewer` (focus `spec`, phase `post-implementation`) | 1 per pipeline | design ↔ implementation traceability; also runs the [convergence check](../hex-core/references/loop.md#convergence-contract) when the target traces to a plan |
    | Stage 1 — Correctness | `reviewer` (focus `quality`, test-coverage emphasis) | 0–1 per pipeline | Specify-phase test adequacy (`high` and above) |
    | Stage 1 — Correctness | `reviewer` (focus `spec`, seams) | 0–1 | contract-wave files and cross-pipeline boundaries (2+ pipelines) |
    | Stage 2 — Panel | `reviewer` (focus `quality`) | 1 | naming, style, pattern compliance |
    | Stage 2 — Panel | `reviewer` (focus `security`) | 0–1 | fires on security-sensitive paths |
    | Stage 2 — Panel | `reviewer` (focus `performance`) | 0–1 | fires on hot-path / async changes |
    | Stage 2 — Panel | `doc-reviewer` | 0–1 | fires on a doc-trigger match |
    | Stage 2 — Panel (`high` and above) | `architect` | 0–1 | boundary / dependency-direction review |
    | Stage 2 — Panel (`high` and above) | `researcher` | 0–1 | SOTA / known-pitfall gap check |
    | Adversary | configured adversary skill (`code-diff` or `plan-artifact`) | 1 at `medium`+ (every configured entry at `max`) | cross-model review |
    | Stage 2 — Panel (`max`) | `simulator` | 0 (4+ at `max` only) | one user pattern each against the target; reported, never fixed |
    
    A project's `tiers.hex-review.<tier>.counts` can override any Count cell
    above against the baseline this table sets
    ([`config.md` § Merge rules](../hex-core/references/config.md#merge-rules)).
    
    Concurrency cap and degraded mode:
    [`protocol.md`](../hex-core/references/protocol.md#worker-coordination). The
    adversary skill name comes from `hex.md › Preferences`
    ([adversary contract](../hex-core/references/adversary.md#adversary-contract));
    `codex-adversary` is only an example value. The adversary runs in every call
    at `medium` and up; when it is unavailable, log the skip line and continue —
    never wait for it. A markdown-artifact target uses
    the `plan-artifact` scope; every other target uses `code-diff`.
    
    ## Project rules and conventions
    
    hex never carries a hardcoded rule or area table. Every phase that needs the
    project's invariants, quality rules, or verification command discovers them
    from **project context** (the client's ambient instructions / project
    rules) and the pointers in the Pointers section of
    `.agents/memory/hex.md`
    ([`memory.md`](../hex-core/references/memory.md#the-three-sections)).
    Reviewers never run the project's verification; they read the gate evidence
    (§ Worker assignment). Path
    hints from `hex.md › Preferences` (e.g. "security review mandatory under
    `src/auth/**`") fold into perspective selection at classification time
    ([`classify.md`](classify.md)).
    
    ## The review report
    
    **Where it goes.** The report is presented inline as the response to this
    invocation — it is not a persisted plan artifact. hex-review's writes land
    only here, on the plan artifact itself, never on the code or diff under
    review. When the target traces to an active plan (the `hex.md › Memory`
    active-plan pointer, or a `## Status` block found in a referenced markdown
    file — see [`memory.md`](../hex-core/references/memory.md)),
    mutate that block: on round entry, flip `State` to `review`; on verdict,
    set `State` to `done` with `Next` cleared (Approve — or `State: landing`,
    not `done`, for a plan carrying a `Repo` column, whose `Next` names the
    landing enumeration, C-324), or leave `State: executing` and set `Next` to
    `/hex-execute <plan path>` (Needs Work / Request Changes). Skip silently when
    no active plan is found — never invent one. An Approve never writes the
    terminal review state — `done`, or `landing` for a plan carrying a `Repo`
    column — where the run ended with a non-empty stranded set
    ([`decompose.md`](../hex-core/references/decompose.md#parallel-by-default-decomposition)).
    This skill runs when invoked, by the user or in loop mode, and remains the
    sole writer of the terminal review state.
    Writing the `Reviewed:` anchor is a Status-block write, the class of write
    `hex-review` already performs — a branch-scope pass only
    ([`loop.md`](../hex-core/references/loop.md#the-last-reviewed-anchor)).
    
    **Federated diff scope (C-309).** When the target traces to a plan carrying a
    `Repo` column, the resolved review scope is not one repo's diff but the
    **union** over the lead (`.`) plus every distinct `Repo` value — each computed
    as `git -C <repo> diff <base>...hex/<plan-slug>` and presented to the panel as
    one diff set with each hunk labelled by its repo. `<base>` is the frozen
    per-repo base SHA **read from the plan's `Repos:` ledger**
    ([`worktree.md` C-317/C-324](../hex-core/references/worktree.md#pipeline-worktree-mechanics)),
    **never re-resolved** from a trunk ref that may have moved since execution
    started. The C-320 pre-flight (step 2) has already proven every participating
    repo reachable, so the union is never silently narrower than the plan. Absent a
    `Repo` column the scope is step 2's single diff, byte-identical. Only the
    scope's construction generalizes — the never-edits and stay-in-scope contracts
    below are unchanged.
    
    When the target traces to a plan artifact, also run the
    [convergence check](../hex-core/references/loop.md#convergence-contract):
    the orchestrator — never a worker — appends any gap as new pipeline rows at the
    end of the plan's Parallelization table (their wave derives as the next
    topological level); the plan stays byte-identical when nothing is
    outstanding ("Converged").
    
    **Fold-Back phase.** After the convergence check and before Upkeep, the
    [Fold-Back phase](../hex-core/references/archive.md) folds the plan's
    `## Spec Deltas` into the project's documented spec home. It runs **only**
    when all four preconditions hold **and** the plan carries a `## Spec Deltas`
    block (the archive.md conditional-load trigger, S-410); otherwise it does not
    run and the Fold-Back block below says so in one line (`not performed —
    <reason>`):
    
    1. the target traces to a plan artifact (as above);
    2. the verdict is **Approve**;
    3. the convergence check reported **Converged**;
    4. this run is about to write the plan's **terminal review state** — `done`,
       or `landing` for a plan carrying a `Repo` column (a federated plan, whose
       Approve writes `landing`, never `done` — so keying on `done` alone would
       strand it, never folding).
    
    Order is not cosmetic: convergence is the mirror of this phase and runs
    first, always
    ([`loop.md`](../hex-core/references/loop.md#convergence-contract)),
    because folding an incompletely delivered plan would write aspiration into
    truth. **Every mechanic is defined in
    [`archive.md`](../hex-core/references/archive.md) and is not restated here** —
    the delta grammar, destination resolution and containment, the safety
    envelope and its four pasted-command checks, halt semantics, idempotence,
    the fold receipt, and revert. The phase's only writes are the one resolved
    spec file and the fold receipt it appends to the plan's `## Spec Deltas`
    block; both land uncommitted, and every run emits the mandatory Fold-Back
    block in the report skeleton below.
    
    **Synthesis self-check.** Before emitting the report, the orchestrator
    confirms on its own draft:
    
    - every duplicate `file:line` finding resolved
      [max-wins](../hex-core/references/severity.md#finding-severity), never
      averaged;
    - every `doc-reviewer` grade mapped onto the
      [severity ladder](../hex-core/references/severity.md#finding-severity);
    - every cross-model escalation is noted in the Cross-Model Adversarial
      section;
    - every empty findings bucket printed `(none)`.
    
    **Required skeleton** (tier files add or drop sections per the breadth they
    run — absence of a section is a tier contract, not a bug):
    
    ```markdown
    ## Code Review: <target>
    ### Summary
    - Verdict: Approve | Needs Work | Request Changes
    - Tier / Baseline / Diff: N files, +L / -L lines, S areas
    ### Stage 1 — Correctness
    ### Stage 2 — <perspectives run at this tier>
    ### Convergence   <!-- when the target traces to a plan artifact -->
    ### Fold-Back     <!-- mandatory when the target traces to a plan; `not performed — <reason>` if a precondition fails -->
    ### Cross-Model Adversarial               <!-- if adversary=on fired -->
    ### Root-Cause Analysis                   <!-- if rca=on -->
    ### Deferred Findings (human judgment required)
    ```
    
    The Convergence section holds one line per unmet requirement ID (`missing`
    | `partial` | `contradicts` | `unrequested`), or the single word
    `Converged` — see the
    [convergence contract](../hex-core/references/loop.md#convergence-contract).
    
    The **Fold-Back section is mandatory whenever the target traces to a plan**,
    and prints `not performed — <reason>` when any precondition fails (verdict not
    Approve; unconverged; not the terminal review state; the target does not trace
    to a plan; or the plan carries no `## Spec Deltas` block). When the phase runs, every line is **pasted command output, never
    narration** — see
    [`archive.md` § evidence](../hex-core/references/archive.md#evidence-is-command-output-not-narration-c-414):
    
    - **target** and how it resolved (`Related Spec:` / carries the IDs / plan
      slug);
    - the **ID-marker convention** and its source (`default` / `hex.md ›
      Preferences`);
    - the **census** — `live` (pasted `grep` transcript) and `incoming` (the
      delta block's IDs);
    - **per-ID disposition** (`C-002 modified`, `C-003 removed`, `C-004 added`);
    - a **per-touched-ID content excerpt** — the live body's first line and its
      pasted non-blank line count beside the incoming body's, so prose loss shows
      in the report;
    - a **per-`MODIFIED` sub-ID census** — the live body's sub-ID set and the
      incoming body's, both as pasted command output (C-405), beside that
      line-count pair, so a dropped inline sub-clause shows in the report;
    - the **containment verdict** with the resolved path and its pasted
      `git ls-files` transcript — printed on **every** run, not only on failure;
    - **destination cleanliness** as pasted `git status --porcelain` output **at
      step 4 and again at step 6**;
    - **`targets: 1`** with prepared-then-written;
    - the **fold receipt** it appended to the plan (`Folded: …`);
    - the **revert** command, `git checkout -- <target>`.
    
    An absent Fold-Back block, or a prose assertion standing where a command
    transcript belongs, is a spec violation.
    
    **Verdict rules** (tier files refine thresholds):
    
    - **Request Changes** — any unresolved
      [Block-tier](../hex-core/references/severity.md#finding-severity) finding,
      a security vulnerability, a breaking change without a migration note, new
      behavior without tests, or an **unjustified constitution violation** (a
      violation with no adequate Constitution Deviations row is automatic
      Request Changes — see the
      [constitution gate](../hex-core/references/protocol.md#constitution-gate)).
    - **Needs Work** — **High- or Warn-tier** findings remain, the cross-model
      pass surfaced actionable findings not yet addressed, or the
      [convergence check](../hex-core/references/loop.md#convergence-contract)
      found unconverged gaps — unconverged gaps cap the verdict at Needs Work,
      never Approve, with `Next: /hex-execute <plan path>`.
    - **Approve** — otherwise.
    
    **Review-only contract.** hex-review **never edits the code or diff under
    review, and never commits.** Its writes are the plan-artifact mutations
    above — the Status block, including the `Reviewed:` anchor line on a
    branch-scope pass, and the append-only convergence rows — plus, under
    the [Fold-Back phase](#the-review-report)'s four preconditions only, the one
    resolved spec file and the fold receipt appended to the plan's `## Spec
    Deltas` block; a fold is never inferred from silence, and every write lands
    uncommitted (revert is `git checkout -- <file>`, see
    [`archive.md`](../hex-core/references/archive.md#revert)). Every finding is
    reported, not applied; the fix loop belongs to
    [`/hex-execute`](../hex-core/references/loop.md#the-review-fix-loop).
    **Fix rounds** are the caller's: cap 2, each re-review covers the fix delta
    only ([`loop.md`](../hex-core/references/loop.md#delta-round-scope)); what
    remains after round 2 goes to the user.
    
    ## Constraints
    
    - **Never edits the code or diff under review, and never commits** — its
      writes are the plan-artifact Status block, including the `Reviewed:`
      anchor line on a branch-scope pass, and the append-only convergence
      rows, and — under the [Fold-Back phase](#the-review-report)'s four
      preconditions only — the one resolved spec file and the fold receipt (see
      [`archive.md`](../hex-core/references/archive.md)).
    - **No approving with an unresolved Block-tier finding** — the verdict
      rules above are binding.
    - **A federated plan's Approve writes `State: landing`, not `done`** (C-324) —
      a plan carrying a `Repo` column stops at `landing` so the satellite locks
      outlive the broken-integration window (removed only on `done`, per
      [`protocol.md` § Upkeep](../hex-core/references/protocol.md#upkeep-step));
      single-repo plans keep `review → done` byte-identically. `landing` is the
      terminal review state the [Fold-Back phase](#the-review-report) already keys
      on.
    - **No mid-flow questions** — ambiguity is resolved at the single gate; in loop mode there is no gate and no question.
    - **Never exceed the concurrency cap**
      ([`protocol.md`](../hex-core/references/protocol.md#worker-coordination)).
    - **Always** cite specific files and lines; **always** pair a finding with
      a remediation, not just a problem.
    - **Always** classify every finding actionable or deferred — nothing
      reaches the report unclassified.
    - **Always stay within the resolved diff scope** (`<base>...<target>`), and
      **across every participating repo** for a federated plan — the C-309 union,
      not one repo's slice. A regression the diff introduces in an unchanged file
      is in scope; pre-existing issues in unrelated code are not.
    - Don't nitpick style the project's own formatter or linter already
      enforces (discovered from project context).
    - **Upkeep**
      ([`protocol.md`](../hex-core/references/protocol.md#upkeep-step)): as the
      final phase, update any `hex.md › Pointers` entry this run revealed as
      drifted. When this run wrote the plan's **terminal review state** (`done`,
      or `landing` for a plan carrying a `Repo` column), also **clear the
      `hex.md › Memory` active-plan pointer** — the first clear in the bundle —
      and record the plan plus its fold target in the artifact index
      ([`archive.md` § Plan archive](../hex-core/references/archive.md#plan-archive)).
    
    ## Handoff
    
    The [handoff contract](../hex-core/references/protocol.md#handoff-contract)
    applies: this block is the run's required final message; one optional
    proceed question may follow it.
    
    ```markdown
    ## Review Complete: <target>
    
    ### Classification
    - Scope: small | medium | large
    - Tier: low | medium | high | xhigh | max
    - Baseline: <ref>
    - Overlays: breadth=<minimal|full|adversarial>, rca=<on|off>, adversary=<on|off>
    
    ### Verdict
    - Approve | Needs Work | Request Changes
    
    ### Findings   <!-- [severity] prefix absent below tier high -->
    - Actionable:
      - [severity] file:line — issue — remediation      <!-- one line per finding; `(none)` if the bucket is empty -->
    - Deferred:
      - [severity] file:line — issue — why human input is needed   <!-- same; `(none)` if empty -->
    
    ### Cross-model review
    - ran — <n> actionable, <n> deferred, <n> dropped   |   skipped: <reason>
    
    ### Fold-Back   <!-- mandatory when the target traces to a plan; full block per § The review report -->
    - target: <file> · marker: <default | hex.md › Preferences> · targets: 1
    - census / disposition / line-counts / containment / cleanliness: pasted transcripts (see report)
    - receipt: <the `Folded: …` lines appended to the plan>   |   not performed — <reason>
    - revert: git checkout -- <file>
    
    ### Next step
        /hex-execute <plan path> "apply review findings"    <!-- actionable findings exist -->
        /hex-finalize                                       <!-- clean Approve, branch or PR target -->
        (none — approved)                                   <!-- clean verdict, plan-artifact or working-tree target -->
    ```
    
    Consumers: `/hex-execute` (actionable findings, the Review-Fix Loop); the
    human (verdict and deferred findings).
    
    $ARGUMENTS
    
  • tier-high.md 8.6 KB
    Loading…
  • tier-low.md 3 KB
    Loading…
  • tier-max.md 2.5 KB
    Loading…
  • tier-medium.md 4.9 KB
    Loading…
  • tier-xhigh.md 9.5 KB
    Loading…

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.