principles-disciple 1.126.0 → 1.128.0

package/tests/core/regression-v1-9-1.test.ts

@@ -1,266 +0,0 @@
-/**
- * Regression tests for bug fixes in v1.9.1
- *
- * Validates fixes for:
- * - #208/#209: isExpectedSubagentError expanded + terminal_error classification
- * - #212: evaluability defaults to weak_heuristic, principles are evaluable
- * - #213: fire-and-forget Promise has .catch()
- * - #214: sleep_reflection timeout expires nocturnal workflow
- * - #207/#210: stateDir properly passed through WorkspaceContext
- */
-
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { EvolutionReducerImpl } from '../../src/core/evolution-reducer.js';
-import {
-  listEvaluablePrinciples,
-  transitionInternalizationStatus,
-  getPrincipleState,
-} from '../../src/core/principle-training-state.js';
-import { isExpectedSubagentError } from '../../src/service/subagent-workflow/subagent-error-utils.js';
-import { WorkspaceContext } from '../../src/core/workspace-context.js';
-import { safeRmDir } from '../test-utils.js';
-
-const tempDirs: string[] = [];
-
-function makeTempDir(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-regression-'));
-  tempDirs.push(dir);
-  return dir;
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    safeRmDir(dir);
-  }
-});
-
-// ── #208/#209: isExpectedSubagentError covers daemon-mode errors ──
-
-describe('#208/#209: isExpectedSubagentError daemon-mode coverage', () => {
-  it('matches original gateway request errors', () => {
-    expect(isExpectedSubagentError('Plugin runtime subagent methods are only available during a gateway request')).toBe(true);
-    expect(isExpectedSubagentError('cannot start workflow for boot session')).toBe(true);
-    expect(isExpectedSubagentError('subagent runtime unavailable')).toBe(true);
-  });
-
-  it('matches NocturnalWorkflowManager specific error', () => {
-    expect(isExpectedSubagentError('NocturnalWorkflowManager: subagent runtime unavailable')).toBe(true);
-  });
-
-  it('matches daemon-mode connection errors', () => {
-    expect(isExpectedSubagentError('subagent is not available')).toBe(true);
-    expect(isExpectedSubagentError('gateway is not running')).toBe(true);
-    expect(isExpectedSubagentError('process isolation error: ECONNREFUSED')).toBe(true);
-    // #3 review fix: connection errors now require 'subagent' in message to reduce false positives
-    expect(isExpectedSubagentError('subagent connection refused')).toBe(true);
-    expect(isExpectedSubagentError('subagent connection reset by peer')).toBe(true);
-  });
-
-  it('does not match unrelated errors', () => {
-    expect(isExpectedSubagentError('file not found')).toBe(false);
-    expect(isExpectedSubagentError('syntax error in config')).toBe(false);
-    expect(isExpectedSubagentError('network timeout to external API')).toBe(false);
-    // #3 review fix: generic connection errors without 'subagent' should NOT match
-    expect(isExpectedSubagentError('connection refused')).toBe(false);
-    expect(isExpectedSubagentError('connection reset by peer')).toBe(false);
-  });
-});
-
-// ── #212: evaluability defaults to weak_heuristic ──
-
-describe('#212: principle evaluability and internalization status', () => {
-  it('new principle without explicit evaluability defaults to weak_heuristic', () => {
-    const workspace = makeTempDir();
-    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
-
-    const id = reducer.createPrincipleFromDiagnosis({
-      painId: 'regression-212-1',
-      painType: 'tool_failure',
-      triggerPattern: 'api call times out after 30s',
-      action: 'implement retry with exponential backoff',
-      source: 'test',
-    });
-
-    expect(id).not.toBeNull();
-    const principle = reducer.getPrincipleById(id!);
-    expect(principle).not.toBeNull();
-    expect(principle!.evaluability).toBe('weak_heuristic');
-  });
-
-  it('new principle with weak_heuristic evaluability gets needs_training status', () => {
-    const workspace = makeTempDir();
-    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
-
-    const id = reducer.createPrincipleFromDiagnosis({
-      painId: 'regression-212-2',
-      painType: 'tool_failure',
-      triggerPattern: 'database connection pool exhausted',
-      action: 'queue requests and retry with timeout',
-      source: 'test',
-    });
-
-    expect(id).not.toBeNull();
-    const trainingState = getPrincipleState(workspace, id!);
-    expect(trainingState.internalizationStatus).toBe('needs_training');
-    expect(trainingState.evaluability).toBe('weak_heuristic');
-  });
-
-  it('new principle with manual_only evaluability gets prompt_only status', () => {
-    const workspace = makeTempDir();
-    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
-
-    const id = reducer.createPrincipleFromDiagnosis({
-      painId: 'regression-212-3',
-      painType: 'user_frustration',
-      triggerPattern: 'ambiguous user intent',
-      action: 'ask clarifying questions before acting',
-      source: 'test',
-      evaluability: 'manual_only',
-    });
-
-    expect(id).not.toBeNull();
-    const trainingState = getPrincipleState(workspace, id!);
-    expect(trainingState.internalizationStatus).toBe('prompt_only');
-    expect(trainingState.evaluability).toBe('manual_only');
-  });
-
-  it('listEvaluablePrinciples includes weak_heuristic principles', () => {
-    const workspace = makeTempDir();
-    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
-
-    // Create a weak_heuristic principle (should be evaluable)
-    const id = reducer.createPrincipleFromDiagnosis({
-      painId: 'regression-212-eval-1',
-      painType: 'tool_failure',
-      triggerPattern: 'regex parse error on empty input',
-      action: 'validate input before regex processing',
-      source: 'test',
-    });
-
-    expect(id).not.toBeNull();
-    const evaluable = listEvaluablePrinciples(workspace);
-    expect(evaluable.length).toBeGreaterThan(0);
-    // Principle IDs are auto-generated (P_001, P_002...), check by the returned ID
-    expect(evaluable.some(p => p.principleId === id)).toBe(true);
-  });
-
-  it('listEvaluablePrinciples excludes manual_only + prompt_only principles', () => {
-    const workspace = makeTempDir();
-    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
-
-    // Create a manual_only principle (should NOT be evaluable)
-    reducer.createPrincipleFromDiagnosis({
-      painId: 'regression-212-noeval-1',
-      painType: 'user_frustration',
-      triggerPattern: 'user confused about feature',
-      action: 'provide contextual help',
-      source: 'test',
-      evaluability: 'manual_only',
-    });
-
-    const evaluable = listEvaluablePrinciples(workspace);
-    expect(evaluable.some(p => p.principleId.includes('regression-212-noeval'))).toBe(false);
-  });
-});
-
-// ── #212: internalization status transition mechanism ──
-
-describe('#212: internalization status transitions', () => {
-  it('transitions prompt_only → needs_training', () => {
-    const workspace = makeTempDir();
-    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
-
-    const id = reducer.createPrincipleFromDiagnosis({
-      painId: 'regression-212-transition-1',
-      painType: 'user_frustration',
-      triggerPattern: 'user error on complex form',
-      action: 'simplify form with progressive disclosure',
-      source: 'test',
-      evaluability: 'manual_only',
-    });
-
-    expect(id).not.toBeNull();
-    const before = getPrincipleState(workspace, id!);
-    expect(before.internalizationStatus).toBe('prompt_only');
-
-    transitionInternalizationStatus(workspace, id!, 'needs_training');
-    const after = getPrincipleState(workspace, id!);
-    expect(after.internalizationStatus).toBe('needs_training');
-  });
-
-  it('rejects invalid transition prompt_only → in_training', () => {
-    const workspace = makeTempDir();
-    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
-
-    const id = reducer.createPrincipleFromDiagnosis({
-      painId: 'regression-212-invalid-transition',
-      painType: 'user_frustration',
-      triggerPattern: 'user error on complex form',
-      action: 'simplify form',
-      source: 'test',
-      evaluability: 'manual_only',
-    });
-
-    expect(() => transitionInternalizationStatus(workspace, id!, 'in_training')).toThrow(
-      'Invalid transition: prompt_only → in_training'
-    );
-  });
-
-  it('transitions regressed → needs_training', () => {
-    const workspace = makeTempDir();
-    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
-
-    const id = reducer.createPrincipleFromDiagnosis({
-      painId: 'regression-212-regress',
-      painType: 'tool_failure',
-      triggerPattern: 'timeout on slow endpoint',
-      action: 'add pagination and caching',
-      source: 'test',
-    });
-
-    // Transition chain: needs_training → in_training → deployed_pending_eval → regressed → needs_training
-    transitionInternalizationStatus(workspace, id!, 'in_training');
-    transitionInternalizationStatus(workspace, id!, 'deployed_pending_eval');
-
-    const before = getPrincipleState(workspace, id!);
-    expect(before.internalizationStatus).toBe('deployed_pending_eval');
-
-    // Can transition to regressed from deployed_pending_eval
-    transitionInternalizationStatus(workspace, id!, 'regressed');
-    const regressed = getPrincipleState(workspace, id!);
-    expect(regressed.internalizationStatus).toBe('regressed');
-
-    // Can transition back to needs_training from regressed
-    transitionInternalizationStatus(workspace, id!, 'needs_training');
-    const after = getPrincipleState(workspace, id!);
-    expect(after.internalizationStatus).toBe('needs_training');
-  });
-});
-
-// ── #207/#210: stateDir via WorkspaceContext ──
-
-describe('#207/#210: WorkspaceContext provides stateDir to evolutionReducer', () => {
-  it('evolutionReducer from WorkspaceContext has stateDir', () => {
-    const workspace = makeTempDir();
-    const wctx = WorkspaceContext.fromHookContext({ workspaceDir: workspace });
-
-    // The reducer should have stateDir set via WorkspaceContext
-    // We can verify by creating a principle and checking training store
-    const reducer = wctx.evolutionReducer;
-    const id = reducer.createPrincipleFromDiagnosis({
-      painId: 'regression-207-1',
-      painType: 'tool_failure',
-      triggerPattern: 'null pointer on empty list',
-      action: 'check for empty list before iteration',
-      source: 'test',
-    });
-
-    expect(id).not.toBeNull();
-    // If stateDir was properly passed, training store should have been written
-    const trainingState = getPrincipleState(workspace, id!);
-    expect(trainingState.principleId).toBe(id);
-  });
-});

package/tests/core/replay-engine.test.ts

@@ -1,165 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { ReplayEngine } from '../../src/core/replay-engine.js';
-import { createImplementationAssetDir, getImplementationAssetRoot } from '../../src/core/code-implementation-storage.js';
-import { safeRmDir } from '../test-utils.js';
-
-describe('ReplayEngine', () => {
-  let tempDir: string;
-  let workspaceDir: string;
-  let stateDir: string;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-replay-engine-'));
-    workspaceDir = path.join(tempDir, 'workspace');
-    stateDir = path.join(tempDir, '.state');
-    fs.mkdirSync(workspaceDir, { recursive: true });
-    fs.mkdirSync(stateDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    safeRmDir(tempDir);
-  });
-
-  it('listReports returns empty array when no replays exist', () => {
-    const engine = new ReplayEngine(workspaceDir, stateDir);
-    expect(engine.listReports('IMPL-1')).toEqual([]);
-  });
-
-  it('listReports returns persisted replay reports sorted by name descending', () => {
-    createImplementationAssetDir(stateDir, 'IMPL-1', '1.0.0');
-    const replayDir = path.join(getImplementationAssetRoot(stateDir, 'IMPL-1'), 'replays');
-    fs.mkdirSync(replayDir, { recursive: true });
-
-    const report1 = {
-      implementationId: 'IMPL-1',
-      generatedAt: '2026-04-08T00:00:00.000Z',
-      overallDecision: 'needs-review',
-      blockers: [],
-      sampleFingerprints: [],
-      replayResults: {
-        painNegative: { total: 0, passed: 0, failed: 0, details: [] },
-        successPositive: { total: 0, passed: 0, failed: 0, details: [] },
-        principleAnchor: { total: 0, passed: 0, failed: 0, details: [] },
-      },
-      evidenceSummary: {
-        evidenceStatus: 'empty',
-        totalSamples: 0,
-        classifiedCounts: { painNegative: 0, successPositive: 0, principleAnchor: 0 },
-      },
-    };
-
-    const report2 = {
-      ...report1,
-      generatedAt: '2026-04-09T00:00:00.000Z',
-      overallDecision: 'pass',
-    };
-
-    fs.writeFileSync(path.join(replayDir, '2026-04-08T00-00-00-000Z.json'), JSON.stringify(report1, null, 2), 'utf-8');
-    fs.writeFileSync(path.join(replayDir, '2026-04-09T00-00-00-000Z.json'), JSON.stringify(report2, null, 2), 'utf-8');
-
-    const engine = new ReplayEngine(workspaceDir, stateDir);
-    const reports = engine.listReports('IMPL-1');
-
-    expect(reports).toHaveLength(2);
-    expect(reports[0].overallDecision).toBe('pass');
-    expect(reports[1].overallDecision).toBe('needs-review');
-  });
-
-  it('getLatestReport returns the most recent report', () => {
-    createImplementationAssetDir(stateDir, 'IMPL-1', '1.0.0');
-    const replayDir = path.join(getImplementationAssetRoot(stateDir, 'IMPL-1'), 'replays');
-    fs.mkdirSync(replayDir, { recursive: true });
-
-    const report = {
-      implementationId: 'IMPL-1',
-      generatedAt: '2026-04-08T00:00:00.000Z',
-      overallDecision: 'pass',
-      blockers: [],
-      sampleFingerprints: [],
-      replayResults: {
-        painNegative: { total: 1, passed: 1, failed: 0, details: [] },
-        successPositive: { total: 0, passed: 0, failed: 0, details: [] },
-        principleAnchor: { total: 0, passed: 0, failed: 0, details: [] },
-      },
-      evidenceSummary: {
-        evidenceStatus: 'observed',
-        totalSamples: 1,
-        classifiedCounts: { painNegative: 1, successPositive: 0, principleAnchor: 0 },
-      },
-    };
-
-    fs.writeFileSync(path.join(replayDir, '2026-04-08T00-00-00-000Z.json'), JSON.stringify(report, null, 2), 'utf-8');
-
-    const engine = new ReplayEngine(workspaceDir, stateDir);
-    const latest = engine.getLatestReport('IMPL-1');
-
-    expect(latest).not.toBeNull();
-    expect(latest!.overallDecision).toBe('pass');
-  });
-
-  it('getLatestReport returns null when no reports exist', () => {
-    const engine = new ReplayEngine(workspaceDir, stateDir);
-    expect(engine.getLatestReport('IMPL-1')).toBeNull();
-  });
-
-  it('hasPassingReport returns true when a passing report exists', () => {
-    createImplementationAssetDir(stateDir, 'IMPL-1', '1.0.0');
-    const replayDir = path.join(getImplementationAssetRoot(stateDir, 'IMPL-1'), 'replays');
-    fs.mkdirSync(replayDir, { recursive: true });
-
-    const report = {
-      implementationId: 'IMPL-1',
-      generatedAt: '2026-04-08T00:00:00.000Z',
-      overallDecision: 'pass',
-      blockers: [],
-      sampleFingerprints: [],
-      replayResults: {
-        painNegative: { total: 1, passed: 1, failed: 0, details: [] },
-        successPositive: { total: 0, passed: 0, failed: 0, details: [] },
-        principleAnchor: { total: 0, passed: 0, failed: 0, details: [] },
-      },
-      evidenceSummary: {
-        evidenceStatus: 'observed',
-        totalSamples: 1,
-        classifiedCounts: { painNegative: 1, successPositive: 0, principleAnchor: 0 },
-      },
-    };
-
-    fs.writeFileSync(path.join(replayDir, '2026-04-08T00-00-00-000Z.json'), JSON.stringify(report, null, 2), 'utf-8');
-
-    const engine = new ReplayEngine(workspaceDir, stateDir);
-    expect(engine.hasPassingReport('IMPL-1')).toBe(true);
-  });
-
-  it('hasPassingReport returns false when no passing report exists', () => {
-    createImplementationAssetDir(stateDir, 'IMPL-1', '1.0.0');
-    const replayDir = path.join(getImplementationAssetRoot(stateDir, 'IMPL-1'), 'replays');
-    fs.mkdirSync(replayDir, { recursive: true });
-
-    const report = {
-      implementationId: 'IMPL-1',
-      generatedAt: '2026-04-08T00:00:00.000Z',
-      overallDecision: 'needs-review',
-      blockers: ['NO REPLAY EVIDENCE'],
-      sampleFingerprints: [],
-      replayResults: {
-        painNegative: { total: 0, passed: 0, failed: 0, details: [] },
-        successPositive: { total: 0, passed: 0, failed: 0, details: [] },
-        principleAnchor: { total: 0, passed: 0, failed: 0, details: [] },
-      },
-      evidenceSummary: {
-        evidenceStatus: 'empty',
-        totalSamples: 0,
-        classifiedCounts: { painNegative: 0, successPositive: 0, principleAnchor: 0 },
-      },
-    };
-
-    fs.writeFileSync(path.join(replayDir, '2026-04-08T00-00-00-000Z.json'), JSON.stringify(report, null, 2), 'utf-8');
-
-    const engine = new ReplayEngine(workspaceDir, stateDir);
-    expect(engine.hasPassingReport('IMPL-1')).toBe(false);
-  });
-});

package/tests/core/risk-calculator.test.ts

@@ -1,168 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { estimateLineChanges, assessRiskLevel, getTargetFileLineCount, calculatePercentageThreshold } from '../../src/core/risk-calculator.js';
-import * as ioUtils from '../../src/utils/io.js';
-import * as fs from 'fs';
-
-vi.mock('../../src/utils/io.js');
-vi.mock('fs');
-
-describe('Risk Calculator', () => {
-    it('should estimate line changes correctly for write_file', () => {
-        const lines = estimateLineChanges({
-            toolName: 'write_file',
-            params: { content: 'line1\nline2\nline3' }
-        });
-        expect(lines).toBe(3);
-    });
-
-    it('should estimate line changes correctly for replace', () => {
-        const lines = estimateLineChanges({
-            toolName: 'replace',
-            params: { new_string: 'a\nb\nc\nd\ne' }
-        });
-        expect(lines).toBe(5);
-    });
-
-    it('should estimate 50 for delete_file', () => {
-        const lines = estimateLineChanges({
-            toolName: 'delete_file',
-            params: {}
-        });
-        expect(lines).toBe(50);
-    });
-
-    it('should assess risk level correctly', () => {
-        // High risk path, large change
-        vi.mocked(ioUtils.isRisky).mockReturnValueOnce(true);
-        let level = assessRiskLevel('src/core.ts', { toolName: 'write', params: { content: Array(105).fill('a').join('\n') } }, ['src/']);
-        expect(level).toBe('CRITICAL');
-
-        // High risk path, small change
-        vi.mocked(ioUtils.isRisky).mockReturnValueOnce(true);
-        level = assessRiskLevel('src/core.ts', { toolName: 'write', params: { content: 'a\nb' } }, ['src/']);
-        expect(level).toBe('HIGH');
-
-        // Low risk path, large change
-        vi.mocked(ioUtils.isRisky).mockReturnValueOnce(false);
-        level = assessRiskLevel('docs/readme.md', { toolName: 'write', params: { content: Array(105).fill('a').join('\n') } }, ['src/']);
-        expect(level).toBe('HIGH');
-
-        // Low risk path, medium change
-        vi.mocked(ioUtils.isRisky).mockReturnValueOnce(false);
-        level = assessRiskLevel('docs/readme.md', { toolName: 'write', params: { content: Array(15).fill('a').join('\n') } }, ['src/']);
-        expect(level).toBe('MEDIUM');
-
-        // Low risk path, small change
-        vi.mocked(ioUtils.isRisky).mockReturnValueOnce(false);
-        level = assessRiskLevel('docs/readme.md', { toolName: 'write', params: { content: 'a\nb' } }, ['src/']);
-        expect(level).toBe('LOW');
-    });
-});
-
-describe('getTargetFileLineCount', () => {
-    it('should return line count when file exists and is readable', () => {
-        vi.mocked(fs.existsSync).mockReturnValue(true);
-        vi.mocked(fs.statSync).mockReturnValue({ isFile: () => true } as any);
-        vi.mocked(fs.readFileSync).mockReturnValue('line1\nline2\nline3\n');
-        
-        const count = getTargetFileLineCount('/some/file.txt');
-        expect(count).toBe(4);
-    });
-
-    it('should return null when file does not exist', () => {
-        vi.mocked(fs.existsSync).mockReturnValue(false);
-        
-        const count = getTargetFileLineCount('/nonexistent/file.txt');
-        expect(count).toBeNull();
-    });
-
-    it('should return null when path is not a regular file', () => {
-        vi.mocked(fs.existsSync).mockReturnValue(true);
-        vi.mocked(fs.statSync).mockReturnValue({ isFile: () => false } as any);
-        
-        const count = getTargetFileLineCount('/some/directory');
-        expect(count).toBeNull();
-    });
-
-    it('should return null and log error when file cannot be read', () => {
-        vi.mocked(fs.existsSync).mockReturnValue(true);
-        vi.mocked(fs.statSync).mockReturnValue({ isFile: () => true } as any);
-        vi.mocked(fs.readFileSync).mockImplementation(() => {
-            const err = new Error('Permission denied');
-            (err as any).code = 'EACCES';
-            throw err;
-        });
-        
-        const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-        
-        const count = getTargetFileLineCount('/some/file.txt');
-        expect(count).toBeNull();
-        expect(consoleSpy).toHaveBeenCalledWith(
-            expect.stringContaining('[PD:RISK_CALC] Failed to read file'),
-            expect.objectContaining({ code: 'EACCES' })
-        );
-        
-        consoleSpy.mockRestore();
-    });
-
-    it('should return 1 for file with no newlines', () => {
-        vi.mocked(fs.existsSync).mockReturnValue(true);
-        vi.mocked(fs.statSync).mockReturnValue({ isFile: () => true } as any);
-        vi.mocked(fs.readFileSync).mockReturnValue('single line content');
-        
-        const count = getTargetFileLineCount('/some/file.txt');
-        expect(count).toBe(1);
-    });
-});
-
-describe('calculatePercentageThreshold', () => {
-    it('should calculate percentage correctly', () => {
-        // 10% of 100 lines = 10 lines
-        const limit = calculatePercentageThreshold(100, 10, 5);
-        expect(limit).toBe(10);
-    });
-
-    it('should enforce minimum floor', () => {
-        // 5% of 100 lines = 5 lines, but min is 20, so result is 20
-        const limit = calculatePercentageThreshold(100, 5, 20);
-        expect(limit).toBe(20);
-    });
-
-    it('should round correctly', () => {
-        // 10% of 99 lines = 9.9, rounds to 10
-        const limit = calculatePercentageThreshold(99, 10, 5);
-        expect(limit).toBe(10);
-    });
-
-    it('should handle zero percentage', () => {
-        const limit = calculatePercentageThreshold(100, 0, 20);
-        expect(limit).toBe(20); // minLines is the floor
-    });
-
-    it('should handle 100 percentage', () => {
-        const limit = calculatePercentageThreshold(100, 100, 20);
-        expect(limit).toBe(100);
-    });
-
-    it('should clamp negative percentage to 0', () => {
-        const limit = calculatePercentageThreshold(100, -10, 20);
-        expect(limit).toBe(20); // minLines is the floor
-    });
-
-    it('should clamp percentage over 100 to 100', () => {
-        const limit = calculatePercentageThreshold(100, 150, 20);
-        expect(limit).toBe(100);
-    });
-
-    it('should respect maxLines upper bound', () => {
-        // 15% of 1000 lines = 150, but max is 100
-        const limit = calculatePercentageThreshold(1000, 15, 20, 100);
-        expect(limit).toBe(100);
-    });
-
-    it('should use minLines when both floor and ceiling apply', () => {
-        // 1% of 100 lines = 1, but min is 20, ceiling doesn't apply
-        const limit = calculatePercentageThreshold(100, 1, 20, 50);
-        expect(limit).toBe(20);
-    });
-});