codecritique 2.2.6 → 2.3.1

package/README.md

@@ -415,7 +415,7 @@ jobs:
 | `anthropic-api-key` | Anthropic API key for Claude models                                                                      | **Yes**  | -                    |
 | `skip-label`        | Label name to skip AI review                                                                             | No       | `ai-review-disabled` |
 | `verbose`           | Show verbose output                                                                                      | No       | `false`              |
-| `model`             | LLM model to use (e.g., `claude-sonnet-4-6`)                                                             | No       | Auto-selected        |
+| `model`             | LLM model to use (e.g., `claude-sonnet-5`)                                                               | 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`              |

package/package.json

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

package/src/feedback-loader.js

@@ -111,7 +111,6 @@ export async function initializeSemanticSimilarity() {
   try {
     embeddingsSystem = getDefaultEmbeddingsSystem();
     await embeddingsSystem.initialize();
-    semanticSimilarityInitialized = true;
     semanticSimilarityAvailable = true;
     verboseLog({}, chalk.green('[FeedbackLoader] Semantic similarity initialized using embeddings system'));
   }
@@ -119,6 +118,11 @@ export async function initializeSemanticSimilarity() {
     console.warn(chalk.yellow(`[FeedbackLoader] Semantic similarity initialization failed: ${error.message}`));
     semanticSimilarityAvailable = false;
   }
+  finally {
+    // Records the attempt, not the outcome. Callers initialize lazily, so a failure
+    // that left this unset would reload the model once per issue.
+    semanticSimilarityInitialized = true;
+  }
 }
 
 /**
@@ -168,74 +172,84 @@ async function calculateSemanticSimilarity(text1, text2) {
 // ISSUE SIMILARITY CHECKING
 // ============================================================================
 
+/** Score above which an issue counts as a repeat of a dismissed one. */
+export const DEFAULT_SIMILARITY_THRESHOLD = 0.7;
+
+// A dismissal on the same line is evidence, not proof: a reworded repeat and a
+// different finding on the same topic score too close together to tell apart. The
+// lower bar catches the reworded repeat while a plainly unrelated finding still posts.
+const SAME_LOCATION_SIMILARITY_THRESHOLD = 0.65;
+
+// The word term is what separates a repost from a new finding: semantic scores
+// alone rank unrelated findings above the threshold.
+const SEMANTIC_WEIGHT = 0.7;
+const WORD_WEIGHT = 0.3;
+
 /**
- * Check if an issue should be skipped based on previous feedback
- * Uses semantic similarity when available, falls back to word-based similarity.
+ * Check if an issue should be skipped based on previous feedback.
+ * Compares against dismissed issues with the combined semantic and word-based score,
+ * initializing the embeddings system on first use.
  *
  * @param {string} issueDescription - Description of the current issue
  * @param {Object} feedbackData - Loaded feedback data
  * @param {Object} options - Filtering options
- * @param {number} [options.similarityThreshold=0.7] - Threshold for considering issues similar
+ * @param {number} [options.similarityThreshold=DEFAULT_SIMILARITY_THRESHOLD] - Threshold for considering issues similar
  * @param {boolean} [options.verbose=false] - Enable verbose progress logging
  * @param {boolean} [options.useSemanticSimilarity=true] - Use semantic similarity when available
+ * @param {string|null} [options.filePath=null] - Path of the file the current issue is on
+ * @param {number|null} [options.lineNumber=null] - Line the current issue is on
  * @returns {Promise<boolean>} True if issue should be skipped
  */
 export async function shouldSkipSimilarIssue(issueDescription, feedbackData, options = {}) {
-  const { similarityThreshold = 0.7, verbose = false, useSemanticSimilarity = true } = options;
+  const {
+    similarityThreshold = DEFAULT_SIMILARITY_THRESHOLD,
+    verbose = false,
+    useSemanticSimilarity = true,
+    filePath = null,
+    lineNumber = null,
+  } = options;
 
   if (!feedbackData || Object.keys(feedbackData).length === 0) {
     return false;
   }
 
-  // Check if similar issues were previously dismissed
+  // Dismissals worth comparing against: one without its own text can never match.
   const dismissedIssues = Object.values(feedbackData).filter(
     (feedback) =>
-      feedback?.overallSentiment === 'negative' ||
-      feedback?.userReplies?.some(
-        (reply) =>
-          reply.body.toLowerCase().includes('false positive') ||
-          reply.body.toLowerCase().includes('not relevant') ||
-          reply.body.toLowerCase().includes('ignore') ||
-          reply.body.toLowerCase().includes('resolved')
-      )
+      feedback?.originalIssue &&
+      (feedback?.overallSentiment === 'negative' ||
+        feedback?.userReplies?.some(
+          (reply) =>
+            reply.body.toLowerCase().includes('false positive') ||
+            reply.body.toLowerCase().includes('not relevant') ||
+            reply.body.toLowerCase().includes('ignore') ||
+            reply.body.toLowerCase().includes('resolved')
+        ))
   );
 
-  if (dismissedIssues.length === 0) {
+  if (!issueDescription || dismissedIssues.length === 0) {
     return false;
   }
 
-  // Determine if we should use semantic similarity
-  const canUseSemanticSimilarity = useSemanticSimilarity && isSemanticSimilarityAvailable();
-
-  verboseLog(verbose && canUseSemanticSimilarity, chalk.cyan('🔍 Using semantic similarity for issue comparison'));
+  // Loaded here rather than by the caller: this is the first point where a comparison
+  // is certain, and the embedding model is the expensive part of making one.
+  if (useSemanticSimilarity) {
+    await initializeSemanticSimilarity();
+  }
 
   // Check similarity with dismissed issues
   for (const dismissed of dismissedIssues) {
-    if (!dismissed.originalIssue) {
-      continue;
-    }
-
-    let similarity;
-    let similarityMethod;
+    const threshold = isSameLocation(dismissed, filePath, lineNumber)
+      ? Math.min(similarityThreshold, SAME_LOCATION_SIMILARITY_THRESHOLD)
+      : similarityThreshold;
 
-    if (canUseSemanticSimilarity) {
-      // Try semantic similarity first using existing embeddings system
-      similarity = await calculateSemanticSimilarity(issueDescription, dismissed.originalIssue);
-      similarityMethod = 'semantic';
-
-      // Fall back to word similarity if semantic calculation failed
-      if (similarity === null) {
-        similarity = calculateWordSimilarity(issueDescription, dismissed.originalIssue);
-        similarityMethod = 'word-based';
-      }
-    }
-    else {
-      // Use word-based similarity
-      similarity = calculateWordSimilarity(issueDescription, dismissed.originalIssue);
-      similarityMethod = 'word-based';
-    }
+    // The hybrid score, not the semantic score alone: a normalized semantic score ranks
+    // unrelated findings above the threshold, so one dismissal would suppress every issue.
+    const { similarity, method: similarityMethod } = await calculateIssueSimilarity(issueDescription, dismissed.originalIssue, {
+      useSemanticSimilarity,
+    });
 
-    if (similarity > similarityThreshold) {
+    if (similarity > threshold) {
       verboseLog(
         verbose,
         chalk.yellow(`⏭️ Skipping similar dismissed issue (${(similarity * 100).toFixed(1)}% ${similarityMethod} similarity)`)
@@ -249,6 +263,19 @@ export async function shouldSkipSimilarIssue(issueDescription, feedbackData, opt
   return false;
 }
 
+/**
+ * Check whether a dismissed issue was recorded at the given file and line.
+ * A null on either side never matches, so an unknown location never narrows anything.
+ *
+ * @param {Object} dismissed - A dismissed feedback entry
+ * @param {string|null} filePath - Path of the current issue
+ * @param {number|null} lineNumber - Line of the current issue
+ * @returns {boolean} True when both locations are known and equal
+ */
+function isSameLocation(dismissed, filePath, lineNumber) {
+  return Boolean(filePath && lineNumber != null && dismissed.filePath === filePath && dismissed.lineNumber === lineNumber);
+}
+
 /**
  * Calculate combined similarity between two issue descriptions.
  * Uses both semantic and word-based similarity for robust comparison.
@@ -275,9 +302,7 @@ export async function calculateIssueSimilarity(text1, text2, options = {}) {
       // Also calculate word similarity for a hybrid score
       const wordSimilarity = calculateWordSimilarity(text1, text2);
 
-      // Combine both scores with more weight on semantic similarity
-      // This helps catch both semantically similar and lexically similar issues
-      const combinedSimilarity = semanticSimilarity * 0.7 + wordSimilarity * 0.3;
+      const combinedSimilarity = semanticSimilarity * SEMANTIC_WEIGHT + wordSimilarity * WORD_WEIGHT;
 
       return {
         similarity: combinedSimilarity,

package/src/feedback-loader.test.js

@@ -527,3 +527,117 @@ describe('loadFeedbackData edge cases', () => {
     expect(result).toHaveProperty('item');
   });
 });
+
+describe('shouldSkipSimilarIssue without a comparable pair', () => {
+  // Nothing to compare means nothing to load the embedding model for.
+  let loader;
+  let initialize;
+
+  beforeEach(async () => {
+    mockConsoleSelective('log', 'warn');
+    vi.resetModules();
+    initialize = vi.fn().mockResolvedValue(undefined);
+
+    // eslint-disable-next-line no-restricted-syntax
+    const freshFactory = await import('./embeddings/factory.js');
+    freshFactory.getDefaultEmbeddingsSystem.mockReturnValue({ initialize, calculateEmbedding: vi.fn() });
+
+    // eslint-disable-next-line no-restricted-syntax
+    loader = await import('./feedback-loader.js');
+  });
+
+  it.each([
+    ['the only dismissal has no text of its own', 'a candidate description', { i1: { overallSentiment: 'negative', originalIssue: '' } }],
+    ['the candidate has no description', '', { i1: { overallSentiment: 'negative', originalIssue: 'a dismissed finding' } }],
+  ])('should not initialize the embeddings system when %s', async (_name, description, feedbackData) => {
+    await expect(loader.shouldSkipSimilarIssue(description, feedbackData)).resolves.toBe(false);
+
+    expect(initialize).not.toHaveBeenCalled();
+  });
+});
+
+describe('shouldSkipSimilarIssue location match', () => {
+  // Word similarity 0.667: above the same-location bar of 0.65, below the 0.9 passed here.
+  // Only the location can decide these cases.
+  const SHARED = 'alpha bravo charlie delta echo foxtrot golf hotel';
+  const DISMISSED = `${SHARED} india juliett`;
+  const REWORDED = `${SHARED} kilo lima`;
+  const UNRELATED = 'mike november oscar papa quebec';
+  const LOCATION = { filePath: '.github/workflows/pr-review.yml', lineNumber: 51 };
+
+  const feedbackData = {
+    issue1: {
+      overallSentiment: 'neutral',
+      originalIssue: DISMISSED,
+      userReplies: [{ body: 'False positive.' }],
+      ...LOCATION,
+    },
+  };
+
+  const check = (description, options) =>
+    shouldSkipSimilarIssue(description, feedbackData, { similarityThreshold: 0.9, useSemanticSimilarity: false, ...options });
+
+  it.each([
+    ['a reworded repeat at the same location', REWORDED, LOCATION, true],
+    ['a reworded repeat on a different line', REWORDED, { ...LOCATION, lineNumber: 52 }, false],
+    ['an unrelated finding at the same location', UNRELATED, LOCATION, false],
+    ['a reworded repeat with no known line', REWORDED, { ...LOCATION, lineNumber: null }, false],
+  ])('should %s -> %s', async (_name, description, options, expected) => {
+    await expect(check(description, options)).resolves.toBe(expected);
+  });
+});
+
+describe('shouldSkipSimilarIssue with semantic similarity available', () => {
+  // Unit vectors whose cosine similarity is exact: [1, 0] against [cos, sin].
+  const vectorFor = (cosine) => [cosine, Math.sqrt(1 - cosine * cosine)];
+  const DISMISSED = 'Missing null check in the handler function';
+  const REPHRASED = 'The handler function does not guard against a null argument';
+  const UNRELATED = 'Prefer const over let for bindings that never change';
+
+  let loader;
+
+  beforeEach(async () => {
+    mockConsoleSelective('log', 'warn');
+    vi.resetModules();
+
+    // eslint-disable-next-line no-restricted-syntax
+    const freshFactory = await import('./embeddings/factory.js');
+    freshFactory.getDefaultEmbeddingsSystem.mockReturnValue({
+      initialize: vi.fn().mockResolvedValue(undefined),
+      calculateEmbedding: vi.fn(async (text) => {
+        if (text === DISMISSED) {
+          return vectorFor(1);
+        }
+        return vectorFor(text === REPHRASED ? 0.98 : 0.8);
+      }),
+    });
+
+    // eslint-disable-next-line no-restricted-syntax
+    loader = await import('./feedback-loader.js');
+    await loader.initializeSemanticSimilarity();
+  });
+
+  it('should skip a dismissed issue that the model rephrased', async () => {
+    const feedbackData = {
+      issue1: {
+        overallSentiment: 'neutral',
+        originalIssue: DISMISSED,
+        userReplies: [{ body: 'False positive.' }],
+      },
+    };
+
+    await expect(loader.shouldSkipSimilarIssue(REPHRASED, feedbackData, { similarityThreshold: 0.7 })).resolves.toBe(true);
+  });
+
+  it('should not skip an unrelated issue once another issue was dismissed', async () => {
+    const feedbackData = {
+      issue1: {
+        overallSentiment: 'neutral',
+        originalIssue: DISMISSED,
+        userReplies: [{ body: 'False positive.' }],
+      },
+    };
+
+    await expect(loader.shouldSkipSimilarIssue(UNRELATED, feedbackData, { similarityThreshold: 0.7 })).resolves.toBe(false);
+  });
+});

package/src/index.js

@@ -63,7 +63,7 @@ program
   .option('--output-file <file>', 'Save output to file (useful with --output json)')
   .option('--no-color', 'Disable colored output')
   .option('--verbose', 'Show verbose output')
-  .option('--model <model>', 'LLM model to use (e.g., claude-sonnet-4-6)')
+  .option('--model <model>', 'LLM model to use (e.g., claude-sonnet-5)')
   .option('--temperature <number>', 'LLM temperature', parseFloat, 0.2)
   .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')

package/src/llm.js

@@ -42,7 +42,11 @@ function getAnthropicClient() {
 }
 
 // Default model
-const DEFAULT_MODEL = 'claude-sonnet-4-6';
+const DEFAULT_MODEL = 'claude-sonnet-5';
+
+// Models after the 4.6 generation reject `temperature` with a 400. Only send it
+// for the older families; unknown models fall back to the API default.
+const SAMPLING_MODEL_PATTERN = /^claude-(?:3|(?:opus|sonnet|haiku)-4-[0-6])/;
 
 // Maximum tokens for response
 const MAX_TOKENS = 4096;
@@ -138,6 +142,8 @@ async function createBatchedMessage(client, requestParams, options) {
  * @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 {boolean} [options.strict=false] - Enforce the schema on the tool input. Every object in the
+ *   schema must set `additionalProperties: false`, and `additionalProperties` accepts no other value.
  * @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
@@ -150,6 +156,7 @@ async function sendPromptToClaude(prompt, options = {}) {
     system = '',
     cachedSystemBlocks = [],
     jsonSchema = null,
+    strict = false,
     cacheTtl = '5m',
   } = options;
 
@@ -169,7 +176,7 @@ async function sendPromptToClaude(prompt, options = {}) {
     const requestParams = {
       model,
       max_tokens: maxTokens,
-      temperature,
+      ...(SAMPLING_MODEL_PATTERN.test(model) ? { temperature } : {}),
       system: systemContent,
       messages: [
         {
@@ -186,6 +193,9 @@ async function sendPromptToClaude(prompt, options = {}) {
           name: 'return_json',
           description: 'Return the final answer strictly as JSON matching the schema.',
           input_schema: jsonSchema,
+          // Omitted rather than sent as false so the tool block stays byte-identical
+          // for callers that do not use it, which keeps their cached prefix valid.
+          ...(strict ? { strict: true } : {}),
         },
       ];
       requestParams.tool_choice = { type: 'tool', name: 'return_json' };
@@ -199,6 +209,22 @@ async function sendPromptToClaude(prompt, options = {}) {
     verboseLog(options, chalk.gray(`  Response stop_reason: ${response.stop_reason}`));
     verboseLog(options, chalk.gray(`  Response content blocks: ${response.content?.length || 0}`));
 
+    // A refusal arrives as HTTP 200 with no tool_use and no text, so it must be caught
+    // here or it surfaces as a missing-output error that hides the real cause.
+    if (response.stop_reason === 'refusal') {
+      const { category, explanation } = response.stop_details || {};
+      const reason = explanation || 'no explanation provided';
+      throw new Error(`Claude declined the request${category ? ` (${category})` : ''}: ${reason}`);
+    }
+
+    // Truncation also arrives as HTTP 200. Without this the tool path reports missing
+    // output and the text path returns a severed answer that reads as a complete one.
+    if (response.stop_reason === 'max_tokens' || response.stop_reason === 'model_context_window_exceeded') {
+      const remedy =
+        response.stop_reason === 'max_tokens' ? 'Increase the configured output limit or continue the response.' : 'Reduce the input size.';
+      throw new Error(`Claude's response was truncated (${response.stop_reason}). ${remedy}`);
+    }
+
     // Process response based on whether we used tool calling
     if (jsonSchema) {
       const toolUse = response.content.find((block) => block.type === 'tool_use' && block.name === 'return_json');
@@ -221,7 +247,7 @@ async function sendPromptToClaude(prompt, options = {}) {
     }
     else {
       return {
-        content: response.content[0]?.text || '',
+        content: response.content?.find((block) => block.type === 'text')?.text || '',
         model: response.model,
         usage: response.usage,
       };

package/src/llm.test.js

@@ -65,13 +65,122 @@ describe('sendPromptToClaude', () => {
 
       expect(mockMessagesCreate).toHaveBeenCalledWith(
         expect.objectContaining({
-          model: 'claude-sonnet-4-6',
+          model: 'claude-sonnet-5',
           max_tokens: 4096,
-          temperature: 0.7,
         })
       );
     });
 
+    it('should surface the refusal explanation instead of a missing-output error', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        stop_reason: 'refusal',
+        stop_details: { type: 'refusal', category: 'cyber', explanation: 'Declined: offensive tooling.' },
+        content: [],
+        model: 'claude-sonnet-5',
+        usage: {},
+      });
+
+      await expect(sendPromptToClaude('Test prompt', { jsonSchema: { type: 'object' } })).rejects.toThrow(
+        'Claude declined the request (cyber): Declined: offensive tooling.'
+      );
+    });
+
+    it.each([
+      ['max_tokens', 'Increase the configured output limit or continue the response.'],
+      ['model_context_window_exceeded', 'Reduce the input size.'],
+    ])('should report a truncated response for stop_reason %s', async (stopReason, remedy) => {
+      mockMessagesCreate.mockResolvedValue({
+        stop_reason: stopReason,
+        content: [],
+        model: 'claude-sonnet-5',
+        usage: {},
+      });
+
+      await expect(sendPromptToClaude('Test prompt', { jsonSchema: { type: 'object' } })).rejects.toThrow(
+        `Claude's response was truncated (${stopReason}). ${remedy}`
+      );
+    });
+
+    it('should report truncation rather than returning a severed plain-text answer', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        stop_reason: 'max_tokens',
+        content: [{ type: 'text', text: 'partial answer cut off mid-' }],
+        model: 'claude-sonnet-5',
+        usage: {},
+      });
+
+      await expect(sendPromptToClaude('Test prompt')).rejects.toThrow('was truncated (max_tokens)');
+    });
+
+    it('should read the text block even when a thinking block precedes it', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        stop_reason: 'end_turn',
+        content: [
+          { type: 'thinking', thinking: '' },
+          { type: 'text', text: 'The real answer' },
+        ],
+        model: 'claude-sonnet-5',
+        usage: {},
+      });
+
+      const result = await sendPromptToClaude('Test prompt');
+
+      expect(result.content).toBe('The real answer');
+    });
+
+    it('should omit temperature for models that reject sampling parameters', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        content: [{ type: 'text', text: 'Response' }],
+        model: 'claude-sonnet-5',
+        usage: {},
+      });
+
+      await sendPromptToClaude('Test prompt', { temperature: 0.5 });
+
+      expect(mockMessagesCreate.mock.calls[0][0]).not.toHaveProperty('temperature');
+    });
+
+    it('should set strict on the return_json tool when requested', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        content: [{ type: 'tool_use', name: 'return_json', input: { ok: true } }],
+        model: 'claude-sonnet-5',
+        usage: {},
+      });
+
+      await sendPromptToClaude('Test prompt', {
+        jsonSchema: { type: 'object', properties: {}, required: [], additionalProperties: false },
+        strict: true,
+      });
+
+      expect(mockMessagesCreate.mock.calls[0][0].tools[0]).toHaveProperty('strict', true);
+    });
+
+    it('should omit strict from the return_json tool by default', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        content: [{ type: 'tool_use', name: 'return_json', input: { ok: true } }],
+        model: 'claude-sonnet-5',
+        usage: {},
+      });
+
+      await sendPromptToClaude('Test prompt', {
+        jsonSchema: { type: 'object', properties: {}, required: [], additionalProperties: false },
+      });
+
+      expect(mockMessagesCreate.mock.calls[0][0].tools[0]).not.toHaveProperty('strict');
+    });
+
+    it('should keep temperature for models that still accept it', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        content: [{ type: 'text', text: 'Response' }],
+        model: 'claude-haiku-4-5',
+        usage: {},
+      });
+
+      await sendPromptToClaude('Test prompt', { model: 'claude-haiku-4-5', temperature: 0.1 });
+
+      expect(mockMessagesCreate).toHaveBeenCalledWith(expect.objectContaining({ temperature: 0.1 }));
+    });
+
     it('should use custom options', async () => {
       mockMessagesCreate.mockResolvedValue({
         content: [{ type: 'text', text: 'Response' }],
@@ -105,7 +214,7 @@ 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',
+        model: 'claude-sonnet-5',
         usage: { input_tokens: 100, output_tokens: 50 },
       };
       mockBatchesCreate.mockResolvedValue({ id: 'msgbatch_123', processing_status: 'in_progress' });
@@ -127,7 +236,7 @@ describe('sendPromptToClaude', () => {
           {
             custom_id: 'codecritique-review',
             params: expect.objectContaining({
-              model: 'claude-sonnet-4-6',
+              model: 'claude-sonnet-5',
               messages: [{ role: 'user', content: 'Review this code' }],
             }),
           },

package/src/project-analyzer.js

@@ -592,6 +592,7 @@ Select files following the criteria in the system instructions.`;
         temperature: 0.1,
         maxTokens: 1000,
         jsonSchema: fileSelectionSchema,
+        strict: true,
       });
 
       verboseLog({}, chalk.gray('   📄 LLM Response preview:'), response.content.substring(0, 200));

package/src/project-analyzer.test.js

@@ -556,7 +556,10 @@ describe('ProjectAnalyzer', () => {
 
       const result = await analyzer.selectFinalKeyFiles(candidates, mockProjectPath);
 
-      expect(llm.sendPromptToClaude).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ model: 'claude-haiku-4-5' }));
+      expect(llm.sendPromptToClaude).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({ model: 'claude-haiku-4-5', strict: true })
+      );
       expect(result.length).toBe(1);
       expect(result[0].relativePath).toBe('package.json');
     });
@@ -673,6 +676,9 @@ describe('ProjectAnalyzer', () => {
       const result = await analyzer.generateProjectSummary(mockKeyFiles, mockProjectPath);
 
       expect(llm.sendPromptToClaude).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ model: 'claude-haiku-4-5' }));
+      // projectSummarySchema sets additionalProperties: false on its top level only, and
+      // the documented strict subset requires it on every object.
+      expect(llm.sendPromptToClaude.mock.calls[0][1]).not.toHaveProperty('strict');
       expect(result.projectName).toBe('test-project');
       expect(result.analysisDate).toBeDefined();
       expect(result.projectPath).toBe(mockProjectPath);

package/src/prompt-cache.js

@@ -248,9 +248,9 @@ You must respond with EXACTLY this JSON structure, with no additional text:
     {
       "type": "bug | improvement | convention | architecture",
       "severity": "critical | high | medium",
-      "description": "Detailed description of an issue that spans multiple files...",
+      "message": "Detailed description of an issue that spans multiple files...",
       "suggestion": "Actionable suggestion to resolve the cross-file issue.",
-      "filesInvolved": ["path/to/file1.js", "path/to/file2.ts"]
+      "files": ["path/to/file1.js", "path/to/file2.ts"]
     }
   ],
   "fileSpecificIssues": {
@@ -272,9 +272,10 @@ You must respond with EXACTLY this JSON structure, with no additional text:
   },
   "recommendations": [
     {
-      "type": "refactoring | testing | documentation",
-      "description": "A high-level recommendation for improving the codebase...",
-      "filesInvolved": ["path/to/relevant/file.js"]
+      "category": "refactoring | testing | documentation",
+      "suggestion": "A high-level recommendation for improving the codebase...",
+      "priority": "high | medium | low",
+      "impact": "Expected benefit of applying this recommendation."
     }
   ]
 }`;

package/src/prompt-cache.test.js

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+import { PR_REVIEW_JSON_SCHEMA } from './prompt-cache.js';
+import { collectPRLevelFindings } from './utils/review-results.js';
+
+/**
+ * The prompt tells the model which field names to emit. `review-results.js` reads
+ * those names back. A divergence drops data silently, so these tests pin the
+ * prompt to the names the consumers actually read.
+ */
+describe('PR_REVIEW_JSON_SCHEMA', () => {
+  it('should name the cross-file issue fields that normalizePRLevelIssue reads', () => {
+    expect(PR_REVIEW_JSON_SCHEMA).toContain('"message"');
+    expect(PR_REVIEW_JSON_SCHEMA).toContain('"files"');
+  });
+
+  it('should name the recommendation fields that normalizeRecommendation reads', () => {
+    // "suggestion" appears in three blocks, so bound the slice at both ends: a slice
+    // that ran to the end of the schema would pass on any later block instead.
+    const start = PR_REVIEW_JSON_SCHEMA.indexOf('"recommendations"');
+    const recommendations = PR_REVIEW_JSON_SCHEMA.slice(start, PR_REVIEW_JSON_SCHEMA.indexOf(']', start) + 1);
+
+    expect(recommendations).toContain('"category"');
+    expect(recommendations).toContain('"suggestion"');
+    expect(recommendations).toContain('"impact"');
+  });
+
+  it('should not name filesInvolved, which no consumer reads', () => {
+    expect(PR_REVIEW_JSON_SCHEMA).not.toContain('filesInvolved');
+  });
+});
+
+describe('collectPRLevelFindings with prompt-shaped input', () => {
+  const holisticAnalysis = {
+    results: {
+      summary: 'PR summary',
+      crossFileIssues: [
+        {
+          type: 'architecture',
+          severity: 'high',
+          message: 'Duplicated retry logic',
+          suggestion: 'Extract a shared helper',
+          files: ['a.js', 'b.js'],
+        },
+      ],
+      recommendations: [{ category: 'testing', suggestion: 'Cover the retry path', impact: 'Fewer regressions' }],
+    },
+  };
+
+  it('should keep the file list from a cross-file issue', () => {
+    const findings = collectPRLevelFindings([], { holisticAnalysis });
+
+    expect(findings.issues[0].files).toEqual(['a.js', 'b.js']);
+    expect(findings.issues[0].description).toBe('Duplicated retry logic');
+  });
+
+  it('should render a recommendation as text rather than raw JSON', () => {
+    const findings = collectPRLevelFindings([], { holisticAnalysis });
+
+    expect(findings.recommendations[0]).toBe('testing: Cover the retry path: Fewer regressions');
+  });
+});

package/src/rag-analyzer.js

@@ -16,7 +16,7 @@ import {
   shouldSkipSimilarIssue,
   extractDismissedPatterns,
   generateFeedbackContext,
-  initializeSemanticSimilarity,
+  DEFAULT_SIMILARITY_THRESHOLD,
   isSemanticSimilarityAvailable,
 } from './feedback-loader.js';
 import * as llm from './llm.js';
@@ -37,9 +37,6 @@ const DEFAULT_TRUNCATE_LINES = 300;
 const GUIDELINE_TRUNCATE_LINES = 400;
 const MAX_PR_COMMENTS_FOR_CONTEXT = 15;
 
-// Track if semantic similarity has been initialized
-let semanticSimilarityInitialized = false;
-
 async function fileExists(filePath) {
   try {
     await fs.promises.access(filePath);
@@ -54,26 +51,6 @@ 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
- */
-async function ensureSemanticSimilarityInitialized() {
-  if (semanticSimilarityInitialized) {
-    return;
-  }
-
-  try {
-    // Initialize semantic similarity using the shared embeddings system
-    await initializeSemanticSimilarity();
-    semanticSimilarityInitialized = true;
-  }
-  catch (error) {
-    console.warn(chalk.yellow(`⚠️ Could not initialize semantic similarity: ${error.message}`));
-    // Continue without semantic similarity - word-based fallback will be used
-  }
-}
-
 // ============================================================================
 // PROMPT FORMATTING HELPERS
 // Note: Static prompt content (critical rules, citation requirements, etc.) is
@@ -578,7 +555,7 @@ async function runAnalysis(filePath, options = {}) {
     if (options.trackFeedback && feedbackData && Object.keys(feedbackData).length > 0) {
       verboseLog(options, chalk.cyan('--- Filtering Results Based on Feedback ---'));
       filteredResults = await filterAnalysisResults(lowSeverityFiltered, feedbackData, {
-        similarityThreshold: options.feedbackThreshold || 0.7,
+        similarityThreshold: options.feedbackThreshold || DEFAULT_SIMILARITY_THRESHOLD,
         verbose: options.verbose,
       });
     }
@@ -764,7 +741,6 @@ function prepareContextForLLM(filePath, content, language, finalCodeExamples, fi
 async function callLLMForAnalysis(context, options = {}) {
   try {
     let prompt;
-    const model = options.model || 'claude-sonnet-4-6';
     const maxTokens = options.maxTokens || 8192; // Default to a safe limit
 
     if (options.isHolisticPRReview) {
@@ -778,7 +754,7 @@ async function callLLMForAnalysis(context, options = {}) {
     const llmResponse = await sendPromptToLLM(prompt, {
       temperature: 0,
       maxTokens: maxTokens,
-      model: model,
+      model: options.model,
       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)
@@ -2492,12 +2468,12 @@ function filterLowSeverityIssues(analysisResults, options = {}) {
  * @param {Object} analysisResults - Raw analysis results from LLM
  * @param {Object} feedbackData - Loaded feedback data
  * @param {Object} options - Filtering options
- * @param {number} [options.similarityThreshold=0.7] - Threshold for considering issues similar to dismissed feedback
+ * @param {number} [options.similarityThreshold=DEFAULT_SIMILARITY_THRESHOLD] - Threshold for considering issues similar to dismissed feedback
  * @param {boolean} [options.verbose=false] - Enable verbose similarity and filtering logs
  * @returns {Promise<Object>} Filtered analysis results
  */
 async function filterAnalysisResults(analysisResults, feedbackData, options = {}) {
-  const { similarityThreshold = 0.7, verbose = false } = options;
+  const { similarityThreshold = DEFAULT_SIMILARITY_THRESHOLD, verbose = false } = options;
 
   if (!analysisResults || !analysisResults.issues || !Array.isArray(analysisResults.issues)) {
     return analysisResults;
@@ -2505,16 +2481,6 @@ async function filterAnalysisResults(analysisResults, feedbackData, options = {}
 
   const originalCount = analysisResults.issues.length;
 
-  // Ensure semantic similarity is initialized for better matching
-  await ensureSemanticSimilarityInitialized();
-
-  // Log whether semantic similarity is available
-  const usingSemanticSimilarity = isSemanticSimilarityAvailable();
-  verboseLog(
-    verbose,
-    chalk.cyan(`🔍 Filtering issues using ${usingSemanticSimilarity ? 'semantic + word-based similarity' : 'word-based similarity only'}`)
-  );
-
   // Filter issues based on feedback (now async due to semantic similarity)
   const filterResults = await Promise.all(
     analysisResults.issues.map(async (issue, index) => {

package/src/rag-analyzer.test.js

@@ -59,6 +59,7 @@ vi.mock('./feedback-loader.js', () => ({
   generateFeedbackContext: vi.fn().mockReturnValue(''),
   initializeSemanticSimilarity: vi.fn().mockResolvedValue(undefined),
   isSemanticSimilarityAvailable: vi.fn().mockReturnValue(false),
+  DEFAULT_SIMILARITY_THRESHOLD: 0.7,
 }));
 
 vi.mock('./llm.js', () => ({
@@ -242,6 +243,12 @@ describe('rag-analyzer', () => {
       expect(result.success).toBe(true);
     });
 
+    it('should forward an explicit model option to the LLM', async () => {
+      await runAnalysis('/test/file.js', { model: 'claude-3-opus' });
+
+      expect(llm.sendPromptToClaude).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ model: 'claude-3-opus' }));
+    });
+
     it('should handle diff-only mode', async () => {
       const result = await runAnalysis('/test/file.js', {
         diffOnly: true,