principles-disciple 1.72.0 → 1.73.0

package/tests/hooks/pain.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { handleAfterToolCall } from '../../src/hooks/pain.js';
+import { handleAfterToolCall, classifyToolFailureSource } from '../../src/hooks/pain.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -7,6 +7,7 @@ import * as ioUtils from '../../src/utils/io.js';
 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';
 
 vi.mock('fs');
 vi.mock('../../src/utils/io.js');
@@ -25,6 +26,77 @@ const mockEmitSync = vi.fn();
 const mockRecordProbationFeedback = vi.fn();
 const mockUpdatePrincipleValueMetrics = vi.fn();
 
+describe('classifyToolFailureSource', () => {
+  it('empty toolName -> dispatch_error', () => {
+    expect(classifyToolFailureSource(undefined, 'tool not found')).toBe('dispatch_error');
+    expect(classifyToolFailureSource('', 'tool not found')).toBe('dispatch_error');
+  });
+
+  it('"Tool not found" (case insensitive) -> dispatch_error', () => {
+    expect(classifyToolFailureSource('read', 'error: tool not found')).toBe('dispatch_error');
+    expect(classifyToolFailureSource('read', 'Tool Not Found')).toBe('dispatch_error');
+    // "tool <name> not found" also matches (e.g. "tool read_file not found")
+    expect(classifyToolFailureSource('read', 'Tool read_file not found')).toBe('dispatch_error');
+  });
+
+  it('"Unknown tool" (case insensitive) -> dispatch_error', () => {
+    expect(classifyToolFailureSource('read', 'error: unknown tool')).toBe('dispatch_error');
+    expect(classifyToolFailureSource('read', 'Unknown Tool')).toBe('dispatch_error');
+    expect(classifyToolFailureSource('read', 'failed: unknown tool read_file')).toBe('dispatch_error');
+  });
+
+  it('Warning-style messages containing "tool not found" -> dispatch_error', () => {
+    // After dropping "error:" prefix, Warning messages with "tool not found" match the dispatch pattern
+    expect(classifyToolFailureSource('read', 'Warning: tool not found was suppressed')).toBe('dispatch_error');
+    expect(classifyToolFailureSource('read', 'Warning: tool not found - already handled')).toBe('dispatch_error');
+  });
+
+  it('real execution errors (ENOENT, EACCES) -> tool_failure', () => {
+    expect(classifyToolFailureSource('read', 'ENOENT: no such file or directory')).toBe('tool_failure');
+    expect(classifyToolFailureSource('write', 'EACCES: permission denied')).toBe('tool_failure');
+    expect(classifyToolFailureSource('edit', 'Error: EIO: I/O error')).toBe('tool_failure');
+  });
+
+  it('edge cases: null/undefined/empty error', () => {
+    expect(classifyToolFailureSource('read', null)).toBe('tool_failure');
+    expect(classifyToolFailureSource('read', undefined)).toBe('tool_failure');
+    expect(classifyToolFailureSource('read', '')).toBe('tool_failure');
+    expect(classifyToolFailureSource('read', 123)).toBe('tool_failure');
+  });
+
+  it('word-boundary: "report_tool_not_found" does NOT match dispatch pattern', () => {
+    expect(classifyToolFailureSource('read', 'report_tool_not_found')).toBe('tool_failure');
+  });
+
+  it('word-boundary: "atoolnotfound" (no spaces) does NOT match dispatch pattern', () => {
+    expect(classifyToolFailureSource('read', 'atoolnotfound')).toBe('tool_failure');
+  });
+
+  it('word-boundary: "unknown_tool" (underscore, no space) does NOT match dispatch pattern', () => {
+    expect(classifyToolFailureSource('read', 'unknown_tool')).toBe('tool_failure');
+  });
+
+  it('whitespace-only toolName -> dispatch_error', () => {
+    expect(classifyToolFailureSource('   ', 'tool not found')).toBe('dispatch_error');
+  });
+
+  it('numeric error value -> tool_failure', () => {
+    expect(classifyToolFailureSource('read', 42)).toBe('tool_failure');
+  });
+
+  it('object error value -> tool_failure', () => {
+    expect(classifyToolFailureSource('read', { code: 'ENOENT' })).toBe('tool_failure');
+  });
+
+  it('"tool <name> not found" with multi-word tool name -> dispatch_error', () => {
+    expect(classifyToolFailureSource('read', 'tool my_custom_tool not found')).toBe('dispatch_error');
+  });
+
+  it('partial match "not found" without "tool" prefix -> tool_failure', () => {
+    expect(classifyToolFailureSource('read', 'file not found')).toBe('tool_failure');
+  });
+});
+
 describe('Post-Write Checks & Pain Hook', () => {
   const workspaceDir = '/mock/workspace';
   const mockEventLog = {
@@ -66,6 +138,9 @@ describe('Post-Write Checks & Pain Hook', () => {
     vi.spyOn(WorkspaceContext, 'fromHookContext').mockReturnValue(mockWctx as any);
     vi.spyOn(EventLogService, 'get').mockReturnValue(mockEventLog as any);
     clearSession('s-success');
+    clearSession('s-low-value-failure');
+    clearSession('s-repeated-failure');
+    resetPainDiagnosticGateForTest();
   });
 
   afterEach(() => {
@@ -99,12 +174,11 @@ describe('Post-Write Checks & Pain Hook', () => {
     handleAfterToolCall(mockEvent as any, mockCtx as any, mockApi as any);
 
     expect(WorkspaceContext.fromHookContext).not.toHaveBeenCalled();
-    expect(mockApi.runtime.agent.resolveAgentWorkspaceDir).toHaveBeenCalledWith(mockApi.config, 'main');
+    expect(mockEmitSync).not.toHaveBeenCalled();
   });
 
-  // TODO: Fix this test - fs.writeFileSync mock not being called
-  it.skip('should capture pain on tool error with correct source', () => {
-    const mockCtx = { workspaceDir, sessionId: 's1', api: { logger: {} } };
+  it('records ordinary write failures as friction only without Runtime V2 diagnosis', () => {
+    const mockCtx = { workspaceDir, sessionId: 's-low-value-failure', api: { logger: {} } };
     const mockEvent = { 
         toolName: 'write', 
         params: { file_path: 'src/main.ts' },
@@ -114,25 +188,49 @@ describe('Post-Write Checks & Pain Hook', () => {
 
     vi.mocked(ioUtils.normalizePath).mockReturnValue('src/main.ts');
     vi.mocked(ioUtils.isRisky).mockReturnValue(false);
-    vi.mocked(ioUtils.serializeKvLines).mockReturnValue('mocked-pain-flag-content');
+    vi.mocked(fs.existsSync).mockReturnValue(false);
 
-    vi.mocked(fs.existsSync).mockReturnValue(true);
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    expect(fs.writeFileSync).not.toHaveBeenCalled();
+    expect(mockEmitSync).not.toHaveBeenCalled();
+    expect(mockEventLog.recordPainSignal).not.toHaveBeenCalled();
+    expect(mockWctx.trajectory.recordPainEvent).not.toHaveBeenCalled();
+    expect(mockWctx.trajectory.recordToolCall).toHaveBeenCalledWith(expect.objectContaining({
+      sessionId: 's-low-value-failure',
+      toolName: 'write',
+      outcome: 'failure',
+    }));
+  });
+
+  it('emits Runtime V2 diagnosis after repeated same write failures', () => {
+    const mockCtx = { workspaceDir, sessionId: 's-repeated-failure', 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);
+    expect(mockEmitSync).not.toHaveBeenCalled();
 
-    expect(fs.writeFileSync).toHaveBeenCalled();
-    const callArgs = vi.mocked(fs.writeFileSync).mock.calls[0];
-    expect(callArgs[0]).toContain('.pain_flag');
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
 
     expect(mockEmitSync).toHaveBeenCalledWith(expect.objectContaining({
       type: 'pain_detected',
       data: expect.objectContaining({
         painType: 'tool_failure',
         source: 'write',
+        reason: expect.stringContaining('diagnosticGate=high_gfi'),
       }),
     }));
     expect(mockWctx.trajectory.recordToolCall).toHaveBeenCalledWith(expect.objectContaining({
-      sessionId: 's1',
+      sessionId: 's-repeated-failure',
       toolName: 'write',
       outcome: 'failure',
     }));
@@ -186,7 +284,7 @@ describe('Post-Write Checks & Pain Hook', () => {
     };
 
     vi.mocked(ioUtils.normalizePath).mockReturnValue('src/main.ts');
-    vi.mocked(ioUtils.isRisky).mockReturnValue(false);
+    vi.mocked(ioUtils.isRisky).mockReturnValue(true);
     vi.mocked(ioUtils.serializeKvLines).mockReturnValue('mocked-pain-flag-content');
     vi.mocked(fs.existsSync).mockImplementation((filePath: fs.PathLike) => {
       const normalizedPath = String(filePath).replace(/\\/g, '/');
@@ -223,4 +321,163 @@ describe('Post-Write Checks & Pain Hook', () => {
     expect(trainingStateWrites).toEqual([]);
   });
 
+  it('should detect failure from nested details.exitCode (exec tool pattern)', () => {
+    const mockCtx = { workspaceDir, sessionId: 's-exec-failure', api: { logger: {} } };
+    const mockEvent = {
+      toolName: 'bash',
+      params: { arguments: 'npm test' },
+      result: { details: { exitCode: 1 } },
+      error: undefined,
+    };
+
+    vi.mocked(ioUtils.normalizePath).mockReturnValue('package.json');
+    vi.mocked(ioUtils.isRisky).mockReturnValue(false);
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    expect(mockWctx.trajectory.recordToolCall).toHaveBeenCalledWith(expect.objectContaining({
+      sessionId: 's-exec-failure',
+      toolName: 'bash',
+      outcome: 'failure',
+    }));
+  });
+
+  it('should prefer result.exitCode over nested details.exitCode when both exist', () => {
+    const mockCtx = { workspaceDir, sessionId: 's-exec-success', api: { logger: {} } };
+    const mockEvent = {
+      toolName: 'bash',
+      params: { arguments: 'npm test' },
+      result: { exitCode: 0, details: { exitCode: 1 } },
+      error: undefined,
+    };
+
+    vi.mocked(ioUtils.normalizePath).mockReturnValue('package.json');
+    vi.mocked(ioUtils.isRisky).mockReturnValue(false);
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    expect(mockEmitSync).not.toHaveBeenCalled();
+    expect(mockWctx.trajectory.recordToolCall).toHaveBeenCalledWith(expect.objectContaining({
+      sessionId: 's-exec-success',
+      toolName: 'bash',
+      outcome: 'success',
+    }));
+  });
+
+  it('should treat undefined exitCode as success', () => {
+    const mockCtx = { workspaceDir, sessionId: 's-no-exitcode', api: { logger: {} } };
+    const mockEvent = {
+      toolName: 'bash',
+      params: { arguments: 'echo hello' },
+      result: { output: 'hello' },
+      error: undefined,
+    };
+
+    vi.mocked(ioUtils.normalizePath).mockReturnValue('package.json');
+    vi.mocked(ioUtils.isRisky).mockReturnValue(false);
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    expect(mockEmitSync).not.toHaveBeenCalled();
+    expect(mockWctx.trajectory.recordToolCall).toHaveBeenCalledWith(expect.objectContaining({
+      sessionId: 's-no-exitcode',
+      toolName: 'bash',
+      outcome: 'success',
+    }));
+  });
+
+  it('should treat exitCode 0 as success even when details.exitCode is non-zero', () => {
+    const mockCtx = { workspaceDir, sessionId: 's-partial-success', api: { logger: {} } };
+    const mockEvent = {
+      toolName: 'bash',
+      params: { arguments: 'npm test' },
+      result: { exitCode: 0, details: { stderr: 'some warnings', exitCode: 2 } },
+      error: undefined,
+    };
+
+    vi.mocked(ioUtils.normalizePath).mockReturnValue('package.json');
+    vi.mocked(ioUtils.isRisky).mockReturnValue(false);
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    expect(mockEmitSync).not.toHaveBeenCalled();
+    expect(mockWctx.trajectory.recordToolCall).toHaveBeenCalledWith(expect.objectContaining({
+      sessionId: 's-partial-success',
+      toolName: 'bash',
+      outcome: 'success',
+    }));
+  });
+
+  it('should treat string exitCode as 0 (not a failure)', () => {
+    const mockCtx = { workspaceDir, sessionId: 's-string-exitcode', api: { logger: {} } };
+    const mockEvent = {
+      toolName: 'bash',
+      params: { arguments: 'npm test' },
+      result: { exitCode: '0' },
+      error: undefined,
+    };
+
+    vi.mocked(ioUtils.normalizePath).mockReturnValue('package.json');
+    vi.mocked(ioUtils.isRisky).mockReturnValue(false);
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    expect(mockEmitSync).not.toHaveBeenCalled();
+    expect(mockWctx.trajectory.recordToolCall).toHaveBeenCalledWith(expect.objectContaining({
+      sessionId: 's-string-exitcode',
+      toolName: 'bash',
+      outcome: 'success',
+    }));
+  });
+
+  it('should treat non-numeric details.exitCode as 0 (not a failure)', () => {
+    const mockCtx = { workspaceDir, sessionId: 's-non-numeric-details', api: { logger: {} } };
+    const mockEvent = {
+      toolName: 'bash',
+      params: { arguments: 'npm test' },
+      result: { details: { exitCode: '1' } },
+      error: undefined,
+    };
+
+    vi.mocked(ioUtils.normalizePath).mockReturnValue('package.json');
+    vi.mocked(ioUtils.isRisky).mockReturnValue(false);
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    expect(mockEmitSync).not.toHaveBeenCalled();
+    expect(mockWctx.trajectory.recordToolCall).toHaveBeenCalledWith(expect.objectContaining({
+      sessionId: 's-non-numeric-details',
+      toolName: 'bash',
+      outcome: 'success',
+    }));
+  });
+
+  it('should fall back to numeric details.exitCode when top-level exitCode is non-numeric', () => {
+    const mockCtx = { workspaceDir, sessionId: 's-fallback-numeric', api: { logger: {} } };
+    const mockEvent = {
+      toolName: 'bash',
+      params: { arguments: 'npm test' },
+      result: { exitCode: '0', details: { exitCode: 1 } },
+      error: undefined,
+    };
+
+    vi.mocked(ioUtils.normalizePath).mockReturnValue('package.json');
+    vi.mocked(ioUtils.isRisky).mockReturnValue(false);
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    expect(mockWctx.trajectory.recordToolCall).toHaveBeenCalledWith(expect.objectContaining({
+      sessionId: 's-fallback-numeric',
+      toolName: 'bash',
+      outcome: 'failure',
+    }));
+  });
+
 });