principles-disciple 1.127.0 → 1.129.0

package/tests/core/pain-diagnostic-gate.test.ts

@@ -1,614 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import { evaluatePainDiagnosticGate, resetPainDiagnosticGateForTest, isCooldownActiveForEpisode } from '../../src/core/pain-diagnostic-gate.js';
-
-describe('PainDiagnosticGate', () => {
-  beforeEach(() => {
-    resetPainDiagnosticGateForTest();
-  });
-
-  it('lets manual pain bypass automatic thresholds', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'manual',
-      score: 1,
-      currentGfi: 0,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'manual',
-    });
-  });
-
-  it('does not diagnose ordinary low-signal tool failures', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: 15,
-      consecutiveErrors: 1,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: false,
-      reason: 'below_gate',
-    });
-  });
-
-  it('diagnoses repeated same failures', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: 50,
-      consecutiveErrors: 4,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'repeated_failure',
-    });
-  });
-
-  it('diagnoses high GFI episodes', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: 72,
-      consecutiveErrors: 2,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'high_gfi',
-    });
-  });
-
-  it('requires stronger score for generic semantic pain', () => {
-    const low = evaluatePainDiagnosticGate({
-      source: 'semantic',
-      score: 45,
-      currentGfi: 0,
-      sessionId: 's1',
-    });
-    const high = evaluatePainDiagnosticGate({
-      source: 'semantic',
-      score: 60,
-      currentGfi: 0,
-      sessionId: 's2',
-    });
-
-    expect(low.shouldDiagnose).toBe(false);
-    expect(high).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'semantic_pain',
-    });
-  });
-
-  it('deduplicates repeated diagnosis within cooldown', () => {
-    const input = {
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: 72,
-      sessionId: 's1',
-      errorHash: 'same',
-      nowMs: 1_000,
-    };
-
-    expect(evaluatePainDiagnosticGate(input).shouldDiagnose).toBe(true);
-    expect(evaluatePainDiagnosticGate({ ...input, nowMs: 2_000 })).toMatchObject({
-      shouldDiagnose: false,
-      reason: 'cooldown',
-    });
-  });
-
-  it('diagnoses subagent_error when score >= painTrigger', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'subagent_error',
-      score: 40,
-      currentGfi: 0,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'subagent_error',
-    });
-  });
-
-  it('skips subagent_error when score < painTrigger', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'subagent_error',
-      score: 39,
-      currentGfi: 0,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: false,
-      reason: 'below_gate',
-    });
-  });
-
-  it('diagnoses llm_paralysis when score >= painTrigger', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'llm_paralysis',
-      score: 40,
-      currentGfi: 0,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'llm_paralysis',
-    });
-  });
-
-  it('diagnoses risky_high_score when isRisky=true and score >= highSeverity', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: 70,
-      currentGfi: 0,
-      isRisky: true,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'risky_high_score',
-    });
-  });
-
-  it('skips risky_high_score when isRisky=true but score < highSeverity', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: 69,
-      currentGfi: 0,
-      isRisky: true,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: false,
-      reason: 'below_gate',
-    });
-  });
-
-  it('diagnoses user_empathy when score >= semanticPain threshold', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'user_empathy',
-      score: 60,
-      currentGfi: 0,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'semantic_pain',
-    });
-  });
-
-  it('uses custom threshold overrides', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: 60,
-      consecutiveErrors: 2,
-      sessionId: 's1',
-      thresholds: {
-        painTrigger: 40,
-        highSeverity: 70,
-        highGfi: 55,
-        repeatedFailure: 4,
-        semanticPain: 60,
-      },
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'high_gfi',
-    });
-  });
-
-  it('handles exact threshold boundary (score === painTrigger)', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'subagent_error',
-      score: 40,
-      currentGfi: 0,
-      sessionId: 's1',
-      thresholds: { painTrigger: 40 },
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'subagent_error',
-    });
-  });
-
-  it('normalizes llm_ prefixed sources (non-paralysis) to semantic', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'llm_confusion',
-      score: 60,
-      currentGfi: 0,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'semantic_pain',
-    });
-  });
-
-  it('llm_paralysis is NOT normalized to semantic', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'llm_paralysis',
-      score: 40,
-      currentGfi: 0,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'llm_paralysis',
-    });
-  });
-
-  it('skips llm_paralysis when score < painTrigger', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'llm_paralysis',
-      score: 39,
-      currentGfi: 0,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: false,
-      reason: 'below_gate',
-    });
-  });
-
-  it('diagnoses llm_paralysis with score 45 (new config default, PRI-274)', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'llm_paralysis',
-      score: 45,
-      currentGfi: 0,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'llm_paralysis',
-    });
-  });
-
-  it('cooldownMs=0 disables cooldown (allows re-diagnosis)', () => {
-    const input = {
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: 72,
-      sessionId: 's1',
-      errorHash: 'same',
-      nowMs: 1_000,
-      cooldownMs: 0,
-    };
-
-    expect(evaluatePainDiagnosticGate(input).shouldDiagnose).toBe(true);
-    expect(evaluatePainDiagnosticGate({ ...input, nowMs: 2_000 }).shouldDiagnose).toBe(true);
-  });
-
-  it('treats NaN score as 0 (below gate)', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: NaN,
-      currentGfi: 72,
-      consecutiveErrors: 4,
-      sessionId: 's1',
-    });
-
-    expect(decision.shouldDiagnose).toBe(true);
-    expect(decision.reason).toBe('repeated_failure');
-  });
-
-  it('treats NaN currentGfi as 0', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: NaN,
-      consecutiveErrors: 1,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: false,
-      reason: 'below_gate',
-    });
-  });
-
-  it('treats Infinity score as finite for gate evaluation', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: Infinity,
-      currentGfi: 0,
-      isRisky: true,
-      sessionId: 's1',
-    });
-
-    expect(decision.shouldDiagnose).toBe(false);
-  });
-
-  it('treats NaN consecutiveErrors as 0', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: 50,
-      consecutiveErrors: NaN,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: false,
-      reason: 'below_gate',
-    });
-  });
-
-  it('episodeKey includes sessionId, source, and errorHash', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'manual',
-      score: 1,
-      currentGfi: 0,
-      sessionId: 's-ep',
-      errorHash: 'hash-abc',
-    });
-
-    expect(decision.episodeKey).toContain('s-ep');
-    expect(decision.episodeKey).toContain('manual');
-    expect(decision.episodeKey).toContain('hash-abc');
-  });
-
-  it('episodeKey uses "unknown" when sessionId missing', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'manual',
-      score: 1,
-      currentGfi: 0,
-    });
-
-    expect(decision.episodeKey).toContain('unknown');
-  });
-
-  it('episodeKey uses "no-hash" when errorHash missing', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'manual',
-      score: 1,
-      currentGfi: 0,
-      sessionId: 's1',
-    });
-
-    expect(decision.episodeKey).toContain('no-hash');
-  });
-
-  it('manual pain is still subject to cooldown', () => {
-    const input = {
-      source: 'manual',
-      score: 100,
-      currentGfi: 0,
-      sessionId: 's1',
-      nowMs: 1_000,
-    };
-
-    const first = evaluatePainDiagnosticGate(input);
-    expect(first.shouldDiagnose).toBe(true);
-
-    const second = evaluatePainDiagnosticGate({ ...input, nowMs: 2_000 });
-    expect(second).toMatchObject({
-      shouldDiagnose: false,
-      reason: 'cooldown',
-    });
-  });
-
-  it('different errorHash produces different episodeKey (no cooldown cross-contamination)', () => {
-    const base = {
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: 72,
-      sessionId: 's1',
-      nowMs: 1_000,
-    };
-
-    expect(evaluatePainDiagnosticGate({ ...base, errorHash: 'hash-a' }).shouldDiagnose).toBe(true);
-    expect(evaluatePainDiagnosticGate({ ...base, errorHash: 'hash-b', nowMs: 2_000 }).shouldDiagnose).toBe(true);
-  });
-
-  it('highGfi defaults to max(highSeverity, painTrigger+30)', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: 72,
-      consecutiveErrors: 1,
-      sessionId: 's1',
-      thresholds: {
-        painTrigger: 40,
-        highSeverity: 70,
-      },
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'high_gfi',
-    });
-  });
-
-  it('gate_block source falls through to below_gate when score below painTrigger', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'gate_blocked',
-      score: 10,
-      currentGfi: 5,
-      consecutiveErrors: 0,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: false,
-      reason: 'below_gate',
-    });
-  });
-
-  it('diagnoses gate_blocked when score >= painTrigger (PRI-274)', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'gate_blocked',
-      score: 45,
-      currentGfi: 0,
-      consecutiveErrors: 0,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: true,
-      reason: 'gate_blocked',
-    });
-  });
-
-  it('skips gate_blocked when score < painTrigger', () => {
-    const decision = evaluatePainDiagnosticGate({
-      source: 'gate_blocked',
-      score: 39,
-      currentGfi: 0,
-      consecutiveErrors: 0,
-      sessionId: 's1',
-    });
-
-    expect(decision).toMatchObject({
-      shouldDiagnose: false,
-      reason: 'below_gate',
-    });
-  });
-
-  it('returns detail string in every decision', () => {
-    const cases = [
-      { source: 'manual' as const, score: 1, currentGfi: 0 },
-      { source: 'tool_failure' as const, score: 10, currentGfi: 5, consecutiveErrors: 0 },
-    ];
-
-    for (const input of cases) {
-      const decision = evaluatePainDiagnosticGate({ ...input, sessionId: 's1' });
-      expect(typeof decision.detail).toBe('string');
-      expect(decision.detail.length).toBeGreaterThan(0);
-    }
-  });
-});
-
-// ── isCooldownActiveForEpisode ─────────────────────────────────────────────────
-
-describe('isCooldownActiveForEpisode', () => {
-  beforeEach(() => {
-    resetPainDiagnosticGateForTest();
-  });
-
-  it('returns false when no diagnosis has been recorded', () => {
-    const result = isCooldownActiveForEpisode('tool_failure', 's1', 'hash-abc');
-    expect(result).toBe(false);
-  });
-
-  it('returns false when cooldownMs is 0 (disabled)', () => {
-    // Record diagnosis
-    evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: 72,
-      sessionId: 's1',
-      errorHash: 'hash-abc',
-      nowMs: 1_000,
-    });
-
-    // With cooldown disabled, should always return false
-    const noCooldown = isCooldownActiveForEpisode('tool_failure', 's1', 'hash-abc', 0);
-    expect(noCooldown).toBe(false);
-  });
-
-  it('different sessionId does not share cooldown', () => {
-    // Record diagnosis for session s1
-    evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: 72,
-      sessionId: 's1',
-      errorHash: 'hash-abc',
-      nowMs: 1_000,
-    });
-
-    // Check for different session s2 - should not be in cooldown
-    const differentSession = isCooldownActiveForEpisode('tool_failure', 's2', 'hash-abc');
-    expect(differentSession).toBe(false);
-  });
-
-  it('different errorHash does not share cooldown', () => {
-    // Record diagnosis for hash-abc
-    evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: 72,
-      sessionId: 's1',
-      errorHash: 'hash-abc',
-      nowMs: 1_000,
-    });
-
-    // Check for different hash - should not be in cooldown
-    const differentHash = isCooldownActiveForEpisode('tool_failure', 's1', 'hash-xyz');
-    expect(differentHash).toBe(false);
-  });
-
-  it('different source does not share cooldown', () => {
-    // Record diagnosis for tool_failure
-    evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: 72,
-      sessionId: 's1',
-      errorHash: 'hash-abc',
-      nowMs: 1_000,
-    });
-
-    // Check for different source dispatch_error - should not be in cooldown
-    const differentSource = isCooldownActiveForEpisode('dispatch_error', 's1', 'hash-abc');
-    expect(differentSource).toBe(false);
-  });
-
-  it('undefined sessionId uses unknown as session identifier', () => {
-    // Record diagnosis with undefined sessionId
-    evaluatePainDiagnosticGate({
-      source: 'tool_failure',
-      score: 50,
-      currentGfi: 72,
-      errorHash: 'hash-abc',
-      nowMs: 1_000,
-    });
-
-    // Check cooldown with undefined sessionId - should not be in cooldown
-    // because evaluate used Date.now() but isCooldownActiveForEpisode uses current Date.now()
-    // and 15 seconds haven't passed
-    const undefinedSession = isCooldownActiveForEpisode('tool_failure', undefined, 'hash-abc');
-    // The episodeKey built from undefined sessionId uses 'unknown'
-    // But we can't reliably test time-based behavior without mocking Date.now()
-    // So we just verify it doesn't throw
-    expect(typeof undefinedSession).toBe('boolean');
-  });
-
-  it('episodeKey alignment: same inputs produce same cooldown state', () => {
-    // Use exact same inputs that would create an episodeKey
-    const episodeInput = {
-      source: 'manual' as const,
-      score: 100,
-      currentGfi: 0,
-      sessionId: 's-ep-test',
-      errorHash: 'hash-ep',
-      nowMs: 5_000,
-    };
-
-    // First diagnosis
-    evaluatePainDiagnosticGate(episodeInput);
-
-    // isCooldownActiveForEpisode should not throw with same inputs
-    const inCooldown = isCooldownActiveForEpisode('manual', 's-ep-test', 'hash-ep');
-    expect(typeof inCooldown).toBe('boolean');
-  });
-});

package/tests/core/pain-score.property.test.ts

@@ -1,19 +0,0 @@
-/**
- * Property-based tests for Pain Score computation
- * 
- * These tests verify INVARIANTS - mathematical properties that MUST hold
- * for ALL possible inputs, not just a few hand-picked examples.
- * 
- * Using fast-check for property-based testing.
- */
-
-// TODO: fast-check package not installed. Skip these tests for now.
-import { describe } from 'vitest';
-
-describe.skip('Property: Pain Score Range Invariant', () => {
-  // Skipped - fast-check package not installed
-  // Original tests:
-  // - INVARIANT: Score MUST be in [0, 100] for ALL inputs
-  // - INVARIANT: Score consistency with exit code
-  // - INVARIANT: Soft score bounds
-});