principles-disciple 1.32.0 → 1.34.0

package/tests/service/nocturnal-workflow-manager.test.ts

@@ -1,441 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import type { TrinityRuntimeAdapter } from '../../core/nocturnal-trinity.js';
-
-// Mock dependencies
-vi.mock('../../src/core/nocturnal-trinity.js', () => ({
-    runTrinityAsync: vi.fn(),
-    TrinityStageFailure: {
-        stage: 'dreamer',
-        reason: '',
-    },
-}));
-
-vi.mock('../../src/core/nocturnal-paths.js', () => ({
-    NocturnalPathResolver: {
-        samplePath: vi.fn((workspaceDir: string, sampleId: string) =>
-            `${workspaceDir}/.state/nocturnal/samples/${sampleId}.json`
-        ),
-        resolveNocturnalDir: vi.fn((workspaceDir: string, _type: string) =>
-            `${workspaceDir}/.state/nocturnal/samples`
-        ),
-    },
-}));
-
-import { NocturnalWorkflowManager, nocturnalWorkflowSpec } from '../../src/service/subagent-workflow/nocturnal-workflow-manager.js';
-import { runTrinityAsync } from '../../src/core/nocturnal-trinity.js';
-import type { TrinityStageFailure, TrinityResult, DreamerOutput, PhilosopherOutput, TrinityDraftArtifact, TrinityTelemetry, TrinityConfig } from '../../src/core/nocturnal-trinity.js';
-
-const mockRunTrinityAsync = runTrinityAsync as ReturnType<typeof vi.fn>;
-
-function createMockRuntimeAdapter() {
-    return {
-        isRuntimeAvailable: vi.fn(() => true),
-        getLastFailureReason: vi.fn(() => null),
-        invokeDreamer: vi.fn<(snapshot: any, principleId: any, maxCandidates: any) => Promise<DreamerOutput>>(),
-        invokePhilosopher: vi.fn<(dreamerOutput: any, principleId: any) => Promise<PhilosopherOutput>>(),
-        invokeScribe: vi.fn<(dreamerOutput: any, philosopherOutput: any, snapshot: any, principleId: any, telemetry: any, config: any) => Promise<TrinityDraftArtifact | null>>(),
-    } as unknown as TrinityRuntimeAdapter;
-}
-
-describe('NocturnalWorkflowManager', () => {
-    let manager: NocturnalWorkflowManager;
-    const mockLogger = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-    let mockRuntimeAdapter: ReturnType<typeof createMockRuntimeAdapter>;
-
-    beforeEach(() => {
-        vi.useFakeTimers({ shouldAdvanceTime: true });
-        vi.clearAllMocks();
-        mockRuntimeAdapter = createMockRuntimeAdapter();
-        manager = new NocturnalWorkflowManager({
-            workspaceDir: '/tmp/test-workspace',
-            stateDir: '/tmp/test-workspace/.state',
-            logger: mockLogger as any,
-            runtimeAdapter: mockRuntimeAdapter,
-        });
-    });
-
-    afterEach(() => {
-        vi.useRealTimers();
-        manager.dispose();
-    });
-
-    describe('NOC-01: WorkflowManager interface', () => {
-        it('implements all WorkflowManager interface methods (7 methods)', () => {
-            expect(typeof manager.startWorkflow).toBe('function');
-            expect(typeof manager.notifyWaitResult).toBe('function');
-            expect(typeof manager.notifyLifecycleEvent).toBe('function');
-            expect(typeof manager.finalizeOnce).toBe('function');
-            expect(typeof manager.sweepExpiredWorkflows).toBe('function');
-            expect(typeof manager.getWorkflowDebugSummary).toBe('function');
-            expect(typeof manager.dispose).toBe('function');
-        });
-
-        it('implements WorkflowManager type', () => {
-            const _wm: import('../../src/service/subagent-workflow/types.js').WorkflowManager = manager;
-            expect(true).toBe(true);
-        });
-    });
-
-    describe('NOC-02: Trinity async path via runtimeAdapter (useTrinity=true)', () => {
-        it('calls invokeDreamer with snapshot and principleId', async () => {
-            const mockDreamerOutput: DreamerOutput = {
-                valid: true,
-                candidates: [],
-                generatedAt: new Date().toISOString(),
-            };
-            const mockPhilosopherOutput: PhilosopherOutput = {
-                valid: true,
-                judgments: [],
-                overallAssessment: '',
-                generatedAt: new Date().toISOString(),
-            };
-            mockRuntimeAdapter.invokeDreamer.mockResolvedValue(mockDreamerOutput);
-            mockRuntimeAdapter.invokePhilosopher.mockResolvedValue(mockPhilosopherOutput);
-            mockRuntimeAdapter.invokeScribe.mockResolvedValue({} as TrinityDraftArtifact);
-
-            await manager.startWorkflow(nocturnalWorkflowSpec, {
-                parentSessionId: 'session-123',
-                taskInput: {},
-                metadata: {
-                    snapshot: { sessionId: 'test-session', stats: { totalAssistantTurns: 5 } } as any,
-                    principleId: 'principle-001',
-                },
-            });
-
-            // Flush microtasks so the Promise.resolve().then() callback runs
-            vi.runAllTicks();
-
-            expect(mockRuntimeAdapter.invokeDreamer).toHaveBeenCalledWith(
-                expect.objectContaining({ sessionId: 'test-session' }),
-                'principle-001',
-                expect.any(Number)
-            );
-        });
-    });
-
-    describe('NOC-03: WorkflowStore event recording', () => {
-        it('records nocturnal_started event', async () => {
-            const mockResult: TrinityResult = {
-                success: true,
-                telemetry: { chainMode: 'trinity', usedStubs: false, dreamerPassed: true, philosopherPassed: true, scribePassed: true, candidateCount: 3, selectedCandidateIndex: 0, stageFailures: [] },
-                failures: [],
-                fallbackOccurred: false,
-            };
-            mockRunTrinityAsync.mockResolvedValue(mockResult);
-
-            await manager.startWorkflow(nocturnalWorkflowSpec, {
-                parentSessionId: 'session-123',
-                taskInput: {},
-                metadata: {
-                    snapshot: { sessionId: 'test-session', stats: { totalAssistantTurns: 5 } } as any,
-                    principleId: 'principle-001',
-                },
-            });
-
-            // Flush microtasks
-            vi.runAllTicks();
-
-            expect(mockLogger.info).toHaveBeenCalledWith(
-                expect.stringContaining('Starting workflow')
-            );
-        });
-    });
-
-    describe('NOC-04: NocturnalWorkflowSpec definition', () => {
-        it('has workflowType=nocturnal', () => {
-            expect(nocturnalWorkflowSpec.workflowType).toBe('nocturnal');
-        });
-
-        it('has transport=runtime_direct', () => {
-            expect(nocturnalWorkflowSpec.transport).toBe('runtime_direct');
-        });
-
-        it('has shouldDeleteSessionAfterFinalize=false', () => {
-            expect(nocturnalWorkflowSpec.shouldDeleteSessionAfterFinalize).toBe(false);
-        });
-
-        it('has timeoutMs=900000 (15 minutes)', () => {
-            expect(nocturnalWorkflowSpec.timeoutMs).toBe(15 * 60 * 1000);
-        });
-
-        it('has ttlMs=1800000 (30 minutes)', () => {
-            expect(nocturnalWorkflowSpec.ttlMs).toBe(30 * 60 * 1000);
-        });
-
-        it('buildPrompt returns empty string', () => {
-            expect(nocturnalWorkflowSpec.buildPrompt({}, {} as any)).toBe('');
-        });
-    });
-
-    describe('NOC-05: sweepExpiredWorkflows', () => {
-        it('sweepExpiredWorkflows is a function', () => {
-            expect(typeof manager.sweepExpiredWorkflows).toBe('function');
-        });
-    });
-
-    describe('notifyWaitResult is no-op (D-10)', () => {
-        it('notifyWaitResult does not throw', async () => {
-            await expect(manager.notifyWaitResult('wf_123', 'ok')).resolves.not.toThrow();
-            await expect(manager.notifyWaitResult('wf_123', 'error', 'test error')).resolves.not.toThrow();
-            await expect(manager.notifyWaitResult('wf_123', 'timeout')).resolves.not.toThrow();
-        });
-    });
-
-    describe('notifyLifecycleEvent is no-op (D-10)', () => {
-        it('notifyLifecycleEvent does not throw for subagent_spawned', async () => {
-            await expect(manager.notifyLifecycleEvent('wf_123', 'subagent_spawned')).resolves.not.toThrow();
-        });
-
-        it('notifyLifecycleEvent does not throw for subagent_ended', async () => {
-            await expect(manager.notifyLifecycleEvent('wf_123', 'subagent_ended', { data: 'test' })).resolves.not.toThrow();
-        });
-    });
-
-    describe('NOC-07: Trinity chain via runtimeAdapter', () => {
-        it('calls runtimeAdapter stage methods when metadata contains snapshot and principleId', async () => {
-            vi.useRealTimers(); // Disable fake timers for this async test
-            try {
-                const mockDreamerOutput: DreamerOutput = {
-                    valid: true,
-                    candidates: [],
-                    generatedAt: new Date().toISOString(),
-                };
-                const mockPhilosopherOutput: PhilosopherOutput = {
-                    valid: true,
-                    judgments: [],
-                    overallAssessment: 'ok',
-                    generatedAt: new Date().toISOString(),
-                };
-                mockRuntimeAdapter.invokeDreamer.mockResolvedValue(mockDreamerOutput);
-                mockRuntimeAdapter.invokePhilosopher.mockResolvedValue(mockPhilosopherOutput);
-                mockRuntimeAdapter.invokeScribe.mockResolvedValue({ selectedCandidateIndex: 0 } as TrinityDraftArtifact);
-
-                await manager.startWorkflow(nocturnalWorkflowSpec, {
-                    parentSessionId: 'session-123',
-                    taskInput: {},
-                    metadata: {
-                        snapshot: { sessionId: 'test-session', stats: { totalAssistantTurns: 5 } } as any,
-                        principleId: 'principle-001',
-                    },
-                });
-
-                // Give async chain time to complete
-                await new Promise(resolve => setTimeout(resolve, 10));
-
-                // Verify invokeDreamer was called (Stage 1 of Trinity chain)
-                expect(mockRuntimeAdapter.invokeDreamer).toHaveBeenCalled();
-                // Verify invokePhilosopher was called (Stage 2)
-                expect(mockRuntimeAdapter.invokePhilosopher).toHaveBeenCalled();
-                // Verify invokeScribe was called (Stage 3)
-                expect(mockRuntimeAdapter.invokeScribe).toHaveBeenCalled();
-            } finally {
-                vi.useFakeTimers({ shouldAdvanceTime: true });
-            }
-        });
-
-        it('startWorkflow returns immediately with state=active (NOC-07)', async () => {
-            const mockDreamerOutput: DreamerOutput = {
-                valid: true,
-                candidates: [],
-                generatedAt: new Date().toISOString(),
-            };
-            const mockPhilosopherOutput: PhilosopherOutput = {
-                valid: true,
-                judgments: [],
-                overallAssessment: '',
-                generatedAt: new Date().toISOString(),
-            };
-            mockRuntimeAdapter.invokeDreamer.mockResolvedValue(mockDreamerOutput);
-            mockRuntimeAdapter.invokePhilosopher.mockResolvedValue(mockPhilosopherOutput);
-            mockRuntimeAdapter.invokeScribe.mockResolvedValue({ selectedCandidateIndex: 0 } as TrinityDraftArtifact);
-
-            const handle = await manager.startWorkflow(nocturnalWorkflowSpec, {
-                parentSessionId: 'session-123',
-                taskInput: {},
-                metadata: {
-                    snapshot: { sessionId: 'test-session', stats: { totalAssistantTurns: 5 } } as any,
-                    principleId: 'principle-001',
-                },
-            });
-
-            // For Trinity async path, handle.state should be 'active' immediately
-            // (Implementation uses Promise.resolve().then() to offload Trinity)
-            expect(handle.state).toBe('active');
-        });
-    });
-
-    describe('NOC-08: Stage event recording from TrinityResult', () => {
-        it('records stage events when Trinity completes successfully', async () => {
-            const mockResult: TrinityResult = {
-                success: true,
-                artifact: {} as any,
-                telemetry: {
-                    chainMode: 'trinity',
-                    usedStubs: false,
-                    dreamerPassed: true,
-                    philosopherPassed: true,
-                    scribePassed: true,
-                    candidateCount: 3,
-                    selectedCandidateIndex: 0,
-                    stageFailures: [],
-                },
-                failures: [],
-                fallbackOccurred: false,
-            };
-            mockRunTrinityAsync.mockResolvedValue(mockResult);
-
-            const mgr = new NocturnalWorkflowManager({
-                workspaceDir: '/tmp/test-workspace',
-                stateDir: '/tmp/test-workspace/.state',
-                logger: mockLogger as any,
-                runtimeAdapter: mockRuntimeAdapter,
-            });
-
-            await mgr.startWorkflow(nocturnalWorkflowSpec, {
-                parentSessionId: 'session-123',
-                taskInput: {},
-                metadata: {
-                    snapshot: { sessionId: 'test-session', stats: { totalAssistantTurns: 5 } } as any,
-                    principleId: 'principle-001',
-                },
-            });
-
-            vi.runAllTicks();
-
-            // Verify nocturnal events were recorded
-            expect(mockLogger.info).toHaveBeenCalledWith(
-                expect.stringContaining('nocturnal')
-            );
-        });
-
-        it('records trinity_dreamer_failed when dreamer stage fails', async () => {
-            const mockResult: TrinityResult = {
-                success: false,
-                telemetry: {
-                    chainMode: 'trinity',
-                    usedStubs: false,
-                    dreamerPassed: false,
-                    philosopherPassed: false,
-                    scribePassed: false,
-                    candidateCount: 0,
-                    selectedCandidateIndex: -1,
-                    stageFailures: ['Dreamer: no candidates'],
-                },
-                failures: [{ stage: 'dreamer', reason: 'no candidates generated' }],
-                fallbackOccurred: false,
-            };
-            mockRunTrinityAsync.mockResolvedValue(mockResult);
-
-            const mgr = new NocturnalWorkflowManager({
-                workspaceDir: '/tmp/test-workspace',
-                stateDir: '/tmp/test-workspace/.state',
-                logger: mockLogger as any,
-                runtimeAdapter: mockRuntimeAdapter,
-            });
-
-            await mgr.startWorkflow(nocturnalWorkflowSpec, {
-                parentSessionId: 'session-123',
-                taskInput: {},
-                metadata: {
-                    snapshot: { sessionId: 'test-session', stats: { totalAssistantTurns: 5 } } as any,
-                    principleId: 'principle-001',
-                },
-            });
-
-            vi.runAllTicks();
-
-            expect(mockLogger.info).toHaveBeenCalled();
-        });
-    });
-
-    describe('NOC-09: Stage failure handling with TrinityStageFailure[]', () => {
-        it('notifies error status when Trinity stage fails', async () => {
-            const mockResult: TrinityResult = {
-                success: false,
-                telemetry: {
-                    chainMode: 'trinity',
-                    usedStubs: false,
-                    dreamerPassed: false,
-                    philosopherPassed: false,
-                    scribePassed: false,
-                    candidateCount: 0,
-                    selectedCandidateIndex: -1,
-                    stageFailures: ['Dreamer: no candidates'],
-                },
-                failures: [
-                    { stage: 'dreamer', reason: 'no candidates generated' },
-                ],
-                fallbackOccurred: false,
-            };
-            mockRunTrinityAsync.mockResolvedValue(mockResult);
-
-            const mgr = new NocturnalWorkflowManager({
-                workspaceDir: '/tmp/test-workspace',
-                stateDir: '/tmp/test-workspace/.state',
-                logger: mockLogger as any,
-                runtimeAdapter: mockRuntimeAdapter,
-            });
-
-            await mgr.startWorkflow(nocturnalWorkflowSpec, {
-                parentSessionId: 'session-123',
-                taskInput: {},
-                metadata: {
-                    snapshot: { sessionId: 'test-session', stats: { totalAssistantTurns: 5 } } as any,
-                    principleId: 'principle-001',
-                },
-            });
-
-            vi.runAllTicks();
-        });
-
-        it('nocturnal_failed event includes TrinityStageFailure[]', async () => {
-            const trinityFailures: TrinityStageFailure[] = [
-                { stage: 'philosopher', reason: 'invalid judgments' },
-            ];
-            const mockResult: TrinityResult = {
-                success: false,
-                telemetry: {
-                    chainMode: 'trinity',
-                    usedStubs: false,
-                    dreamerPassed: true,
-                    philosopherPassed: false,
-                    scribePassed: false,
-                    candidateCount: 3,
-                    selectedCandidateIndex: -1,
-                    stageFailures: ['Philosopher: invalid judgments'],
-                },
-                failures: trinityFailures,
-                fallbackOccurred: false,
-            };
-            mockRunTrinityAsync.mockResolvedValue(mockResult);
-
-            const mgr = new NocturnalWorkflowManager({
-                workspaceDir: '/tmp/test-workspace',
-                stateDir: '/tmp/test-workspace/.state',
-                logger: mockLogger as any,
-                runtimeAdapter: mockRuntimeAdapter,
-            });
-
-            await mgr.startWorkflow(nocturnalWorkflowSpec, {
-                parentSessionId: 'session-123',
-                taskInput: {},
-                metadata: {
-                    snapshot: { sessionId: 'test-session', stats: { totalAssistantTurns: 5 } } as any,
-                    principleId: 'principle-001',
-                },
-            });
-
-            vi.runAllTicks();
-        });
-    });
-
-    // NOC-10: Full state machine transitions
-    // These tests verify the full active->finalizing->completed state machine via notifyWaitResult.
-    // Skipped: vitest fake timers don't reliably flush Promise microtasks in this async context.
-    // The state machine behavior is covered by NOC-07/08/09 unit tests.
-    describe.skip('NOC-10: Full state machine transitions', () => {
-        it.todo('transitions to completed on Trinity success');
-        it.todo('transitions to terminal_error on Trinity failure');
-        it.todo('records trinity_completed before nocturnal_completed');
-    });
-});

package/tests/tools/critique-prompt.test.ts

@@ -1,260 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-// 导入待测试的函数
-import { buildCritiquePromptV2 } from '../../src/tools/critique-prompt.js';
-import type { OpenClawPluginApi } from '../../src/openclaw-sdk.js';
-
-describe('buildCritiquePromptV2', () => {
-    let tempDir: string;
-    let mockApi: OpenClawPluginApi;
-
-    beforeEach(() => {
-        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'critique-prompt-test-'));
-        
-        mockApi = {
-            id: "test-plugin",
-            name: "Test Plugin",
-            source: "local",
-            config: {},
-            runtime: {} as any,
-            logger: {
-                info: vi.fn(),
-                error: vi.fn(),
-                warn: vi.fn(),
-                debug: vi.fn(),
-            },
-            registerTool: vi.fn(),
-            registerHook: vi.fn(),
-            registerHttpRoute: vi.fn(),
-            registerChannel: vi.fn(),
-            registerGatewayMethod: vi.fn(),
-            registerCli: vi.fn(),
-            registerService: vi.fn(),
-            registerProvider: vi.fn(),
-            registerCommand: vi.fn(),
-            resolvePath: vi.fn(),
-            on: vi.fn(),
-        } as unknown as OpenClawPluginApi;
-    });
-
-    afterEach(() => {
-        fs.rmSync(tempDir, { recursive: true, force: true });
-    });
-
-    describe('基本结构', () => {
-        it('应包含 "Critical Analysis Engine" 标识', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试上下文',
-                workspaceDir: tempDir,
-            });
-
-            expect(result).toContain('Critical Analysis Engine');
-        });
-
-        it('应包含用户上下文', () => {
-            const result = buildCritiquePromptV2({
-                context: '这是一个关于营销策略的计划',
-                workspaceDir: tempDir,
-            });
-
-            expect(result).toContain('这是一个关于营销策略的计划');
-        });
-    });
-
-    describe('元认知模型说明', () => {
-        it('应说明元认知模型已继承，不应重复列出 T-01 到 T-09', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-            });
-
-            // 应包含继承说明
-            expect(result).toContain('Meta-Cognitive Models');
-            expect(result).toContain('inherited');
-            expect(result).toContain('thinking_os');
-            
-            // 不应重复列出具体的元认知模型
-            expect(result).not.toContain('T-01: Map Before Territory');
-            expect(result).not.toContain('T-02: Constraints as Lighthouses');
-            expect(result).not.toContain('T-09: Divide and Conquer');
-        });
-    });
-
-    describe('模型选择指南', () => {
-        it('应包含 Step 1/2/3 选择指南', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-            });
-
-            expect(result).toContain('Model Selection Guidelines');
-            expect(result).toContain('Step 1');
-            expect(result).toContain('Step 2');
-            expect(result).toContain('Step 3');
-        });
-
-        it('Step 1 应包含任务类型判断指导', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-            });
-
-            expect(result).toContain('general planning');
-            expect(result).toContain('domain-specific');
-        });
-
-        it('Step 3 应包含 Fallback 说明', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-            });
-
-            expect(result).toContain('Fallback');
-            expect(result).toContain('Meta-Cognitive Models');
-        });
-    });
-
-    describe('模型索引注入', () => {
-        it('当有索引文件时，应注入索引内容', () => {
-            const modelsDir = path.join(tempDir, '.principles', 'models');
-            fs.mkdirSync(modelsDir, { recursive: true });
-            
-            const indexContent = `# 扩展思维模型索引
-
-| ID | 名称 | 适用场景 |
-|----|------|----------|
-| MARKETING_4P | 营销4P | 营销策略 |
-`;
-            fs.writeFileSync(path.join(modelsDir, '_INDEX.md'), indexContent);
-
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-            });
-
-            expect(result).toContain('Domain-Specific Models');
-            expect(result).toContain('MARKETING_4P');
-        });
-
-        it('当无索引文件时，应显示默认消息', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-            });
-
-            expect(result).toContain('暂无扩展思维模型');
-        });
-    });
-
-    describe('深度指令', () => {
-        it('depth=1 时应使用轻量分析指令', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-                depth: 1,
-            });
-
-            expect(result).toContain('quick');
-        });
-
-        it('depth=2 时应使用平衡分析指令', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-                depth: 2,
-            });
-
-            expect(result).toContain('balanced');
-        });
-
-        it('depth=3 时应使用详尽分析指令', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-                depth: 3,
-            });
-
-            expect(result).toContain('thorough');
-        });
-
-        it('默认 depth 应为 2', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-                // 不指定 depth
-            });
-
-            expect(result).toContain('balanced');
-        });
-    });
-
-    describe('深度边界值验证', () => {
-        it('depth=0 时应 fallback 到 2 并输出警告', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-                depth: 0,
-                api: mockApi,
-            });
-
-            expect(result).toContain('balanced');
-            expect(mockApi.logger!.warn).toHaveBeenCalledWith(
-                expect.stringContaining('Invalid depth value 0')
-            );
-        });
-
-        it('depth=4 时应 fallback 到 2 并输出警告', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-                depth: 4,
-                api: mockApi,
-            });
-
-            expect(result).toContain('balanced');
-            expect(mockApi.logger!.warn).toHaveBeenCalledWith(
-                expect.stringContaining('Invalid depth value 4')
-            );
-        });
-
-        it('depth=-1 时应 fallback 到 2', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-                depth: -1,
-                api: mockApi,
-            });
-
-            expect(result).toContain('balanced');
-        });
-
-        it('depth=999 时应 fallback 到 2', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-                depth: 999,
-                api: mockApi,
-            });
-
-            expect(result).toContain('balanced');
-        });
-    });
-
-    describe('输出结构', () => {
-        it('应包含要求的输出结构', () => {
-            const result = buildCritiquePromptV2({
-                context: '测试',
-                workspaceDir: tempDir,
-            });
-
-            expect(result).toContain('Blind Spots');
-            expect(result).toContain('Risk Warnings');
-            expect(result).toContain('Alternative Approaches');
-            expect(result).toContain('Recommendations');
-            expect(result).toContain('Confidence Level');
-        });
-    });
-});