principles-disciple 1.103.0 → 1.104.1

package/tests/hooks/single-gate-pain-admission.test.ts

@@ -0,0 +1,258 @@
+/**
+ * Single-Gate Pain Admission Tests — PRI-363
+ *
+ * Tests that tool failure path uses only a single gate (TriggerController)
+ * for deciding whether to create a diagnostic task.
+ *
+ * This test validates:
+ * 1. No dual-gate drift — evaluatePainAdmissionForToolCall calls only TriggerController
+ * 2. Cooldown preserved — same episode does not repeat diagnosis within 15 min
+ * 3. Tool failure defaults to evidence_only per PEAT design
+ * 4. Manual pain bypasses all gates
+ *
+ * ERR checklist:
+ * - ERR-001: No `as` casts on untrusted runtime values.
+ * - ERR-002: Every decision carries reason + nextAction.
+ * - ERR-009: Malformed/missing state fails loud with reason.
+ * - ERR-024/025/048: Production-path wiring tests.
+ */
+
+import { beforeEach, describe, expect, it } from 'vitest';
+import { evaluatePainAdmissionForToolCall, resetTriggerCooldownForTest } from '../../src/hooks/after-tool-call-helpers.js';
+import type { PluginHookAfterToolCallEvent } from '../../src/openclaw-sdk.js';
+import type { ToolCallObservation, ToolCallOutcome } from '../../src/hooks/after-tool-call-types.js';
+
+// ── Test Helpers ─────────────────────────────────────────────────────────────
+
+function createMockEvent(
+  toolName: string,
+  error: unknown,
+  params: Record<string, unknown> = {},
+): PluginHookAfterToolCallEvent {
+  return {
+    toolName,
+    params,
+    result: null,
+    error,
+    durationMs: 100,
+  };
+}
+
+function createMockObservation(
+  painScore: number,
+  isRisk: boolean,
+  errorHash: string,
+): ToolCallObservation {
+  return {
+    params: {
+      filePath: '/tmp/test.md',
+      content: 'test content',
+    },
+    relPath: '/tmp/test.md',
+    isRisk,
+    errorType: 'EACCES',
+    errorHash,
+    errorText: 'Permission denied',
+    painScore,
+    traceId: 'test-trace-id',
+  };
+}
+
+function createMockOutcome(isFailure: boolean, failureSource: 'tool_failure' | 'dispatch_error' | undefined): ToolCallOutcome {
+  return {
+    isFailure,
+    exitCode: isFailure ? 1 : 0,
+    failureSource,
+  };
+}
+
+function createMockConfig(get: (key: string) => unknown) {
+  return { get };
+}
+
+describe('Single-Gate Pain Admission — PRI-363', () => {
+  beforeEach(() => {
+    resetTriggerCooldownForTest();
+  });
+
+  describe('Non-write-tool failures', () => {
+    it('should reject non-write-tool failures', () => {
+      const toolName = 'read'; // Not a write tool
+      const error = new Error('ENOENT: file not found');
+      const painScore = 72;
+      const errorHash = 'abc123';
+      const sessionId = 'session-001';
+      const workspaceDir = '/tmp/workspace';
+
+      const event = createMockEvent(toolName, error, {
+        path: '/tmp/test.md',
+      });
+
+      const observation = createMockObservation(painScore, false, errorHash);
+      const outcome = createMockOutcome(true, 'tool_failure');
+      const sessionState = {
+        currentGfi: 30,
+        consecutiveErrors: 2,
+      };
+
+      const config = createMockConfig(() => undefined);
+
+      const decision = evaluatePainAdmissionForToolCall(
+        event,
+        observation,
+        outcome,
+        sessionState,
+        sessionState,
+        sessionId,
+        workspaceDir,
+        config,
+      );
+
+      expect(decision.admitted).toBe(false);
+      expect(decision.stage).toBe('not_applicable');
+      expect(decision.reason).toBe('not_a_write_tool_failure');
+    });
+  });
+
+  describe('Tool failure default behavior', () => {
+    it('tool_failure defaults to evidence_only (PEAT design)', () => {
+      const toolName = 'write';
+      const error = new Error('EACCES: permission denied');
+      const painScore = 80; // Very high score
+      const errorHash = 'abc123';
+      const sessionId = 'session-001';
+      const workspaceDir = '/tmp/workspace';
+
+      const event = createMockEvent(toolName, error, {
+        file_path: '/tmp/test.md',
+        content: 'test',
+      });
+
+      const observation = createMockObservation(painScore, false, errorHash);
+      const outcome = createMockOutcome(true, 'tool_failure');
+      const sessionState = {
+        currentGfi: 80,
+        consecutiveErrors: 2,
+      };
+
+      const config = createMockConfig(() => undefined);
+
+      const decision = evaluatePainAdmissionForToolCall(
+        event,
+        observation,
+        outcome,
+        sessionState,
+        sessionState,
+        sessionId,
+        workspaceDir,
+        config,
+      );
+
+      // Per PEAT design, tool_failure is infrastructure noise
+      // and defaults to evidence_only
+      expect(decision.admitted).toBe(false);
+      expect(decision.stage).toBe('trigger_rejected');
+      expect(decision.reason).toContain('infrastructure noise');
+    });
+  });
+
+  describe('Cooldown behavior', () => {
+    it('should not repeat diagnosis within 15 min cooldown (same episode)', () => {
+      const toolName = 'write';
+      const error = new Error('EACCES: permission denied');
+      const errorHash = 'abc123';
+      const sessionId = 'session-001';
+      const painScore = 72; // High score would normally trigger diagnosis
+      const workspaceDir = '/tmp/workspace';
+
+      const event = createMockEvent(toolName, error, {
+        file_path: '/tmp/test.md',
+        content: 'test',
+      });
+
+      const observation = createMockObservation(painScore, false, errorHash);
+      const outcome = createMockOutcome(true, 'tool_failure');
+      const sessionState = {
+        currentGfi: 30,
+        consecutiveErrors: 2,
+      };
+
+      const config = createMockConfig(() => undefined);
+
+      // First call — tool_failure defaults to evidence_only
+      const decision1 = evaluatePainAdmissionForToolCall(
+        event,
+        observation,
+        outcome,
+        sessionState,
+        sessionState,
+        sessionId,
+        workspaceDir,
+        config,
+      );
+
+      expect(decision1.admitted).toBe(false);
+      expect(decision1.stage).toBe('trigger_rejected');
+
+      // Second call within cooldown — should still not admit
+      // (even though cooldown is set, triage decision is still evidence_only)
+      const decision2 = evaluatePainAdmissionForToolCall(
+        event,
+        observation,
+        outcome,
+        sessionState,
+        sessionState,
+        sessionId,
+        workspaceDir,
+        config,
+      );
+
+      expect(decision2.admitted).toBe(false);
+      expect(decision2.stage).toBe('trigger_rejected');
+    });
+  });
+
+  describe('Structural validation', () => {
+    it('should always return structured decisions with reason + detail', () => {
+      const toolName = 'write';
+      const error = new Error('EACCES: permission denied');
+      const painScore = 35;
+      const errorHash = 'abc123';
+      const sessionId = 'session-001';
+      const workspaceDir = '/tmp/workspace';
+
+      const event = createMockEvent(toolName, error, {
+        file_path: '/tmp/test.md',
+        content: 'test',
+      });
+
+      const observation = createMockObservation(painScore, false, errorHash);
+      const outcome = createMockOutcome(true, 'tool_failure');
+      const sessionState = {
+        currentGfi: 30,
+        consecutiveErrors: 1,
+      };
+
+      const config = createMockConfig(() => undefined);
+
+      const decision = evaluatePainAdmissionForToolCall(
+        event,
+        observation,
+        outcome,
+        sessionState,
+        sessionState,
+        sessionId,
+        workspaceDir,
+        config,
+      );
+
+      // ERR-002: Every decision carries reason + nextAction
+      expect(decision).toHaveProperty('admitted');
+      expect(decision).toHaveProperty('stage');
+      expect(decision).toHaveProperty('reason');
+      expect(decision).toHaveProperty('detail');
+      expect(decision.reason).toBeTruthy();
+      expect(decision.detail).toBeTruthy();
+    });
+  });
+});

package/tests/integration/auto-entry-gate.test.ts

@@ -16,7 +16,8 @@ import * as path from 'path';
 import { handleAfterToolCall } from '../../src/hooks/pain.js';
 import { WorkspaceContext } from '../../src/core/workspace-context.js';
 import { EventLogService } from '../../src/core/event-log.js';
-import { resetPainDiagnosticGateForTest, evaluatePainDiagnosticGate } from '../../src/core/pain-diagnostic-gate.js';
+import { resetTriggerCooldownForTest } from '../../src/hooks/after-tool-call-helpers.js';
+import { evaluatePainDiagnosticGate, resetPainDiagnosticGateForTest } from '../../src/core/pain-diagnostic-gate.js';
 import * as ioUtils from '../../src/utils/io.js';
 
 vi.mock('fs');
@@ -75,9 +76,10 @@ describe('Auto-Entry Gate Integration', () => {
     mockEmitSync.mockReset();
     mockRecordProbationFeedback.mockReset();
     mockUpdatePrincipleValueMetrics.mockReset();
-    vi.spyOn(WorkspaceContext, 'fromHookContext').mockReturnValue(mockWctx as any);
+    vi.spyOn(WorkspaceContext, 'fromHookContextExplicit').mockReturnValue(mockWctx as any);
     vi.spyOn(EventLogService, 'get').mockReturnValue(mockEventLog as any);
     vi.spyOn(fs, 'existsSync').mockReturnValue(false);
+    resetTriggerCooldownForTest();
     resetPainDiagnosticGateForTest();
   });
 
@@ -121,11 +123,18 @@ describe('Auto-Entry Gate Integration', () => {
     vi.mocked(ioUtils.normalizePath).mockReturnValue('src/main.ts');
     vi.mocked(ioUtils.isRisky).mockReturnValue(false);
 
-    // First failure — accumulates GFI, does not emit
+    // PRI-363: trigger controller requires consecutiveErrors >= 4 for upgrade
+    // First 3 failures — accumulates friction, does not emit
     handleAfterToolCall(mockEvent as any, mockCtx as any);
     expect(mockEmitSync).not.toHaveBeenCalled();
 
-    // Second failure — repeated, should emit
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+    expect(mockEmitSync).not.toHaveBeenCalled();
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+    expect(mockEmitSync).not.toHaveBeenCalled();
+
+    // Fourth failure — repeated, should emit
     handleAfterToolCall(mockEvent as any, mockCtx as any);
 
     expect(mockEmitSync).toHaveBeenCalledWith(
@@ -134,7 +143,6 @@ describe('Auto-Entry Gate Integration', () => {
         data: expect.objectContaining({
           painType: 'tool_failure',
           source: 'write',
-          reason: expect.stringContaining('diagnosticGate=high_gfi'),
         }),
       }),
     );

package/tests/integration/mvp-surface-registry-guard.test.ts

@@ -435,11 +435,11 @@ describe('MVP Surface Registry Guard (PRI-289)', () => {
       expect(guarded).toBeNull();
     });
 
-    it('guardService returns null for quiet surfaces', async () => {
+    it('guardService returns the service for core surfaces (trajectory is now core)', async () => {
       const { guardService } = await import('../../src/core/surface-guard.js');
       const service = { api: null, start: () => {} };
       const guarded = guardService('service:trajectory', service);
-      expect(guarded).toBeNull();
+      expect(guarded).toBe(service);
     });
 
     it('guardService returns null for unregistered surfaces', async () => {