@expo/code-review-cli 0.9.2 → 0.11.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

@@ -8,7 +8,7 @@ import { addTokenUsage, AgentTimeoutError, assertModelsResolvable, buildOpencode
 import { buildEngineMap, claudeTemperatureNote, claudeTokenCredential, startClaudeCode, } from "./claude-code.js";
 import { routeAgents } from "./router.js";
 import { buildCrossCuttingSystem, buildCrossCuttingTask, buildReviewerSystem, buildReviewerTask, NO_TOOLS_INSTRUCTION, } from "./prompts.js";
-import { fingerprintFinding, isOverallRiskHandoff, parseReviewerOutput } from "./schema.js";
+import { fingerprintFinding, isOverallRiskHandoff, parseReviewerOutput, REVIEW_TRACE_AGENT_LIMIT, REVIEW_TRACE_BYTES_LIMIT, REVIEW_TRACE_CHECKED_LIMIT, REVIEW_TRACE_UNCERTAINTY_LIMIT, } from "./schema.js";
 import { adjudicateFeedback } from "./adjudicate.js";
 import { buildManifestMembership, manifestKey, normalizeManifestPath } from "./stack.js";
 import { confirmStackRequalifications, patchConfirmer } from "./stack-confirm.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();
@@ -283,6 +289,10 @@ export async function runReview(source, options) {
     // reviewers produced before the failure — partial findings are exactly what's
     // needed to debug a run that died mid-way.
     const agentFindings = {};
+    // Bounded, conclusion-only diagnostics for machine consumers of the hidden
+    // comment state. These are deliberately separate from findings: they never reach
+    // the coordinator, verification, policy, or decision paths.
+    const agentTrace = {};
     // First reviewer (by scheduling order) that produced each fingerprint, so a finding's
     // originating agent can be carried through the coordinator's merge/rewrite by matching
     // on fingerprint. Kept separate from agentFindings so the coordinator prompt and the
@@ -324,7 +334,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 +477,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 +491,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,
@@ -489,6 +500,9 @@ export async function runReview(source, options) {
                 trackTokens(task.bucket, tokens);
                 trackModel(task.bucket, taskModel(task), model);
                 (agentFindings[task.bucket] ??= []).push(...value.findings);
+                if (value.trace) {
+                    mergeTraceNotes(agentTrace, task.bucket, value.trace);
+                }
                 for (const finding of value.findings) {
                     const fp = fingerprintFinding(finding);
                     if (!agentByFp.has(fp)) {
@@ -497,7 +511,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 +520,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 +545,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 +557,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 +575,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 +587,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 +648,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 +723,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;
@@ -854,6 +868,7 @@ export async function runReview(source, options) {
         }
         progress(formatUsageSummary(tokenTotals, sum(agentCosts)));
         await appendStepSummary(renderUsageMarkdown(agentTokens, agentCosts, tokenTotals, sum(agentCosts), agentModels));
+        const reviewTrace = buildReviewTrace(agentTrace);
         await safeLog(logPath, {
             ...baseRecord,
             agentCosts,
@@ -862,6 +877,7 @@ export async function runReview(source, options) {
             agentTokens,
             agentModels,
             agentFindings,
+            reviewTrace,
             coverageNotes,
             verifierDropped,
             requalificationStrips,
@@ -878,7 +894,14 @@ export async function runReview(source, options) {
         });
         // Engine-owned: overwrite whatever the coordinator may have emitted under this key,
         // so setup advice is always the checker's, never model text.
-        const reviewed = { ...output, setupNotes };
+        // `CoordinatorOutputSchema` knows the engine field so cached/embedded reviews can
+        // parse it, but the coordinator must never author it. Strip any model-supplied
+        // value and attach only the trace assembled from reviewer pass outputs.
+        const outputWithTrace = attachReviewTrace(output, reviewTrace);
+        const reviewed = {
+            ...outputWithTrace,
+            setupNotes,
+        };
         return feedbackRecords ? { ...reviewed, feedback: feedbackRecords } : reviewed;
     }
     catch (error) {
@@ -889,6 +912,7 @@ export async function runReview(source, options) {
             tokens: tokenTotals,
             agentTokens,
             agentFindings,
+            reviewTrace: buildReviewTrace(agentTrace),
             durationMs: Date.now() - started,
             decision: null,
             findingCount: 0,
@@ -903,6 +927,50 @@ export async function runReview(source, options) {
         await restoreCwd();
     }
 }
+export function mergeTraceNotes(target, agent, notes) {
+    const current = target[agent] ?? { checked: [], uncertainties: [] };
+    const checked = [...new Set([...current.checked, ...notes.checked])].slice(0, REVIEW_TRACE_CHECKED_LIMIT);
+    const uncertainties = [...new Set([...current.uncertainties, ...notes.uncertainties])].slice(0, REVIEW_TRACE_UNCERTAINTY_LIMIT);
+    if (checked.length > 0 || uncertainties.length > 0) {
+        target[agent] = { checked, uncertainties };
+    }
+}
+export function buildReviewTrace(agents) {
+    // Sorting makes the cap deterministic even though concurrent passes finish in a
+    // nondeterministic order. The byte ceiling protects GitHub's ~65k comment limit;
+    // the trace shares that body with visible findings and their durable state.
+    const entries = Object.entries(agents).sort(([left], [right]) => left.localeCompare(right));
+    if (entries.length === 0) {
+        return undefined;
+    }
+    const kept = entries.slice(0, REVIEW_TRACE_AGENT_LIMIT);
+    let truncatedAgents = entries.length - kept.length;
+    for (;;) {
+        const trace = {
+            version: 1,
+            trust: "unverified-model-diagnostics",
+            agents: Object.fromEntries(kept),
+            ...(truncatedAgents > 0 ? { truncatedAgents } : {}),
+        };
+        if (Buffer.byteLength(JSON.stringify(trace), "utf8") <= REVIEW_TRACE_BYTES_LIMIT) {
+            return trace;
+        }
+        if (kept.length === 0) {
+            return undefined;
+        }
+        kept.pop();
+        truncatedAgents++;
+    }
+}
+/**
+ * Replace any coordinator-authored trace with the engine-assembled value. The
+ * coordinator reads untrusted PR data, so its output can never populate this hidden
+ * machine-consumer channel even when it emits a locally schema-valid object.
+ */
+export function attachReviewTrace(output, reviewTrace) {
+    const { reviewTrace: _coordinatorTrace, ...withoutTrace } = output;
+    return { ...withoutTrace, ...(reviewTrace ? { reviewTrace } : {}) };
+}
 /**
  * Policy backstop: strip the internal risk handoff, drop suggestions unless
  * opted in, cap by count (most severe first), and downgrade

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,72 @@ 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 });
+/**
+ * Bounded, non-finding diagnostics a reviewer may leave for machine consumers.
+ * These notes explain what a clean pass actually checked without exposing a raw
+ * transcript or chain-of-thought. They remain unverified model output, so the
+ * engine labels the assembled trace with an explicit trust classification.
+ */
+export const REVIEW_TRACE_AGENT_LIMIT = 12;
+export const REVIEW_TRACE_CHECKED_LIMIT = 3;
+export const REVIEW_TRACE_UNCERTAINTY_LIMIT = 2;
+export const REVIEW_TRACE_NOTE_LIMIT = 240;
+export const REVIEW_TRACE_BYTES_LIMIT = 6_000;
+export const ReviewerTraceNotesSchema = z.object({
+    checked: z
+        .array(z.string().min(1).max(REVIEW_TRACE_NOTE_LIMIT))
+        .max(REVIEW_TRACE_CHECKED_LIMIT)
+        .default([]),
+    uncertainties: z
+        .array(z.string().min(1).max(REVIEW_TRACE_NOTE_LIMIT))
+        .max(REVIEW_TRACE_UNCERTAINTY_LIMIT)
+        .default([]),
+});
+/** Provider-facing shape each sub-reviewer is asked to emit. */
+const ReviewerModelOutputSchema = z.object({
+    findings: z.array(ModelFindingSchema).default([]),
+    trace: ReviewerTraceNotesSchema.optional(),
+});
+/**
+ * Local trust boundary for reviewer output. Findings stay strict, while diagnostics
+ * fail soft: a malformed optional trace must never discard otherwise valid findings
+ * or turn a clean pass into a coverage gap.
  */
-const ModelFindingSchema = FindingSchema.omit({ agent: true }).transform((finding) => finding);
-/** Shape each sub-reviewer must emit. */
-export const ReviewerOutputSchema = z.object({
+export const ReviewerOutputSchema = z
+    .object({
     findings: z.array(ModelFindingSchema).default([]),
+    trace: z.unknown().optional(),
+})
+    .transform((output) => {
+    const trace = ReviewerTraceNotesSchema.safeParse(output.trace);
+    return {
+        findings: output.findings,
+        ...(trace.success ? { trace: trace.data } : {}),
+    };
+});
+export const ReviewTraceSchema = z.object({
+    version: z.literal(1),
+    trust: z.literal("unverified-model-diagnostics"),
+    agents: z.record(z.string(), ReviewerTraceNotesSchema),
+    truncatedAgents: z.number().int().nonnegative().optional(),
 });
 /** 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
@@ -125,6 +167,14 @@ export const CoordinatorOutputSchema = z.object({
     // Optional (like couldNotComplete) so every internal CoordinatorOutput literal stays
     // valid without restating an engine-owned field.
     setupNotes: z.array(z.string()).optional(),
+    /**
+     * Machine-readable reviewer diagnostics embedded in the hidden PR-comment state.
+     * Engine-owned and excluded from the coordinator's provider-side schema. It is not
+     * rendered as prose and must never affect the decision or finding set.
+     */
+    // Fail soft here too: the coordinator cannot author this engine field, and a
+    // malformed injected value must not fail consolidation before the engine strips it.
+    reviewTrace: ReviewTraceSchema.optional().catch(undefined),
 });
 /** How an author's reply to a finding held up against the source. */
 export const FEEDBACK_VERDICTS = ["accepted", "refuted", "unclear"];
@@ -271,9 +321,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 +391,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, ReviewerModelOutputSchema);
+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.11.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.