codecritique 2.0.6 → 2.0.8

package/package.json

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

package/src/llm.js

@@ -44,6 +44,44 @@ const DEFAULT_MODEL = 'claude-sonnet-4-5';
 // Maximum tokens for response
 const MAX_TOKENS = 4096;
 
+const MAX_CACHE_CONTROL_BLOCKS = 4;
+
+function normalizeSystemBlock(block, cacheControl) {
+  const normalizedBlock = typeof block === 'string' ? { type: 'text', text: block } : { type: 'text', ...block };
+
+  if (cacheControl) {
+    return {
+      ...normalizedBlock,
+      cache_control: normalizedBlock.cache_control || cacheControl,
+    };
+  }
+
+  return normalizedBlock;
+}
+
+function buildSystemContent(system, cachedSystemBlocks, cacheControl) {
+  if (!system && cachedSystemBlocks.length === 0) {
+    return 'You are an expert code reviewer with deep knowledge of software engineering principles, design patterns, and best practices.';
+  }
+
+  const systemBlocks = [];
+  const appendBlock = (block) => {
+    const cacheable = systemBlocks.filter((existingBlock) => existingBlock.cache_control).length < MAX_CACHE_CONTROL_BLOCKS;
+    systemBlocks.push(normalizeSystemBlock(block, cacheable ? cacheControl : null));
+  };
+
+  if (Array.isArray(system)) {
+    system.forEach(appendBlock);
+  }
+  else if (system) {
+    appendBlock(system);
+  }
+
+  cachedSystemBlocks.filter(Boolean).forEach(appendBlock);
+
+  return systemBlocks;
+}
+
 /**
  * Send a prompt to Claude and get a structured JSON response using tool calling.
  * Uses prompt caching for system prompts to reduce token costs.
@@ -51,12 +89,21 @@ const MAX_TOKENS = 4096;
  * @param {string} prompt - The prompt to send to Claude
  * @param {Object} options - Options for the request
  * @param {string} options.system - System prompt (will be cached for cost optimization)
+ * @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)
  * @returns {Promise<Object>} The response from Claude with structured data
  */
 async function sendPromptToClaude(prompt, options = {}) {
-  const { model = DEFAULT_MODEL, maxTokens = MAX_TOKENS, temperature = 0.7, system = '', jsonSchema = null, cacheTtl = '5m' } = options;
+  const {
+    model = DEFAULT_MODEL,
+    maxTokens = MAX_TOKENS,
+    temperature = 0.7,
+    system = '',
+    cachedSystemBlocks = [],
+    jsonSchema = null,
+    cacheTtl = '5m',
+  } = options;
 
   try {
     verboseLog(options, chalk.cyan('Sending prompt to Claude...'));
@@ -68,15 +115,7 @@ async function sendPromptToClaude(prompt, options = {}) {
     // TTL options: '5m' (default, no extra cost) or '1h' (extended, extra cost for cache writes)
     const cacheControl = cacheTtl === '1h' ? { type: 'ephemeral', ttl: '1h' } : { type: 'ephemeral' };
 
-    const systemContent = system
-      ? [
-          {
-            type: 'text',
-            text: system,
-            cache_control: cacheControl,
-          },
-        ]
-      : 'You are an expert code reviewer with deep knowledge of software engineering principles, design patterns, and best practices.';
+    const systemContent = buildSystemContent(system, cachedSystemBlocks, cacheControl);
 
     // Build base request parameters
     const requestParams = {

package/src/llm.test.js

@@ -241,6 +241,62 @@ describe('sendPromptToClaude', () => {
         })
       );
     });
+
+    it('should append additional cached system blocks', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        content: [{ type: 'text', text: 'Response' }],
+        model: 'claude-sonnet-4-5',
+        usage: {},
+      });
+
+      await sendPromptToClaude('Test', {
+        system: 'Base review rules',
+        cachedSystemBlocks: ['Custom project instructions', 'Project architecture context'],
+      });
+
+      expect(mockMessagesCreate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          system: [
+            {
+              type: 'text',
+              text: 'Base review rules',
+              cache_control: { type: 'ephemeral' },
+            },
+            {
+              type: 'text',
+              text: 'Custom project instructions',
+              cache_control: { type: 'ephemeral' },
+            },
+            {
+              type: 'text',
+              text: 'Project architecture context',
+              cache_control: { type: 'ephemeral' },
+            },
+          ],
+        })
+      );
+    });
+
+    it('should include extra system blocks without exceeding cache breakpoint limits', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        content: [{ type: 'text', text: 'Response' }],
+        model: 'claude-sonnet-4-5',
+        usage: {},
+      });
+
+      await sendPromptToClaude('Test', {
+        system: 'Base review rules',
+        cachedSystemBlocks: ['Block 1', 'Block 2', 'Block 3', 'Block 4'],
+      });
+
+      const request = mockMessagesCreate.mock.calls.at(-1)[0];
+      expect(request.system).toHaveLength(5);
+      expect(request.system.filter((block) => block.cache_control)).toHaveLength(4);
+      expect(request.system.at(-1)).toEqual({
+        type: 'text',
+        text: 'Block 4',
+      });
+    });
   });
 
   describe('message format', () => {

package/src/project-analyzer.js

@@ -16,6 +16,8 @@ import { isDocumentationFile, isTestFile } from './utils/file-validation.js';
 import { verboseLog } from './utils/logging.js';
 import { escapeSqlString } from './utils/string-utils.js';
 
+const TERM_SEARCH_CONTENT_CANDIDATE_LIMIT = 500;
+
 // Consolidated file classification configuration
 const FILE_PATTERNS = {
   config: {
@@ -383,14 +385,18 @@ export class ProjectAnalyzer {
       // Unified query function
       const queryFiles = async (config) => {
         try {
-          let query = table.query().select(['path', 'name', 'content', 'type', 'language']);
-
           if (config.whereClause) {
-            query = query.where(`${projectPathFilter} AND (${config.whereClause})`);
+            return await table
+              .query()
+              .select(['path', 'name', 'content', 'type', 'language'])
+              .where(`${projectPathFilter} AND (${config.whereClause})`)
+              .limit(config.limit || 30)
+              .toArray();
           }
           else if (config.terms) {
-            // For term-based searches, query ALL files and sort by depth to prioritize shallow config files
-            const allFiles = await table.query().select(['path', 'name', 'content', 'type', 'language']).where(projectPathFilter).toArray(); // NO LIMIT - get all files
+            // For term-based searches, query metadata first and only fetch content for
+            // the shallow candidate set used for matching.
+            const allFiles = await table.query().select(['path', 'name', 'type', 'language']).where(projectPathFilter).toArray();
 
             // Sort by path depth (shorter paths first) to prioritize config files
             allFiles.sort((a, b) => {
@@ -399,25 +405,78 @@ export class ProjectAnalyzer {
               return depthA - depthB;
             });
 
-            // Take only the first 500 after sorting to ensure we have shallow files
-            const sortedFiles = allFiles.slice(0, 500);
+            // Dedupe by path before capping: transient duplicate rows can exist for
+            // the same file (different content_hash) when a partial run hasn't pruned
+            // stale embeddings, and they would otherwise consume candidate slots and
+            // bloat the content query. Keep the shallowest occurrence (allFiles is
+            // already depth-sorted), then take the first 500 distinct shallow files.
+            const seenPaths = new Set();
+            const sortedFiles = [];
+            for (const file of allFiles) {
+              if (file.path) {
+                if (seenPaths.has(file.path)) {
+                  continue;
+                }
+                seenPaths.add(file.path);
+              }
+              sortedFiles.push(file);
+              if (sortedFiles.length >= TERM_SEARCH_CONTENT_CANDIDATE_LIMIT) {
+                break;
+              }
+            }
+            if (sortedFiles.length === 0) {
+              return [];
+            }
 
-            return sortedFiles.filter((result) => {
-              const content = (result.content || '').toLowerCase();
-              const pathName = (result.path || '').toLowerCase();
-              const name = (result.name || '').toLowerCase();
-              const matches = config.terms.some(
-                (term) => content.includes(term.toLowerCase()) || pathName.includes(term.toLowerCase()) || name.includes(term.toLowerCase())
-              );
+            const candidatePaths = sortedFiles.map((file) => file.path).filter(Boolean);
+            const contentByPath = new Map();
+            if (candidatePaths.length > 0) {
+              const pathList = candidatePaths.map((candidatePath) => `'${escapeSqlString(candidatePath)}'`).join(', ');
+              // No row limit here: the result set is already bounded by the IN list of
+              // distinct candidate paths. A limit could truncate rows when duplicate
+              // rows exist for a path, silently dropping content for matched files.
+              const contentResults = await table
+                .query()
+                .select(['path', 'content'])
+                .where(`${projectPathFilter} AND path IN (${pathList})`)
+                .toArray();
+
+              for (const result of contentResults) {
+                // Prefer non-empty content when duplicate rows exist for a path.
+                if (contentByPath.get(result.path)) {
+                  continue;
+                }
+                contentByPath.set(result.path, result.content || '');
+              }
+            }
 
-              return matches;
-            });
+            return sortedFiles
+              .filter((result) => {
+                const content = (contentByPath.get(result.path) || '').toLowerCase();
+                const pathName = (result.path || '').toLowerCase();
+                const name = (result.name || '').toLowerCase();
+                const matches = config.terms.some(
+                  (term) =>
+                    content.includes(term.toLowerCase()) || pathName.includes(term.toLowerCase()) || name.includes(term.toLowerCase())
+                );
+
+                return matches;
+              })
+              .map((result) => {
+                return {
+                  ...result,
+                  content: contentByPath.get(result.path) || '',
+                };
+              });
           }
           else {
-            query = query.where(projectPathFilter);
+            return await table
+              .query()
+              .select(['path', 'name', 'content', 'type', 'language'])
+              .where(projectPathFilter)
+              .limit(config.limit || 30)
+              .toArray();
           }
-
-          return await query.limit(config.limit || 30).toArray();
         }
         catch (error) {
           verboseLog({}, chalk.yellow(`     ⚠️ Query failed for ${config.category}: ${error.message}`));

package/src/project-analyzer.test.js

@@ -410,6 +410,79 @@ describe('ProjectAnalyzer', () => {
       expect(queryChain.where).toHaveBeenCalledWith(expect.stringContaining("/mock/we''re/project"));
     });
 
+    it('should bound content reads for term-based key file searches', async () => {
+      const queryCalls = [];
+      mockTable.query.mockImplementation(() => {
+        const call = {
+          select: [],
+          where: [],
+          limit: [],
+        };
+        queryCalls.push(call);
+
+        const chain = {
+          select: vi.fn((columns) => {
+            call.select.push(columns);
+            return chain;
+          }),
+          where: vi.fn((clause) => {
+            call.where.push(clause);
+            return chain;
+          }),
+          limit: vi.fn((limit) => {
+            call.limit.push(limit);
+            return chain;
+          }),
+          toArray: vi.fn(async () => {
+            const selectedColumns = call.select[0] || [];
+            if (selectedColumns.includes('content')) {
+              return [
+                {
+                  path: 'package.json',
+                  name: 'package.json',
+                  content: '{"name": "test-project"}',
+                  type: 'json',
+                  language: 'json',
+                },
+              ];
+            }
+
+            return [
+              {
+                path: 'package.json',
+                name: 'package.json',
+                type: 'json',
+                language: 'json',
+              },
+            ];
+          }),
+        };
+
+        return chain;
+      });
+
+      const result = await analyzer.mineKeyFilesFromEmbeddings(mockProjectPath);
+
+      expect(result.some((file) => file.path === 'package.json')).toBe(true);
+      expect(
+        queryCalls.some((call) => {
+          const selectedColumns = call.select[0] || [];
+          return selectedColumns.includes('content') && call.where[0] === "project_path = '/mock/project'" && call.limit.length === 0;
+        })
+      ).toBe(false);
+      expect(
+        queryCalls.some((call) => {
+          const selectedColumns = call.select[0] || [];
+          return (
+            selectedColumns.includes('path') &&
+            selectedColumns.includes('name') &&
+            !selectedColumns.includes('content') &&
+            call.where[0] === "project_path = '/mock/project'"
+          );
+        })
+      ).toBe(true);
+    });
+
     it('should handle table optimization errors gracefully', async () => {
       mockTable.optimize.mockRejectedValue(new Error('legacy format'));
       mockTable.query().toArray.mockResolvedValue([]);

package/src/rag-analyzer.js

@@ -42,6 +42,20 @@ const embeddingsSystem = getDefaultEmbeddingsSystem();
 // Track if semantic similarity has been initialized
 let semanticSimilarityInitialized = false;
 
+async function fileExists(filePath) {
+  try {
+    await fs.promises.access(filePath);
+    return true;
+  }
+  catch {
+    return false;
+  }
+}
+
+async function readTextFile(filePath) {
+  return await fs.promises.readFile(filePath, 'utf8');
+}
+
 /**
  * Initialize semantic similarity for feedback filtering
  * Uses the shared embeddings system from feedback-loader.js
@@ -448,7 +462,7 @@ async function runAnalysis(filePath, options = {}) {
     }
 
     // Check if file exists
-    if (!fs.existsSync(filePath)) {
+    if (!(await fileExists(filePath))) {
       throw new Error(`File not found: ${filePath}`);
     }
 
@@ -457,12 +471,14 @@ async function runAnalysis(filePath, options = {}) {
     let fullFileContent;
     if (options.diffOnly && options.diffContent) {
       content = options.diffContent;
-      // For PR reviews, always read the full file content for context awareness
-      fullFileContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : null;
+      // For PR reviews, always read the full file content for context awareness.
+      // Tolerate a missing/unreadable file (e.g. deleted in the window after the
+      // existence check) by degrading to null; downstream falls back to file.content.
+      fullFileContent = await readTextFile(filePath).catch(() => null);
       verboseLog(options, chalk.blue(`Analyzing diff only for ${path.basename(filePath)}`));
     }
     else {
-      content = fs.readFileSync(filePath, 'utf8');
+      content = await readTextFile(filePath);
       fullFileContent = content;
       verboseLog(options, chalk.blue(`Analyzing full file ${path.basename(filePath)}`));
     }
@@ -835,6 +851,46 @@ MARKDOWN FORMATTING IN DESCRIPTIONS AND SUGGESTIONS:
 Your response must start with { and end with } with no additional text.`;
 }
 
+function buildCachedProjectContextBlocks({ roleDefinition, customDocsSection, projectArchitectureSection }) {
+  const blocks = [];
+
+  if (roleDefinition?.trim()) {
+    blocks.push(`REVIEW ROLE AND PROJECT INSTRUCTIONS
+
+${roleDefinition}`);
+  }
+
+  if (customDocsSection?.trim() && !customDocsSection.includes('No custom instructions provided.')) {
+    blocks.push(`CUSTOM PROJECT INSTRUCTIONS
+
+${customDocsSection}`);
+  }
+
+  if (projectArchitectureSection?.trim()) {
+    blocks.push(`PROJECT ARCHITECTURE CONTEXT
+
+${projectArchitectureSection}`);
+  }
+
+  return blocks;
+}
+
+/**
+ * Build the user-prompt sentence that points the model at the cached system blocks.
+ * Returns an empty string when no cached blocks were emitted, so the prompt never
+ * instructs the model to use context that was not sent.
+ *
+ * @param {string[]} cachedSystemBlocks - Cached blocks produced for this request
+ * @param {string} subject - What is being evaluated (e.g. 'this file')
+ * @returns {string} Instruction sentence, or '' when there is no cached context
+ */
+function buildCachedContextInstruction(cachedSystemBlocks, subject) {
+  if (!cachedSystemBlocks || cachedSystemBlocks.length === 0) {
+    return '';
+  }
+  return `Use the cached project context, project architecture, and custom instructions when evaluating ${subject}.`;
+}
+
 // LLM call function - sends prompt with cached system content for cost optimization
 async function sendPromptToLLM(promptConfig, llmOptions) {
   try {
@@ -946,12 +1002,14 @@ async function sendPromptToLLM(promptConfig, llmOptions) {
     verboseLog(llmOptions, chalk.gray(`  Prompt config has systemPrompt: ${!!promptConfig.systemPrompt}`));
     verboseLog(llmOptions, chalk.gray(`  Prompt config has userPrompt: ${!!promptConfig.userPrompt}`));
     verboseLog(llmOptions, chalk.gray(`  System prompt length: ${promptConfig.systemPrompt?.length || 0} chars`));
+    verboseLog(llmOptions, chalk.gray(`  Cached system blocks: ${promptConfig.cachedSystemBlocks?.length || 0}`));
     verboseLog(llmOptions, chalk.gray(`  User prompt length: ${promptConfig.userPrompt?.length || 0} chars`));
 
     // Send prompt with system (cached) and user (dynamic) content
     const response = await llm.sendPromptToClaude(promptConfig.userPrompt, {
       ...llmOptions,
       system: promptConfig.systemPrompt,
+      cachedSystemBlocks: promptConfig.cachedSystemBlocks || [],
       jsonSchema: codeReviewSchema,
     });
 
@@ -1096,21 +1154,21 @@ ${addLineNumbers(file.content)}
 
   // Build the cached system prompt (contains all static rules)
   const systemPrompt = buildCachedSystemPrompt('code');
+  const cachedSystemBlocks = buildCachedProjectContextBlocks({
+    roleDefinition,
+    customDocsSection,
+    projectArchitectureSection,
+  });
 
   // Build the dynamic user prompt (contains all variable content)
   const userPrompt = finalizePrompt(`
 ## REVIEW TYPE: CODE FILE ANALYSIS
 
-${roleDefinition}
-
 ${reviewInstructions}
 
-${customDocsSection}
-
 ${fileSection}
 
-CONTEXT FROM PROJECT:
-${projectArchitectureSection}
+${buildCachedContextInstruction(cachedSystemBlocks, 'this file')}
 
 CONTEXT A: EXPLICIT GUIDELINES FROM DOCUMENTATION
 ${formattedGuidelines}
@@ -1136,7 +1194,7 @@ Analyze the FILE TO REVIEW above using the 4-stage methodology:
 - If you analyzed something and found it's fine, simply don't include it in the output
 `);
 
-  return { systemPrompt, userPrompt };
+  return { systemPrompt, userPrompt, cachedSystemBlocks };
 }
 
 /**
@@ -1215,22 +1273,22 @@ ${addLineNumbers(file.content)}
 
   // Build the cached system prompt (contains all static rules)
   const systemPrompt = buildCachedSystemPrompt('test');
+  const cachedSystemBlocks = buildCachedProjectContextBlocks({
+    roleDefinition,
+    customDocsSection,
+    projectArchitectureSection,
+  });
 
   // Build the dynamic user prompt (contains all variable content)
   const userPrompt = finalizePrompt(`
 ## REVIEW TYPE: TEST FILE ANALYSIS
 
-${roleDefinition}
-
 ${reviewInstructions}
 
 ${fileSection}
 
 ## ANALYSIS CONTEXT
-${customDocsSection}
-
-CONTEXT FROM PROJECT:
-${projectArchitectureSection}
+${buildCachedContextInstruction(cachedSystemBlocks, 'this test file')}
 
 CONTEXT A: TESTING GUIDELINES AND BEST PRACTICES
 ${formattedGuidelines}
@@ -1253,7 +1311,7 @@ Analyze the TEST FILE above using the 5-stage methodology:
 - If you analyzed something and found it's fine, simply don't include it in the output
 `);
 
-  return { systemPrompt, userPrompt };
+  return { systemPrompt, userPrompt, cachedSystemBlocks };
 }
 
 /**
@@ -1371,20 +1429,23 @@ For each file in this PR, you have access to:
 
   // Build the cached system prompt (contains all static rules)
   const systemPrompt = buildCachedSystemPrompt('pr');
+  const cachedSystemBlocks = buildCachedProjectContextBlocks({
+    roleDefinition,
+    customDocsSection,
+    projectArchitectureSection,
+  });
 
   // Build the dynamic user prompt (contains all variable content)
   const userPrompt = finalizePrompt(`
 ## REVIEW TYPE: HOLISTIC PR ANALYSIS
 
-${roleDefinition}
-
 ## PULL REQUEST OVERVIEW
 - **Total Files**: ${prFiles.length}
 - **Source Files**: ${prFiles.filter((f) => !f.isTest).length}
 - **Test Files**: ${prFiles.filter((f) => f.isTest).length}
 
 ## UNIFIED CONTEXT FROM PROJECT
-${projectArchitectureSection}
+${buildCachedContextInstruction(cachedSystemBlocks, 'this pull request')}
 
 ### PROJECT CODE EXAMPLES
 ${formattedCodeExamples}
@@ -1398,9 +1459,6 @@ ${formattedPRComments}
 ## PR FILES WITH CHANGES
 ${formattedPRFiles}
 
-## CUSTOM INSTRUCTIONS
-${customDocsSection}
-
 ## YOUR TASK
 
 Analyze ALL PR FILES above using the 5-stage methodology:
@@ -1418,7 +1476,7 @@ Analyze ALL PR FILES above using the 5-stage methodology:
 - If you analyzed something and found it's fine, simply don't include it in the output
 `);
 
-  return { systemPrompt, userPrompt };
+  return { systemPrompt, userPrompt, cachedSystemBlocks };
 }
 
 /**
@@ -1487,7 +1545,7 @@ async function getPRCommentContext(filePath, options = {}) {
       verboseLog(options, chalk.blue(`🔍 Using pre-computed query embedding for PR comment search`));
       // We still need the file content for the search function, but not for embedding
       try {
-        fileContent = fs.readFileSync(filePath, 'utf8');
+        fileContent = await readTextFile(filePath);
         const maxEmbeddingLength = 8000; // Keep consistent with original truncation
         contentForSearch = fileContent.length > maxEmbeddingLength ? fileContent.substring(0, maxEmbeddingLength) : fileContent;
       }
@@ -1505,7 +1563,7 @@ async function getPRCommentContext(filePath, options = {}) {
     else {
       // Fallback to original behavior if no pre-computed embedding provided
       try {
-        fileContent = fs.readFileSync(filePath, 'utf8');
+        fileContent = await readTextFile(filePath);
       }
       catch (readError) {
         debug(`[getPRCommentContext] Could not read file ${filePath}: ${readError.message}`);

package/src/rag-analyzer.test.js

@@ -41,6 +41,10 @@ vi.mock('node:fs', () => ({
   default: {
     readFileSync: vi.fn(),
     existsSync: vi.fn().mockReturnValue(true),
+    promises: {
+      access: vi.fn().mockResolvedValue(undefined),
+      readFile: vi.fn(),
+    },
   },
 }));
 
@@ -155,6 +159,8 @@ describe('rag-analyzer', () => {
     mockEmbeddingsSystem.updatePRCommentsIndex.mockReset().mockResolvedValue(undefined);
     fs.readFileSync.mockReturnValue('const x = 1;\nconsole.log(x);');
     fs.existsSync.mockReturnValue(true);
+    fs.promises.access.mockReset().mockResolvedValue(undefined);
+    fs.promises.readFile.mockReset().mockResolvedValue('const x = 1;\nconsole.log(x);');
   });
 
   afterEach(() => {
@@ -197,7 +203,7 @@ describe('rag-analyzer', () => {
     });
 
     it('should return error when file does not exist', async () => {
-      fs.existsSync.mockReturnValue(false);
+      fs.promises.access.mockRejectedValue(new Error('ENOENT'));
       const result = await runAnalysis('/test/nonexistent.js');
       expect(result.success).toBe(false);
       expect(result.error).toContain('File not found');
@@ -369,13 +375,13 @@ describe('rag-analyzer', () => {
       ['whitespace only', '   \n\n   '],
       ['normal content', 'const x = 1;\nfunction test() {}'],
     ])('should handle %s', async (_, content) => {
-      fs.readFileSync.mockReturnValue(content);
+      fs.promises.readFile.mockResolvedValue(content);
       const result = await runAnalysis('/test/file.js');
       expect(result).toBeDefined();
     });
 
     it('should handle very long files', async () => {
-      fs.readFileSync.mockReturnValue(createMockLongCode(1000));
+      fs.promises.readFile.mockResolvedValue(createMockLongCode(1000));
       const result = await runAnalysis('/test/long.js');
       expect(result.success).toBe(true);
     });
@@ -772,7 +778,9 @@ describe('rag-analyzer', () => {
         customDocs: [{ content: 'Mandatory internal review rule', document_title: 'Internal Standards' }],
       });
 
-      expect(llm.sendPromptToClaude).toHaveBeenCalledWith(expect.stringContaining('Mandatory internal review rule'), expect.any(Object));
+      const [, options] = llm.sendPromptToClaude.mock.calls.at(-1);
+      expect(options.cachedSystemBlocks.join('\n')).toContain('Mandatory internal review rule');
+      expect(llm.sendPromptToClaude.mock.calls.at(-1)[0]).not.toContain('Mandatory internal review rule');
     });
 
     it('should log selected chunks when verbose', async () => {
@@ -954,7 +962,7 @@ describe('rag-analyzer', () => {
 
   describe('gatherUnifiedContextForPR error handling', () => {
     it('should handle file context gathering errors', async () => {
-      fs.readFileSync.mockImplementation((path) => {
+      fs.promises.readFile.mockImplementation((path) => {
         if (path.includes('error-file')) {
           throw new Error('Read error');
         }
@@ -1181,7 +1189,7 @@ describe('rag-analyzer', () => {
           return <div>{data}</div>;
         }
       `;
-      fs.readFileSync.mockReturnValue(richCode);
+      fs.promises.readFile.mockResolvedValue(richCode);
       setupSuccessfulLLMResponse();
       const result = await runAnalysis('/test/Dashboard.jsx');
       expect(result.success).toBe(true);