ghagga 3.2.0 → 3.4.0

package/dist/commands/review.test.js

@@ -6,6 +6,24 @@
  * needing an actual LLM API key.
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+// Mutable control cell for the mocked `FilesystemGraphLoader` — lets
+// individual tests (blast-radius integration coverage, R4-002) drive the
+// graph/metadata `load()` returns without needing a real `.ghagga/graph.json`
+// on disk. Declared with `vi.hoisted` so it's initialized before the
+// `vi.mock('ghagga-core', ...)` factory below runs (which is itself hoisted).
+const graphLoaderControl = vi.hoisted(() => ({
+    // biome-ignore lint/suspicious/noExplicitAny: test control cell, shape mirrors DependencyGraph
+    graph: null,
+    // biome-ignore lint/suspicious/noExplicitAny: test control cell, shape mirrors GraphMetadata
+    metadata: null,
+    // When set, `load()` invokes the constructor's `onOversize`/`onMalformed`
+    // callback (mirroring the REAL FilesystemGraphLoader contract) and
+    // resolves to null — lets tests drive the oversize/malformed degrade path
+    // without a real oversized/corrupt graph.json on disk.
+    oversize: null,
+    malformed: null,
+    loadCallCount: 0,
+}));
 // ─── Mock ghagga-core to prevent actual LLM calls ───────────────
 vi.mock('ghagga-core', () => {
     const mockTools = [
@@ -117,6 +135,62 @@ vi.mock('ghagga-core', () => {
     ];
     return {
         reviewPipeline: vi.fn(),
+        // Blast-radius wire-up (sdd/scip-graph-wireup): a real class so
+        // `new FilesystemGraphLoader(...)` never throws; `load()` defaults to
+        // null (no graph) unless an individual test overrides the instance.
+        FilesystemGraphLoader: class {
+            opts;
+            constructor(_repoRoot, 
+            // biome-ignore lint/suspicious/noExplicitAny: mirrors real FilesystemGraphLoaderOptions
+            opts) {
+                this.opts = opts;
+            }
+            async load() {
+                graphLoaderControl.loadCallCount++;
+                if (graphLoaderControl.oversize) {
+                    this.opts?.onOversize?.(graphLoaderControl.oversize.bytes, graphLoaderControl.oversize.max);
+                    return null;
+                }
+                if (graphLoaderControl.malformed) {
+                    this.opts?.onMalformed?.(graphLoaderControl.malformed);
+                    return null;
+                }
+                return graphLoaderControl.graph;
+            }
+            async loadMetadata() {
+                return graphLoaderControl.metadata;
+            }
+        },
+        // Wired in alongside FilesystemGraphLoader (R4-001 fix): reviewCommand
+        // wraps the already-loaded graph in one of these instead of handing the
+        // pipeline the same FilesystemGraphLoader instance (which would re-read
+        // graph.json a second time).
+        NullGraphLoader: class {
+            async load() {
+                return null;
+            }
+            async loadMetadata() {
+                return null;
+            }
+        },
+        PreloadedGraphLoader: class {
+            graph;
+            metadata;
+            constructor(graph, metadata) {
+                this.graph = graph;
+                this.metadata = metadata;
+            }
+            async load() {
+                return this.graph;
+            }
+            async loadMetadata() {
+                return this.metadata ?? null;
+            }
+        },
+        detectLanguage: vi.fn().mockReturnValue(undefined),
+        GRAPH_VERSION: 1,
+        isGraphStale: vi.fn().mockReturnValue(false),
+        parseDiffFiles: vi.fn().mockReturnValue([]),
         formatReviewComment: vi.fn().mockReturnValue('<!-- ghagga-review -->\nbody'),
         formatBoxSummary: vi.fn().mockReturnValue([]),
         REVIEW_COMMENT_MARKER: '<!-- ghagga-review -->',
@@ -196,19 +270,21 @@ describe('CLI review module', () => {
 });
 describe('CLI output formatting and exit codes', () => {
     // We test the internal formatting/exit code logic by checking types/contracts
-    it('defines valid exit codes: PASSED=0, SKIPPED=0, FAILED=1, NEEDS_HUMAN_REVIEW=1, PARTIAL=1', () => {
+    it('defines valid exit codes: PASSED=0, SKIPPED=0, FAILED=1, NEEDS_HUMAN_REVIEW=1, PARTIAL=1, INCONCLUSIVE=1', () => {
         const exitCodes = {
             PASSED: 0,
             SKIPPED: 0,
             FAILED: 1,
             NEEDS_HUMAN_REVIEW: 1,
             PARTIAL: 1,
+            INCONCLUSIVE: 1,
         };
         expect(exitCodes.PASSED).toBe(0);
         expect(exitCodes.SKIPPED).toBe(0);
         expect(exitCodes.FAILED).toBe(1);
         expect(exitCodes.NEEDS_HUMAN_REVIEW).toBe(1);
         expect(exitCodes.PARTIAL).toBe(1);
+        expect(exitCodes.INCONCLUSIVE).toBe(1);
     });
     it('ReviewResult findings have expected structure', () => {
         const finding = {
@@ -396,6 +472,16 @@ describe('reviewCommand — functional tests', () => {
         }));
         expect(exitSpy).toHaveBeenCalledWith(0);
     });
+    it('should call reviewPipeline with hybrid-4r mode', async () => {
+        const diff = 'diff --git a/file.ts b/file.ts\n+console.log("hello");';
+        mockExecSync.mockReturnValue(diff);
+        mockReviewPipeline.mockResolvedValue(makeReviewResult({ status: 'PASSED' }));
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions({ mode: 'hybrid-4r' }));
+        expect(mockReviewPipeline).toHaveBeenCalledWith(expect.objectContaining({
+            mode: 'hybrid-4r',
+        }));
+    });
     it('should exit 1 when review status is FAILED', async () => {
         mockExecSync.mockReturnValue('diff content');
         mockReviewPipeline.mockResolvedValue(makeReviewResult({ status: 'FAILED' }));
@@ -547,6 +633,205 @@ describe('reviewCommand — functional tests', () => {
         expect(settings.reviewLevel).toBe('strict');
         expect(settings.customRules).toEqual(['/rules/custom.yml']);
     });
+    it('populates ReviewInput.providerChain from .ghagga.json providerChain (cross-engine routing)', async () => {
+        const diff = 'diff --git a/file.ts b/file.ts\n+line';
+        mockExecSync.mockReturnValue(diff);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({
+            providerChain: [
+                {
+                    provider: 'gateway',
+                    model: 'claude-sonnet-4-6',
+                    targetProvider: 'cli-claude',
+                },
+                {
+                    provider: 'gateway',
+                    model: 'claude-opus-4-6',
+                    targetProvider: 'cli-claude',
+                },
+                {
+                    provider: 'gateway',
+                    model: 'gpt-5.5',
+                    targetProvider: 'codex-cli',
+                    gatewayUrl: 'http://localhost:3001',
+                },
+            ],
+        }));
+        mockReviewPipeline.mockResolvedValue(makeReviewResult());
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions({ apiKey: 'gw-token' }));
+        const callArgs = mockReviewPipeline.mock.calls[0]?.[0];
+        const providerChain = callArgs.providerChain;
+        expect(providerChain).toHaveLength(3);
+        expect(providerChain[0]).toMatchObject({
+            provider: 'gateway',
+            model: 'claude-sonnet-4-6',
+            targetProvider: 'cli-claude',
+            apiKey: 'gw-token',
+        });
+        expect(providerChain[1]).toMatchObject({
+            provider: 'gateway',
+            model: 'claude-opus-4-6',
+            targetProvider: 'cli-claude',
+            apiKey: 'gw-token',
+        });
+        expect(providerChain[2]).toMatchObject({
+            provider: 'gateway',
+            model: 'gpt-5.5',
+            targetProvider: 'codex-cli',
+            gatewayUrl: 'http://localhost:3001',
+            apiKey: 'gw-token',
+        });
+    });
+    it('leaves ReviewInput.providerChain undefined when .ghagga.json has no providerChain (regression-safe)', async () => {
+        const diff = 'diff --git a/file.ts b/file.ts\n+line';
+        mockExecSync.mockReturnValue(diff);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({ reviewLevel: 'strict' }));
+        mockReviewPipeline.mockResolvedValue(makeReviewResult());
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        const callArgs = mockReviewPipeline.mock.calls[0]?.[0];
+        expect(callArgs.providerChain).toBeUndefined();
+    });
+    it('rejects a malformed providerChain entry with a clear error and exits 1', async () => {
+        const diff = 'diff --git a/file.ts b/file.ts\n+line';
+        mockExecSync.mockReturnValue(diff);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({
+            providerChain: [{ provider: 'anthropic', model: 'claude-sonnet-4-6' }],
+        }));
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('providerChain'));
+    });
+    it('rejects a providerChain entry missing model with a clear error and exits 1', async () => {
+        const diff = 'diff --git a/file.ts b/file.ts\n+line';
+        mockExecSync.mockReturnValue(diff);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({
+            providerChain: [{ provider: 'gateway' }],
+        }));
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('providerChain'));
+    });
+    it('sets settings.pinLensesToFirst when .ghagga.json pinLensesToFirst is true', async () => {
+        const diff = 'diff --git a/file.ts b/file.ts\n+line';
+        mockExecSync.mockReturnValue(diff);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({ pinLensesToFirst: true }));
+        mockReviewPipeline.mockResolvedValue(makeReviewResult());
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        const callArgs = mockReviewPipeline.mock.calls[0]?.[0];
+        const settings = callArgs.settings;
+        expect(settings.pinLensesToFirst).toBe(true);
+    });
+    it('leaves settings.pinLensesToFirst undefined when .ghagga.json omits pinLensesToFirst', async () => {
+        const diff = 'diff --git a/file.ts b/file.ts\n+line';
+        mockExecSync.mockReturnValue(diff);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({ reviewLevel: 'strict' }));
+        mockReviewPipeline.mockResolvedValue(makeReviewResult());
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        const callArgs = mockReviewPipeline.mock.calls[0]?.[0];
+        const settings = callArgs.settings;
+        expect(settings.pinLensesToFirst).toBeUndefined();
+    });
+    it('rejects a non-boolean pinLensesToFirst with a clear error and exits 1', async () => {
+        const diff = 'diff --git a/file.ts b/file.ts\n+line';
+        mockExecSync.mockReturnValue(diff);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({ pinLensesToFirst: 'yes' }));
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('pinLensesToFirst'));
+    });
+    it('sets settings.contrarianCount when .ghagga.json contrarianCount is 1', async () => {
+        const diff = 'diff --git a/file.ts b/file.ts\n+line';
+        mockExecSync.mockReturnValue(diff);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({ contrarianCount: 1 }));
+        mockReviewPipeline.mockResolvedValue(makeReviewResult());
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        const callArgs = mockReviewPipeline.mock.calls[0]?.[0];
+        const settings = callArgs.settings;
+        expect(settings.contrarianCount).toBe(1);
+    });
+    it('leaves settings.contrarianCount undefined when .ghagga.json omits contrarianCount', async () => {
+        const diff = 'diff --git a/file.ts b/file.ts\n+line';
+        mockExecSync.mockReturnValue(diff);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({ reviewLevel: 'strict' }));
+        mockReviewPipeline.mockResolvedValue(makeReviewResult());
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        const callArgs = mockReviewPipeline.mock.calls[0]?.[0];
+        const settings = callArgs.settings;
+        expect(settings.contrarianCount).toBeUndefined();
+    });
+    it('rejects a non-integer or zero contrarianCount with a clear error and exits 1', async () => {
+        const diff = 'diff --git a/file.ts b/file.ts\n+line';
+        mockExecSync.mockReturnValue(diff);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({ contrarianCount: 'yes' }));
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('contrarianCount'));
+        exitSpy.mockClear();
+        errorSpy.mockClear();
+        mockReadFileSync.mockReturnValue(JSON.stringify({ contrarianCount: 0 }));
+        await reviewCommand('.', defaultOptions());
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('contrarianCount'));
+    });
+    it('sets settings.refuterCount when .ghagga.json refuterCount is 2', async () => {
+        const diff = 'diff --git a/file.ts b/file.ts\n+line';
+        mockExecSync.mockReturnValue(diff);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({ refuterCount: 2 }));
+        mockReviewPipeline.mockResolvedValue(makeReviewResult());
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        const callArgs = mockReviewPipeline.mock.calls[0]?.[0];
+        const settings = callArgs.settings;
+        expect(settings.refuterCount).toBe(2);
+    });
+    it('leaves settings.refuterCount undefined when .ghagga.json omits refuterCount', async () => {
+        const diff = 'diff --git a/file.ts b/file.ts\n+line';
+        mockExecSync.mockReturnValue(diff);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({ reviewLevel: 'strict' }));
+        mockReviewPipeline.mockResolvedValue(makeReviewResult());
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        const callArgs = mockReviewPipeline.mock.calls[0]?.[0];
+        const settings = callArgs.settings;
+        expect(settings.refuterCount).toBeUndefined();
+    });
+    it('rejects a non-integer or below-2 refuterCount with a clear error and exits 1', async () => {
+        const diff = 'diff --git a/file.ts b/file.ts\n+line';
+        mockExecSync.mockReturnValue(diff);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({ refuterCount: 'yes' }));
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('refuterCount'));
+        exitSpy.mockClear();
+        errorSpy.mockClear();
+        mockReadFileSync.mockReturnValue(JSON.stringify({ refuterCount: 1 }));
+        await reviewCommand('.', defaultOptions());
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('refuterCount'));
+    });
     it('should handle non-Error thrown objects in catch block', async () => {
         mockExecSync.mockReturnValue('diff');
         mockReviewPipeline.mockRejectedValue('string error');
@@ -896,4 +1181,245 @@ describe('Phase 7: config file with new tool fields', () => {
         expect(settings.disabledTools).toContain('cpd');
     });
 });
+// ═══════════════════════════════════════════════════════════════
+// Blast-radius glue integration coverage (R4-002)
+//
+// The pure seams (`resolveBlastRadiusEnabled`, `checkGraphStaleness`,
+// `computeUncoveredLanguages`) are unit-tested in
+// `review-blast-radius.test.ts`. This block exercises the side-effecting
+// GLUE in `reviewCommand` itself — the `execSync('git rev-parse HEAD')`
+// try/catch, the outer try/catch around the staleness/coverage block, and
+// the warn ordering — with a present graph, an oversize/malformed graph,
+// and a failing `git rev-parse HEAD`. It also locks in the R4-001 fix: the
+// graph is loaded exactly once and the oversize/malformed warning fires
+// exactly once.
+// ═══════════════════════════════════════════════════════════════
+describe('reviewCommand — blast-radius glue integration (R4-002)', () => {
+    // biome-ignore lint/suspicious/noExplicitAny: mock spy type
+    let logSpy;
+    // biome-ignore lint/suspicious/noExplicitAny: mock spy type
+    let errorSpy;
+    // biome-ignore lint/suspicious/noExplicitAny: mock spy type
+    let exitSpy;
+    const diff = 'diff --git a/file.ts b/file.ts\n+line';
+    function makeGraph() {
+        return {
+            version: 1,
+            rootDir: '.',
+            nodes: {
+                'src/main.go': {
+                    hash: 'h',
+                    language: 'go',
+                    imports: [],
+                    exports: [],
+                    calls: [],
+                    isTest: false,
+                },
+            },
+        };
+    }
+    function makeMetadata() {
+        return {
+            lastIndexedCommit: 'abc123',
+            lastIndexedAt: new Date().toISOString(),
+            schemaVersion: 1,
+            fileCount: 1,
+            languages: ['go'],
+            indexDurationMs: 10,
+        };
+    }
+    beforeEach(() => {
+        vi.clearAllMocks();
+        logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        // biome-ignore lint/suspicious/noExplicitAny: mock cast
+        exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => { }));
+        // Auto-enable blast-radius: existsSync(<repo>/.ghagga/graph.json) → true,
+        // existsSync(<repo>/.ghagga.json) → false (no config file to load).
+        mockExistsSync.mockImplementation((p) => String(p).includes('graph.json'));
+        graphLoaderControl.graph = null;
+        graphLoaderControl.metadata = null;
+        graphLoaderControl.oversize = null;
+        graphLoaderControl.malformed = null;
+        graphLoaderControl.loadCallCount = 0;
+        mockReviewPipeline.mockResolvedValue(makeReviewResult());
+    });
+    afterEach(() => {
+        logSpy.mockRestore();
+        errorSpy.mockRestore();
+        exitSpy.mockRestore();
+        graphLoaderControl.graph = null;
+        graphLoaderControl.metadata = null;
+        graphLoaderControl.oversize = null;
+        graphLoaderControl.malformed = null;
+        graphLoaderControl.loadCallCount = 0;
+    });
+    it('present valid graph: blast-radius enables, no crash, review continues (PASSED)', async () => {
+        graphLoaderControl.graph = makeGraph();
+        graphLoaderControl.metadata = makeMetadata();
+        mockExecSync.mockReturnValue(diff);
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        expect(graphLoaderControl.loadCallCount).toBe(1);
+        expect(mockReviewPipeline).toHaveBeenCalledTimes(1);
+        const callArgs = mockReviewPipeline.mock.calls[0]?.[0];
+        // The pipeline must receive a loader wrapping the already-loaded graph
+        // (Preloaded/Null), NEVER the same FilesystemGraphLoader instance that
+        // review.ts already called `.load()` on — that identity is what would
+        // cause a second filesystem read (R4-001).
+        expect(callArgs.graphLoader.constructor.name).not.toBe('FilesystemGraphLoader');
+        expect(exitSpy).toHaveBeenCalledWith(0);
+    });
+    it('oversize graph: degrades gracefully, review continues, warning fires exactly once (R4-001)', async () => {
+        graphLoaderControl.oversize = { bytes: 25_000_000, max: 20_000_000 };
+        mockExecSync.mockReturnValue(diff);
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        expect(graphLoaderControl.loadCallCount).toBe(1);
+        const oversizeWarnings = logSpy.mock.calls.filter((call) => String(call[0]).includes('Dependency graph exceeds'));
+        expect(oversizeWarnings).toHaveLength(1);
+        // Review continues (degrades) rather than crashing or aborting.
+        expect(mockReviewPipeline).toHaveBeenCalledTimes(1);
+        expect(exitSpy).toHaveBeenCalledWith(0);
+    });
+    it('malformed graph: degrades gracefully, review continues, warning fires exactly once (R4-001)', async () => {
+        graphLoaderControl.malformed = 'invalid JSON';
+        mockExecSync.mockReturnValue(diff);
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        expect(graphLoaderControl.loadCallCount).toBe(1);
+        const malformedWarnings = logSpy.mock.calls.filter((call) => String(call[0]).includes('stale/corrupt'));
+        expect(malformedWarnings).toHaveLength(1);
+        expect(mockReviewPipeline).toHaveBeenCalledTimes(1);
+        expect(exitSpy).toHaveBeenCalledWith(0);
+    });
+    it('git rev-parse HEAD throws: staleness check skipped, review continues, no crash', async () => {
+        graphLoaderControl.graph = makeGraph();
+        graphLoaderControl.metadata = makeMetadata();
+        mockExecSync.mockImplementation((cmd) => {
+            if (String(cmd).includes('rev-parse HEAD')) {
+                throw new Error('fatal: not a git repository');
+            }
+            return diff;
+        });
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        // The staleness check is skipped (currentHead falls back to '') but the
+        // review is NOT aborted by the failing git call — it must degrade, not
+        // propagate the throw.
+        expect(mockReviewPipeline).toHaveBeenCalledTimes(1);
+        expect(exitSpy).toHaveBeenCalledWith(0);
+        expect(errorSpy).not.toHaveBeenCalled();
+    });
+});
+// ═══════════════════════════════════════════════════════════════
+// Fail-closed --anchor (hybrid-4r-anchor)
+// process.exit is mocked as a no-op — every fail-closed path MUST
+// return after exit(1) so reviewPipeline is never reached.
+// ═══════════════════════════════════════════════════════════════
+describe('reviewCommand — fail-closed --anchor', () => {
+    // biome-ignore lint/suspicious/noExplicitAny: mock spy type
+    let logSpy;
+    // biome-ignore lint/suspicious/noExplicitAny: mock spy type
+    let errorSpy;
+    // biome-ignore lint/suspicious/noExplicitAny: mock spy type
+    let exitSpy;
+    const DIFF = 'diff --git a/file.ts b/file.ts\n+line';
+    const MATCHING_SHA = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+    const OTHER_SHA = 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        // biome-ignore lint/suspicious/noExplicitAny: mock cast
+        exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => { }));
+        mockExistsSync.mockReturnValue(false);
+        mockReviewPipeline.mockResolvedValue(makeReviewResult());
+    });
+    afterEach(() => {
+        logSpy.mockRestore();
+        errorSpy.mockRestore();
+        exitSpy.mockRestore();
+    });
+    function mockGitDiffAndRevs(headSha, verifySha) {
+        mockExecSync.mockImplementation((cmd) => {
+            const c = String(cmd);
+            if (c.includes('--verify')) {
+                return `${verifySha}\n`;
+            }
+            if (c.includes('rev-parse HEAD')) {
+                return `${headSha}\n`;
+            }
+            return DIFF;
+        });
+    }
+    it('calls reviewPipeline when options.anchor matches HEAD', async () => {
+        mockGitDiffAndRevs(MATCHING_SHA, MATCHING_SHA);
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions({ anchor: 'aaaaaaaa' }));
+        expect(mockReviewPipeline).toHaveBeenCalledTimes(1);
+    });
+    it('exits 1 on HEAD/anchor mismatch and does not run the pipeline', async () => {
+        mockGitDiffAndRevs(MATCHING_SHA, OTHER_SHA);
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions({ anchor: 'aaaaaaaa' }));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('anchor'));
+        expect(mockReviewPipeline).not.toHaveBeenCalled();
+    });
+    it('skips the mismatch check when fileConfig.anchor is "auto"', async () => {
+        mockExecSync.mockReturnValue(DIFF);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({ anchor: 'auto' }));
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions());
+        expect(mockReviewPipeline).toHaveBeenCalledTimes(1);
+    });
+    it('exits 1 on invalid anchor values and does not run the pipeline', async () => {
+        mockExecSync.mockReturnValue(DIFF);
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions({ anchor: '../x' }));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('anchor'));
+        expect(mockReviewPipeline).not.toHaveBeenCalled();
+        exitSpy.mockClear();
+        errorSpy.mockClear();
+        mockReviewPipeline.mockClear();
+        await reviewCommand('.', defaultOptions({ anchor: 'main' }));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(mockReviewPipeline).not.toHaveBeenCalled();
+    });
+    it('lets options.anchor override config auto and still mismatch-fails', async () => {
+        mockGitDiffAndRevs(MATCHING_SHA, OTHER_SHA);
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(JSON.stringify({ anchor: 'auto' }));
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions({ anchor: 'aaaaaaaa' }));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('anchor'));
+        expect(mockReviewPipeline).not.toHaveBeenCalled();
+    });
+    it('exits 1 when git rev-parse throws and does not run the pipeline', async () => {
+        mockExecSync.mockImplementation((cmd) => {
+            const c = String(cmd);
+            if (c.includes('rev-parse')) {
+                throw new Error('fatal: not a git repository');
+            }
+            return DIFF;
+        });
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions({ anchor: 'aaaaaaaa' }));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('anchor'));
+        expect(mockReviewPipeline).not.toHaveBeenCalled();
+    });
+    it('exits 1 when resolved HEAD or verify SHA is empty and does not run the pipeline', async () => {
+        mockGitDiffAndRevs('', MATCHING_SHA);
+        const { reviewCommand } = await import('./review.js');
+        await reviewCommand('.', defaultOptions({ anchor: 'aaaaaaaa' }));
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('anchor'));
+        expect(mockReviewPipeline).not.toHaveBeenCalled();
+    });
+});
 //# sourceMappingURL=review.test.js.map