@weldr/runr 0.3.1 → 0.7.2

package/dist/supervisor/__tests__/evidence-gate.test.js

@@ -1,111 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateNoChangesEvidence, formatEvidenceErrors } from '../evidence-gate.js';
-describe('validateNoChangesEvidence', () => {
-    const allowlist = ['src/game/**', 'src/utils/**'];
-    describe('when no evidence provided', () => {
-        it('should fail with no evidence', () => {
-            const result = validateNoChangesEvidence(undefined, allowlist);
-            expect(result.ok).toBe(false);
-            expect(result.errors).toContain('No evidence provided for no_changes_needed claim');
-        });
-        it('should fail with empty evidence object', () => {
-            const result = validateNoChangesEvidence({}, allowlist);
-            expect(result.ok).toBe(false);
-            expect(result.errors.length).toBeGreaterThan(0);
-        });
-    });
-    describe('files_checked evidence', () => {
-        it('should pass with files_checked in scope', () => {
-            const result = validateNoChangesEvidence({ files_checked: ['src/game/combat.ts', 'src/game/utils.ts'] }, allowlist);
-            expect(result.ok).toBe(true);
-            expect(result.satisfied_by).toBe('files_checked');
-        });
-        it('should fail with files_checked out of scope', () => {
-            const result = validateNoChangesEvidence({ files_checked: ['package.json', 'src/game/combat.ts'] }, allowlist);
-            expect(result.ok).toBe(false);
-            expect(result.errors.some(e => e.includes('outside scope'))).toBe(true);
-        });
-        it('should fail with empty files_checked array', () => {
-            const result = validateNoChangesEvidence({ files_checked: [] }, allowlist);
-            expect(result.ok).toBe(false);
-        });
-    });
-    describe('grep_output evidence', () => {
-        it('should pass with non-empty grep_output', () => {
-            const result = validateNoChangesEvidence({ grep_output: 'src/game/combat.ts:42: function alreadyImplemented()' }, allowlist);
-            expect(result.ok).toBe(true);
-            expect(result.satisfied_by).toBe('grep_output');
-        });
-        it('should fail with empty grep_output', () => {
-            const result = validateNoChangesEvidence({ grep_output: '' }, allowlist);
-            expect(result.ok).toBe(false);
-        });
-        it('should fail with whitespace-only grep_output', () => {
-            const result = validateNoChangesEvidence({ grep_output: '   \n\t  ' }, allowlist);
-            expect(result.ok).toBe(false);
-        });
-    });
-    describe('commands_run evidence', () => {
-        it('should pass with commands_run all exit_code 0', () => {
-            const result = validateNoChangesEvidence({
-                commands_run: [
-                    { command: 'grep -r "feature" src/', exit_code: 0 },
-                    { command: 'test -f src/feature.ts', exit_code: 0 }
-                ]
-            }, allowlist);
-            expect(result.ok).toBe(true);
-            expect(result.satisfied_by).toBe('commands_run');
-        });
-        it('should fail with commands_run containing non-zero exit_code', () => {
-            const result = validateNoChangesEvidence({
-                commands_run: [
-                    { command: 'grep -r "feature" src/', exit_code: 1 }
-                ]
-            }, allowlist);
-            expect(result.ok).toBe(false);
-            expect(result.errors.some(e => e.includes('failed commands'))).toBe(true);
-        });
-        it('should fail with empty commands_run array', () => {
-            const result = validateNoChangesEvidence({ commands_run: [] }, allowlist);
-            expect(result.ok).toBe(false);
-        });
-    });
-    describe('priority order', () => {
-        it('should prefer files_checked over grep_output', () => {
-            const result = validateNoChangesEvidence({
-                files_checked: ['src/game/combat.ts'],
-                grep_output: 'some output'
-            }, allowlist);
-            expect(result.ok).toBe(true);
-            expect(result.satisfied_by).toBe('files_checked');
-        });
-        it('should fall back to grep_output if files_checked is out of scope', () => {
-            const result = validateNoChangesEvidence({
-                files_checked: ['package.json'],
-                grep_output: 'some valid output'
-            }, allowlist);
-            expect(result.ok).toBe(true);
-            expect(result.satisfied_by).toBe('grep_output');
-        });
-    });
-});
-describe('formatEvidenceErrors', () => {
-    it('should return empty string for ok result', () => {
-        const result = formatEvidenceErrors({
-            ok: true,
-            errors: [],
-            satisfied_by: 'files_checked'
-        });
-        expect(result).toBe('');
-    });
-    it('should format errors for failed result', () => {
-        const result = formatEvidenceErrors({
-            ok: false,
-            errors: ['No evidence provided', 'files_checked is empty']
-        });
-        expect(result).toContain('Insufficient evidence');
-        expect(result).toContain('No evidence provided');
-        expect(result).toContain('files_checked is empty');
-        expect(result).toContain('Required:');
-    });
-});

package/dist/supervisor/__tests__/ownership.test.js

@@ -1,103 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { checkOwnership } from '../runner.js';
-describe('checkOwnership', () => {
-    describe('when no ownership declared', () => {
-        it('does not enforce - always returns ok', () => {
-            const result = checkOwnership(['README.md', 'src/index.ts', 'package.json'], [], // no ownership declared
-            ['node_modules/**']);
-            expect(result.ok).toBe(true);
-            expect(result.owned_paths).toEqual([]);
-            expect(result.semantic_changed).toEqual([]);
-            expect(result.violating_files).toEqual([]);
-        });
-        it('does not enforce even with changes outside would-be owns', () => {
-            // This is the key test: tasks without owns should continue to work unchanged
-            const result = checkOwnership(['README.md', 'docs/guide.md', 'src/unrelated.ts'], [], // no ownership - no enforcement
-            []);
-            expect(result.ok).toBe(true);
-            expect(result.violating_files).toEqual([]);
-        });
-    });
-    describe('when ownership declared', () => {
-        it('allows changes within owned paths', () => {
-            const result = checkOwnership(['courses/a/lesson1.md', 'courses/a/lesson2.md'], ['courses/a/**'], []);
-            expect(result.ok).toBe(true);
-            expect(result.owned_paths).toEqual(['courses/a/**']);
-            expect(result.semantic_changed).toEqual(['courses/a/lesson1.md', 'courses/a/lesson2.md']);
-            expect(result.violating_files).toEqual([]);
-        });
-        it('detects violation when changing files outside owned paths', () => {
-            const result = checkOwnership(['courses/a/lesson1.md', 'README.md'], ['courses/a/**'], []);
-            expect(result.ok).toBe(false);
-            expect(result.owned_paths).toEqual(['courses/a/**']);
-            expect(result.semantic_changed).toEqual(['courses/a/lesson1.md', 'README.md']);
-            expect(result.violating_files).toEqual(['README.md']);
-        });
-        it('reports all violating files', () => {
-            const result = checkOwnership(['courses/a/lesson.md', 'README.md', 'docs/guide.md', 'src/index.ts'], ['courses/a/**'], []);
-            expect(result.ok).toBe(false);
-            expect(result.violating_files).toEqual(['README.md', 'docs/guide.md', 'src/index.ts']);
-        });
-        it('supports multiple owned paths', () => {
-            const result = checkOwnership(['courses/a/lesson.md', 'docs/a.md'], ['courses/a/**', 'docs/**'], []);
-            expect(result.ok).toBe(true);
-            expect(result.violating_files).toEqual([]);
-        });
-    });
-    describe('env artifact filtering', () => {
-        it('excludes env artifacts from ownership check', () => {
-            const result = checkOwnership(['courses/a/lesson.md', 'node_modules/foo/bar.js'], ['courses/a/**'], ['node_modules/**']);
-            expect(result.ok).toBe(true);
-            expect(result.semantic_changed).toEqual(['courses/a/lesson.md']);
-            expect(result.violating_files).toEqual([]);
-        });
-        it('only checks semantic changes, not env noise', () => {
-            // If all changes are env artifacts, no enforcement needed
-            const result = checkOwnership(['node_modules/foo/bar.js', '.next/cache/file'], ['courses/a/**'], ['node_modules/**', '.next/**']);
-            expect(result.ok).toBe(true);
-            expect(result.semantic_changed).toEqual([]);
-            expect(result.violating_files).toEqual([]);
-        });
-    });
-    describe('rename handling (when both paths are included)', () => {
-        it('blocks rename from outside into owned paths', () => {
-            // Simulates: git mv README.md courses/a/README.md
-            // listChangedFiles now returns BOTH paths
-            const result = checkOwnership(['README.md', 'courses/a/README.md'], ['courses/a/**'], []);
-            expect(result.ok).toBe(false);
-            expect(result.violating_files).toEqual(['README.md']);
-        });
-        it('allows rename within owned paths', () => {
-            // Simulates: git mv courses/a/old.md courses/a/new.md
-            const result = checkOwnership(['courses/a/old.md', 'courses/a/new.md'], ['courses/a/**'], []);
-            expect(result.ok).toBe(true);
-            expect(result.violating_files).toEqual([]);
-        });
-        it('blocks rename from owned to outside', () => {
-            // Simulates: git mv courses/a/file.md README.md
-            const result = checkOwnership(['courses/a/file.md', 'README.md'], ['courses/a/**'], []);
-            expect(result.ok).toBe(false);
-            expect(result.violating_files).toEqual(['README.md']);
-        });
-    });
-    describe('defensive normalization', () => {
-        it('normalizes raw directory paths to glob patterns', () => {
-            // Caller passes raw "courses/a/" instead of normalized "courses/a/**"
-            const result = checkOwnership(['courses/a/lesson.md'], ['courses/a/'], // raw, not normalized
-            []);
-            expect(result.ok).toBe(true);
-            expect(result.owned_paths).toEqual(['courses/a/**']); // normalized in output
-        });
-        it('normalizes Windows-style paths', () => {
-            const result = checkOwnership(['courses/a/lesson.md'], ['courses\\a\\'], // Windows-style
-            []);
-            expect(result.ok).toBe(true);
-            expect(result.owned_paths).toEqual(['courses/a/**']);
-        });
-        it('handles ./prefix in ownership patterns', () => {
-            const result = checkOwnership(['courses/a/lesson.md'], ['./courses/a/'], []);
-            expect(result.ok).toBe(true);
-            expect(result.owned_paths).toEqual(['courses/a/**']);
-        });
-    });
-});

package/dist/supervisor/__tests__/state-machine.test.js

@@ -1,290 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createInitialState, updatePhase, stopRun, computeResumeTargetPhase, prepareForResume } from '../state-machine.js';
-describe('createInitialState', () => {
-    it('creates state with INIT phase', () => {
-        const state = createInitialState({
-            run_id: 'test-run-123',
-            repo_path: '/test/repo',
-            task_text: 'Test task',
-            allowlist: ['src/**'],
-            denylist: ['node_modules/**']
-        });
-        expect(state.run_id).toBe('test-run-123');
-        expect(state.repo_path).toBe('/test/repo');
-        expect(state.phase).toBe('INIT');
-        expect(state.milestone_index).toBe(0);
-        expect(state.scope_lock.allowlist).toEqual(['src/**']);
-        expect(state.scope_lock.denylist).toEqual(['node_modules/**']);
-        expect(state.risk_score).toBe(0);
-        expect(state.retries).toBe(0);
-    });
-    it('parses task text into milestones', () => {
-        const state = createInitialState({
-            run_id: 'test',
-            repo_path: '/test',
-            task_text: 'Add a new feature\n\nMore details here',
-            allowlist: [],
-            denylist: []
-        });
-        expect(state.milestones.length).toBeGreaterThan(0);
-        expect(state.milestones[0].goal).toBe('Add a new feature');
-    });
-});
-describe('updatePhase', () => {
-    it('updates phase and tracks last_successful_phase as previous phase', () => {
-        const initial = createInitialState({
-            run_id: 'test',
-            repo_path: '/test',
-            task_text: 'Test',
-            allowlist: [],
-            denylist: []
-        });
-        const updated = updatePhase(initial, 'PLAN');
-        expect(updated.phase).toBe('PLAN');
-        // last_successful_phase tracks the previous phase (INIT in this case)
-        expect(updated.last_successful_phase).toBe('INIT');
-        // updated_at is set (may be same as initial if test runs in same ms)
-        expect(typeof updated.updated_at).toBe('string');
-        expect(updated.updated_at.length).toBeGreaterThan(0);
-    });
-    it('preserves other state properties', () => {
-        const initial = createInitialState({
-            run_id: 'preserve-test',
-            repo_path: '/preserve',
-            task_text: 'Preserve task',
-            allowlist: ['src/**'],
-            denylist: ['dist/**']
-        });
-        const updated = updatePhase(initial, 'IMPLEMENT');
-        expect(updated.run_id).toBe('preserve-test');
-        expect(updated.repo_path).toBe('/preserve');
-        expect(updated.scope_lock.allowlist).toEqual(['src/**']);
-    });
-});
-describe('stopRun', () => {
-    it('sets phase to STOPPED and records reason', () => {
-        const initial = createInitialState({
-            run_id: 'stop-test',
-            repo_path: '/test',
-            task_text: 'Test',
-            allowlist: [],
-            denylist: []
-        });
-        const stopped = stopRun(initial, 'verification_failed');
-        expect(stopped.phase).toBe('STOPPED');
-        expect(stopped.stop_reason).toBe('verification_failed');
-    });
-    it('preserves state when stopping', () => {
-        let state = createInitialState({
-            run_id: 'stop-preserve',
-            repo_path: '/test',
-            task_text: 'Test',
-            allowlist: ['src/**'],
-            denylist: []
-        });
-        state = updatePhase(state, 'IMPLEMENT');
-        state = { ...state, milestone_index: 2 };
-        const stopped = stopRun(state, 'complete');
-        expect(stopped.milestone_index).toBe(2);
-        expect(stopped.scope_lock.allowlist).toEqual(['src/**']);
-    });
-});
-describe('phase ordering', () => {
-    it('follows expected phase progression for success path', () => {
-        const phases = [];
-        let state = createInitialState({
-            run_id: 'phase-order',
-            repo_path: '/test',
-            task_text: 'Test',
-            allowlist: [],
-            denylist: []
-        });
-        phases.push(state.phase);
-        state = updatePhase(state, 'PLAN');
-        phases.push(state.phase);
-        state = updatePhase(state, 'IMPLEMENT');
-        phases.push(state.phase);
-        state = updatePhase(state, 'VERIFY');
-        phases.push(state.phase);
-        state = updatePhase(state, 'REVIEW');
-        phases.push(state.phase);
-        state = updatePhase(state, 'CHECKPOINT');
-        phases.push(state.phase);
-        state = updatePhase(state, 'FINALIZE');
-        phases.push(state.phase);
-        expect(phases).toEqual([
-            'INIT',
-            'PLAN',
-            'IMPLEMENT',
-            'VERIFY',
-            'REVIEW',
-            'CHECKPOINT',
-            'FINALIZE'
-        ]);
-    });
-    it('can loop back to IMPLEMENT after CHECKPOINT for multiple milestones', () => {
-        let state = createInitialState({
-            run_id: 'loop-test',
-            repo_path: '/test',
-            task_text: 'Multi milestone task',
-            allowlist: [],
-            denylist: []
-        });
-        // First milestone
-        state = updatePhase(state, 'PLAN');
-        state = updatePhase(state, 'IMPLEMENT');
-        state = updatePhase(state, 'VERIFY');
-        state = updatePhase(state, 'REVIEW');
-        state = updatePhase(state, 'CHECKPOINT');
-        state = { ...state, milestone_index: 1 };
-        // Second milestone - loops back to IMPLEMENT
-        state = updatePhase(state, 'IMPLEMENT');
-        expect(state.phase).toBe('IMPLEMENT');
-        expect(state.milestone_index).toBe(1);
-        state = updatePhase(state, 'VERIFY');
-        state = updatePhase(state, 'REVIEW');
-        state = updatePhase(state, 'CHECKPOINT');
-        state = { ...state, milestone_index: 2 };
-        // Finalize after all milestones
-        state = updatePhase(state, 'FINALIZE');
-        expect(state.phase).toBe('FINALIZE');
-        expect(state.milestone_index).toBe(2);
-    });
-    it('stops on verification failure', () => {
-        let state = createInitialState({
-            run_id: 'verify-fail',
-            repo_path: '/test',
-            task_text: 'Test',
-            allowlist: [],
-            denylist: []
-        });
-        state = updatePhase(state, 'PLAN');
-        state = updatePhase(state, 'IMPLEMENT');
-        state = updatePhase(state, 'VERIFY');
-        // Verification fails - stop run
-        state = stopRun(state, 'verification_failed');
-        expect(state.phase).toBe('STOPPED');
-        expect(state.stop_reason).toBe('verification_failed');
-        // last_successful_phase is set by updatePhase (previous phase), not stopRun
-        expect(state.last_successful_phase).toBe('IMPLEMENT');
-    });
-});
-describe('computeResumeTargetPhase', () => {
-    it('returns current phase if not STOPPED', () => {
-        const state = createInitialState({
-            run_id: 'test',
-            repo_path: '/test',
-            task_text: 'Test',
-            allowlist: [],
-            denylist: []
-        });
-        const updated = updatePhase(state, 'IMPLEMENT');
-        expect(computeResumeTargetPhase(updated)).toBe('IMPLEMENT');
-    });
-    it('returns next phase after last_successful_phase when STOPPED', () => {
-        let state = createInitialState({
-            run_id: 'test',
-            repo_path: '/test',
-            task_text: 'Test',
-            allowlist: [],
-            denylist: []
-        });
-        state = updatePhase(state, 'PLAN');
-        state = updatePhase(state, 'IMPLEMENT');
-        state = updatePhase(state, 'VERIFY');
-        state = stopRun(state, 'stalled_timeout');
-        // last_successful_phase is IMPLEMENT (from the VERIFY transition)
-        expect(state.last_successful_phase).toBe('IMPLEMENT');
-        expect(computeResumeTargetPhase(state)).toBe('VERIFY');
-    });
-    it('returns INIT when STOPPED with no last_successful_phase', () => {
-        const state = createInitialState({
-            run_id: 'test',
-            repo_path: '/test',
-            task_text: 'Test',
-            allowlist: [],
-            denylist: []
-        });
-        const stopped = stopRun(state, 'guard_violation');
-        expect(computeResumeTargetPhase(stopped)).toBe('INIT');
-    });
-});
-describe('prepareForResume', () => {
-    it('clears stop state and sets resume phase', () => {
-        let state = createInitialState({
-            run_id: 'test',
-            repo_path: '/test',
-            task_text: 'Test',
-            allowlist: [],
-            denylist: []
-        });
-        // Simulate normal phase progression: INIT -> PLAN -> IMPLEMENT -> VERIFY
-        // Each updatePhase sets last_successful_phase to the PREVIOUS phase
-        state = updatePhase(state, 'PLAN'); // last_successful_phase = 'INIT'
-        state = updatePhase(state, 'IMPLEMENT'); // last_successful_phase = 'PLAN'
-        state = updatePhase(state, 'VERIFY'); // last_successful_phase = 'IMPLEMENT'
-        state = stopRun(state, 'stalled_timeout');
-        state = { ...state, last_error: 'Some error' };
-        const resumed = prepareForResume(state);
-        // Resume from phase after last_successful_phase ('IMPLEMENT' -> 'VERIFY')
-        expect(resumed.phase).toBe('VERIFY');
-        expect(resumed.stop_reason).toBeUndefined();
-        expect(resumed.last_error).toBeUndefined();
-        expect(resumed.resume_token).toBe('test');
-    });
-    it('increments auto_resume_count when requested', () => {
-        let state = createInitialState({
-            run_id: 'test',
-            repo_path: '/test',
-            task_text: 'Test',
-            allowlist: [],
-            denylist: []
-        });
-        state = stopRun(state, 'stalled_timeout');
-        const resumed = prepareForResume(state, { incrementAutoResumeCount: true });
-        expect(resumed.auto_resume_count).toBe(1);
-        // Resume again
-        const stoppedAgain = stopRun(resumed, 'worker_call_timeout');
-        const resumedAgain = prepareForResume(stoppedAgain, { incrementAutoResumeCount: true });
-        expect(resumedAgain.auto_resume_count).toBe(2);
-    });
-    it('preserves auto_resume_count when not incrementing', () => {
-        let state = createInitialState({
-            run_id: 'test',
-            repo_path: '/test',
-            task_text: 'Test',
-            allowlist: [],
-            denylist: []
-        });
-        state = { ...state, auto_resume_count: 3 };
-        state = stopRun(state, 'stalled_timeout');
-        const resumed = prepareForResume(state);
-        expect(resumed.auto_resume_count).toBe(3);
-    });
-    it('handles missing auto_resume_count (migration-safe)', () => {
-        let state = createInitialState({
-            run_id: 'test',
-            repo_path: '/test',
-            task_text: 'Test',
-            allowlist: [],
-            denylist: []
-        });
-        // Simulate old state without auto_resume_count
-        delete state.auto_resume_count;
-        state = stopRun(state, 'stalled_timeout');
-        const resumed = prepareForResume(state, { incrementAutoResumeCount: true });
-        expect(resumed.auto_resume_count).toBe(1);
-    });
-    it('uses custom resumeToken when provided', () => {
-        let state = createInitialState({
-            run_id: 'original-run',
-            repo_path: '/test',
-            task_text: 'Test',
-            allowlist: [],
-            denylist: []
-        });
-        state = stopRun(state, 'stalled_timeout');
-        const resumed = prepareForResume(state, { resumeToken: 'custom-token' });
-        expect(resumed.resume_token).toBe('custom-token');
-    });
-});

package/dist/workers/__tests__/claude.test.js

@@ -1,88 +0,0 @@
-import { describe, it, expect } from 'vitest';
-function extractTextFromClaudeJson(output) {
-    try {
-        const parsed = JSON.parse(output);
-        return parsed.result || parsed.content || parsed.message || output;
-    }
-    catch {
-        // If not valid JSON, return raw output
-        return output;
-    }
-}
-describe('extractTextFromClaudeJson', () => {
-    it('extracts result field from valid JSON', () => {
-        const input = '{"result":"Hello World"}';
-        expect(extractTextFromClaudeJson(input)).toBe('Hello World');
-    });
-    it('extracts content field when result is missing', () => {
-        const input = '{"content":"Content text","other":"ignored"}';
-        expect(extractTextFromClaudeJson(input)).toBe('Content text');
-    });
-    it('extracts message field as fallback', () => {
-        const input = '{"message":"Message text"}';
-        expect(extractTextFromClaudeJson(input)).toBe('Message text');
-    });
-    it('returns raw output when not valid JSON', () => {
-        const input = 'This is plain text, not JSON';
-        expect(extractTextFromClaudeJson(input)).toBe('This is plain text, not JSON');
-    });
-    it('returns raw output for truncated JSON', () => {
-        const input = '{"result":"trun';
-        expect(extractTextFromClaudeJson(input)).toBe('{"result":"trun');
-    });
-    it('returns raw output for empty object with no known fields', () => {
-        const input = '{"unknown":"field"}';
-        // Returns the original input since result/content/message are all falsy
-        expect(extractTextFromClaudeJson(input)).toBe('{"unknown":"field"}');
-    });
-    it('handles empty string result', () => {
-        const input = '{"result":"","content":"fallback"}';
-        // Empty string is falsy, so falls through to content
-        expect(extractTextFromClaudeJson(input)).toBe('fallback');
-    });
-    it('handles null values', () => {
-        const input = '{"result":null,"content":"actual content"}';
-        expect(extractTextFromClaudeJson(input)).toBe('actual content');
-    });
-    it('handles nested JSON in result', () => {
-        const input = '{"result":"{\\"nested\\":\\"json\\"}"}';
-        expect(extractTextFromClaudeJson(input)).toBe('{"nested":"json"}');
-    });
-    it('handles array response gracefully', () => {
-        const input = '["array","response"]';
-        // Arrays don't have result/content/message, returns original
-        expect(extractTextFromClaudeJson(input)).toBe('["array","response"]');
-    });
-    it('handles error field in response', () => {
-        const input = '{"error":"Something went wrong","result":""}';
-        // Empty result is falsy, but we don't currently use error field
-        // This returns the raw input since result/content/message are empty/missing
-        expect(extractTextFromClaudeJson(input)).toBe('{"error":"Something went wrong","result":""}');
-    });
-    it('handles whitespace in output', () => {
-        const input = '  {"result":"with spaces"}  ';
-        // JSON.parse handles leading/trailing whitespace
-        expect(extractTextFromClaudeJson(input)).toBe('with spaces');
-    });
-    it('handles newlines in result text', () => {
-        const input = '{"result":"line1\\nline2\\nline3"}';
-        expect(extractTextFromClaudeJson(input)).toBe('line1\nline2\nline3');
-    });
-});
-describe('Claude JSON error handling', () => {
-    it('fails loud on completely invalid input', () => {
-        // Current implementation returns the raw output, which is reasonable
-        // but we might want to distinguish "valid text" from "parse error" later
-        const input = '}{invalid';
-        const result = extractTextFromClaudeJson(input);
-        // Currently returns raw - this is acceptable behavior
-        expect(result).toBe('}{invalid');
-    });
-    it('handles BOM characters', () => {
-        const input = '\uFEFF{"result":"with BOM"}';
-        // JSON.parse may fail with BOM prefix
-        const result = extractTextFromClaudeJson(input);
-        // Should either parse successfully or return raw
-        expect(result.includes('with BOM') || result.includes('\uFEFF')).toBe(true);
-    });
-});