principles-disciple 1.8.1 → 1.8.2

package/tests/commands/samples.test.ts

@@ -0,0 +1,65 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { handleSamplesCommand } from '../../src/commands/samples.js';
+import { WorkspaceContext } from '../../src/core/workspace-context.js';
+
+vi.mock('../../src/core/workspace-context.js');
+
+describe('Samples Command', () => {
+  const mockTrajectory = {
+    listCorrectionSamples: vi.fn().mockReturnValue([
+      { sampleId: 'sample-1', sessionId: 's1', reviewStatus: 'pending', qualityScore: 88 },
+    ]),
+    reviewCorrectionSample: vi.fn().mockReturnValue({ sampleId: 'sample-1', reviewStatus: 'approved' }),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(WorkspaceContext.fromHookContext).mockReturnValue({
+      trajectory: mockTrajectory,
+    } as any);
+  });
+
+  it('lists pending samples by default', () => {
+    const result = handleSamplesCommand({
+      args: '',
+      config: { workspaceDir: '/mock/workspace', language: 'en' },
+    } as any);
+
+    expect(mockTrajectory.listCorrectionSamples).toHaveBeenCalledWith('pending');
+    expect(result.text).toContain('sample-1');
+  });
+
+  it('approves a pending sample', () => {
+    const result = handleSamplesCommand({
+      args: 'review approve sample-1 useful-fix',
+      config: { workspaceDir: '/mock/workspace', language: 'en' },
+    } as any);
+
+    expect(mockTrajectory.reviewCorrectionSample).toHaveBeenCalledWith('sample-1', 'approved', 'useful-fix');
+    expect(result.text).toContain('sample-1');
+    expect(result.text).toContain('approved');
+  });
+
+  it('rejects invalid review decisions before writing', () => {
+    const result = handleSamplesCommand({
+      args: 'review maybe sample-1',
+      config: { workspaceDir: '/mock/workspace', language: 'en' },
+    } as any);
+
+    expect(mockTrajectory.reviewCorrectionSample).not.toHaveBeenCalled();
+    expect(result.text).toContain('Invalid review action');
+  });
+
+  it('returns a user-facing error when the sample is missing', () => {
+    mockTrajectory.reviewCorrectionSample.mockImplementation(() => {
+      throw new Error('not found');
+    });
+
+    const result = handleSamplesCommand({
+      args: 'review reject sample-404',
+      config: { workspaceDir: '/mock/workspace', language: 'en' },
+    } as any);
+
+    expect(result.text).toContain('Failed to review sample');
+  });
+});

package/tests/commands/strategy.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { handleInitStrategy, handleManageOkr } from '../../src/commands/strategy';
+
+describe('Slash Commands Hook', () => {
+  it('should handle /init-strategy command', () => {
+    const mockCtx = { 
+        workspaceDir: '/mock/workspace',
+        commandBody: '/init-strategy',
+        channel: 'cli',
+        isAuthorizedSender: true,
+        config: {} as any
+    };
+
+    const result = handleInitStrategy(mockCtx as any);
+
+    expect(result).toBeDefined();
+    expect(result.text).toContain('Strategy Initialization');
+  });
+
+  it('should handle /manage-okr command', () => {
+    const mockCtx = { 
+        workspaceDir: '/mock/workspace',
+        commandBody: '/manage-okr',
+        channel: 'cli',
+        isAuthorizedSender: true,
+        config: {} as any
+    };
+
+    const result = handleManageOkr(mockCtx as any);
+
+    expect(result).toBeDefined();
+    expect(result.text).toContain('OKR Management');
+  });
+});

package/tests/commands/thinking-os.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleThinkingOs } from '../../src/commands/thinking-os';
+import * as fs from 'fs';
+import * as path from 'path';
+
+vi.mock('fs');
+
+describe('Thinking OS Command', () => {
+    // Use path.resolve for cross-platform compatibility
+    const workspaceDir = path.resolve('/mock/workspace');
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it('should return default help text if no subcommand is provided', () => {
+        const result = handleThinkingOs({ config: { workspaceDir }, args: '' } as any);
+        expect(result.text).toContain('Governance Console');
+        expect(result.text).toContain('/thinking-os status');
+    });
+
+    it('should format usage report on status', () => {
+        const usageLogPath = path.join(workspaceDir, '.state', 'thinking_os_usage.json');
+        const thinkingOsPath = path.join(workspaceDir, '.principles', 'THINKING_OS.md');
+
+        vi.mocked(fs.existsSync).mockImplementation((p: fs.PathOrFileDescriptor) => {
+            const pStr = p.toString();
+            return pStr === usageLogPath || pStr === thinkingOsPath;
+        });
+        vi.mocked(fs.readFileSync).mockImplementation((p: fs.PathOrFileDescriptor) => {
+            const pStr = p.toString();
+            if (pStr === usageLogPath) {
+                return JSON.stringify({
+                    '_total_turns': 100,
+                    'T-01': 10,
+                    'T-06': 3
+                });
+            }
+            if (pStr === thinkingOsPath) {
+                return '### T-01: Map Before Territory (地图先于领土)\n### T-06: Occam\'s Razor (奥卡姆剃刀)';
+            }
+            return '';
+        });
+
+        const result = handleThinkingOs({ config: { workspaceDir }, args: 'status' } as any);
+        expect(result.text).toContain('Total turns tracked: **100**');
+        expect(result.text).toContain('T-01 | Map Before Territory (地图先于领土) | 10 | ✅ 10.0%');
+    });
+
+    it('should handle propose subcommand', () => {
+        const result = handleThinkingOs({ config: { workspaceDir }, args: 'propose newly proposed test model with a signal section' } as any);
+
+        expect(fs.appendFileSync).toHaveBeenCalled();
+        // Check that the result mentions the file (cross-platform)
+        expect(result.text).toContain('THINKING_OS_CANDIDATES.md');
+    });
+
+    it('should return validation error if propose is empty', () => {
+        const result = handleThinkingOs({ config: { workspaceDir }, args: 'propose   ' } as any);
+        expect(result.text).toContain('Usage: `/thinking-os propose');
+        expect(fs.appendFileSync).not.toHaveBeenCalled();
+    });
+
+    it('should run audit and warn about overused models', () => {
+        const usageLogPath = path.join(workspaceDir, '.state', 'thinking_os_usage.json');
+        const thinkingOsPath = path.join(workspaceDir, '.principles', 'THINKING_OS.md');
+
+        vi.mocked(fs.existsSync).mockImplementation(() => true);
+
+        vi.mocked(fs.readFileSync).mockImplementation((p: fs.PathOrFileDescriptor) => {
+            const pStr = p.toString();
+            if (pStr === usageLogPath) {
+                return JSON.stringify({
+                    '_total_turns': 10,
+                    'T-01': 8 // 80% usage
+                });
+            }
+            if (pStr === thinkingOsPath) {
+                return '### T-01: Map\n### T-02: Constraints';
+            }
+            return '';
+        });
+
+        const result = handleThinkingOs({ config: { workspaceDir }, args: 'audit' } as any);
+        expect(result.text).toContain('Active models**: 2');
+        expect(result.text).toContain('possibly too broad a pattern');
+    });
+});

package/tests/core/adaptive-thresholds.test.ts

@@ -0,0 +1,261 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  loadThresholdState,
+  updateThresholdState,
+  resetThresholdState,
+  getEffectiveThresholds,
+  getDetailedThresholdState,
+  DEFAULT_THRESHOLDS,
+  MAX_ADJUSTMENT_PER_STEP,
+  THRESHOLD_STATE_FILE,
+} from '../../src/core/adaptive-thresholds.js';
+
+// ---------------------------------------------------------------------------
+// Test Helpers
+// ---------------------------------------------------------------------------
+
+function createTempStateDir(): string {
+  const tmpDir = path.join(__dirname, '..', '..', '.tmp', `threshold-test-${Date.now()}`);
+  fs.mkdirSync(tmpDir, { recursive: true });
+  return tmpDir;
+}
+
+function cleanupStateDir(stateDir: string): void {
+  if (fs.existsSync(stateDir)) {
+    fs.rmSync(stateDir, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tests: loadThresholdState
+// ---------------------------------------------------------------------------
+
+describe('loadThresholdState', () => {
+  let stateDir: string;
+
+  beforeEach(() => {
+    stateDir = createTempStateDir();
+  });
+
+  afterEach(() => {
+    cleanupStateDir(stateDir);
+  });
+
+  it('returns default thresholds when no state file exists', () => {
+    const result = loadThresholdState(stateDir);
+    expect(result.success).toBe(true);
+    expect(result.usedDefaults).toBe(true);
+    expect(result.thresholds).toEqual(DEFAULT_THRESHOLDS);
+  });
+
+  it('loads persisted thresholds', () => {
+    // Step constraint limits adjustment to MAX_ADJUSTMENT_PER_STEP per call
+    // schemaCompletenessMin: 0.6 + 0.05 = 0.65 (one step)
+    updateThresholdState(stateDir, 'schemaCompletenessMin', 0.65, 'test adjustment');
+
+    // Then load it back
+    const result = loadThresholdState(stateDir);
+    expect(result.success).toBe(true);
+    expect(result.usedDefaults).toBe(false);
+    expect(result.thresholds.schemaCompletenessMin).toBe(0.65);
+  });
+
+  it('clamps values to bounds', () => {
+    // Try to set above maximum
+    updateThresholdState(stateDir, 'principleAlignmentMin', 1.5, 'test');
+    const result = loadThresholdState(stateDir);
+    expect(result.thresholds.principleAlignmentMin).toBeLessThanOrEqual(1.0);
+  });
+
+  it('returns defaults on corrupted state', () => {
+    // Write corrupted JSON
+    const statePath = path.join(stateDir, THRESHOLD_STATE_FILE);
+    fs.writeFileSync(statePath, 'not valid json{', 'utf-8');
+
+    const result = loadThresholdState(stateDir);
+    expect(result.success).toBe(true);
+    expect(result.usedDefaults).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: updateThresholdState
+// ---------------------------------------------------------------------------
+
+describe('updateThresholdState', () => {
+  let stateDir: string;
+
+  beforeEach(() => {
+    stateDir = createTempStateDir();
+  });
+
+  afterEach(() => {
+    cleanupStateDir(stateDir);
+  });
+
+  it('updates a threshold value', () => {
+    // Step constraint limits adjustment per call
+    // schemaCompletenessMin: 0.6 + 0.05 (max step) = 0.65
+    const result = updateThresholdState(stateDir, 'schemaCompletenessMin', 0.65, 'test adjustment');
+    expect(result.success).toBe(true);
+    expect(result.changed).toBe(true);
+    expect(result.oldValue).toBe(DEFAULT_THRESHOLDS.schemaCompletenessMin);
+    expect(result.newValue).toBe(0.65);
+    expect(result.reason).toBe('test adjustment');
+  });
+
+  it('enforces max adjustment per step', () => {
+    const largeDelta = DEFAULT_THRESHOLDS.schemaCompletenessMin + MAX_ADJUSTMENT_PER_STEP + 0.1;
+    const result = updateThresholdState(stateDir, 'schemaCompletenessMin', largeDelta, 'large step');
+    expect(result.success).toBe(true);
+    expect(result.changed).toBe(true);
+    // Should only move by MAX_ADJUSTMENT_PER_STEP
+    expect(result.newValue).toBe(DEFAULT_THRESHOLDS.schemaCompletenessMin + MAX_ADJUSTMENT_PER_STEP);
+  });
+
+  it('ignores changes smaller than minimum', () => {
+    const smallChange = DEFAULT_THRESHOLDS.schemaCompletenessMin + 0.001;
+    const result = updateThresholdState(stateDir, 'schemaCompletenessMin', smallChange, 'tiny step');
+    expect(result.success).toBe(true);
+    expect(result.changed).toBe(false);
+  });
+
+  it('rejects unknown threshold names', () => {
+    const result = updateThresholdState(stateDir, 'unknownThreshold' as any, 0.5, 'test');
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Unknown threshold');
+  });
+
+  it('persists changes to disk', () => {
+    // Step constraint limits adjustment to MAX_ADJUSTMENT_PER_STEP per call
+    // executabilityMin: 0.65 + 0.05 (max step) = 0.70
+    updateThresholdState(stateDir, 'executabilityMin', 0.70, 'persistence test');
+    const loaded = loadThresholdState(stateDir);
+    expect(loaded.thresholds.executabilityMin).toBe(0.70);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: resetThresholdState
+// ---------------------------------------------------------------------------
+
+describe('resetThresholdState', () => {
+  let stateDir: string;
+
+  beforeEach(() => {
+    stateDir = createTempStateDir();
+  });
+
+  afterEach(() => {
+    cleanupStateDir(stateDir);
+  });
+
+  it('resets all thresholds to defaults', () => {
+    // Change some values
+    updateThresholdState(stateDir, 'schemaCompletenessMin', 0.9, 'change 1');
+    updateThresholdState(stateDir, 'principleAlignmentMin', 0.95, 'change 2');
+
+    // Reset
+    resetThresholdState(stateDir);
+
+    // Verify defaults
+    const result = loadThresholdState(stateDir);
+    expect(result.thresholds).toEqual(DEFAULT_THRESHOLDS);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: getEffectiveThresholds
+// ---------------------------------------------------------------------------
+
+describe('getEffectiveThresholds', () => {
+  let stateDir: string;
+
+  beforeEach(() => {
+    stateDir = createTempStateDir();
+  });
+
+  afterEach(() => {
+    cleanupStateDir(stateDir);
+  });
+
+  it('returns default thresholds when no state file exists', () => {
+    const thresholds = getEffectiveThresholds(stateDir);
+    expect(thresholds).toEqual(DEFAULT_THRESHOLDS);
+  });
+
+  it('returns persisted thresholds', () => {
+    // Note: step constraint limits adjustment per call
+    // Set to a value within one step: default (0.5) + MAX_ADJUSTMENT_PER_STEP (0.05) = 0.55
+    updateThresholdState(stateDir, 'boundednessMin', 0.55, 'test');
+    const thresholds = getEffectiveThresholds(stateDir);
+    expect(thresholds.boundednessMin).toBe(0.55);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: getDetailedThresholdState
+// ---------------------------------------------------------------------------
+
+describe('getDetailedThresholdState', () => {
+  let stateDir: string;
+
+  beforeEach(() => {
+    stateDir = createTempStateDir();
+  });
+
+  afterEach(() => {
+    cleanupStateDir(stateDir);
+  });
+
+  it('returns null when no state file exists', () => {
+    const state = getDetailedThresholdState(stateDir);
+    expect(state).toBeNull();
+  });
+
+  it('returns detailed state with metadata', () => {
+    updateThresholdState(stateDir, 'confidenceMin', 0.75, 'test adjustment');
+    const state = getDetailedThresholdState(stateDir);
+    expect(state).not.toBeNull();
+    expect(state!.thresholds.confidenceMin).toBeDefined();
+    expect(state!.thresholds.confidenceMin!.lastUpdatedAt).toBeDefined();
+    expect(state!.thresholds.confidenceMin!.adjustmentCount).toBe(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: Default values integrity
+// ---------------------------------------------------------------------------
+
+describe('DEFAULT_THRESHOLDS', () => {
+  it('has values in valid range (0-1)', () => {
+    for (const value of Object.values(DEFAULT_THRESHOLDS)) {
+      expect(value).toBeGreaterThanOrEqual(0);
+      expect(value).toBeLessThanOrEqual(1);
+    }
+  });
+
+  it('has aggregateMin higher than minimum possible weighted aggregate', () => {
+    // aggregateMin (0.65) should be higher than the minimum possible
+    // aggregate score given all thresholds at minimum values.
+    // This ensures aggregateMin provides an additional quality gate.
+    const weights = {
+      schemaCompletenessMin: 0.15,
+      principleAlignmentMin: 0.30,
+      executabilityMin: 0.20,
+      boundednessMin: 0.20,
+      confidenceMin: 0.15,
+    };
+    const minPossibleAggregate =
+      DEFAULT_THRESHOLDS.schemaCompletenessMin * weights.schemaCompletenessMin +
+      DEFAULT_THRESHOLDS.principleAlignmentMin * weights.principleAlignmentMin +
+      DEFAULT_THRESHOLDS.executabilityMin * weights.executabilityMin +
+      DEFAULT_THRESHOLDS.boundednessMin * weights.boundednessMin +
+      DEFAULT_THRESHOLDS.confidenceMin * weights.confidenceMin;
+    
+    // aggregateMin should be at or above the minimum possible aggregate
+    expect(DEFAULT_THRESHOLDS.aggregateMin).toBeGreaterThanOrEqual(minPossibleAggregate);
+  });
+});

package/tests/core/config-service.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ConfigService } from '../../src/core/config-service.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+vi.mock('fs');
+
+describe('ConfigService', () => {
+    const stateDir = '/mock/state';
+    const configPath = path.join(stateDir, 'pain_settings.json');
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        ConfigService.reset();
+    });
+
+    it('should create and return a PainConfig instance', () => {
+        const mockConfig = {
+            thresholds: { pain_trigger: 50 }
+        };
+
+        vi.mocked(fs.existsSync).mockImplementation((p) => p.toString() === configPath);
+        vi.mocked(fs.readFileSync).mockImplementation((p) => {
+            if (p.toString() === configPath) return JSON.stringify(mockConfig);
+            return '';
+        });
+
+        const config = ConfigService.get(stateDir);
+        expect(config).toBeDefined();
+        expect(config.get('thresholds.pain_trigger')).toBe(50);
+    });
+
+    it('should return the same instance for the same stateDir', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+
+        const config1 = ConfigService.get(stateDir);
+        const config2 = ConfigService.get(stateDir);
+
+        expect(config1).toBe(config2);
+    });
+
+    it('should create a new instance when stateDir changes', () => {
+        const stateDir1 = '/mock/state1';
+        const stateDir2 = '/mock/state2';
+        const configPath1 = path.join(stateDir1, 'pain_settings.json');
+        const configPath2 = path.join(stateDir2, 'pain_settings.json');
+
+        vi.mocked(fs.existsSync).mockImplementation((p) => 
+            p.toString() === configPath1 || p.toString() === configPath2
+        );
+        vi.mocked(fs.readFileSync).mockImplementation((p) => {
+            if (p.toString() === configPath1) return JSON.stringify({ thresholds: { pain_trigger: 10 } });
+            if (p.toString() === configPath2) return JSON.stringify({ thresholds: { pain_trigger: 20 } });
+            return '';
+        });
+
+        const config1 = ConfigService.get(stateDir1);
+        expect(config1.get('thresholds.pain_trigger')).toBe(10);
+
+        const config2 = ConfigService.get(stateDir2);
+        expect(config2.get('thresholds.pain_trigger')).toBe(20);
+
+        expect(config1).not.toBe(config2);
+    });
+
+    it('should reset the singleton instance', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+
+        const config1 = ConfigService.get(stateDir);
+        ConfigService.reset();
+        const config2 = ConfigService.get(stateDir);
+
+        expect(config1).not.toBe(config2);
+    });
+
+    it('should reload config when instance is recreated after reset', () => {
+        vi.mocked(fs.existsSync).mockImplementation((p) => p.toString() === configPath);
+        vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ thresholds: { pain_trigger: 99 } }));
+
+        const config1 = ConfigService.get(stateDir);
+        expect(config1.get('thresholds.pain_trigger')).toBe(99);
+
+        ConfigService.reset();
+
+        vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ thresholds: { pain_trigger: 88 } }));
+        const config2 = ConfigService.get(stateDir);
+        expect(config2.get('thresholds.pain_trigger')).toBe(88);
+    });
+});

package/tests/core/config.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { PainConfig } from '../../src/core/config.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+vi.mock('fs');
+
+describe('PainConfig', () => {
+    const stateDir = '/mock/state';
+    const configPath = path.join(stateDir, 'pain_settings.json');
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it('should load config from file if it exists', () => {
+        const mockConfig = {
+            thresholds: {
+                pain_trigger: 40,
+                cognitive_paralysis_input: 5000
+            },
+            scores: {
+                paralysis: 50
+            }
+        };
+
+        vi.mocked(fs.existsSync).mockImplementation((p) => p.toString() === configPath);
+        vi.mocked(fs.readFileSync).mockImplementation((p) => {
+            if (p.toString() === configPath) return JSON.stringify(mockConfig);
+            return '';
+        });
+
+        const config = new PainConfig(stateDir);
+        config.load();
+
+        expect(config.get('thresholds.pain_trigger')).toBe(40);
+        expect(config.get('thresholds.cognitive_paralysis_input')).toBe(5000);
+        expect(config.get('scores.paralysis')).toBe(50);
+    });
+
+    it('should return default values if file does not exist', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+
+        const config = new PainConfig(stateDir);
+        config.load();
+
+        // Check some defaults
+        expect(config.get('thresholds.pain_trigger')).toBe(40);
+        expect(config.get('scores.paralysis')).toBe(30);
+    });
+
+    it('should return nested values using dot notation', () => {
+        const config = new PainConfig(stateDir);
+        // Using defaults
+        config.load();
+        expect(config.get('intervals.worker_poll_ms')).toBe(15 * 60 * 1000);
+    });
+
+    it('should skip undefined values during merge', () => {
+        const mockConfig = {
+            thresholds: {
+                pain_trigger: undefined // Should NOT overwrite default
+            }
+        };
+
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
+
+        const config = new PainConfig(stateDir);
+        config.load();
+
+        expect(config.get('thresholds.pain_trigger')).toBe(40); // Default remains
+    });
+
+    it('should validate and correct out-of-range values', () => {
+        const mockConfig = {
+            intervals: {
+                worker_poll_ms: 500 // Too fast, should be corrected
+            }
+        };
+
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
+
+        const config = new PainConfig(stateDir);
+        config.load();
+
+        expect(config.get('intervals.worker_poll_ms')).toBe(15 * 60 * 1000); // Reset to default
+    });
+});