@expo/code-review-cli 0.9.2 → 0.10.0

package/build/core/review-cache.js

@@ -0,0 +1,108 @@
+// @ref LLP 0005#review-result-cache [implements] — automated CI reuses only a complete result whose full review input hashes identically
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { lstat, readlink } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathInside } from "./exec.js";
+const packageVersion = createRequire(import.meta.url)("../../package.json")
+    .version;
+/**
+ * Version the cache-key contract independently of the embedded comment-state shape.
+ * Bump this whenever review inputs gain a new source that is not represented below.
+ */
+const REVIEW_INPUT_HASH_VERSION = 1;
+/** Canonical JSON: object-key order never turns the same input into a cache miss. */
+function canonicalJson(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value) ?? "null";
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(canonicalJson).join(",")}]`;
+    }
+    const record = value;
+    return `{${Object.keys(record)
+        .filter((key) => record[key] !== undefined)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
+        .join(",")}}`;
+}
+/**
+ * Hash every input that can change the code-review result while deliberately
+ * excluding checkout-local paths and commit OIDs. A restack changes OIDs; when the
+ * scoped changed-file contents, normalized patch, prompts/config and PR prose are
+ * byte-identical, that is the cache hit this key is meant to recognize.
+ */
+function normalizedPatch(patch, binary) {
+    return (patch
+        .split("\n")
+        // Blob ids are volatile across a restack. A binary patch has no textual content
+        // to hash, so retain its index line as the only content identity available.
+        .filter((line) => binary || !line.startsWith("index "))
+        // Unrelated lines landing earlier in the file move hunk coordinates without
+        // changing the code under review. Preserve any trailing function heading.
+        .map((line) => line.replace(/^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@(.*)$/, "@@ @@$1"))
+        .join("\n"));
+}
+async function fileContentIdentity(root, file) {
+    const abs = path.resolve(root, file.path);
+    if (!pathInside(abs, root)) {
+        throw new Error(`review cache path escapes the PR tree: ${file.path}`);
+    }
+    let stat;
+    try {
+        stat = await lstat(abs);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { kind: "missing" };
+        }
+        throw error;
+    }
+    if (stat.isSymbolicLink()) {
+        // Never follow a PR-controlled symlink out of the materialized tree.
+        return { kind: "symlink", target: await readlink(abs), mode: stat.mode & 0o777 };
+    }
+    if (!stat.isFile()) {
+        return { kind: "other", mode: stat.mode & 0o777 };
+    }
+    const hash = createHash("sha256");
+    for await (const chunk of createReadStream(abs)) {
+        hash.update(chunk);
+    }
+    return { kind: "file", digest: hash.digest("hex"), mode: stat.mode & 0o777 };
+}
+export async function reviewInputHash(options) {
+    const { configDir: _configDir, ...portableConfig } = options.config;
+    const sortedFiles = [...options.files].sort((a, b) => a.path.localeCompare(b.path) || (a.status ?? "").localeCompare(b.status ?? ""));
+    const files = [];
+    // Sequential reads avoid opening one descriptor per changed file on a very wide PR.
+    for (const file of sortedFiles) {
+        files.push({
+            path: file.path,
+            patch: normalizedPatch(file.patch, file.binary === true),
+            status: file.status ?? "",
+            binary: file.binary === true,
+            content: await fileContentIdentity(options.readRoot, file),
+        });
+    }
+    const input = {
+        version: REVIEW_INPUT_HASH_VERSION,
+        engineVersion: packageVersion,
+        files,
+        config: portableConfig,
+        metadata: options.metadata,
+        agents: options.agents ? [...options.agents].sort() : null,
+        route: options.route === true,
+        contextText: options.contextText ?? null,
+    };
+    return createHash("sha256").update(canonicalJson(input)).digest("hex");
+}
+/** Partial/failed reviews must be retried, never made durable by a cache hit. */
+export function reviewCanBeReused(review) {
+    return review.couldNotComplete !== true && review.incomplete.length === 0;
+}
+/** Exact hash match plus the completeness guard used by every CI comment shape. */
+export function reviewMatchesInput(review, storedHash, currentHash) {
+    return (storedHash === currentHash && /^[a-f0-9]{64}$/.test(storedHash) && reviewCanBeReused(review));
+}

package/build/core/review.js

@@ -70,6 +70,12 @@ export function effectiveConcurrency(config, env = process.env) {
     }
     return 6;
 }
+/** Prefix live model activity with its stable agent bucket and optional pass label. */
+export function formatAgentActivity(agent, label, line) {
+    const pass = label === agent ? "" : label.startsWith(`${agent} `) ? label.slice(agent.length).trim() : label;
+    const activity = line.replace(/[\r\n]+/g, " ").trim();
+    return `  [${agent}] ${pass ? `${pass}: ` : ""}${activity}`;
+}
 export async function runReview(source, options) {
     const { config } = options;
     const started = Date.now();
@@ -324,7 +330,7 @@ export async function runReview(source, options) {
         let selectedAgents = explicitAgents ?? config.agents;
         if (!explicitAgents && options.route) {
             progress("Routing: selecting relevant agents…");
-            const routed = await routeAgents(handle, config, workspace.files);
+            const routed = await routeAgents(handle, config, workspace.files, (line) => progress(formatAgentActivity("router", "router", line)));
             selectedAgents = routed.agents;
             progress(routed.routed
                 ? `Router selected: ${selectedAgents.map((a) => a.id).join(", ")}`
@@ -467,6 +473,7 @@ export async function runReview(source, options) {
         });
         let completedPasses = 0;
         let failedPasses = 0;
+        const taskProgress = (task, line) => progress(formatAgentActivity(task.bucket, task.label, line));
         // promptAndParse already retries internally (same-session corrective, then a
         // bounded fresh session). We do NOT wrap it in another retry loop. On a genuine
         // TIMEOUT, instead of dropping the work we break it into units that converge:
@@ -480,7 +487,7 @@ export async function runReview(source, options) {
                     system: task.system,
                     text: buildTaskText(task),
                     title: task.title,
-                    onActivity: (line) => progress(`  ${task.label}: ${line}`),
+                    onActivity: (line) => taskProgress(task, line),
                     maxWaitMs: task.maxWaitMs,
                     maxToolCalls: task.maxToolCalls,
                     finalizeOnTimeout: true,
@@ -497,7 +504,7 @@ export async function runReview(source, options) {
                 }
                 completedPasses++;
                 if (truncated) {
-                    progress(`  ${task.label}: hit its budget — returned partial findings`);
+                    taskProgress(task, "hit its budget — returned partial findings");
                     incomplete.push(`${capitalize(task.coverageLabel)} ran out of time; its findings may be incomplete.`);
                 }
                 return;
@@ -506,7 +513,7 @@ export async function runReview(source, options) {
                 // Non-timeout errors are genuine failures — record and move on.
                 if (!(error instanceof AgentTimeoutError)) {
                     failedPasses++;
-                    progress(`  ${task.label}: FAILED (${errorMessage(error)})`);
+                    taskProgress(task, `FAILED (${errorMessage(error)})`);
                     // An auth/permission failure hits every pass identically; push one shared,
                     // actionable note (deduped into a single coverage line) instead of N generic
                     // per-pass failures that bury the real, fixable cause.
@@ -531,7 +538,7 @@ export async function runReview(source, options) {
                     const mid = Math.ceil(task.files.length / 2);
                     const left = task.files.slice(0, mid);
                     const right = task.files.slice(mid);
-                    progress(`  ${task.label}: exceeded ${minutes}m — splitting into 2 smaller passes (${left.length} + ${right.length} files)`);
+                    taskProgress(task, `exceeded ${minutes}m — splitting into 2 smaller passes (${left.length} + ${right.length} files)`);
                     const over = { depth: task.depth + 1, maxWaitMs: childCap };
                     enqueue(childTask(task, left, `↳${left.length}f`, over));
                     enqueue(childTask(task, right, `↳${right.length}f`, over));
@@ -543,7 +550,7 @@ export async function runReview(source, options) {
                 // without tools; it just can't open a caller outside the diff. A lighter
                 // cross-file review beats the coverage gap it used to report.
                 if (!task.fallback && remaining > FALLBACK_TIMEOUT_MS) {
-                    progress(`  ${task.label}: exceeded ${minutes}m — retrying ${filesLabel(task.files)} with a fast no-tools pass`);
+                    taskProgress(task, `exceeded ${minutes}m — retrying ${filesLabel(task.files)} with a fast no-tools pass`);
                     enqueue(childTask(task, task.files, "(no-tools fallback)", {
                         fallback: true,
                         maxWaitMs: FALLBACK_TIMEOUT_MS,
@@ -561,7 +568,7 @@ export async function runReview(source, options) {
                 failedPasses++;
                 const couldStillReduce = (canSubdivide && task.depth < MAX_SUBDIVIDE_DEPTH) || !task.fallback;
                 if (error.reason === "stall") {
-                    progress(`  ${task.label}: its model requests went silent (stalled) and did not recover — ` +
+                    taskProgress(task, `its model requests went silent (stalled) and did not recover — ` +
                         `most likely provider rate limiting; reporting a coverage gap`);
                     // Name the likely cause. OpenCode retries a 429 internally without surfacing
                     // it, so provider throttling reaches us as pure silence — indistinguishable
@@ -573,11 +580,11 @@ export async function runReview(source, options) {
                         `those changes were not fully reviewed.`);
                 }
                 else if (couldStillReduce) {
-                    progress(`  ${task.label}: exceeded ${minutes}m and the run's time budget is spent — reporting a coverage gap`);
+                    taskProgress(task, `exceeded ${minutes}m and the run's time budget is spent — reporting a coverage gap`);
                     incomplete.push(`${capitalize(task.coverageLabel)} timed out and the overall review budget was exhausted before it could be broken down further; those changes were not fully reviewed.`);
                 }
                 else {
-                    progress(`  ${task.label}: exceeded ${minutes}m even at its smallest reviewable unit — reporting a coverage gap`);
+                    taskProgress(task, `exceeded ${minutes}m even at its smallest reviewable unit — reporting a coverage gap`);
                     incomplete.push(`${capitalize(task.coverageLabel)} exceeded its time budget even after being reduced to its smallest reviewable unit; those changes were not fully reviewed.`);
                 }
             }
@@ -634,7 +641,7 @@ export async function runReview(source, options) {
             progress("Coordinating findings…");
             let consolidated;
             try {
-                const { output: rawOutput, cost, tokens: coordinatorTokens, truncated: coordinatorTruncated, model: coordinatorModel, } = await coordinate(handle, config, metadata, agentFindings, coverageNotes, stackManifest);
+                const { output: rawOutput, cost, tokens: coordinatorTokens, truncated: coordinatorTruncated, model: coordinatorModel, } = await coordinate(handle, config, metadata, agentFindings, coverageNotes, stackManifest, (line) => progress(formatAgentActivity("coordinator", "coordinator", line)));
                 agentCosts["coordinator"] = cost;
                 trackTokens("coordinator", coordinatorTokens);
                 trackModel("coordinator", config.coordinator.model, coordinatorModel);
@@ -709,7 +716,7 @@ export async function runReview(source, options) {
                 stackManifest &&
                 grounded.some((finding) => finding.requalifiedBy)) {
                 progress("Confirming stacked-PR requalifications against their patches…");
-                const confirmation = await confirmStackRequalifications(grounded, options.stackConfirm.maxConfirmations, patchConfirmer(handle, source), progress);
+                const confirmation = await confirmStackRequalifications(grounded, options.stackConfirm.maxConfirmations, patchConfirmer(handle, source, (line) => progress(formatAgentActivity(STACK_VERIFIER_AGENT, STACK_VERIFIER_AGENT, line))), progress);
                 grounded = confirmation.findings;
                 requalificationStrips.push(...confirmation.strippedFindings);
                 agentCosts[STACK_VERIFIER_AGENT] = confirmation.cost;

package/build/core/router.js

@@ -6,7 +6,7 @@ import { parseRouteOutput } from "./schema.js";
  * `alwaysRun` are unioned in regardless. Falls back to ALL agents if the router
  * returns nothing usable or errors — a review must never run with zero agents.
  */
-export async function routeAgents(handle, config, files) {
+export async function routeAgents(handle, config, files, onActivity) {
     const always = config.agents.filter((agent) => agent.alwaysRun);
     try {
         const { value } = await promptAndParse(handle, {
@@ -14,6 +14,7 @@ export async function routeAgents(handle, config, files) {
             system: buildRouterSystem(),
             text: buildRouterTask(config.agents, files),
             title: "route",
+            onActivity,
         }, parseRouteOutput);
         const byId = new Map(config.agents.map((agent) => [agent.id, agent]));
         const picked = value.agents

package/build/core/schema.js

@@ -66,9 +66,6 @@ export const VerdictSchema = z.object({
     verified: z.boolean(),
     reason: z.string().default(""),
 });
-export function parseVerdict(text) {
-    return VerdictSchema.parse(extractJsonObject(text));
-}
 /**
  * A stack verifier's verdict on whether a later stacked PR's patch actually
  * addresses an absence-style finding (v2 patch confirmation). Fails toward
@@ -79,27 +76,27 @@ export const StackVerdictSchema = z.object({
     addressed: z.boolean(),
     reason: z.string().default(""),
 });
-export function parseStackVerdict(text) {
-    return StackVerdictSchema.parse(extractJsonObject(text));
-}
 // @ref LLP 0011#attribution-and-identity [implements] — `agent` is engine-populated, so the model-facing schema drops it at the parse boundary instead of trusting call sites to strip it
 /**
  * The finding shape a MODEL may emit: `FindingSchema` minus the engine-only `agent`.
  * Both model outputs parse through this, so an `agent` a reviewer pass or the
  * coordinator invented is dropped where model JSON becomes typed data — the engine's own
- * fingerprint lookup is then the only thing that can set it. The transform re-widens the
- * result to `Finding` so downstream code (which does set `agent`) needs no change.
+ * fingerprint lookup is then the only thing that can set it. This schema deliberately
+ * has no Zod transform: the Claude runtime converts it to JSON Schema so the provider
+ * can enforce the same contract before the local parse boundary checks it again.
  */
-const ModelFindingSchema = FindingSchema.omit({ agent: true }).transform((finding) => finding);
+const ModelFindingSchema = FindingSchema.omit({ agent: true });
 /** Shape each sub-reviewer must emit. */
 export const ReviewerOutputSchema = z.object({
     findings: z.array(ModelFindingSchema).default([]),
 });
 /** Mode-agnostic coordinator result; each Reporter decides how to render it. */
-export const CoordinatorOutputSchema = z.object({
+const CoordinatorModelOutputSchema = z.object({
     decision: z.enum(DECISIONS),
     findings: z.array(ModelFindingSchema).default([]),
     summary: z.string(),
+});
+export const CoordinatorOutputSchema = CoordinatorModelOutputSchema.extend({
     /**
      * Human-readable notes about reduced coverage (e.g. a review pass that hit its
      * time limit and returned partial findings, or was skipped). Populated by the
@@ -271,9 +268,6 @@ export const AdjudicationSchema = z.object({
     verdict: z.enum(FEEDBACK_VERDICTS),
     reason: z.enum(FEEDBACK_REASONS).default("other"),
 });
-export function parseAdjudication(text) {
-    return AdjudicationSchema.parse(extractJsonObject(text));
-}
 /** Minimum normalized evidence length to key a fingerprint on the code (below
  * this we fall back to the title). */
 const MIN_FP_EVIDENCE_LEN = 12;
@@ -344,12 +338,20 @@ export function extractJsonObject(text) {
 export const RouteOutputSchema = z.object({
     agents: z.array(z.string()).default([]),
 });
-export function parseRouteOutput(text) {
-    return RouteOutputSchema.parse(extractJsonObject(text));
-}
-export function parseReviewerOutput(text) {
-    return ReviewerOutputSchema.parse(extractJsonObject(text));
-}
-export function parseCoordinatorOutput(text) {
-    return CoordinatorOutputSchema.parse(extractJsonObject(text));
+/**
+ * Bind local Zod validation to the draft-07 JSON Schema Claude Code consumes.
+ * Local parsing remains authoritative; provider-side validation is a reliability
+ * layer that repairs malformed output before it reaches this trust boundary.
+ */
+// @ref LLP 0003#retry-taxonomy [implements] — Claude receives the same contract as the local parser and repairs mismatches in-session
+function structuredParser(parseSchema, outputSchema = parseSchema) {
+    const parser = ((text) => parseSchema.parse(extractJsonObject(text)));
+    parser.jsonSchema = z.toJSONSchema(outputSchema, { target: "draft-7" });
+    return parser;
 }
+export const parseVerdict = structuredParser(VerdictSchema);
+export const parseStackVerdict = structuredParser(StackVerdictSchema);
+export const parseAdjudication = structuredParser(AdjudicationSchema);
+export const parseRouteOutput = structuredParser(RouteOutputSchema);
+export const parseReviewerOutput = structuredParser(ReviewerOutputSchema);
+export const parseCoordinatorOutput = structuredParser(CoordinatorOutputSchema, CoordinatorModelOutputSchema);

package/build/core/stack-confirm.js

@@ -103,7 +103,7 @@ export async function confirmStackRequalifications(findings, maxConfirmations, c
  * it into the no-tools stack verifier, and require `addressed: true`. The patch is
  * inlined, never materialized — there is no disk read and no tool use at all.
  */
-export function patchConfirmer(handle, source) {
+export function patchConfirmer(handle, source, onActivity) {
     // Per-run patch memo: distinct findings citing the same (prNumber, file) each get
     // their own verdict but share one gh fetch. The source fails open to null (never
     // rejects), so memoizing the promise is safe.
@@ -131,6 +131,7 @@ export function patchConfirmer(handle, source) {
             // A timeout here throws AgentTimeoutError, which the caller catches and STRIPS
             // (fail toward blocking) — so no finalize salvage, unlike the main verifier.
             finalizeOnTimeout: false,
+            onActivity: (line) => onActivity?.(`PR #${prNumber}: ${line}`),
         }, parseStackVerdict);
         return { addressed: value.addressed === true, cost, tokens, model };
     };

package/build/core/verify.js

@@ -123,6 +123,7 @@ export async function verifyFindings(handle, findings, cwd, onProgress) {
                 title: `verify-${index}`,
                 maxWaitMs: VERIFY_TIMEOUT_MS,
                 finalizeOnTimeout: true,
+                onActivity: (line) => onProgress?.(`  [verifier] #${index + 1}: ${line}`),
             }, parseVerdict);
             cost += verifyCost;
             addTokenUsage(tokens, verifyTokens);

package/build/reporters/github.js

@@ -314,7 +314,7 @@ export class GitHubReporter {
      * (annotate mode). Either way the feedback path fails soft — it never blocks the
      * comment from being posted.
      */
-    async report(review, feedback) {
+    async report(review, feedback, inputHash) {
         // Carry forward any per-PR dismissals recorded in the existing comment so they
         // survive re-reviews (a dismissed finding stays in the collapsed section).
         const existing = await this.findExistingComment();
@@ -332,7 +332,7 @@ export class GitHubReporter {
             ? applyPins(feedback, pinsIn)
             : await this.computeFeedback(withFp, priorRecords, pinsIn);
         const link = await this.linkContextAsync();
-        await this.upsertComment(renderMarkdown(review, this.options.commentTag, dismissed, link, records, pins));
+        await this.upsertComment(renderMarkdown(review, this.options.commentTag, dismissed, link, records, pins, inputHash));
     }
     /** Post/update the aggregate multi-scope comment (comment:'single' mode). */
     async reportAggregate(results, unmatchedFiles, feedback) {
@@ -599,7 +599,7 @@ export class GitHubReporter {
         const link = await this.linkContextAsync();
         const body = isAggregate
             ? renderAggregateMarkdown(state.scopes, this.options.commentTag, next.dismissed, link, undefined, next.feedback, next.pins)
-            : renderMarkdown(state.review, this.options.commentTag, next.dismissed, link, next.feedback, next.pins);
+            : renderMarkdown(state.review, this.options.commentTag, next.dismissed, link, next.feedback, next.pins, state.inputHash);
         await this.patchComment(existing.id, body);
         return {
             dismissedCount: next.dismissed.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/code-review-cli",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "Generic, config-driven AI code reviewer engine. Repos supply their agents via .expo-code-review/.",
   "license": "MIT",
   "repository": {

package/templates/agents/security.md

@@ -3,11 +3,11 @@
 description: Security and secrets. Injection, credential or secret leakage, unsafe shell/child-process use, missing validation at trust boundaries.
 alwaysRun: true
 # Security is the highest-stakes agent and benefits most from stronger threat-model
-# reasoning, so it runs on the pro tier even though the other specialists use the
+# reasoning, so it runs on the Opus tier even though the other specialists use the
 # default model. Scoped to this one agent to limit the extra latency/rate-limit cost;
-# subdivide-on-timeout + the per-fetch deadline keep a slow pro pass from hanging.
+# subdivide-on-timeout + the per-fetch deadline keep a slow Opus pass from hanging.
 # @ref LLP 0009#config-and-prompt-templates [implements]
-model: openai/gpt-5.5-pro
+model: anthropic/claude-opus-5
 ---
 
 # Security & secrets

package/templates/atlantis.yml

@@ -81,6 +81,11 @@ jobs:
           # disable setup-node's auto package-manager cache.
           package-manager-cache: false
 
+      # The anthropic/… models run through the Claude Code CLI (claude-code
+      # engine). Pinned exactly — see workflow.yml (expo-code-review.yml).
+      - name: Install Claude Code CLI
+        run: npm install -g @anthropic-ai/claude-code@2.1.212
+
       # SECURITY: the base-ref checkout includes every .expo-code-review/ config,
       # whose auth.tokenEnv names the forwarded model credential. `ecr verify-config`
       # sweeps every config and refuses unless tokenEnv appears exactly once, in a
@@ -89,7 +94,7 @@ jobs:
       # @ref LLP 0009#guard-step-ordering-and-job-budgets [implements] — same $ECR_VERSION feeds guard and review
       - name: Guard config tokenEnv (root + routing + all scopes)
         env:
-          ECR_EXPECTED_TOKEN_ENV: ${{ vars.ECR_EXPECTED_TOKEN_ENV || 'OPENAI_API_KEY' }}
+          ECR_EXPECTED_TOKEN_ENV: ${{ vars.ECR_EXPECTED_TOKEN_ENV || 'CLAUDE_CODE_REVIEW_SHARED_API_TOKEN' }}
         run: npx --yes -p "@expo/code-review-cli@$ECR_VERSION" ecr verify-config
 
       # Running via `issue_comment` makes this a manual /review, which the CLI detects
@@ -101,10 +106,11 @@ jobs:
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           # Layer-1 auth lock: keep in sync with the guard's EXPECTED.
-          ECR_EXPECTED_TOKEN_ENV: ${{ vars.ECR_EXPECTED_TOKEN_ENV || 'OPENAI_API_KEY' }}
-          # OpenAI API key — the env var named by auth.tokenEnv in config.jsonc.
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          # Optional: override the model for every agent (uses your OpenCode login).
+          ECR_EXPECTED_TOKEN_ENV: ${{ vars.ECR_EXPECTED_TOKEN_ENV || 'CLAUDE_CODE_REVIEW_SHARED_API_TOKEN' }}
+          # Anthropic review credential — the env var named by auth.tokenEnv in
+          # config.jsonc (see workflow.yml for the accepted token shapes).
+          CLAUDE_CODE_REVIEW_SHARED_API_TOKEN: ${{ secrets.CLAUDE_CODE_REVIEW_SHARED_API_TOKEN }}
+          # Optional: override the model for every agent.
           REVIEWER_MODEL: ${{ vars.REVIEWER_MODEL }}
         run: |
           # Build the flags as a bash array so the path never word-splits.

package/templates/command.yml

@@ -111,6 +111,12 @@ jobs:
           # to save an empty cache and error).
           package-manager-cache: false
 
+      # The anthropic/… models run through the Claude Code CLI (claude-code
+      # engine). Pinned exactly — see workflow.yml (expo-code-review.yml).
+      - name: Install Claude Code CLI
+        if: steps.cmd.outputs.run == 'true'
+        run: npm install -g @anthropic-ai/claude-code@2.1.212
+
       # SECURITY: the base-ref checkout above includes every .expo-code-review/
       # config.jsonc + routing.jsonc, whose auth.tokenEnv names the env var the CLI
       # forwards as the model credential. The canonical guard ships with the CLI:
@@ -126,7 +132,7 @@ jobs:
         if: steps.cmd.outputs.run == 'true'
         env:
           # (Comma-separated set for a multi-credential auth.providers config.)
-          ECR_EXPECTED_TOKEN_ENV: ${{ vars.ECR_EXPECTED_TOKEN_ENV || 'OPENAI_API_KEY' }}
+          ECR_EXPECTED_TOKEN_ENV: ${{ vars.ECR_EXPECTED_TOKEN_ENV || 'CLAUDE_CODE_REVIEW_SHARED_API_TOKEN' }}
         run: npx --yes -p "@expo/code-review-cli@$ECR_VERSION" ecr verify-config
 
       - name: Run AI review
@@ -136,12 +142,13 @@ jobs:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           # Layer-1 auth lock: the CLI refuses to run when the tokenEnv it would honor
           # differs from this. Keep it in sync with the guard's EXPECTED.
-          ECR_EXPECTED_TOKEN_ENV: ${{ vars.ECR_EXPECTED_TOKEN_ENV || 'OPENAI_API_KEY' }}
-          # OpenAI API key — the env var named by auth.tokenEnv in config.jsonc.
-          # Store it as a repo secret; a project-scoped key restricted to model
-          # inference (with a spend limit) is all the reviewer needs.
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          # Optional: override the model for every agent (uses your OpenCode login).
+          ECR_EXPECTED_TOKEN_ENV: ${{ vars.ECR_EXPECTED_TOKEN_ENV || 'CLAUDE_CODE_REVIEW_SHARED_API_TOKEN' }}
+          # Anthropic review credential — the env var named by auth.tokenEnv in
+          # config.jsonc. Store it as a repo secret: an `sk-ant-oat…` token minted
+          # by `claude setup-token`, or an `sk-ant-api…` Console key (the Claude
+          # Code CLI reads either).
+          CLAUDE_CODE_REVIEW_SHARED_API_TOKEN: ${{ secrets.CLAUDE_CODE_REVIEW_SHARED_API_TOKEN }}
+          # Optional: override the model for every agent.
           REVIEWER_MODEL: ${{ vars.REVIEWER_MODEL }}
           AGENTS: ${{ steps.cmd.outputs.agents }}
           ROUTE: ${{ steps.cmd.outputs.route }}

package/templates/config.jsonc

@@ -1,15 +1,17 @@
 // @ref LLP 0009#config-and-prompt-templates — root config: agent roster by filename, phase-1 defaults, auth
 {
-  // Default model for every agent. Override per-agent via frontmatter in the
-  // agent's markdown, or at runtime with the REVIEWER_MODEL env var
-  // (e.g. REVIEWER_MODEL=openai/gpt-5.4-mini).
-  "model": "openai/gpt-5.5",
+  // Default model for every agent. Anthropic models run through the Claude Code
+  // CLI engine (`claude -p`), inferred per agent from the model id — see `auth`
+  // below for the credential. Override per-agent via frontmatter in the agent's
+  // markdown, or at runtime with the REVIEWER_MODEL env var
+  // (e.g. REVIEWER_MODEL=anthropic/claude-haiku-4-5).
+  "model": "anthropic/claude-sonnet-5",
 
   // Agents: every markdown file in agents/ is one reviewer (id = filename).
   // Add or remove files to change the roster — no list needed here.
   // shared.md (prepended to every agent + coordinator) and coordinator.md are
   // reserved filenames. Per-agent overrides go in each file's YAML frontmatter,
-  // e.g. `---\nmodel: openai/gpt-5.5-pro\n---`.
+  // e.g. `---\nmodel: anthropic/claude-opus-5\n---`.
 
   // @ref LLP 0009#config-and-prompt-templates [implements] — suggestions off by default, not a schema limit
   "policy": {
@@ -46,49 +48,39 @@
   // HTML marker used to find + update the single PR comment. Keep it stable.
   "commentTag": "expo-ai-code-reviewer",
 
-  // How model credentials are provided. Default: an OpenAI API key.
-  //   "api-key": tokenEnv names the env var holding a provider API key. In CI,
-  //              store the key as a repo secret and pass it under that env var
-  //              (the scaffolded workflow does). If you omit `auth` entirely,
-  //              OpenCode's own login / ambient provider env vars are used.
-  // For Anthropic/Claude, see the dedicated block below (it now runs through the
-  // Claude Code CLI). For another provider, omit `auth` and set REVIEWER_MODEL
-  // after an `opencode auth login` for that provider.
+  // How model credentials are provided. Default: Anthropic via the Claude Code
+  // CLI. Anthropic models always run through that CLI — the engine is inferred
+  // per agent from the `anthropic/…` model id, so this entry only supplies the
+  // credential. In CI the tokenEnv holds the review credential (an `sk-ant-oat…`
+  // token minted by `claude setup-token`, or an `sk-ant-api…` Console key — the
+  // CLI reads either); locally an active `claude` login is enough, and the entry
+  // could even be omitted. ECR_EXPECTED_TOKEN_ENV (repo variable / workflow
+  // fallback) must equal this tokenEnv. `ecr setup-auth` walks you through it.
   //
-  // MIXED setup (a ChatGPT/Codex subscription for the default models, plus a
-  // metered API key for pro-tier models the subscription doesn't offer): use the
-  // per-provider map instead, reference `openai-api/...` models in the frontmatter
-  // of the agents that need the pro tier, and set ECR_EXPECTED_TOKEN_ENV in the
-  // workflow to the comma-separated set of both env names.
-  //   "auth": { "providers": {
-  //     "openai":     { "mode": "oauth",   "tokenEnv": "CODEX_OAUTH_ACCESS_TOKEN" },
-  //     "openai-api": { "mode": "api-key", "tokenEnv": "OPENAI_API_KEY", "upstream": "openai" }
-  //   } }
-  // (openai oauth: tokenEnv holds the ACCESS token from an `opencode auth login`
-  // ChatGPT sign-in — `ecr setup-auth` extracts it. NEVER share the refresh
-  // token: it is single-use and dies on first rotation.)
+  // Other providers run through OpenCode:
+  //   "api-key": tokenEnv names the env var holding a provider API key. In CI,
+  //              store the key as a repo secret and pass it under that env var.
+  //   "auth": { "mode": "api-key", "provider": "openai", "tokenEnv": "OPENAI_API_KEY" }
   //
-  // Anthropic runs through the Claude Code CLI, inferred from the model — set your
-  // models to "anthropic/…" (e.g. anthropic/claude-opus-5, anthropic/claude-sonnet-5)
-  // and run `claude setup-token`, exporting the token as CLAUDE_CODE_OAUTH_TOKEN (CI)
-  // or rely on your local `claude` login. An auth entry is OPTIONAL (tokenEnv just
-  // names the credential env); `ecr setup-auth` walks you through it.
+  //   ChatGPT/Codex subscription ("oauth"): tokenEnv holds the ACCESS token from
+  //   an `opencode auth login` ChatGPT sign-in — `ecr setup-auth` extracts it.
+  //   NEVER share the refresh token: it is single-use and dies on first rotation.
   //   "auth": { "providers": {
-  //     "anthropic": { "tokenEnv": "CLAUDE_CODE_OAUTH_TOKEN" }
+  //     "openai": { "mode": "oauth", "tokenEnv": "CODEX_OAUTH_ACCESS_TOKEN" }
   //   } }
   //
-  // MIXING engines is supported: the engine is inferred per agent from its model, so
-  // an anthropic entry may coexist with an openai (or any other) OpenCode provider.
-  // Each agent's `model` selects its engine — an `anthropic/…` agent runs through the
-  // Claude Code CLI while an `openai/…` agent runs through OpenCode, in the SAME run.
+  // MIXING engines is supported: the engine is inferred per agent from its model,
+  // so this anthropic entry may coexist with an openai (or any other) OpenCode
+  // provider — an `anthropic/…` agent runs through the Claude Code CLI while an
+  // `openai/…` agent runs through OpenCode, in the SAME run:
   //   "auth": { "providers": {
-  //     "anthropic": { "tokenEnv": "CLAUDE_CODE_OAUTH_TOKEN" },
+  //     "anthropic": { "tokenEnv": "CLAUDE_CODE_REVIEW_SHARED_API_TOKEN" },
   //     "openai":    { "mode": "oauth", "tokenEnv": "CODEX_OAUTH_ACCESS_TOKEN" }
   //   } }
   "auth": {
-    "mode": "api-key",
-    "provider": "openai",
-    "tokenEnv": "OPENAI_API_KEY"
+    "providers": {
+      "anthropic": { "tokenEnv": "CLAUDE_CODE_REVIEW_SHARED_API_TOKEN" }
+    }
   },
 
   // Stack-aware requalification (ROOT-ONLY; off by default). When on, `ecr ci` walks

package/templates/coordinator.md

@@ -1,11 +1,11 @@
 <!-- @ref LLP 0009#config-and-prompt-templates — pro tier pinned on purpose: consolidation quality over serial-tail latency -->
 ---
 # The coordinator makes the final call — de-duping, re-judging severity, and
-# deciding — so it runs on the pro tier: consolidation quality matters more here
+# deciding — so it runs on the Opus tier: consolidation quality matters more here
 # than the small serial-tail latency it adds (no repo tools, one bounded pass).
 # Override with a cheaper model if you'd rather trade decision quality for latency.
 # @ref LLP 0009#config-and-prompt-templates [implements]
-model: openai/gpt-5.5-pro
+model: anthropic/claude-opus-5
 ---
 
 # Coordinator — consolidation & decision