codecritique 2.1.2 → 2.2.0

package/README.md

@@ -418,9 +418,12 @@ jobs:
 | `model`             | LLM model to use (e.g., `claude-sonnet-4-6`)                                                             | No       | Auto-selected        |
 | `max-tokens`        | Maximum tokens for LLM response                                                                          | No       | Auto-calculated      |
 | `cache-ttl`         | Cache TTL for LLM prompts: "5m" (default, no extra cost) or "1h" (extended, extra cost for cache writes) | No       | `5m`                 |
+| `batch`             | Use Anthropic Message Batches for lower-cost, asynchronous reviews                                       | No       | `false`              |
 | `concurrency`       | Concurrency for processing multiple files                                                                | No       | `3`                  |
 | `custom-docs`       | Custom documents (format: `"title:path,title:path"`)                                                     | No       | `''`                 |
 
+Batch mode trades latency for Anthropic's Message Batches API discount. Processing may take up to 24 hours, and batch requests are not eligible for Zero Data Retention. GitHub-hosted jobs can run for at most six hours; the action polls in-process and cannot resume a batch after the job ends. If holistic analysis falls back to per-file reviews, each concurrency wave can incur a separate batch wait and further increase runtime.
+
 > **Note**: The action uses sensible defaults for all review parameters. It always:
 >
 > - Uses JSON output format for parsing results
@@ -545,6 +548,10 @@ VERBOSE=true
 
 Set `CODECRITIQUE_SKIP_DOTENV=1` to disable `.env` loading, as the shell wrapper does after forwarding its supported variables.
 
+### Trust and Prompt Injection
+
+Repository files, diffs, custom documents, and PR comments are untrusted data included in LLM prompts. A malicious repository can attempt to influence generated review text despite prompt boundaries and truncation. Treat CodeCritique output as advisory, review findings before acting on them, and never grant generated suggestions automatic execution privileges.
+
 ## Output Formats
 
 CodeCritique supports three output formats:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecritique",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "description": "AI-powered code review tool for any programming language",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -42,6 +42,7 @@ async function cleanupEmbeddingsSystemIfInitialized() {
 }
 
 const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const parseIntegerOption = (value) => Number.parseInt(value, 10);
 
 // Configure command-line interface
 program.name('codecritique').description('CLI tool for AI-powered code review using the RAG approach').version(packageJson.version);
@@ -64,11 +65,12 @@ program
   .option('--verbose', 'Show verbose output')
   .option('--model <model>', 'LLM model to use (e.g., claude-sonnet-4-6)')
   .option('--temperature <number>', 'LLM temperature', parseFloat, 0.2)
-  .option('--max-tokens <number>', 'LLM max tokens', parseInt, 8192)
+  .option('--max-tokens <number>', 'LLM max tokens', parseIntegerOption, 8192)
   .option('--cache-ttl <ttl>', 'Cache TTL for LLM prompts: "5m" (default, no extra cost) or "1h" (extended, extra cost for writes)', '5m')
+  .option('--batch', 'Use the asynchronous Anthropic Message Batches API for lower-cost reviews')
   .option('--similarity-threshold <number>', 'Threshold for finding similar code examples', parseFloat, 0.6)
-  .option('--max-examples <number>', 'Max similar code examples to use', parseInt, 5)
-  .option('--concurrency <number>', 'Concurrency for processing multiple files', parseInt, 3)
+  .option('--max-examples <number>', 'Max similar code examples to use', parseIntegerOption, 5)
+  .option('--concurrency <number>', 'Concurrency for processing multiple files', parseIntegerOption, 3)
   .option(
     '--doc <specs...>',
     'A document to provide custom instructions to the LLM (e.g., "Engineering Guidelines:./docs/guidelines.md"). Can be specified multiple times.'
@@ -142,11 +144,11 @@ program
   .option('-t, --token <token>', 'GitHub API token (or set GITHUB_TOKEN env var)')
   .option('--since <date>', 'Only analyze PRs since this date (ISO format)')
   .option('--until <date>', 'Only analyze PRs until this date (ISO format)')
-  .option('--limit <number>', 'Limit number of PRs to analyze', parseInt)
+  .option('--limit <number>', 'Limit number of PRs to analyze', parseIntegerOption)
   .option('--resume', 'Resume interrupted analysis')
   .option('--clear', 'Clear existing data before analysis')
-  .option('--concurrency <number>', 'Number of concurrent requests', parseInt, 2)
-  .option('--batch-size <number>', 'Batch size for processing', parseInt, 50)
+  .option('--concurrency <number>', 'Number of concurrent requests', parseIntegerOption, 2)
+  .option('--batch-size <number>', 'Batch size for processing', parseIntegerOption, 50)
   .option('--verbose', 'Show verbose output')
   .action(analyzePRHistory);
 
@@ -349,6 +351,7 @@ async function runCodeReview(options) {
     temperature: options.temperature,
     maxTokens: options.maxTokens,
     cacheTtl: options.cacheTtl,
+    batch: options.batch,
     similarityThreshold: options.similarityThreshold,
     maxExamples: options.maxExamples,
     concurrency: options.concurrency,
@@ -1092,11 +1095,12 @@ async function emitEmptyReviewOutputIfNeeded(options, aggregateResult = {}) {
 }
 
 async function emitErrorReviewOutputIfNeeded(options, error, aggregateResult = {}) {
-  if (!shouldEmitReviewOutput(options)) {
+  if (!shouldEmitReviewOutput(options) && !aggregateResult.results?.length) {
     return false;
   }
 
-  await outputReviewResults([createReviewErrorResult(error)], options, {
+  const reviewResults = aggregateResult.results?.length ? aggregateResult.results : [{ filePath: 'review', success: false, error }];
+  await outputReviewResults(reviewResults, options, {
     ...aggregateResult,
     success: false,
     error,
@@ -1104,14 +1108,6 @@ async function emitErrorReviewOutputIfNeeded(options, error, aggregateResult = {
   return true;
 }
 
-function createReviewErrorResult(error) {
-  return {
-    filePath: 'review',
-    success: false,
-    error,
-  };
-}
-
 /**
  * Output results in JSON format
  *
@@ -1139,6 +1135,8 @@ async function outputJson(reviewResults, options, aggregateResult = {}) {
       }, 0),
       skippedFiles: reviewResults.filter((r) => r.skipped).length,
       errorFiles: reviewResults.filter((r) => !r.success).length,
+      incomplete: aggregateResult.success === false,
+      error: aggregateResult.success === false ? aggregateResult.error : undefined,
     },
     details: reviewResults.map((r) => {
       if (!r.success) {
@@ -1151,6 +1149,8 @@ async function outputJson(reviewResults, options, aggregateResult = {}) {
       return {
         filePath: r.filePath,
         success: true,
+        partial: r.partial || undefined,
+        error: r.partial ? r.error : undefined,
         language: r.language,
         review: r.results, // Contains summary and actionable issues (with optional codeSuggestion)
         // Optionally include similar examples if needed
@@ -1207,6 +1207,9 @@ async function outputMarkdown(reviewResults, options, aggregateResult = {}) {
   if (errorFiles > 0) {
     lines.push(`- **Errors:** ${errorFiles}`);
   }
+  if (aggregateResult.success === false) {
+    lines.push(`- **Review Incomplete:** ${aggregateResult.error || 'Some review work failed.'}`);
+  }
 
   appendPRLevelFindingsMarkdown(lines, prLevelFindings);
 
@@ -1218,6 +1221,9 @@ async function outputMarkdown(reviewResults, options, aggregateResult = {}) {
       lines.push(`**Error:** ${fileResult.error}`, '');
       return;
     }
+    if (fileResult.partial) {
+      lines.push(`**Partial review:** ${fileResult.error || 'Some review segments failed.'}`, '');
+    }
     if (fileResult.skipped) {
       lines.push('*Skipped (based on exclusion patterns or file type).*', '');
       return;
@@ -1295,6 +1301,9 @@ function outputText(reviewResults, cliOptions, aggregateResult = {}) {
   if (errorFiles > 0) {
     console.log(`Errors: ${chalk.red(errorFiles)}`);
   }
+  if (aggregateResult.success === false) {
+    console.warn(chalk.yellow(`Review Incomplete: ${aggregateResult.error || 'Some review work failed.'}`));
+  }
   console.log(chalk.bold.blue('================================================'));
 
   outputPRLevelFindingsText(prLevelFindings);
@@ -1306,6 +1315,9 @@ function outputText(reviewResults, cliOptions, aggregateResult = {}) {
       console.log(chalk.bold.red('================================================'));
       return;
     }
+    if (fileResult.partial) {
+      console.warn(chalk.yellow(`\nPartial review for ${fileResult.filePath}: ${fileResult.error || 'Some review segments failed.'}`));
+    }
     if (fileResult.skipped) {
       verboseLog(cliOptions, chalk.yellow(`\nSkipped: ${fileResult.filePath}`));
       return;

package/src/index.test.js

@@ -0,0 +1,86 @@
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { program } from 'commander';
+import { expect, it, onTestFinished, vi } from 'vitest';
+
+const { originalArgv, originalListeners, reviewFile } = vi.hoisted(() => {
+  const originalArgv = process.argv;
+  const originalListeners = Object.fromEntries(['SIGINT', 'SIGTERM', 'exit'].map((event) => [event, process.listeners(event)]));
+  process.argv = ['node', 'index.js', 'analyze', '--file', 'src/index.js', '--max-examples', '12'];
+  return {
+    originalArgv,
+    originalListeners,
+    reviewFile: vi.fn().mockResolvedValue({
+      success: false,
+      error: 'Review incomplete',
+      results: [
+        {
+          filePath: 'src/index.js',
+          success: true,
+          partial: true,
+          error: 'Batch expired',
+          results: { issues: [{ severity: 'high', description: 'Visible partial finding', lineNumbers: [1] }] },
+        },
+      ],
+    }),
+  };
+});
+
+vi.unmock('chalk');
+vi.mock('./rag-review.js', () => ({
+  reviewFile,
+  reviewFiles: vi.fn(),
+  reviewPullRequest: vi.fn(),
+}));
+
+import './index.js';
+
+it('parses integer options and renders incomplete results in every output format', async () => {
+  const directory = await mkdtemp(join(tmpdir(), 'codecritique-output-'));
+  onTestFinished(async () => {
+    process.argv = originalArgv;
+    for (const [event, listeners] of Object.entries(originalListeners)) {
+      process
+        .listeners(event)
+        .filter((listener) => !listeners.includes(listener))
+        .forEach((listener) => process.removeListener(event, listener));
+    }
+    await rm(directory, { recursive: true, force: true });
+  });
+  await vi.waitFor(() => expect(reviewFile).toHaveBeenCalled());
+  expect(reviewFile.mock.calls[0][1].maxExamples).toBe(12);
+  await vi.waitFor(() => expect(console.log).toHaveBeenCalledWith('    Visible partial finding'));
+  expect(console.warn.mock.calls.some(([message]) => String(message).includes('Partial review for src/index.js'))).toBe(true);
+  expect(console.warn.mock.calls.some(([message]) => String(message).includes('Review incomplete'))).toBe(true);
+
+  const jsonPath = join(directory, 'review.json');
+  await program.parseAsync(['node', 'index.js', 'analyze', '--file', 'src/index.js', '--output', 'json', '--output-file', jsonPath]);
+  const jsonOutput = JSON.parse(await readFile(jsonPath, 'utf8'));
+  expect(jsonOutput.summary).toEqual(expect.objectContaining({ errorFiles: 0, incomplete: true, error: 'Review incomplete' }));
+  expect(jsonOutput.details).toEqual([
+    expect.objectContaining({
+      success: true,
+      partial: true,
+      error: 'Batch expired',
+      review: expect.objectContaining({ issues: [expect.objectContaining({ description: 'Visible partial finding' })] }),
+    }),
+  ]);
+
+  const markdownPath = join(directory, 'review.md');
+  await program.parseAsync([
+    'node',
+    'index.js',
+    'analyze',
+    '--file',
+    'src/index.js',
+    '--output',
+    'markdown',
+    '--output-file',
+    markdownPath,
+  ]);
+  const markdownOutput = await readFile(markdownPath, 'utf8');
+  expect(markdownOutput).toContain('**Review Incomplete:** Review incomplete');
+  expect(markdownOutput).toContain('**Partial review:** Batch expired');
+  expect(markdownOutput).toContain('Visible partial finding');
+});

package/src/llm.js

@@ -12,6 +12,7 @@
  * requests, reducing input token costs by 75%.
  */
 
+import { setTimeout as delay } from 'node:timers/promises';
 import { Anthropic } from '@anthropic-ai/sdk';
 import chalk from 'chalk';
 import dotenv from 'dotenv';
@@ -46,6 +47,9 @@ const DEFAULT_MODEL = 'claude-sonnet-4-6';
 // Maximum tokens for response
 const MAX_TOKENS = 4096;
 
+const DEFAULT_BATCH_POLL_INTERVAL_MS = 10000;
+const MAX_BATCH_POLL_FAILURES = 3;
+
 const MAX_CACHE_CONTROL_BLOCKS = 4;
 
 function normalizeSystemBlock(block, cacheControl) {
@@ -84,6 +88,47 @@ function buildSystemContent(system, cachedSystemBlocks, cacheControl) {
   return systemBlocks;
 }
 
+async function createBatchedMessage(client, requestParams, options) {
+  const customId = 'codecritique-review';
+  let batch = await client.messages.batches.create({
+    requests: [{ custom_id: customId, params: requestParams }],
+  });
+
+  verboseLog(options, chalk.cyan(`Submitted Claude message batch ${batch.id}; waiting for completion...`));
+  let consecutivePollFailures = 0;
+
+  while (batch.processing_status !== 'ended') {
+    await delay(DEFAULT_BATCH_POLL_INTERVAL_MS);
+    try {
+      batch = await client.messages.batches.retrieve(batch.id);
+      consecutivePollFailures = 0;
+    }
+    catch (error) {
+      consecutivePollFailures++;
+      if (consecutivePollFailures >= MAX_BATCH_POLL_FAILURES) {
+        throw new Error(`Unable to poll Claude message batch ${batch.id} after ${MAX_BATCH_POLL_FAILURES} attempts: ${error.message}`);
+      }
+      console.warn(chalk.yellow(`Unable to poll Claude message batch ${batch.id}; retrying: ${error.message}`));
+    }
+  }
+
+  const results = await client.messages.batches.results(batch.id);
+  for await (const response of results) {
+    if (response.custom_id !== customId) {
+      continue;
+    }
+
+    if (response.result.type === 'succeeded') {
+      return response.result.message;
+    }
+
+    const detail = response.result.type === 'errored' ? `: ${response.result.error.error.message}` : '';
+    throw new Error(`Claude batch request ${response.result.type}${detail}`);
+  }
+
+  throw new Error('Claude batch response did not contain the review request');
+}
+
 /**
  * Send a prompt to Claude and get a structured JSON response using tool calling.
  * Uses prompt caching for system prompts to reduce token costs.
@@ -94,6 +139,7 @@ function buildSystemContent(system, cachedSystemBlocks, cacheControl) {
  * @param {Array<string|Object>} options.cachedSystemBlocks - Additional stable system blocks to cache when possible
  * @param {Object} options.jsonSchema - JSON schema for structured output
  * @param {string} options.cacheTtl - Cache TTL: '5m' (default, no extra cost) or '1h' (extended, extra cost for writes)
+ * @param {boolean} [options.batch=false] - Use the asynchronous Message Batches API
  * @returns {Promise<Object>} The response from Claude with structured data
  */
 async function sendPromptToClaude(prompt, options = {}) {
@@ -145,7 +191,9 @@ async function sendPromptToClaude(prompt, options = {}) {
       requestParams.tool_choice = { type: 'tool', name: 'return_json' };
     }
 
-    const response = await client.messages.create(requestParams);
+    const response = options.batch
+      ? await createBatchedMessage(client, requestParams, options)
+      : await client.messages.create(requestParams);
 
     // Log response structure for debugging
     verboseLog(options, chalk.gray(`  Response stop_reason: ${response.stop_reason}`));

package/src/llm.test.js

@@ -2,15 +2,31 @@ import { sendPromptToClaude } from './llm.js';
 
 // Create hoisted mock for the Anthropic SDK
 const mockMessagesCreate = vi.hoisted(() => vi.fn());
+const mockBatchesCreate = vi.hoisted(() => vi.fn());
+const mockBatchesRetrieve = vi.hoisted(() => vi.fn());
+const mockBatchesResults = vi.hoisted(() => vi.fn());
+
+vi.mock('node:timers/promises', () => ({ setTimeout: vi.fn() }));
 
 vi.mock('@anthropic-ai/sdk', () => ({
   Anthropic: class MockAnthropic {
     messages = {
       create: mockMessagesCreate,
+      batches: {
+        create: mockBatchesCreate,
+        retrieve: mockBatchesRetrieve,
+        results: mockBatchesResults,
+      },
     };
   },
 }));
 
+function batchResults(...responses) {
+  return (async function* iterateResults() {
+    yield* responses;
+  })();
+}
+
 describe('sendPromptToClaude', () => {
   beforeEach(() => {
     mockConsoleSelective('log', 'error');
@@ -85,6 +101,72 @@ describe('sendPromptToClaude', () => {
         })
       );
     });
+
+    it('should retry polling and unwrap a successful batch request', async () => {
+      const message = {
+        content: [{ type: 'text', text: 'Batched response' }],
+        model: 'claude-sonnet-4-6',
+        usage: { input_tokens: 100, output_tokens: 50 },
+      };
+      mockBatchesCreate.mockResolvedValue({ id: 'msgbatch_123', processing_status: 'in_progress' });
+      mockBatchesRetrieve
+        .mockRejectedValueOnce(new Error('Temporary network error'))
+        .mockRejectedValueOnce(new Error('Temporary network error'))
+        .mockResolvedValueOnce({ id: 'msgbatch_123', processing_status: 'in_progress' })
+        .mockRejectedValueOnce(new Error('Temporary network error'))
+        .mockRejectedValueOnce(new Error('Temporary network error'))
+        .mockResolvedValueOnce({ id: 'msgbatch_123', processing_status: 'ended' });
+      mockBatchesResults.mockResolvedValue(batchResults({ custom_id: 'codecritique-review', result: { type: 'succeeded', message } }));
+
+      const result = await sendPromptToClaude('Review this code', { batch: true });
+
+      expect(result.content).toBe('Batched response');
+      expect(mockMessagesCreate).not.toHaveBeenCalled();
+      expect(mockBatchesCreate).toHaveBeenCalledWith({
+        requests: [
+          {
+            custom_id: 'codecritique-review',
+            params: expect.objectContaining({
+              model: 'claude-sonnet-4-6',
+              messages: [{ role: 'user', content: 'Review this code' }],
+            }),
+          },
+        ],
+      });
+      expect(mockBatchesRetrieve).toHaveBeenCalledTimes(6);
+      expect(mockBatchesRetrieve).toHaveBeenCalledWith('msgbatch_123');
+      expect(mockBatchesResults).toHaveBeenCalledWith('msgbatch_123');
+    });
+
+    it('should stop polling after repeated retrieval failures', async () => {
+      mockBatchesCreate.mockResolvedValue({ id: 'msgbatch_123', processing_status: 'in_progress' });
+      mockBatchesRetrieve.mockRejectedValue(new Error('Unauthorized'));
+
+      await expect(sendPromptToClaude('Review this code', { batch: true })).rejects.toThrow(
+        'Unable to poll Claude message batch msgbatch_123 after 3 attempts: Unauthorized'
+      );
+      expect(mockBatchesRetrieve).toHaveBeenCalledTimes(3);
+    });
+
+    it.each([
+      [{ type: 'errored', error: { error: { message: 'Request overloaded' } } }, 'Claude batch request errored: Request overloaded'],
+      [{ type: 'canceled' }, 'Claude batch request canceled'],
+      [{ type: 'expired' }, 'Claude batch request expired'],
+    ])('should report an unsuccessful batch result', async (batchResult, expectedMessage) => {
+      mockBatchesCreate.mockResolvedValue({ id: 'msgbatch_123', processing_status: 'ended' });
+      mockBatchesResults.mockResolvedValue(batchResults({ custom_id: 'codecritique-review', result: batchResult }));
+
+      await expect(sendPromptToClaude('Review this code', { batch: true })).rejects.toThrow(expectedMessage);
+    });
+
+    it('should reject a batch response without the review result', async () => {
+      mockBatchesCreate.mockResolvedValue({ id: 'msgbatch_123', processing_status: 'ended' });
+      mockBatchesResults.mockResolvedValue(batchResults());
+
+      await expect(sendPromptToClaude('Review this code', { batch: true })).rejects.toThrow(
+        'Claude batch response did not contain the review request'
+      );
+    });
   });
 
   describe('structured JSON response with tool calling', () => {

package/src/rag-analyzer.js

@@ -782,6 +782,7 @@ async function callLLMForAnalysis(context, options = {}) {
       isJsonMode: true, // Standardize on using JSON mode if available
       verbose: options.verbose || false, // Pass verbose flag for cache statistics
       cacheTtl: options.cacheTtl || '5m', // Pass cache TTL option (default: 5m, no extra cost)
+      batch: options.batch || false,
     });
 
     verboseLog(options, chalk.blue('Received LLM response, attempting to parse...'));
@@ -2343,7 +2344,8 @@ async function gatherUnifiedContextForPR(prFiles, options = {}) {
   // Aggregate and deduplicate results
   for (const context of allContexts) {
     (context.finalCodeExamples || []).forEach((example) => {
-      const key = example.path;
+      const normalizedContent = example.content?.trim();
+      const key = normalizedContent ? `content:${normalizedContent}` : example.path ? `path:${example.path}` : null;
       if (
         key &&
         (!allProcessedContext.codeExamples.has(key) || example.similarity > allProcessedContext.codeExamples.get(key).similarity)

package/src/rag-analyzer.test.js

@@ -196,6 +196,14 @@ describe('rag-analyzer', () => {
       expect(result.error).toContain('LLM unavailable');
     });
 
+    it('should forward batch transport options to the LLM', async () => {
+      setupSuccessfulLLMResponse();
+
+      await runAnalysis('/test/file.js', { batch: true });
+
+      expect(llm.sendPromptToClaude).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ batch: true }));
+    });
+
     it('should initialize embeddings system', async () => {
       setupSuccessfulLLMResponse();
       await runAnalysis('/test/file.js');
@@ -1136,6 +1144,32 @@ describe('rag-analyzer', () => {
         expect(context.codeExamples[0].similarity).toBeGreaterThanOrEqual(0.7);
       }
     });
+
+    it('should deduplicate identical code content from different paths', async () => {
+      mockEmbeddingsSystem.findSimilarCode
+        .mockResolvedValueOnce([{ path: '/first.js', content: 'shared implementation', similarity: 0.7 }])
+        .mockResolvedValueOnce([{ path: '/second.js', content: ' shared implementation ', similarity: 0.9 }]);
+      const context = await gatherUnifiedContextForPR([
+        { filePath: '/src/file1.js', content: 'code1' },
+        { filePath: '/src/file2.js', content: 'code2' },
+      ]);
+
+      expect(context.codeExamples).toEqual([
+        expect.objectContaining({ path: '/second.js', content: ' shared implementation ', similarity: 0.9 }),
+      ]);
+    });
+
+    it('should keep content keys separate from path fallbacks', async () => {
+      mockEmbeddingsSystem.findSimilarCode
+        .mockResolvedValueOnce([{ path: '/first.js', content: '', similarity: 0.9 }])
+        .mockResolvedValueOnce([{ path: '/second.js', content: ' /first.js ', similarity: 0.8 }]);
+      const context = await gatherUnifiedContextForPR([
+        { filePath: '/src/file1.js', content: 'code1' },
+        { filePath: '/src/file2.js', content: 'code2' },
+      ]);
+
+      expect(context.codeExamples.map((example) => example.path)).toEqual(['/first.js', '/second.js']);
+    });
   });
 
   // ==========================================================================

package/src/rag-review.js

@@ -399,6 +399,9 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
 
       // Create a synthetic "file" path for holistic analysis
       const holisticResult = await runAnalysis('PR_HOLISTIC_REVIEW', holisticOptions);
+      if (!holisticResult?.success) {
+        throw new Error(holisticResult?.error || 'Holistic PR analysis failed');
+      }
 
       // Convert holistic result to individual file results format for compatibility
       const results = prFiles.map((file) => {
@@ -525,8 +528,10 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
       }
 
       // Return fallback results
+      const failedReviewCount = results.filter((result) => !result?.success).length;
       return {
-        success: true,
+        success: failedReviewCount === 0,
+        error: failedReviewCount > 0 ? `${failedReviewCount} file review(s) failed after holistic review fallback` : undefined,
         results: results,
         prContext: prContext,
         sharedContextStats: {

package/src/rag-review.test.js

@@ -436,6 +436,36 @@ describe('rag-review', () => {
       expect(result.success).toBe(true);
     });
 
+    it('should retain successful fallback results when another file fails', async () => {
+      shouldProcessFile.mockReturnValue(true);
+      getFileContentFromGit.mockReturnValue('const x = 1;');
+      getChangedLinesInfo.mockReturnValue({
+        hasChanges: true,
+        addedLines: [1],
+        removedLines: [],
+        fullDiff: '+ code',
+      });
+      shouldChunkPR.mockReturnValue({ shouldChunk: false, estimatedTokens: 1000 });
+      runAnalysis
+        .mockResolvedValueOnce({ success: false, error: 'Claude batch request expired' })
+        .mockResolvedValueOnce({
+          success: true,
+          filePath: '/src/a.js',
+          results: { issues: [{ description: 'Known issue' }] },
+        })
+        .mockResolvedValueOnce({ success: false, filePath: '/src/b.js', error: 'Claude batch request expired' });
+
+      const result = await reviewPullRequest(['/src/a.js', '/src/b.js'], { batch: true });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('1 file review(s) failed after holistic review fallback');
+      expect(result.results).toEqual([
+        expect.objectContaining({ success: true, filePath: '/src/a.js' }),
+        expect.objectContaining({ success: false, filePath: '/src/b.js', error: 'Claude batch request expired' }),
+      ]);
+      expect(runAnalysis).toHaveBeenLastCalledWith('/src/b.js', expect.objectContaining({ batch: true, isPRReview: true, diffOnly: true }));
+    });
+
     it('should handle multiple files with different statuses', async () => {
       runAnalysis
         .mockResolvedValueOnce({