principles-disciple 1.93.0 → 1.95.0

package/src/hooks/trajectory-evidence.ts

@@ -0,0 +1,75 @@
+/**
+ * Trajectory Evidence Builder — PRI-326
+ *
+ * Extracted from pain.ts to avoid circular imports between
+ * pain.ts and after-tool-call-helpers.ts.
+ *
+ * Pure data extraction — reads from trajectory DB, sanitizes, returns evidence entries.
+ */
+
+import { sanitizeAssistantText } from './message-sanitize.js';
+import type { PainEvidenceEntry } from '@principles/core/runtime-v2';
+import { MAX_EVIDENCE_ENTRIES, MAX_EVIDENCE_NOTE_CHARS } from '@principles/core/runtime-v2';
+import type { WorkspaceContext } from '../core/workspace-context.js';
+
+export function buildTrajectoryEvidence(wctx: WorkspaceContext, sessionId: string): PainEvidenceEntry[] {
+  const evidence: PainEvidenceEntry[] = [];
+
+  if (!wctx.trajectory || sessionId === 'unknown') {
+    evidence.push({
+      sourceRef: 'owner_message:unavailable',
+      note: `trajectory_unavailable: ${!wctx.trajectory ? 'no_trajectory_db' : 'unknown_session'}`,
+    });
+    return evidence.slice(0, MAX_EVIDENCE_ENTRIES);
+  }
+
+  try {
+    const userTurns = wctx.trajectory.listUserTurnsForSession(sessionId) ?? [];
+    const lastCorrectionTurn = [...userTurns].reverse().find(t => t.correctionDetected);
+    if (lastCorrectionTurn) {
+      const sanitizedOwnerMessage = sanitizeAssistantText(
+        (lastCorrectionTurn.rawExcerpt ?? '').slice(0, MAX_EVIDENCE_NOTE_CHARS)
+      );
+      evidence.push({
+        sourceRef: `owner_message:${lastCorrectionTurn.createdAt}`,
+        note: sanitizedOwnerMessage,
+      });
+    }
+  } catch (e) {
+    evidence.push({
+      sourceRef: 'owner_message:unavailable',
+      note: `trajectory_user_turns_unavailable: ${String(e).slice(0, 100)}`,
+    });
+  }
+
+  try {
+    const assistantTurns = wctx.trajectory.listAssistantTurns(sessionId) ?? [];
+    const recentAssistant = assistantTurns.slice(-3);
+    for (const turn of recentAssistant) {
+      if (evidence.length >= MAX_EVIDENCE_ENTRIES) break;
+      const sanitizedNote = sanitizeAssistantText(
+        (turn.sanitizedText ?? '').slice(0, MAX_EVIDENCE_NOTE_CHARS)
+      );
+      evidence.push({
+        sourceRef: `agent_turn:${turn.createdAt}`,
+        note: sanitizedNote,
+      });
+    }
+  } catch (e) {
+    if (evidence.length < MAX_EVIDENCE_ENTRIES) {
+      evidence.push({
+        sourceRef: 'agent_turn:unavailable',
+        note: `trajectory_assistant_turns_unavailable: ${String(e).slice(0, 100)}`,
+      });
+    }
+  }
+
+  if (evidence.length === 0) {
+    evidence.push({
+      sourceRef: 'trajectory:empty',
+      note: 'trajectory_available_but_empty: no user correction or assistant turns found',
+    });
+  }
+
+  return evidence.slice(0, MAX_EVIDENCE_ENTRIES);
+}

package/tests/commands/pain.test.ts

@@ -1,10 +1,19 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { handlePainCommand } from '../../src/commands/pain.js';
+import { handlePainCommand, handlePainReportCommand } from '../../src/commands/pain.js';
 import * as sessionTracker from '../../src/core/session-tracker.js';
 import { WorkspaceContext } from '../../src/core/workspace-context.js';
 
 vi.mock('../../src/core/session-tracker.js');
 vi.mock('../../src/core/workspace-context.js');
+vi.mock('../../src/core/pd-config-loader.js', () => ({
+  loadPdConfigForPlugin: vi.fn().mockReturnValue({ ok: true, effective: {}, source: 'defaults', warnings: [], errors: [] }),
+}));
+vi.mock('@principles/core/runtime-v2', () => ({
+  PainToPrincipleService: vi.fn(),
+  PrincipleTreeLedgerAdapter: vi.fn(function(this: any) { this.stateDir = ''; }),
+}));
+
+import { PainToPrincipleService } from '@principles/core/runtime-v2';
 
 describe('Pain Command', () => {
     const workspaceDir = '/mock/workspace';
@@ -106,3 +115,173 @@ describe('Pain Command', () => {
         expect(result.text).toContain('approved samples');
     });
 });
+
+describe('Pain Report Command (/pd-pain)', () => {
+    const workspaceDir = '/mock/workspace';
+    const sessionId = 's1';
+
+    const mockEvolutionReducer = { emitSync: vi.fn() };
+    const mockWctx = {
+        workspaceDir,
+        stateDir: '/mock/workspace/.state',
+        evolutionReducer: mockEvolutionReducer,
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(WorkspaceContext.fromHookContext).mockReturnValue(mockWctx as any);
+    });
+
+    async function runPainReport(args: string, lang = 'en') {
+        return handlePainReportCommand({
+            args,
+            config: { workspaceDir, language: lang },
+            sessionId,
+        } as any);
+    }
+
+    it('rejects empty args', async () => {
+        const result = await runPainReport('');
+        expect(result.text).toContain('Please provide a pain reason');
+    });
+
+    it('rejects missing session ID', async () => {
+        const result = await handlePainReportCommand({
+            args: 'something broke',
+            config: { workspaceDir, language: 'en' },
+        } as any);
+        expect(result.text).toContain('Session ID not available');
+    });
+
+    it('reports success when recordPain returns succeeded', async () => {
+        const mockRecordPain = vi.fn().mockResolvedValue({
+            status: 'succeeded',
+            painId: 'manual_123_abc',
+            taskId: 'diagnosis_manual_123_abc',
+            candidateIds: [],
+            ledgerEntryIds: [],
+            observabilityWarnings: [],
+            latencyMs: 100,
+        });
+        vi.mocked(PainToPrincipleService).mockImplementation(function(this: any) { this.recordPain = mockRecordPain; } as any);
+
+        const result = await runPainReport('something broke');
+        expect(result.text).toContain('Pain recorded');
+        expect(result.text).toContain('manual_');
+        expect(result.text).not.toContain('not accepted');
+    });
+
+    it('reports retried as pain recorded with retry info, NOT as "not accepted"', async () => {
+        const mockRecordPain = vi.fn().mockResolvedValue({
+            status: 'retried',
+            painId: 'manual_456_def',
+            taskId: 'diagnosis_manual_456_def',
+            failureCategory: 'output_invalid',
+            message: 'Diagnostician output failed validation',
+            candidateIds: [],
+            ledgerEntryIds: [],
+            observabilityWarnings: [],
+            latencyMs: 200,
+        });
+        vi.mocked(PainToPrincipleService).mockImplementation(function(this: any) { this.recordPain = mockRecordPain; } as any);
+
+        const result = await runPainReport('something broke');
+        expect(result.text).toContain('Pain recorded');
+        expect(result.text).toContain('retry');
+        expect(result.text).toContain('diagnosis_manual_456_def');
+        expect(result.text).toContain('output_invalid');
+        expect(result.text).toContain('/pd-status');
+        // Must NOT say "not accepted" or "failed"
+        expect(result.text).not.toContain('not accepted');
+        expect(result.text).not.toContain('未成功');
+    });
+
+    it('reports retried in Chinese correctly', async () => {
+        const mockRecordPain = vi.fn().mockResolvedValue({
+            status: 'retried',
+            painId: 'manual_789_xyz',
+            taskId: 'diagnosis_manual_789_xyz',
+            failureCategory: 'output_invalid',
+            candidateIds: [],
+            ledgerEntryIds: [],
+            observabilityWarnings: [],
+            latencyMs: 200,
+        });
+        vi.mocked(PainToPrincipleService).mockImplementation(function(this: any) { this.recordPain = mockRecordPain; } as any);
+
+        const result = await runPainReport('something broke', 'zh');
+        expect(result.text).toContain('Pain 已记录');
+        expect(result.text).toContain('重试');
+        expect(result.text).not.toContain('未成功');
+        expect(result.text).not.toContain('not accepted');
+    });
+
+    it('reports retried without failureCategory or message', async () => {
+        const mockRecordPain = vi.fn().mockResolvedValue({
+            status: 'retried',
+            painId: 'manual_000_nocat',
+            taskId: 'diagnosis_manual_000_nocat',
+            candidateIds: [],
+            ledgerEntryIds: [],
+            observabilityWarnings: [],
+            latencyMs: 150,
+        });
+        vi.mocked(PainToPrincipleService).mockImplementation(function(this: any) { this.recordPain = mockRecordPain; } as any);
+
+        const result = await runPainReport('something broke');
+        expect(result.text).toContain('Pain recorded');
+        expect(result.text).toContain('retry');
+        expect(result.text).toContain('diagnosis_manual_000_nocat');
+        // No error category or detail lines when absent
+        expect(result.text).not.toContain('Error category');
+        expect(result.text).not.toContain('Detail');
+    });
+
+    it('reports failed as "not accepted" with reason', async () => {
+        const mockRecordPain = vi.fn().mockResolvedValue({
+            status: 'failed',
+            painId: 'manual_fail_1',
+            taskId: 'diagnosis_manual_fail_1',
+            failureCategory: 'runtime_unavailable',
+            message: 'No runner available',
+            candidateIds: [],
+            ledgerEntryIds: [],
+            observabilityWarnings: [],
+            latencyMs: 50,
+        });
+        vi.mocked(PainToPrincipleService).mockImplementation(function(this: any) { this.recordPain = mockRecordPain; } as any);
+
+        const result = await runPainReport('something broke');
+        expect(result.text).toContain('not accepted');
+        expect(result.text).toContain('failed');
+        expect(result.text).toContain('runtime_unavailable');
+        expect(result.text).toContain('No runner available');
+    });
+
+    it('reports degraded as "not accepted"', async () => {
+        const mockRecordPain = vi.fn().mockResolvedValue({
+            status: 'degraded',
+            painId: 'manual_deg_1',
+            taskId: 'diagnosis_manual_deg_1',
+            candidateIds: [],
+            ledgerEntryIds: [],
+            observabilityWarnings: [],
+            latencyMs: 30,
+        });
+        vi.mocked(PainToPrincipleService).mockImplementation(function(this: any) { this.recordPain = mockRecordPain; } as any);
+
+        const result = await runPainReport('something broke');
+        expect(result.text).toContain('not accepted');
+        expect(result.text).toContain('degraded');
+    });
+
+    it('reports error on exception', async () => {
+        vi.mocked(PainToPrincipleService).mockImplementation(function(this: any) {
+            throw new Error('DB connection failed');
+        });
+
+        const result = await runPainReport('something broke');
+        expect(result.text).toContain('Failed to record pain');
+        expect(result.text).toContain('DB connection failed');
+    });
+});

package/tests/hooks/pain.test.ts

@@ -544,3 +544,228 @@ describe('Post-Write Checks & Pain Hook', () => {
   });
 
 });
+
+// ── 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');
+  });
+});