principles-disciple 1.92.0 → 1.94.0

package/tests/hooks/pain.test.ts

@@ -8,9 +8,14 @@ import { WorkspaceContext } from '../../src/core/workspace-context.js';
 import { EventLogService } from '../../src/core/event-log.js';
 import { setInjectedProbationIds, clearSession } from '../../src/core/session-tracker.js';
 import { resetPainDiagnosticGateForTest } from '../../src/core/pain-diagnostic-gate.js';
+import { loadFeatureFlagFromConfig } from '../../src/core/pd-config-loader.js';
 
 vi.mock('fs');
 vi.mock('../../src/utils/io.js');
+vi.mock('../../src/core/pd-config-loader.js', () => ({
+  loadPdConfigForPlugin: vi.fn(() => ({ ok: true, source: 'mock', effective: {}, errors: [] })),
+  loadFeatureFlagFromConfig: vi.fn(() => ({ enabled: false, source: 'mock' })),
+}));
 vi.mock('../../src/core/evolution-engine.js', () => ({
   recordEvolutionSuccess: vi.fn(),
   recordEvolutionFailure: vi.fn(),
@@ -480,4 +485,287 @@ describe('Post-Write Checks & Pain Hook', () => {
     }));
   });
 
+  it('PEAT-B1: triage evidence_only returns early before PainDiagnosticGate (no cooldown pollution)', () => {
+    // Enable the evidence triage feature flag
+    vi.mocked(loadFeatureFlagFromConfig).mockReturnValue({ enabled: true, source: 'test' });
+
+    const mockCtx = { workspaceDir, sessionId: 's-triage-evidence', api: { logger: {} } };
+    const mockEvent = {
+      toolName: 'write',
+      params: { file_path: 'src/main.ts' },
+      error: 'Permission denied',
+      result: { exitCode: 1 },
+    };
+
+    vi.mocked(ioUtils.normalizePath).mockReturnValue('src/main.ts');
+    vi.mocked(ioUtils.isRisky).mockReturnValue(false);
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    // Core assertion: pain_detected event is NOT emitted — gate was not reached
+    expect(mockEmitSync).not.toHaveBeenCalled();
+    // Core assertion: recordPainSignal is NOT called — triage prevented gate evaluation
+    expect(mockEventLog.recordPainSignal).not.toHaveBeenCalled();
+    // Core assertion: trajectory pain event is NOT recorded — cooldown not polluted
+    expect(mockWctx.trajectory.recordPainEvent).not.toHaveBeenCalled();
+    // But tool call IS still tracked (friction tracking, not diagnosis)
+    expect(mockWctx.trajectory.recordToolCall).toHaveBeenCalledWith(expect.objectContaining({
+      sessionId: 's-triage-evidence',
+      toolName: 'write',
+      outcome: 'failure',
+    }));
+  });
+
+  it('PEAT-B1: triage admit proceeds to PainDiagnosticGate and cooldown', () => {
+    // For owner_reported source kinds, triage admits, so gate IS reached
+    vi.mocked(loadFeatureFlagFromConfig).mockReturnValue({ enabled: true, source: 'test' });
+
+    const mockCtx = { workspaceDir, sessionId: 's-triage-admit', api: { logger: {} } };
+    // Manual pain command — triggers the manual pain path
+    const mockEvent = {
+      toolName: 'pain',
+      params: { input: 'test pain' },
+      result: { exitCode: 0 },
+      error: undefined,
+    };
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    // Core assertion: pain_detected event IS emitted — gate WAS reached
+    expect(mockEmitSync).toHaveBeenCalledWith(expect.objectContaining({
+      type: 'pain_detected',
+    }));
+    // Core assertion: recordPainSignal IS called
+    expect(mockEventLog.recordPainSignal).toHaveBeenCalledWith(
+      's-triage-admit',
+      expect.objectContaining({ score: 100, source: 'manual' }),
+    );
+  });
+
+});
+
+// ── PRI-326: Decomposed Pipeline Tests ────────────────────────────────────────
+
+import {
+  classifyToolCallOutcome,
+  buildToolCallObservation,
+  handleProbationFeedback,
+  evaluatePainAdmissionForToolCall,
+} from '../../src/hooks/after-tool-call-helpers.js';
+import type { ToolCallOutcome, ToolCallObservation } from '../../src/hooks/after-tool-call-types.js';
+
+describe('PRI-326: classifyToolCallOutcome', () => {
+  it('returns success for exitCode 0 with no error', () => {
+    const result = classifyToolCallOutcome({
+      toolName: 'read',
+      params: {},
+      result: { exitCode: 0 },
+      error: undefined,
+    } as any);
+    expect(result.isFailure).toBe(false);
+    expect(result.exitCode).toBe(0);
+    expect(result.failureSource).toBeUndefined();
+  });
+
+  it('detects failure from top-level exitCode', () => {
+    const result = classifyToolCallOutcome({
+      toolName: 'bash',
+      params: {},
+      result: { exitCode: 1 },
+      error: undefined,
+    } as any);
+    expect(result.isFailure).toBe(true);
+    expect(result.exitCode).toBe(1);
+    expect(result.failureSource).toBe('tool_failure');
+  });
+
+  it('falls back to nested details.exitCode', () => {
+    const result = classifyToolCallOutcome({
+      toolName: 'bash',
+      params: {},
+      result: { details: { exitCode: 2 } },
+      error: undefined,
+    } as any);
+    expect(result.isFailure).toBe(true);
+    expect(result.exitCode).toBe(2);
+  });
+
+  it('prefers top-level exitCode over nested', () => {
+    const result = classifyToolCallOutcome({
+      toolName: 'bash',
+      params: {},
+      result: { exitCode: 0, details: { exitCode: 1 } },
+      error: undefined,
+    } as any);
+    expect(result.isFailure).toBe(false);
+    expect(result.exitCode).toBe(0);
+  });
+
+  it('detects failure from error field even with exitCode 0', () => {
+    const result = classifyToolCallOutcome({
+      toolName: 'write',
+      params: {},
+      result: { exitCode: 0 },
+      error: 'Permission denied',
+    } as any);
+    expect(result.isFailure).toBe(true);
+    expect(result.failureSource).toBe('tool_failure');
+  });
+
+  it('classifies dispatch_error for tool not found', () => {
+    const result = classifyToolCallOutcome({
+      toolName: 'read',
+      params: {},
+      result: { exitCode: 1 },
+      error: 'tool read_file not found',
+    } as any);
+    expect(result.isFailure).toBe(true);
+    expect(result.failureSource).toBe('dispatch_error');
+  });
+
+  it('treats non-numeric exitCode as 0', () => {
+    const result = classifyToolCallOutcome({
+      toolName: 'bash',
+      params: {},
+      result: { exitCode: '0' as any },
+      error: undefined,
+    } as any);
+    expect(result.isFailure).toBe(false);
+  });
+});
+
+describe('PRI-326: evaluatePainAdmissionForToolCall', () => {
+  const workspaceDir = '/mock/workspace';
+  const mockConfig = { get: vi.fn().mockReturnValue(undefined) };
+  const baseOutcome: ToolCallOutcome = { isFailure: true, exitCode: 1, failureSource: 'tool_failure' };
+  const baseObservation: ToolCallObservation = {
+    params: { filePath: 'src/main.ts' },
+    relPath: 'src/main.ts',
+    isRisk: false,
+    errorType: 'Other',
+    errorHash: 'abc123',
+    errorText: 'Permission denied',
+    painScore: 10,
+    traceId: 'trace-123',
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetPainDiagnosticGateForTest();
+    vi.mocked(loadFeatureFlagFromConfig).mockReturnValue({ enabled: false, source: 'test' });
+  });
+
+  it('returns not_applicable for non-write tool', () => {
+    const result = evaluatePainAdmissionForToolCall(
+      { toolName: 'read' } as any, baseObservation, baseOutcome, undefined, undefined, 's1', workspaceDir, mockConfig
+    );
+    expect(result.stage).toBe('not_applicable');
+    expect(result.admitted).toBe(false);
+  });
+
+  it('returns not_applicable for success', () => {
+    const successOutcome: ToolCallOutcome = { isFailure: false, exitCode: 0, failureSource: undefined };
+    const result = evaluatePainAdmissionForToolCall(
+      { toolName: 'write' } as any, baseObservation, successOutcome, undefined, undefined, 's1', workspaceDir, mockConfig
+    );
+    expect(result.stage).toBe('not_applicable');
+  });
+
+  it('returns triage_evidence_only when feature flag on and tool_failure triage rejects', () => {
+    vi.mocked(loadFeatureFlagFromConfig).mockReturnValue({ enabled: true, source: 'test' });
+
+    const result = evaluatePainAdmissionForToolCall(
+      { toolName: 'write' } as any, baseObservation, baseOutcome, undefined, undefined, 's1', workspaceDir, mockConfig
+    );
+    expect(result.stage).toBe('triage_evidence_only');
+    expect(result.admitted).toBe(false);
+    expect(result.reason).toBeTruthy();
+  });
+
+  it('returns gate_admitted when consecutive errors exceed repeatedFailure threshold', () => {
+    vi.mocked(loadFeatureFlagFromConfig).mockReturnValue({ enabled: false, source: 'test' });
+    // consecutiveErrors=5 >= default repeatedFailure threshold of 4 → gate admits via repeated_failure
+    const highConsecutiveState = { currentGfi: 0, consecutiveErrors: 5, lastErrorHash: 'abc123' } as any;
+
+    const result = evaluatePainAdmissionForToolCall(
+      { toolName: 'write' } as any, baseObservation, baseOutcome, highConsecutiveState, undefined, 's-gate-admitted-test', workspaceDir, mockConfig
+    );
+    expect(result.stage).toBe('gate_admitted');
+    expect(result.admitted).toBe(true);
+    expect(result.gateResult?.shouldDiagnose).toBe(true);
+    expect(result.gateResult?.reason).toBe('repeated_failure');
+  });
+
+  it('includes reason and detail in every decision', () => {
+    const result = evaluatePainAdmissionForToolCall(
+      { toolName: 'read' } as any, baseObservation, baseOutcome, undefined, undefined, 's1', workspaceDir, mockConfig
+    );
+    expect(result.reason).toBeTruthy();
+    expect(result.detail).toBeTruthy();
+  });
+});
+
+describe('PRI-326: buildToolCallObservation params defense', () => {
+  const profile = { risk_paths: [] } as any;
+
+  it('handles null params without crashing', () => {
+    const outcome: ToolCallOutcome = { isFailure: true, exitCode: 1, failureSource: 'tool_failure' };
+    const result = buildToolCallObservation(
+      { params: null, error: 'fail', result: {} } as any,
+      outcome, '/workspace', profile
+    );
+    expect(result.relPath).toBe('unknown');
+    expect(result.params.filePath).toBeUndefined();
+  });
+
+  it('handles undefined params without crashing', () => {
+    const outcome: ToolCallOutcome = { isFailure: true, exitCode: 1, failureSource: 'tool_failure' };
+    const result = buildToolCallObservation(
+      { params: undefined, error: 'fail', result: {} } as any,
+      outcome, '/workspace', profile
+    );
+    expect(result.relPath).toBe('unknown');
+  });
+
+  it('handles array params without crashing', () => {
+    const outcome: ToolCallOutcome = { isFailure: true, exitCode: 1, failureSource: 'tool_failure' };
+    const result = buildToolCallObservation(
+      { params: ['bad'], error: 'fail', result: {} } as any,
+      outcome, '/workspace', profile
+    );
+    expect(result.relPath).toBe('unknown');
+  });
+
+  it('handles string params without crashing', () => {
+    const outcome: ToolCallOutcome = { isFailure: true, exitCode: 1, failureSource: 'tool_failure' };
+    const result = buildToolCallObservation(
+      { params: 'not-an-object', error: 'fail', result: {} } as any,
+      outcome, '/workspace', profile
+    );
+    expect(result.relPath).toBe('unknown');
+  });
+});
+
+describe('PRI-326: buildToolCallObservation unserializable result defense', () => {
+  const profile = { risk_paths: [] } as any;
+  const outcome: ToolCallOutcome = { isFailure: true, exitCode: 1, failureSource: 'tool_failure' };
+
+  it('handles BigInt result without crashing', () => {
+    const result = buildToolCallObservation(
+      { params: {}, error: undefined, result: { val: BigInt(42) } } as any,
+      outcome, '/workspace', profile
+    );
+    expect(result.errorText).toContain('unserializable result');
+  });
+
+  it('handles circular reference result without crashing', () => {
+    const circular: any = { name: 'loop' };
+    circular.self = circular;
+    const result = buildToolCallObservation(
+      { params: {}, error: undefined, result: circular } as any,
+      outcome, '/workspace', profile
+    );
+    expect(result.errorText).toContain('unserializable result');
+  });
 });

package/tests/hooks/triage-adapter.test.ts

@@ -0,0 +1,260 @@
+/**
+ * Triage Adapter Tests — PEAT-B1
+ *
+ * Tests the plugin-side adapter that maps hook context to SourceKind
+ * and calls the pure triage policy from principles-core.
+ *
+ * ERR checklist:
+ * - ERR-001: Source kind resolved from runtime values, not `as` casts.
+ * - ERR-002: Every triage result has reason + nextAction.
+ * - ERR-024/025/048: Production-path tests for the adapter.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  resolveSourceKindFromToolFailure,
+  resolveSourceKindFromLlmDetection,
+  resolveSourceKindFromGateBlock,
+  resolveSourceKindFromCommand,
+  resolveSourceKindFromProvider,
+  resolveSourceKindFromSubagent,
+  evaluateEvidenceTriage,
+  isHighConfidenceUnsafeAction,
+} from '../../src/hooks/triage-adapter.js';
+
+// ── resolveSourceKindFromToolFailure ────────────────────────────────────────
+
+describe('resolveSourceKindFromToolFailure', () => {
+  it('maps pain tool to agent_on_owner_request with openclaw_context_bound', () => {
+    expect(resolveSourceKindFromToolFailure('pain', 'tool_failure', 'openclaw_context_bound')).toBe('agent_on_owner_request');
+  });
+
+  it('maps pain tool to owner_reported without openclaw_context_bound', () => {
+    expect(resolveSourceKindFromToolFailure('pain', 'tool_failure')).toBe('owner_reported');
+    expect(resolveSourceKindFromToolFailure('pain', 'tool_failure', 'automatic_hook')).toBe('owner_reported');
+  });
+
+  it('maps skill:pain to agent_on_owner_request with openclaw_context_bound', () => {
+    expect(resolveSourceKindFromToolFailure('skill:pain', 'tool_failure', 'openclaw_context_bound')).toBe('agent_on_owner_request');
+  });
+
+  it('maps dispatch_error to dispatch_error', () => {
+    expect(resolveSourceKindFromToolFailure('read', 'dispatch_error')).toBe('dispatch_error');
+  });
+
+  it('maps regular tool failure to tool_failure', () => {
+    expect(resolveSourceKindFromToolFailure('write', 'tool_failure')).toBe('tool_failure');
+    expect(resolveSourceKindFromToolFailure('exec', 'tool_failure')).toBe('tool_failure');
+  });
+
+  it('maps undefined tool name with tool_failure to tool_failure', () => {
+    expect(resolveSourceKindFromToolFailure(undefined, 'tool_failure')).toBe('tool_failure');
+  });
+});
+
+// ── resolveSourceKindFromLlmDetection ───────────────────────────────────────
+
+describe('resolveSourceKindFromLlmDetection', () => {
+  it('maps gfi triggered to gfi_threshold', () => {
+    expect(resolveSourceKindFromLlmDetection('llm_some_rule', true)).toBe('gfi_threshold');
+  });
+
+  it('maps llm_paralysis to llm_paralysis', () => {
+    expect(resolveSourceKindFromLlmDetection('llm_paralysis', false)).toBe('llm_paralysis');
+  });
+
+  it('maps llm_* detection rules to semantic', () => {
+    expect(resolveSourceKindFromLlmDetection('llm_repetition', false)).toBe('semantic');
+    expect(resolveSourceKindFromLlmDetection('llm_loop', false)).toBe('semantic');
+  });
+
+  it('maps user_empathy to empathy_inferred', () => {
+    expect(resolveSourceKindFromLlmDetection('user_empathy', false)).toBe('empathy_inferred');
+  });
+
+  it('maps unknown source to unknown', () => {
+    expect(resolveSourceKindFromLlmDetection('something_else', false)).toBe('unknown');
+  });
+});
+
+// ── Other resolve functions ─────────────────────────────────────────────────
+
+describe('resolveSourceKindFromGateBlock', () => {
+  it('returns rulehost_block', () => {
+    expect(resolveSourceKindFromGateBlock()).toBe('rulehost_block');
+  });
+});
+
+describe('resolveSourceKindFromCommand', () => {
+  it('returns owner_reported', () => {
+    expect(resolveSourceKindFromCommand()).toBe('owner_reported');
+  });
+});
+
+describe('resolveSourceKindFromProvider', () => {
+  it('returns provider_failure for non-rate-limit', () => {
+    expect(resolveSourceKindFromProvider(false)).toBe('provider_failure');
+  });
+
+  it('returns rate_limit for rate-limit', () => {
+    expect(resolveSourceKindFromProvider(true)).toBe('rate_limit');
+  });
+});
+
+describe('resolveSourceKindFromSubagent', () => {
+  it('returns subagent_error', () => {
+    expect(resolveSourceKindFromSubagent()).toBe('subagent_error');
+  });
+});
+
+// ── evaluateEvidenceTriage ──────────────────────────────────────────────────
+
+describe('evaluateEvidenceTriage', () => {
+  it('admits owner_reported regardless of score', () => {
+    const result = evaluateEvidenceTriage('owner_reported', 100);
+    expect(result.decision).toBe('admit');
+    expect(result.reason).toBeTruthy();
+    expect(result.nextAction).toBeTruthy();
+  });
+
+  it('returns evidence_only for tool_failure', () => {
+    const result = evaluateEvidenceTriage('tool_failure', 70);
+    expect(result.decision).toBe('evidence_only');
+    expect(result.reason).toBeTruthy();
+    expect(result.nextAction).toBeTruthy();
+  });
+
+  it('returns health_only for provider_failure', () => {
+    const result = evaluateEvidenceTriage('provider_failure', 60);
+    expect(result.decision).toBe('health_only');
+  });
+
+  it('returns owner_confirm for empathy_inferred', () => {
+    const result = evaluateEvidenceTriage('empathy_inferred', 80);
+    expect(result.decision).toBe('owner_confirm');
+  });
+
+  it('admits rulehost_block when isUnsafeHighConfidence is true', () => {
+    const result = evaluateEvidenceTriage('rulehost_block', 80, { isUnsafeHighConfidence: true });
+    expect(result.decision).toBe('admit');
+  });
+
+  it('returns evidence_only for rulehost_block when isUnsafeHighConfidence is false', () => {
+    const result = evaluateEvidenceTriage('rulehost_block', 80, { isUnsafeHighConfidence: false });
+    expect(result.decision).toBe('evidence_only');
+  });
+});
+
+// ── isHighConfidenceUnsafeAction ─────────────────────────────────────────────
+
+describe('isHighConfidenceUnsafeAction', () => {
+  it('returns true when isRisky and score >= 70', () => {
+    expect(isHighConfidenceUnsafeAction(70, true)).toBe(true);
+    expect(isHighConfidenceUnsafeAction(90, true)).toBe(true);
+  });
+
+  it('returns false when score < 70', () => {
+    expect(isHighConfidenceUnsafeAction(45, true)).toBe(false);
+    expect(isHighConfidenceUnsafeAction(69, true)).toBe(false);
+  });
+
+  it('returns false when not risky', () => {
+    expect(isHighConfidenceUnsafeAction(90, false)).toBe(false);
+  });
+});
+
+// ── Evidence-Only Cooldown Contract ──────────────────────────────────────────
+//
+// Core contract: when triage returns evidence_only/owner_confirm/health_only,
+// the caller (hook) MUST NOT proceed to evaluatePainDiagnosticGate, which writes
+// cooldown. These tests verify the adapter-level guarantee: non-admit decisions
+// are surfaced clearly with the right nextAction, so the caller can distinguish
+// evidence-only from admit.
+
+describe('evidence-only cooldown contract', () => {
+  it('tool_failure returns evidence_only — no admit, caller must skip gate', () => {
+    const result = evaluateEvidenceTriage('tool_failure', 70);
+    expect(result.decision).toBe('evidence_only');
+    expect(result.decision).not.toBe('admit');
+    expect(result.nextAction).toContain('evidence');
+  });
+
+  it('dispatch_error returns evidence_only — no admit', () => {
+    const result = evaluateEvidenceTriage('dispatch_error', 50);
+    expect(result.decision).toBe('evidence_only');
+    expect(result.decision).not.toBe('admit');
+  });
+
+  it('semantic (LLM detection) returns evidence_only — no admit', () => {
+    const result = evaluateEvidenceTriage('semantic', 55);
+    expect(result.decision).toBe('evidence_only');
+    expect(result.decision).not.toBe('admit');
+  });
+
+  it('llm_paralysis returns evidence_only — no admit', () => {
+    const result = evaluateEvidenceTriage('llm_paralysis', 40);
+    expect(result.decision).toBe('evidence_only');
+    expect(result.decision).not.toBe('admit');
+  });
+
+  it('gfi_threshold returns evidence_only — no admit', () => {
+    const result = evaluateEvidenceTriage('gfi_threshold', 70);
+    expect(result.decision).toBe('evidence_only');
+    expect(result.decision).not.toBe('admit');
+  });
+
+  it('empathy_inferred returns owner_confirm — no admit', () => {
+    const result = evaluateEvidenceTriage('empathy_inferred', 80);
+    expect(result.decision).toBe('owner_confirm');
+    expect(result.decision).not.toBe('admit');
+  });
+
+  it('provider_failure returns health_only — no admit', () => {
+    const result = evaluateEvidenceTriage('provider_failure', 60);
+    expect(result.decision).toBe('health_only');
+    expect(result.decision).not.toBe('admit');
+  });
+
+  it('rulehost_block WITHOUT isUnsafeHighConfidence returns evidence_only — no admit', () => {
+    const result = evaluateEvidenceTriage('rulehost_block', 45);
+    expect(result.decision).toBe('evidence_only');
+    expect(result.decision).not.toBe('admit');
+  });
+
+  it('rulehost_block WITH isUnsafeHighConfidence=true upgrades to admit', () => {
+    // This is the ONLY path where rulehost_block reaches the gate
+    const result = evaluateEvidenceTriage('rulehost_block', 80, { isUnsafeHighConfidence: true });
+    expect(result.decision).toBe('admit');
+    expect(result.reason).toContain('unsafe');
+  });
+
+  it('every LLM-typical source kind produces non-admit decision (cooldown-safe)', () => {
+    // These are the source kinds that handleLlmOutput produces
+    const llmSources = [
+      { kind: 'semantic' as const, score: 55 },
+      { kind: 'llm_paralysis' as const, score: 40 },
+      { kind: 'gfi_threshold' as const, score: 70 },
+      { kind: 'empathy_inferred' as const, score: 80 },
+    ];
+    for (const { kind, score } of llmSources) {
+      const result = evaluateEvidenceTriage(kind, score);
+      expect(result.decision).not.toBe('admit');
+      expect(result.reason).toBeTruthy();
+      expect(result.nextAction).toBeTruthy();
+    }
+  });
+
+  it('every after_tool_call-typical source kind produces non-admit decision (cooldown-safe)', () => {
+    // These are the source kinds that handleAfterToolCall produces
+    const toolSources = [
+      { kind: 'tool_failure' as const, score: 70 },
+      { kind: 'dispatch_error' as const, score: 50 },
+    ];
+    for (const { kind, score } of toolSources) {
+      const result = evaluateEvidenceTriage(kind, score);
+      expect(result.decision).not.toBe('admit');
+      expect(result.reason).toBeTruthy();
+      expect(result.nextAction).toBeTruthy();
+    }
+  });
+});