bssm-oss · justn-hyeok · Apr 1, 2026 · Apr 1, 2026 · Apr 1, 2026 · Apr 1, 2026
diff --git a/packages/core/src/l1/reviewer.ts b/packages/core/src/l1/reviewer.ts
@@ -462,6 +462,9 @@ Format: \`CRITICAL (85%)\` or \`WARNING (60%)\`
 - **"What if" speculation** — cite concrete code, not hypotheticals
 - **Config values** — JSON/YAML values are intentional choices
 - **Test patterns** — mocks, stubs, simplified logic are intentional in tests
- **Test patterns** — mocks, stubs, simplified logic are intentional in tests
+const value = /* some expression */;
+if (!value) return; // early return
+const result = value?.someMethod(); // ?? fallback
- **Test patterns** — mocks, stubs, simplified logic are intentional in tests
+const value = /* some expression */;
+if (!value) return; // early return
+const result = value?.someMethod(); // ?? fallback
+- **Guarded values** — if there is an early return, null check, or ?? fallback that handles the value BEFORE the line you're looking at, it is NOT a bug
+- **Division by zero with prior guard** — if the divisor is checked (<=0, ===0, etc.) with an early return above, do NOT flag division by zero
- **Division by zero with prior guard** — if the divisor is checked (<=0, ===0, etc.) with an early return above, do NOT flag division by zero
+const value = /* some expression */;
+if (value <= 0) return; // early return
+const result = value / /* some divisor */;
- **Division by zero with prior guard** — if the divisor is checked (<=0, ===0, etc.) with an early return above, do NOT flag division by zero
+const value = /* some expression */;
+if (value <= 0) return; // early return
+const result = value / /* some divisor */;
+- **Null/undefined with ?? or ?.** — if the value uses ?? (nullish coalescing) or ?. (optional chaining) on the SAME expression, the null case is handled
 
-
+const value = /* some expression */;
+const result = value?.someMethod(); // ?? (nullish coalescing) or ?. (optional chaining)
-
+const value = /* some expression */;
+const result = value?.someMethod(); // ?? (nullish coalescing) or ?. (optional chaining)
 **Example Evidence Document:**
 

diff --git a/packages/core/src/pipeline/hallucination-filter.ts b/packages/core/src/pipeline/hallucination-filter.ts
@@ -83,8 +83,138 @@ export function filterHallucinations(
       }
     }
-    }
+
+### Potential for incomplete evidence merging in deduplication
+
-    }
+if (a.divisor === 0) {
+    doc.confidence = 0;
+    return;
+}
-    }
+if (a.value === 0 || a.value === null) {
+    doc.confidence = 0;
+    return;
+}
-    }
+if (a.value === null || a.value === undefined) {
+    doc.confidence = 0;
+    return;
+}
-    }
+if (a.speculation === "what if") {
+    doc.confidence = 0;
+    return;
+}
-    }
+// Example improvement: Add context-aware logic to detect self-contradiction
+export function detectSelfContradiction(doc: EvidenceDocument, context: string): boolean {
+  // Implement more sophisticated logic here
+  // ...
+}
-    }
+
+### Potential for incomplete evidence merging in deduplication
+
-    }
+if (a.divisor === 0) {
+    doc.confidence = 0;
+    return;
+}
-    }
+if (a.value === 0 || a.value === null) {
+    doc.confidence = 0;
+    return;
+}
-    }
+if (a.value === null || a.value === undefined) {
+    doc.confidence = 0;
+    return;
+}
-    }
+if (a.speculation === "what if") {
+    doc.confidence = 0;
+    return;
+}
-    }
+// Example improvement: Add context-aware logic to detect self-contradiction
+export function detectSelfContradiction(doc: EvidenceDocument, context: string): boolean {
+  // Implement more sophisticated logic here
+  // ...
+}
 
+    // Check 4: Self-contradiction — finding admits the issue is already handled
+    if (detectSelfContradiction(doc)) {
+      doc.confidence = Math.round((doc.confidence ?? 50) * 0.3);
-      doc.confidence = Math.round((doc.confidence ?? 50) * 0.3);
+// Add a check for empty evidence list
+export function detectSelfContradiction(doc: EvidenceDocument): boolean {
+  if (!doc) return false;
+  const text = [
+    doc.problem || '',
+    ...(doc.evidence || []), // Check if evidence list is empty
+    doc.suggestion || ''
+  ].join(' ').trim();
+
+  if (!text) return false;
+  return SELF_CONTRADICTION_PATTERNS.some(p => p.test(text));
+}
-      doc.confidence = Math.round((doc.confidence ?? 50) * 0.3);
+// Add a check for empty evidence list
+export function detectSelfContradiction(doc: EvidenceDocument): boolean {
+  if (!doc) return false;
+  const text = [
+    doc.problem || '',
+    ...(doc.evidence || []), // Check if evidence list is empty
+    doc.suggestion || ''
+  ].join(' ').trim();
+
+  if (!text) return false;
+  return SELF_CONTRADICTION_PATTERNS.some(p => p.test(text));
+}
+    }
+
     filtered.push(doc);
   }
 
   return { filtered, removed };
 }
+
+const SELF_CONTRADICTION_PATTERNS = [
+  /already\s+(?:handled|checked|validated|prevented|avoided|guarded|addressed)/i,
+  /prior\s+check/i,
+  /(?:is|are)\s+avoided\s+due\s+to/i,
+  /not\s+a\s+concern/i,
+  /already\s+returns?\s+(?:early|before|50|default)/i,
+  /(?:guard|check)\s+(?:above|before|prevents?|ensures?)/i,
+  /however.*(?:is|are)\s+(?:already|properly)\s+(?:handled|checked)/i,
+];
+
+/**
+ * Detect findings that contradict themselves by admitting the issue is handled.
+ * Example: "Division by zero possible" + evidence "avoided due to prior check"
+ */
+export function detectSelfContradiction(doc: EvidenceDocument): boolean {
+  if (!doc) return false;
+  const text = [
+    doc.problem || '',
+    ...(doc.evidence || []),
+    doc.suggestion || ''
+  ].join(' ').trim();
+
+  if (!text) return false;
+  return SELF_CONTRADICTION_PATTERNS.some(p => p.test(text));
-  return SELF_CONTRADICTION_PATTERNS.some(p => p.test(text));
+
+I've also noticed some test coverage issues that might be worth mentioning.
+
+## Issues in Test Coverage
+
+### Incomplete test coverage for edge cases in deduplication
+
-  return SELF_CONTRADICTION_PATTERNS.some(p => p.test(text));
+
+I've also noticed some test coverage issues that might be worth mentioning.
+
+## Issues in Test Coverage
+
+### Incomplete test coverage for edge cases in deduplication
+
+}
-}
+export function detectSelfContradiction(doc: EvidenceDocument | null): boolean {
+  if (!doc) return false;
+  // ...
+}
-}
+export function detectSelfContradiction(doc: EvidenceDocument | null): boolean {
+  if (!doc) return false;
+  // ...
+}
+
+/**
+ * Deduplicate evidence documents at the individual finding level.
+ * Merges findings on the same file + overlapping line range + similar title.
+ * Keeps highest confidence, combines evidence lists.
+ *
+ * Optimized: Groups by filePath first to avoid O(N^2) comparison across different files.
+ */
+export function deduplicateEvidence(docs: EvidenceDocument[]): EvidenceDocument[] {
+  if (!docs || docs.length <= 1) return docs || [];
-  if (!docs || docs.length <= 1) return docs || [];
+export function deduplicateEvidence(docs: EvidenceDocument[]): EvidenceDocument[] {
+  if (!docs || docs.length === 0) {
+    throw new Error('Invalid input: empty array');
+  }
+  // ...
+}
-  if (!docs || docs.length <= 1) return docs || [];
+export function deduplicateEvidence(docs: EvidenceDocument[]): EvidenceDocument[] {
+  if (!docs || docs.length === 0) {
+    throw new Error('Invalid input: empty array');
+  }
+  // ...
+}
+
+  // Group by filePath to reduce comparison space
+  const fileGroups = new Map<string, EvidenceDocument[]>();
+  for (const doc of docs) {
+    const list = fileGroups.get(doc.filePath || 'unknown') || [];
+    list.push(doc);
+    fileGroups.set(doc.filePath || 'unknown', list);
+  }
+
+  const result: EvidenceDocument[] = [];
+
+  for (const group of fileGroups.values()) {
+    if (group.length === 1) {
-    if (group.length === 1) {
+// Example improvement: Use a hash table to group findings
+export function deduplicateEvidence(docs: EvidenceDocument[]): EvidenceDocument[] {
+  const findingGroups = new Map<string, EvidenceDocument[]>();
+  // ...
+}
-    if (group.length === 1) {
+// Example improvement: Use a hash table to group findings
+export function deduplicateEvidence(docs: EvidenceDocument[]): EvidenceDocument[] {
+  const findingGroups = new Map<string, EvidenceDocument[]>();
+  // ...
+}
+      result.push(group[0]);
+      continue;
+    }
+
+    const mergedIndices = new Set<number>();
+    for (let i = 0; i < group.length; i++) {
+      if (mergedIndices.has(i)) continue;
+
+      let primary = { ...group[i], evidence: [...(group[i].evidence || [])] };
+      let hasSelfContradiction = detectSelfContradiction(primary);
+
+      for (let j = i + 1; j < group.length; j++) {
+        if (mergedIndices.has(j)) continue;
+
+        if (shouldMergeEvidence(primary, group[j])) {
+          // Merge: keep higher confidence, combine evidence
+          const primaryConf = primary.confidence ?? 0;
+          const otherConf = group[j].confidence ?? 0;
-          const otherConf = group[j].confidence ?? 0;
+if (primary.confidence < 0 || primary.confidence > 100) {
+  throw new Error('Invalid confidence level');
+}
-          const otherConf = group[j].confidence ?? 0;
+if (primary.confidence < 0 || primary.confidence > 100) {
+  throw new Error('Invalid confidence level');
+}
+          if (otherConf > primaryConf) {
+            primary.confidence = otherConf;
+          }
-          }
+
+### Incomplete handling of optional evidence fields
+
-          }
+
+### Incomplete handling of optional evidence fields
+
+
+          // Add unique evidence items
+          const otherEvidence = group[j].evidence || [];
+          for (const e of otherEvidence) {
+            if (!primary.evidence.includes(e)) {
+              primary.evidence.push(e);
+            }
+          }
+          hasSelfContradiction = hasSelfContradiction || detectSelfContradiction(group[j]);
+          mergedIndices.add(j);
+        }
+      }
+      if (hasSelfContradiction) {
+        primary.confidence = Math.round((primary.confidence ?? 50) * 0.3);
+      }
+      result.push(primary);
+    }
+  }
+
+  return result;
+}
+
+function shouldMergeEvidence(a: EvidenceDocument, b: EvidenceDocument): boolean {
+  // Same file is guaranteed by caller (deduplicateEvidence groups by filePath)
+
+  // Overlapping line ranges (within 15 lines)
+  const LINE_TOLERANCE = 15;
+  const overlap =
+    a.lineRange[0] <= b.lineRange[1] + LINE_TOLERANCE &&
+    b.lineRange[0] <= a.lineRange[1] + LINE_TOLERANCE;
+
+  if (!overlap) return false;
+
+  // Similar titles (Jaccard > 0.5)
+  const titleSim = jaccardSimilarity(a.issueTitle || '', b.issueTitle || '');
+  return titleSim > 0.5;
-  return titleSim > 0.5;
+if (typeof text !== 'string') {
+  return 0;
+}
-  return titleSim > 0.5;
+if (typeof text !== 'string') {
+  return 0;
+}
+}
+
+function jaccardSimilarity(a: string, b: string): number {
+  if (!a && !b) return 1;
+  if (!a || !b) return 0;
+
+  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
-  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+function jaccardSimilarity(a: string, b: string): number {
+  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/).filter(Boolean));
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) intersection++;
+  }
+  const union = wordsA.size + wordsB.size - intersection;
+  if (union === 0) return 0; // add check for zero union
+  return intersection / union;
+}
-  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+function jaccardSimilarity(a: string, b: string): number {
+  if (typeof a !== 'string' || typeof b !== 'string') {
+    throw new Error('Both inputs must be strings');
+  }
+  if (a.trim() === '' || b.trim() === '') {
+    return 0; // or throw an error, depending on the desired behavior
+  }
+  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/).filter(Boolean));
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) intersection++;
+  }
+  const union = wordsA.size + wordsB.size - intersection;
+  return union === 0 ? 1 : intersection / union;
+}
-  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+function jaccardSimilarity(a: string, b: string): number {
+  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/).filter(Boolean));
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) intersection++;
+  }
+  const union = wordsA.size + wordsB.size - intersection;
+  if (union === 0) return 0; // add check for zero union
+  return intersection / union;
+}
-  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+function jaccardSimilarity(a: string, b: string): number {
+  if (typeof a !== 'string' || typeof b !== 'string') {
+    throw new Error('Both inputs must be strings');
+  }
+  if (a.trim() === '' || b.trim() === '') {
+    return 0; // or throw an error, depending on the desired behavior
+  }
+  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/).filter(Boolean));
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) intersection++;
+  }
+  const union = wordsA.size + wordsB.size - intersection;
+  return union === 0 ? 1 : intersection / union;
+}
+  const wordsB = new Set(b.toLowerCase().split(/\s+/).filter(Boolean));
+
+  if (wordsA.size === 0 && wordsB.size === 0) return 1;
+
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) intersection++;
+  }
+
+  const union = wordsA.size + wordsB.size - intersection;
+  return union <= 0 ? 0 : intersection / union;
+}
diff --git a/packages/core/src/pipeline/orchestrator.ts b/packages/core/src/pipeline/orchestrator.ts
@@ -750,6 +750,10 @@ export async function runPipeline(input: PipelineInput, progress?: ProgressEmitt
     }
     allEvidenceDocs = hallucinationResult.filtered;
 
+    // === EVIDENCE DEDUP: Merge duplicate findings (#439) ===
+    const { deduplicateEvidence } = await import('./hallucination-filter.js');
+    allEvidenceDocs = deduplicateEvidence(allEvidenceDocs);
-    allEvidenceDocs = deduplicateEvidence(allEvidenceDocs);
+// Change dynamic import to static import
+import { deduplicateEvidence } from './hallucination-filter.js';
+
+// ...
+
+const { filtered } = hallucinationResult;
+allEvidenceDocs = deduplicateEvidence(allEvidenceDocs);
-    allEvidenceDocs = deduplicateEvidence(allEvidenceDocs);
+// Change dynamic import to static import
+import { deduplicateEvidence } from './hallucination-filter.js';
+
+// ...
+
+const { filtered } = hallucinationResult;
+allEvidenceDocs = deduplicateEvidence(allEvidenceDocs);
+
     // === CONFIDENCE: Compute L1 confidence for non-rule docs ===
     const totalReviewers = allReviewerInputs.length;
     const totalDiffLines = filteredDiffContent.split('\n').length;

diff --git a/packages/core/src/tests/hallucination-filter.test.ts b/packages/core/src/tests/hallucination-filter.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { filterHallucinations } from '../pipeline/hallucination-filter.js';
-import { filterHallucinations } from '../pipeline/hallucination-filter.js';
+// Add test cases for edge scenarios
+it('should handle empty evidence list', () => {
+  const docs = [makeDoc({
+    issueTitle: 'Null pointer dereference',
+    filePath: 'src/utils.ts',
+    lineRange: [10, 12],
+    evidence: [], // Empty evidence list
+  })];
+  const result = deduplicateEvidence(docs);
+
+  expect(result).toHaveLength(1);
+});
-import { filterHallucinations } from '../pipeline/hallucination-filter.js';
+// Add test cases for edge scenarios
+it('should handle empty evidence list', () => {
+  const docs = [makeDoc({
+    issueTitle: 'Null pointer dereference',
+    filePath: 'src/utils.ts',
+    lineRange: [10, 12],
+    evidence: [], // Empty evidence list
+  })];
+  const result = deduplicateEvidence(docs);
+
+  expect(result).toHaveLength(1);
+});
+import { filterHallucinations, detectSelfContradiction, deduplicateEvidence } from '../pipeline/hallucination-filter.js';
 import type { EvidenceDocument } from '../types/core.js';
 
 // Minimal diff for testing
@@ -115,6 +115,30 @@ describe('filterHallucinations', () => {
     expect(result.removed).toHaveLength(0);
   });
 
+  it('should penalize confidence for self-contradicting findings', () => {
+    const docs = [makeDoc({
+      evidence: ['Division by zero is avoided due to prior check on line 5'],
+      confidence: 80,
+    })];
+    const result = filterHallucinations(docs, SAMPLE_DIFF);
+
+    expect(result.filtered).toHaveLength(1);
+    expect(result.filtered[0].confidence).toBe(24); // 80 * 0.3
+  });
+
+  it('should not penalize confidence for findings without self-contradiction', () => {
+    const docs = [makeDoc({
+      problem: 'Division by zero on line 12',
+      evidence: ['computeValue() may return 0'],
+      suggestion: 'Validate the divisor is non-zero',
+      confidence: 80,
+    })];
+    const result = filterHallucinations(docs, SAMPLE_DIFF);
+
+    expect(result.filtered).toHaveLength(1);
+    expect(result.filtered[0].confidence).toBe(80);
+  });
+
   it('should correctly split mixed valid/invalid docs', () => {
     const docs = [
       makeDoc({ filePath: 'src/utils.ts', lineRange: [11, 12] }), // valid
@@ -133,3 +157,89 @@ describe('filterHallucinations', () => {
     ]);
   });
 });
+
+describe('deduplicateEvidence', () => {
+  it('should merge findings on same file, same line, similar title', () => {
+    const docs = [
+      makeDoc({
+        issueTitle: 'Null pointer dereference risk',
+        filePath: 'src/utils.ts',
+        lineRange: [10, 12],
+        confidence: 70,
+        evidence: ['evidence A'],
+      }),
+      makeDoc({
+        issueTitle: 'Null pointer dereference possible',
+        filePath: 'src/utils.ts',
+        lineRange: [11, 13],
+        confidence: 85,
+        evidence: ['evidence B'],
+      }),
+    ];
+    const result = deduplicateEvidence(docs);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].confidence).toBe(85); // higher confidence kept
+    expect(result[0].evidence).toContain('evidence A');
+    expect(result[0].evidence).toContain('evidence B');
+  });
+
+  it('should not merge findings on different files', () => {
+    const docs = [
+      makeDoc({
+        issueTitle: 'Null pointer dereference',
+        filePath: 'src/utils.ts',
+        lineRange: [10, 12],
+      }),
+      makeDoc({
+        issueTitle: 'Null pointer dereference',
+        filePath: 'src/index.ts',
+        lineRange: [10, 12],
+      }),
+    ];
+    const result = deduplicateEvidence(docs);
+
+    expect(result).toHaveLength(2);
+  });
+
+  it('should not merge findings with very different titles', () => {
+    const docs = [
+      makeDoc({
+        issueTitle: 'SQL injection vulnerability',
+        filePath: 'src/utils.ts',
+        lineRange: [10, 12],
+      }),
+      makeDoc({
+        issueTitle: 'Memory leak in event handler',
+        filePath: 'src/utils.ts',
+        lineRange: [10, 12],
+      }),
+    ];
+    const result = deduplicateEvidence(docs);
+
+    expect(result).toHaveLength(2);
+  });
+
+  it('should preserve self-contradiction penalty after merge', () => {
+    const docs = [
+      makeDoc({
+        issueTitle: 'Division by zero risk in helper',
+        filePath: 'src/utils.ts',
+        lineRange: [10, 12],
+        confidence: 24,
+        evidence: ['Division by zero is avoided due to prior check on line 5'],
+      }),
+      makeDoc({
+        issueTitle: 'Division by zero possible in helper',
+        filePath: 'src/utils.ts',
+        lineRange: [11, 13],
+        confidence: 80,
+        evidence: ['Potential divide by zero in compute path'],
+      }),
+    ];
+    const result = deduplicateEvidence(docs);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].confidence).toBe(24); // max(24,80)=80 then contradiction penalty => 24
+  });
+});
diff --git a/src/tests/critical-core-errors-orchestrator.test.ts b/src/tests/critical-core-errors-orchestrator.test.ts
@@ -84,6 +84,7 @@ vi.mock('../../packages/core/src/l0/quality-tracker.js', () => ({
 
 vi.mock('../../packages/shared/src/utils/diff.js', () => ({
   extractMultipleSnippets: vi.fn(),
-  extractMultipleSnippets: vi.fn(),
+afterEach(() => {
+  vi.restoreAllMocks();
+});
-  extractMultipleSnippets: vi.fn(),
+vi.mock('../../packages/shared/src/utils/diff.js', () => ({
+  extractFileListFromDiff: vi.fn().mockImplementation((diffString) => {
+    if (typeof diffString !== 'string') {
+      throw new Error('Invalid diff string');
+    }
+    return [];
+  }),
+}));
-  extractMultipleSnippets: vi.fn(),
+vi.mock('../../packages/shared/src/utils/diff.js', () => ({
+  extractMultipleSnippets: vi.fn(),
+  extractFileListFromDiff: vi.fn().mockReturnValue([]), // Always return empty array for testing purposes
+  parseDiffFileRanges: vi.fn().mockReturnValue([]),
+  readSurroundingContext: vi.fn().mockResolvedValue(null),
+}));
-  extractMultipleSnippets: vi.fn(),
+afterEach(() => {
+  vi.restoreAllMocks();
+});
-  extractMultipleSnippets: vi.fn(),
+vi.mock('../../packages/shared/src/utils/diff.js', () => ({
+  extractFileListFromDiff: vi.fn().mockImplementation((diffString) => {
+    if (typeof diffString !== 'string') {
+      throw new Error('Invalid diff string');
+    }
+    return [];
+  }),
+}));
-  extractMultipleSnippets: vi.fn(),
+vi.mock('../../packages/shared/src/utils/diff.js', () => ({
+  extractMultipleSnippets: vi.fn(),
+  extractFileListFromDiff: vi.fn().mockReturnValue([]), // Always return empty array for testing purposes
+  parseDiffFileRanges: vi.fn().mockReturnValue([]),
+  readSurroundingContext: vi.fn().mockResolvedValue(null),
+}));
+  extractFileListFromDiff: vi.fn().mockReturnValue([]),
   parseDiffFileRanges: vi.fn().mockReturnValue([]),
   readSurroundingContext: vi.fn().mockResolvedValue(null),
 }));

diff --git a/src/tests/e2e-mock-scenarios.test.ts b/src/tests/e2e-mock-scenarios.test.ts
@@ -79,12 +79,11 @@ vi.mock('../../packages/core/src/l0/quality-tracker.js', () => ({
     getRecords: vi.fn().mockReturnValue([]),
   })),
 }));
-
 vi.mock('../../packages/shared/src/utils/diff.js', () => ({
   extractMultipleSnippets: vi.fn(),
+  extractFileListFromDiff: vi.fn().mockReturnValue([]),
   parseDiffFileRanges: vi.fn().mockReturnValue([]),
   readSurroundingContext: vi.fn().mockResolvedValue(null),
-  extractFileListFromDiff: vi.fn().mockReturnValue([]),
 }));
 
 vi.mock('../../packages/shared/src/utils/logger.js', () => ({

diff --git a/src/tests/orchestrator-branches.test.ts b/src/tests/orchestrator-branches.test.ts
@@ -79,6 +79,9 @@ vi.mock('../../packages/core/src/l0/quality-tracker.js', () => ({
 
 vi.mock('../../packages/shared/src/utils/diff.js', () => ({
   extractMultipleSnippets: vi.fn(),
-  extractMultipleSnippets: vi.fn(),
+vi.mock('../../packages/shared/src/utils/diff.js', () => ({
+  readSurroundingContext: vi.fn().mockImplementation((context) => {
+    try {
+      // Simulate reading the surrounding context
+      return Promise.resolve(null);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }),
+}));
-  extractMultipleSnippets: vi.fn(),
+vi.mock('../../packages/shared/src/utils/diff.js', () => ({
+  readSurroundingContext: vi.fn().mockImplementation((context) => {
+    try {
+      // Simulate reading the surrounding context
+      return Promise.resolve(null);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }),
+}));
+  extractFileListFromDiff: vi.fn().mockReturnValue([]),
+  parseDiffFileRanges: vi.fn().mockReturnValue([]),
+  readSurroundingContext: vi.fn().mockResolvedValue(null),
 }));
 
 vi.mock('../../packages/shared/src/utils/logger.js', () => ({

diff --git a/src/tests/pipeline-chunk-parallel.test.ts b/src/tests/pipeline-chunk-parallel.test.ts
@@ -79,6 +79,9 @@ vi.mock('../../packages/core/src/l0/quality-tracker.js', () => ({
 
 vi.mock('../../packages/shared/src/utils/diff.js', () => ({
   extractMultipleSnippets: vi.fn(),
+  extractFileListFromDiff: vi.fn().mockReturnValue([]),
+  parseDiffFileRanges: vi.fn().mockReturnValue([]),
+  readSurroundingContext: vi.fn().mockResolvedValue(null),
 }));
 
 vi.mock('../../packages/shared/src/utils/logger.js', () => ({