pierre-review 0.1.53 → 0.1.55

package/dist/api/routes/me.js

@@ -41,7 +41,7 @@ export async function meRoutes(app) {
             },
             feedLastSeenAt: feedLastSeen ? feedLastSeen.toISOString() : null,
             newFeedItems,
-            claudeReviewEnabled: config.claudeReviewEnabled,
+            // Claude Review is now the Pro `claudeReview` capability (in `pro` below).
             deploymentMode: config.deploymentMode,
             pro: getProCapabilities(),
         };

package/dist/app.js

@@ -19,7 +19,6 @@ import { feedRoutes } from './api/routes/feed.js';
 import { mergersRoutes } from './api/routes/mergers.js';
 import { insightsRoutes } from './api/routes/insights.js';
 import { activityRoutes } from './api/routes/activity.js';
-import { claudeReviewRoutes } from './api/routes/claude-review.js';
 export async function buildApp() {
     const app = Fastify({
         // In production (the installed CLI) the per-request "incoming request" /
@@ -132,10 +131,9 @@ export async function buildApp() {
     await app.register(mergersRoutes);
     await app.register(insightsRoutes);
     await app.register(activityRoutes);
-    // Claude Review is local-only + opt-in. Only register its routes when enabled,
-    // so the clone-manager / gh-CLI dependency is unreachable in cloud mode.
-    if (config.claudeReviewEnabled)
-        await app.register(claudeReviewRoutes);
+    // Claude Review moved into the @pierre/pro plugin (its routes register there, gated on the
+    // `claudeReview` capability). The SDK-run / diff-prep / GitHub-post infra + the tables stay
+    // in core behind the ctx.review seam; nothing to register here.
     return app;
 }
 //# sourceMappingURL=app.js.map

package/dist/config.js

@@ -141,18 +141,16 @@ export const config = {
         digestMaxReposPerRefresh: intFromEnv('PRO_DIGEST_MAX_REPOS', 30),
         digestMinIntervalSec: intFromEnv('PRO_DIGEST_MIN_INTERVAL_SEC', 60),
     },
-    // ---- Claude Review (agentic PR review; opt-in, LOCAL-ONLY) ----
-    // OFF by default: the feature spends real money / Agent-SDK credits per run.
-    // Enable with ENABLE_CLAUDE_REVIEW=true. FORCE-DISABLED in cloud mode (it
-    // shells out to a local gh + writable clone dir that don't exist on Railway).
-    claudeReviewEnabled: !isCloud && process.env.ENABLE_CLAUDE_REVIEW === 'true',
+    // ---- Claude Review — CORE infra knobs (the product moved to @pierre/pro) ----
+    // The SDK-run / diff-prep infra behind the ctx.review seam reads these. The old
+    // `claudeReviewEnabled` env flag was removed — Claude Review is now the Pro
+    // `claudeReview` capability (PRO_CLAUDE_REVIEW_ENABLED); the routing thresholds,
+    // concurrency + queue caps, and the default-model picker moved to PRO_REVIEW_* env.
     // Partial clones + ephemeral worktrees live here (a user-writable home path,
     // never the read-only install dir). CLONE_DIR overrides.
     cloneDir: process.env.CLONE_DIR ?? resolve(homedir(), '.pierre-review', 'clones'),
     // Soft cap on the clone cache before LRU cleanup evicts idle repos (default 2 GiB).
     cloneCacheMaxBytes: intFromEnv('CLONE_CACHE_MAX_BYTES', 2 * 1024 * 1024 * 1024),
-    // Default model for the picker; per-run model still overrides on the request.
-    defaultReviewModel: process.env.DEFAULT_REVIEW_MODEL ?? 'claude-sonnet-4-6',
     // Per-run caps (cost/disk/time runaway guards). The diff is inlined in full, so
     // reviews need far fewer turns than the old default; 30 is still generous.
     reviewMaxTurns: intFromEnv('REVIEW_MAX_TURNS', 30),
@@ -191,16 +189,8 @@ export const config = {
     // Applied only to effort-capable models (Sonnet/Opus); Haiku ignores it.
     reviewEffort: effortFromEnv('REVIEW_EFFORT', 'medium'),
     reviewDiffOnlyEffort: effortFromEnv('REVIEW_DIFF_ONLY_EFFORT', 'low'),
-    // At most one review per PR; this caps concurrent reviews across all PRs. Default
-    // 4 so the user can bulk-review (extras queue, see review-manager). Raising this
-    // also DISABLES the per-run env auth adjustment (which mutates process.env and is
-    // only safe at concurrency 1 — see auth.applyClaudeReviewAuth); the raw ambient
-    // env is used instead. Set REVIEW_CONCURRENCY=1 to restore prefer-ambient + the
-    // API-key fallback.
-    reviewConcurrency: intFromEnv('REVIEW_CONCURRENCY', 4),
-    // Hard ceiling on QUEUED (not-yet-started) reviews, a runaway guard for bulk
-    // triggering; further starts return 'busy' until the queue drains.
-    reviewMaxQueued: intFromEnv('REVIEW_MAX_QUEUED', 50),
+    // (Review concurrency + queue caps + the routing thresholds moved to the plugin's
+    // PRO_REVIEW_* env — the plugin owns the queue/manager + the mode-routing decision.)
     // ---- AI Fix (Pro: agentic code fixer) — core infra knobs ----
     // The write-capable fixer (packages/pro/ai-fix) reuses the review clone/agent
     // machinery. A runaway fixer is pricier than a review (it edits + re-reads files),
@@ -217,26 +207,6 @@ export const config = {
     // rebased commit that conflicts gets one resolver pass, up to this many steps, then
     // we abort the rebase rather than loop forever on a pathological history.
     aiFixRebaseMaxSteps: intFromEnv('AI_FIX_REBASE_MAX_STEPS', 10),
-    // ---- Claude Review routing (diff-only vs worktree) — THE THRESHOLDS ----
-    // The deterministic pre-check (review/routing.ts) decides, BEFORE the agent runs,
-    // whether a PR can be reviewed from its diff alone (fast, tool-less, no worktree)
-    // or needs the full cloned worktree as explorable context. A change stays
-    // 'diff_only' only if it is within EVERY ceiling below AND touches no exported/
-    // public API; otherwise it routes to 'worktree'. The numbers are deliberately
-    // CONSERVATIVE — any tie routes to worktree, since over-reviewing is safe but
-    // under-reviewing a risky change is not. Every decision input is logged on the
-    // run (claude_reviews.route_reason) so these can be tuned against the agent's own
-    // scopeUsed self-report. This is the single place to review/adjust the thresholds.
-    reviewRouting: {
-        // Max (non-noise) files changed for a diff-only review.
-        maxFiles: intFromEnv('REVIEW_ROUTE_MAX_FILES', 5),
-        // Max added + deleted lines (non-noise files) for a diff-only review.
-        maxLines: intFromEnv('REVIEW_ROUTE_MAX_LINES', 150),
-        // Max distinct directories touched for a diff-only review.
-        maxDirs: intFromEnv('REVIEW_ROUTE_MAX_DIRS', 2),
-        // Max distinct top-level subsystems (first path segment) for a diff-only review.
-        maxSubsystems: intFromEnv('REVIEW_ROUTE_MAX_SUBSYSTEMS', 1),
-    },
 };
 // Fail loud at startup if a required cloud var is missing — mirrors the
 // gh-auth loud failure. Called from index.ts only when deploymentMode==='cloud'.

package/dist/db/queries.js

@@ -1,4 +1,3 @@
-import { createHash } from 'node:crypto';
 import { and, asc, count, desc, eq, exists, gt, gte, inArray, isNotNull, isNull, lt, lte, ne, notInArray, or, sql, } from 'drizzle-orm';
 // Local copy of the shared `REASON_PRIORITY` value constant. `@pierre-review/shared`
 // is a types-only workspace package that is NOT shipped in the published tarball,
@@ -16,6 +15,8 @@ const REASON_PRIORITY = [
 import { db, schema, isPg } from './client.js';
 import { runTransaction } from './client.js';
 import { config } from '../config.js';
+import { getProCapabilities } from '../pro/contract.js';
+import { createHash } from 'node:crypto';
 import { computeApprovalInfoByPr, computeTriage, } from './triage.js';
 import { getAccountUserId } from '../auth/account.js';
 import { ensureRoutingPrFiles } from '../sync/routing-files.js';
@@ -30,6 +31,11 @@ function iso(d) {
 function emptyCounts() {
     return { resolved: 0, likely_addressed: 0, replied_unresolved: 0, untouched: 0 };
 }
+// GitHub anchors a file in a PR's "Files changed" diff by the SHA-256 of its path; used to
+// deep-link the Changes tab's per-file rows (getPrDetail).
+function diffAnchorId(path) {
+    return createHash('sha256').update(path, 'utf8').digest('hex');
+}
 function mapUser(u) {
     return {
         id: u.id,
@@ -1441,7 +1447,7 @@ function myTurnReasonsFor(participation, prId) {
 // Gated on the feature flag (force-off in cloud) so no items appear where Claude Review
 // doesn't exist. Never member-/bot-filtered (a run has no member author).
 async function getClaudeReviewFeedItems(accountId, repoIds, since) {
-    if (!config.claudeReviewEnabled)
+    if (!getProCapabilities().claudeReview)
         return [];
     const conds = [
         eq(repos.accountId, accountId),
@@ -2979,7 +2985,7 @@ async function getActionableActivityIds(accountId) {
     for (const r of await listRepos(accountId))
         repoNameById.set(r.id, r.fullName);
     const threadIds = new Set((await getThreadsAwaiting(localUserId, accountId, repoNameById)).map((ta) => ta.threadId));
-    const claudeReviewIds = config.claudeReviewEnabled
+    const claudeReviewIds = getProCapabilities().claudeReview
         ? new Set((await getUnactionedClaudeReviews(accountId)).map((c) => c.reviewId))
         : new Set();
     return { reviewRequestPrIds, watchedPrIds, approvedPrIds, threadIds, claudeReviewIds };
@@ -3138,7 +3144,7 @@ export async function getMyTurn(accountId) {
     }
     // Completed-but-unactioned Claude reviews (local-only feature; empty otherwise).
     // A manual "Done" hides the run until a newer run finishes (see claudeDismissedIds).
-    const claudeReviewsToAction = config.claudeReviewEnabled
+    const claudeReviewsToAction = getProCapabilities().claudeReview
         ? (await getUnactionedClaudeReviews(accountId)).filter((c) => !claudeDismissedIds.has(c.reviewId))
         : [];
     const users = referencedUsers.size > 0
@@ -3723,138 +3729,24 @@ export async function setRepoInboxWatch(accountId, repoId, watch) {
         .execute();
     return updated.length > 0;
 }
-// GitHub anchors a file in the PR "Files changed" diff by the SHA-256 of its
-// path; we expose it so a finding can deep-link into the PR diff.
-function diffAnchorId(path) {
-    return createHash('sha256').update(path, 'utf8').digest('hex');
-}
-function mapFinding(r) {
-    return {
-        id: r.id,
-        reviewId: r.reviewId,
-        path: r.path,
-        line: r.line,
-        side: r.side,
-        diffAnchorId: diffAnchorId(r.path),
-        severity: r.severity,
-        title: r.title,
-        body: r.body,
-        editedBody: r.editedBody,
-        suggestion: r.suggestion,
-        diffHunk: r.diffHunk,
-        anchored: r.anchored,
-        fileInDiff: r.fileInDiff,
-        included: r.included,
-        postedAt: iso(r.postedAt),
-        githubCommentId: r.githubCommentId,
-        postedCommentKind: r.postedCommentKind,
-        createdAt: r.createdAt.toISOString(),
-    };
-}
-function mapReview(r, findings) {
-    return {
-        id: r.id,
-        prId: r.prId,
-        headSha: r.headSha,
-        status: r.status,
-        model: r.model,
-        scope: r.scope,
-        reviewMode: r.reviewMode,
-        routeReason: r.routeReason,
-        summary: r.summary,
-        verdict: r.verdict,
-        userBody: r.userBody,
-        userVerdict: r.userVerdict,
-        costUsd: r.costUsd,
-        inputTokens: r.inputTokens,
-        outputTokens: r.outputTokens,
-        cacheReadTokens: r.cacheReadTokens,
-        cacheCreationTokens: r.cacheCreationTokens,
-        numTurns: r.numTurns,
-        diffBytes: r.diffBytes,
-        diffCapped: r.diffCapped,
-        error: r.error,
-        excludedFiles: r.excludedFiles ?? [],
-        postedReviewId: r.postedReviewId,
-        postedAt: iso(r.postedAt),
-        createdAt: r.createdAt.toISOString(),
-        finishedAt: iso(r.finishedAt),
-        findings: findings.map(mapFinding),
-    };
-}
-export async function getClaudeReviewById(reviewId, accountId) {
-    const rows = await db
-        .select({ review: claudeReviews })
-        .from(claudeReviews)
-        .innerJoin(pullRequests, eq(pullRequests.id, claudeReviews.prId))
-        .innerJoin(repos, eq(repos.id, pullRequests.repoId))
-        .where(and(eq(claudeReviews.id, reviewId), eq(repos.accountId, accountId)))
-        .limit(1)
-        .execute();
-    const row = rows[0]?.review ?? null;
-    if (!row)
-        return null;
-    const findings = await db
-        .select()
-        .from(claudeReviewFindings)
-        .where(eq(claudeReviewFindings.reviewId, reviewId))
-        .orderBy(asc(claudeReviewFindings.id))
-        .execute();
-    return mapReview(row, findings);
-}
-// The most recent run for a PR (with findings), or null if never run.
-export async function getLatestClaudeReview(prId, accountId) {
-    const rows = await db
-        .select({ id: claudeReviews.id })
-        .from(claudeReviews)
-        .innerJoin(pullRequests, eq(pullRequests.id, claudeReviews.prId))
-        .innerJoin(repos, eq(repos.id, pullRequests.repoId))
-        .where(and(eq(claudeReviews.prId, prId), eq(repos.accountId, accountId)))
-        .orderBy(desc(claudeReviews.id))
-        .limit(1)
-        .execute();
-    const row = rows[0] ?? null;
-    if (!row)
-        return null;
-    return getClaudeReviewById(row.id, accountId);
-}
-// All runs for a PR (newest first), lighter shape for the history selector.
-export async function listClaudeReviewHistory(prId, accountId) {
-    const rows = await db
-        .select({ review: claudeReviews })
-        .from(claudeReviews)
-        .innerJoin(pullRequests, eq(pullRequests.id, claudeReviews.prId))
-        .innerJoin(repos, eq(repos.id, pullRequests.repoId))
-        .where(and(eq(claudeReviews.prId, prId), eq(repos.accountId, accountId)))
-        .orderBy(desc(claudeReviews.id))
-        .execute();
-    return rows.map(({ review: r }) => ({
-        id: r.id,
-        headSha: r.headSha,
-        status: r.status,
-        model: r.model,
-        scope: r.scope,
-        reviewMode: r.reviewMode,
-        verdict: r.verdict,
-        userVerdict: r.userVerdict,
-        costUsd: r.costUsd,
-        postedAt: iso(r.postedAt),
-        createdAt: r.createdAt.toISOString(),
-        finishedAt: iso(r.finishedAt),
-    }));
-}
+// ---- Claude Review reads (CORE-owned surfaces only) ----
+// The FEATURE-only reads (getClaudeReviewById/Latest/History/listAll + the post/PR
+// contexts + mapReview/mapFinding) MOVED to packages/pro/src/claude-review/persist.ts
+// when Claude Review became a Pro capability. The two readers below stay CORE because
+// CORE surfaces consume them: listClaudeReviewsByRepo (Activity console) +
+// getUnactionedClaudeReviews (My-Turn inbox). Both read the still-core tables.
 // Repo-oriented Claude-review retrieval for the Activity single-repo console: ALL runs
 // for a repo's PRs, grouped by PR (newest run first within each), PRs ordered by
 // most-recent run desc. Richer than listAllClaudeReviews (which keeps only one
 // latest-succeeded run per PR). IDOR-sensitive id getter: scoped by accountId, and
-// gated on config.claudeReviewEnabled. An unowned repo (cross-account) → empty list.
+// gated on getProCapabilities().claudeReview. An unowned repo (cross-account) → empty list.
 export async function listClaudeReviewsByRepo(repoId, accountId) {
-    if (!config.claudeReviewEnabled)
+    if (!getProCapabilities().claudeReview)
         return { enabled: false, prs: [] };
     // Ownership: a repo not owned by this account leaks nothing (404-equivalent).
     const owned = await getRepo(repoId, accountId);
     if (!owned)
-        return { enabled: config.claudeReviewEnabled, prs: [] };
+        return { enabled: getProCapabilities().claudeReview, prs: [] };
     const rows = await db
         .select({
         review: claudeReviews,
@@ -3902,60 +3794,6 @@ export async function listClaudeReviewsByRepo(repoId, accountId) {
     }
     return { enabled: true, prs: [...byPr.values()] };
 }
-// Cross-PR list of prior Claude reviews: ONE entry per PR = that PR's most-recent
-// SUCCEEDED run, accountId-scoped, restricted to PRs still within the timeline
-// window (open, or last touched within `backfillDays`), newest-first by finish
-// time. Used by GET /api/claude-reviews to populate the "prior reviews" view.
-export async function listAllClaudeReviews(accountId) {
-    // Same window cutoff getTimeline uses for its overlap predicate (now − backfillDays).
-    const cutoff = new Date(Date.now() - config.backfillDays * 24 * 60 * 60 * 1000);
-    const rows = await db
-        .select({
-        reviewId: claudeReviews.id,
-        prId: claudeReviews.prId,
-        owner: repos.owner,
-        name: repos.name,
-        prNumber: pullRequests.number,
-        prTitle: pullRequests.title,
-        prState: pullRequests.state,
-        summary: claudeReviews.summary,
-        verdict: claudeReviews.verdict,
-        headSha: claudeReviews.headSha,
-        status: claudeReviews.status,
-        createdAt: claudeReviews.createdAt,
-        finishedAt: claudeReviews.finishedAt,
-    })
-        .from(claudeReviews)
-        .innerJoin(pullRequests, eq(pullRequests.id, claudeReviews.prId))
-        .innerJoin(repos, eq(repos.id, pullRequests.repoId))
-        .where(and(eq(repos.accountId, accountId), eq(claudeReviews.status, 'succeeded'), or(eq(pullRequests.state, 'open'), gte(sql `coalesce(${pullRequests.mergedAt}, ${pullRequests.closedAt}, ${pullRequests.openedAt})`, tsBound(cutoff)))))
-        .orderBy(desc(claudeReviews.finishedAt), desc(claudeReviews.createdAt))
-        .execute();
-    // Keep the first (most-recent) succeeded run per PR. N is small (single local
-    // user), so a JS pass is simpler and portable across both dialects.
-    const seen = new Set();
-    const items = [];
-    for (const r of rows) {
-        if (seen.has(r.prId))
-            continue;
-        seen.add(r.prId);
-        items.push({
-            reviewId: r.reviewId,
-            prId: r.prId,
-            repoFullName: `${r.owner}/${r.name}`,
-            prNumber: r.prNumber,
-            prTitle: r.prTitle,
-            prState: r.prState,
-            summary: r.summary,
-            verdict: r.verdict,
-            headSha: r.headSha,
-            status: r.status,
-            createdAt: r.createdAt.toISOString(),
-            finishedAt: iso(r.finishedAt),
-        });
-    }
-    return items;
-}
 // Completed Claude reviews on OPEN PRs that haven't been actioned: each PR's
 // MOST-RECENT succeeded run, kept only when it was never posted (postedAt null).
 // Account-scoped. Feeds the My Turn "Claude reviews to action" section so finished
@@ -4003,91 +3841,6 @@ export async function getUnactionedClaudeReviews(accountId) {
     }
     return out;
 }
-export async function getFindingPostContext(findingId, accountId) {
-    const rows = await db
-        .select({
-        finding: claudeReviewFindings,
-        reviewId: claudeReviews.id,
-        reviewHeadSha: claudeReviews.headSha,
-        owner: repos.owner,
-        name: repos.name,
-        prNumber: pullRequests.number,
-    })
-        .from(claudeReviewFindings)
-        .innerJoin(claudeReviews, eq(claudeReviews.id, claudeReviewFindings.reviewId))
-        .innerJoin(pullRequests, eq(pullRequests.id, claudeReviews.prId))
-        .innerJoin(repos, eq(repos.id, pullRequests.repoId))
-        .where(and(eq(claudeReviewFindings.id, findingId), eq(repos.accountId, accountId)))
-        .limit(1)
-        .execute();
-    const row = rows[0] ?? null;
-    if (!row)
-        return null;
-    return {
-        finding: row.finding,
-        reviewId: row.reviewId,
-        reviewHeadSha: row.reviewHeadSha,
-        owner: row.owner,
-        name: row.name,
-        prNumber: row.prNumber,
-    };
-}
-export async function getClaudeReviewContext(reviewId, accountId) {
-    const rows = await db
-        .select({
-        review: claudeReviews,
-        owner: repos.owner,
-        name: repos.name,
-        prNumber: pullRequests.number,
-    })
-        .from(claudeReviews)
-        .innerJoin(pullRequests, eq(pullRequests.id, claudeReviews.prId))
-        .innerJoin(repos, eq(repos.id, pullRequests.repoId))
-        .where(and(eq(claudeReviews.id, reviewId), eq(repos.accountId, accountId)))
-        .limit(1)
-        .execute();
-    const row = rows[0] ?? null;
-    if (!row)
-        return null;
-    return {
-        review: row.review,
-        owner: row.owner,
-        name: row.name,
-        prNumber: row.prNumber,
-    };
-}
-export async function getReviewPrContext(prId, accountId) {
-    const rows = await db
-        .select({
-        prId: pullRequests.id,
-        owner: repos.owner,
-        name: repos.name,
-        number: pullRequests.number,
-        title: pullRequests.title,
-        body: pullRequests.body,
-        baseRefName: pullRequests.baseRefName,
-        headSha: pullRequests.headSha,
-    })
-        .from(pullRequests)
-        .innerJoin(repos, eq(repos.id, pullRequests.repoId))
-        .where(and(eq(pullRequests.id, prId), eq(repos.accountId, accountId)))
-        .limit(1)
-        .execute();
-    const row = rows[0] ?? null;
-    if (!row)
-        return null;
-    return {
-        prId: row.prId,
-        owner: row.owner,
-        name: row.name,
-        repoFullName: `${row.owner}/${row.name}`,
-        number: row.number,
-        title: row.title,
-        body: row.body,
-        baseRefName: row.baseRefName,
-        headSha: row.headSha,
-    };
-}
 // Resolve a review thread to its GitHub node id + parent-PR coordinates, for a
 // reply (addPullRequestReviewThreadReply) or resolve/unresolve mutation. The
 // thread's GitHub node id is the GraphQL `pullRequestReviewThreadId` / `threadId`.

package/dist/index.js

@@ -28,12 +28,8 @@ export async function start() {
             console.warn('local user unknown (gh api user failed) — "my turn" disabled');
     }
     const app = await buildApp();
-    // Heal any Claude review runs left mid-flight by a crash (their 'running'
-    // status is persisted). Only relevant when the feature is enabled.
-    if (config.claudeReviewEnabled) {
-        const { reconcileReviewsOnStartup } = await import('./review/review-manager.js');
-        await reconcileReviewsOnStartup(app.log);
-    }
+    // (Claude Review moved into @pierre/pro — its crash-orphan reconcile now runs inside
+    // plugin.register during bindProPlugin below, alongside the AI-Fix reconcile.)
     // Bind the optional Pro plugin (dynamic import; no-ops in OSS mode). Same
     // "optional subsystem, degrade gracefully" posture as the scheduler below.
     {

package/dist/pro/bind.js

@@ -9,6 +9,7 @@ import { recordAiUsage, getAiUsageSummary } from '../db/usage.js';
 import { reviewEvents, registerLearningsProvider } from '../review/events.js';
 import { cheapComplete } from '../review/llm.js';
 import { detectClaudeAuth } from '../review/auth.js';
+import { hasUserAnthropicKey, setUserAnthropicKey, } from '../review/local-settings.js';
 import { getAccessToken } from '../auth/account.js';
 import { createPullRequest, fetchPrHeadInfo, fetchPrUnifiedDiff, } from '../github/mutations.js';
 import { fetchActionsJobLog } from '../github/actions-logs.js';
@@ -42,7 +43,7 @@ export async function bindProPlugin(app) {
     if (!mod)
         return;
     const plugin = (mod.default ?? mod);
-    if (plugin?.apiVersion !== 6 || typeof plugin.register !== 'function') {
+    if (plugin?.apiVersion !== 7 || typeof plugin.register !== 'function') {
         app.log.warn({ apiVersion: plugin?.apiVersion }, 'pro contract mismatch — skipped');
         return;
     }
@@ -105,6 +106,19 @@ export async function bindProPlugin(app) {
             mergeResolveAndPush: async (a) => (await import('../coding/merge.js')).mergeResolveAndPush(a),
             pushResolved: async (a) => (await import('../coding/merge.js')).pushResolved(a),
         },
+        // Claude Review infra: diff prep + the SDK run + the GitHub review POST. Lazy so the
+        // Agent SDK (agent.js) loads only when a review actually runs, not at every boot.
+        review: {
+            prepareReview: async (a) => (await import('../review/prepare.js')).prepareReview(a),
+            runReview: async (a) => (await import('../review/agent.js')).runReview(a),
+            postReview: async (a) => (await import('../review/post-seam.js')).postReview(a),
+            postFinding: async (a) => (await import('../review/post-seam.js')).postFinding(a),
+            getLocalKeyStatus: () => ({ hasUserKey: hasUserAnthropicKey() }),
+            setLocalKey: (k) => {
+                setUserAnthropicKey(k ?? '');
+                return { hasUserKey: hasUserAnthropicKey(), auth: detectClaudeAuth().status };
+            },
+        },
     };
     try {
         setProCapabilities(await plugin.register(app, ctx));

package/dist/pro/contract.js

@@ -7,6 +7,7 @@ const EMPTY = {
     aiAnalysis: false,
     aiFix: false,
     teamInsights: false,
+    claudeReview: false,
 };
 let active = EMPTY;
 export function setProCapabilities(c) {