principles-disciple 1.104.0 → 1.104.2

package/tests/hooks/raw-observation-adapter.test.ts

@@ -0,0 +1,312 @@
+/**
+ * Raw Observation Adapter Tests — PRI-362
+ *
+ * Tests the unified resolveSourceKind function that maps RawObservation
+ * to SourceKind, replacing scattered resolveSourceKindFrom* functions.
+ *
+ * Each test case asserts behavior is consistent with legacy functions
+ * (regression protection).
+ *
+ * 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 type { RawObservation } from '../../src/hooks/raw-observation-types.js';
+import { resolveSourceKind } from '../../src/hooks/raw-observation-adapter.js';
+
+// ── Tool Failure: agent_on_owner_request ──────────────────────────────────
+
+describe('resolveSourceKind: agent_on_owner_request', () => {
+  it('maps pain tool with openclaw_context_bound provenance to agent_on_owner_request', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      toolName: 'pain',
+      failureSource: 'tool_failure',
+      provenance: 'openclaw_context_bound',
+    };
+    expect(resolveSourceKind(obs)).toBe('agent_on_owner_request');
+  });
+
+  it('maps skill:pain with openclaw_context_bound to agent_on_owner_request', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      toolName: 'skill:pain',
+      failureSource: 'tool_failure',
+      provenance: 'openclaw_context_bound',
+    };
+    expect(resolveSourceKind(obs)).toBe('agent_on_owner_request');
+  });
+});
+
+// ── Tool Failure: owner_reported ───────────────────────────────────────────
+
+describe('resolveSourceKind: owner_reported', () => {
+  it('maps pain tool without openclaw_context_bound to owner_reported', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      toolName: 'pain',
+      failureSource: 'tool_failure',
+      provenance: 'automatic_hook',
+    };
+    expect(resolveSourceKind(obs)).toBe('owner_reported');
+  });
+
+  it('maps pain tool with undefined provenance to owner_reported', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      toolName: 'pain',
+      failureSource: 'tool_failure',
+    };
+    expect(resolveSourceKind(obs)).toBe('owner_reported');
+  });
+
+  it('maps manual entry to owner_reported', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      isManualEntry: true,
+    };
+    expect(resolveSourceKind(obs)).toBe('owner_reported');
+  });
+});
+
+// ── Tool Failure: tool_failure ────────────────────────────────────────────
+
+describe('resolveSourceKind: tool_failure', () => {
+  it('maps regular tool failure to tool_failure', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      toolName: 'write',
+      failureSource: 'tool_failure',
+    };
+    expect(resolveSourceKind(obs)).toBe('tool_failure');
+  });
+
+  it('maps exec failure to tool_failure', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      toolName: 'exec',
+      failureSource: 'tool_failure',
+    };
+    expect(resolveSourceKind(obs)).toBe('tool_failure');
+  });
+
+  it('maps undefined tool name with tool_failure to tool_failure', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      failureSource: 'tool_failure',
+    };
+    expect(resolveSourceKind(obs)).toBe('tool_failure');
+  });
+
+  it('maps non-zero exit code to tool_failure', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      toolName: 'read',
+      nonZeroExit: true,
+    };
+    expect(resolveSourceKind(obs)).toBe('tool_failure');
+  });
+
+  it('maps timeout to tool_failure', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      toolName: 'exec',
+      timedOut: true,
+    };
+    expect(resolveSourceKind(obs)).toBe('tool_failure');
+  });
+});
+
+// ── Tool Failure: dispatch_error ─────────────────────────────────────────
+
+describe('resolveSourceKind: dispatch_error', () => {
+  it('maps dispatch_error failure source to dispatch_error', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      toolName: 'read',
+      failureSource: 'dispatch_error',
+    };
+    expect(resolveSourceKind(obs)).toBe('dispatch_error');
+  });
+
+  it('maps tool not found to dispatch_error', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      toolNotFound: true,
+    };
+    expect(resolveSourceKind(obs)).toBe('dispatch_error');
+  });
+});
+
+// ── Provider Failure: rate_limit ─────────────────────────────────────────
+
+describe('resolveSourceKind: rate_limit', () => {
+  it('maps rate limit to rate_limit', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      isRateLimit: true,
+    };
+    expect(resolveSourceKind(obs)).toBe('rate_limit');
+  });
+});
+
+// ── Provider Failure: provider_failure ───────────────────────────────────
+
+describe('resolveSourceKind: provider_failure', () => {
+  it('maps non-rate-limit provider failure to provider_failure', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      isRateLimit: false,
+    };
+    expect(resolveSourceKind(obs)).toBe('provider_failure');
+  });
+
+  it('maps undefined rate_limit to provider_failure', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      // isRateLimit undefined should be provider_failure
+    };
+    // This test depends on the implementation decision for undefined
+    // For now, we'll skip it until we clarify the behavior
+    expect(resolveSourceKind(obs)).not.toBe('rate_limit');
+  });
+});
+
+// ── Gate Block: rulehost_block ───────────────────────────────────────────
+
+describe('resolveSourceKind: rulehost_block', () => {
+  it('maps gate block to rulehost_block', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      isGateBlock: true,
+    };
+    expect(resolveSourceKind(obs)).toBe('rulehost_block');
+  });
+});
+
+// ── LLM Detection: gfi_threshold ─────────────────────────────────────────
+
+describe('resolveSourceKind: gfi_threshold', () => {
+  it('maps GFI triggered to gfi_threshold', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      detectionSource: 'llm_some_rule',
+      isGfiTriggered: true,
+    };
+    expect(resolveSourceKind(obs)).toBe('gfi_threshold');
+  });
+});
+
+// ── LLM Detection: llm_paralysis ─────────────────────────────────────────
+
+describe('resolveSourceKind: llm_paralysis', () => {
+  it('maps llm_paralysis to llm_paralysis', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      detectionSource: 'llm_paralysis',
+      isGfiTriggered: false,
+    };
+    expect(resolveSourceKind(obs)).toBe('llm_paralysis');
+  });
+});
+
+// ── LLM Detection: semantic ──────────────────────────────────────────────
+
+describe('resolveSourceKind: semantic', () => {
+  it('maps llm_* detection rules to semantic', () => {
+    const obs1: RawObservation = {
+      observedAt: new Date().toISOString(),
+      detectionSource: 'llm_repetition',
+      isGfiTriggered: false,
+    };
+    expect(resolveSourceKind(obs1)).toBe('semantic');
+
+    const obs2: RawObservation = {
+      observedAt: new Date().toISOString(),
+      detectionSource: 'llm_loop',
+      isGfiTriggered: false,
+    };
+    expect(resolveSourceKind(obs2)).toBe('semantic');
+  });
+});
+
+// ── LLM Detection: empathy_inferred ──────────────────────────────────────
+
+describe('resolveSourceKind: empathy_inferred', () => {
+  it('maps user_empathy to empathy_inferred', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      detectionSource: 'user_empathy',
+      isGfiTriggered: false,
+    };
+    expect(resolveSourceKind(obs)).toBe('empathy_inferred');
+  });
+});
+
+// ── Subagent Error: subagent_error ───────────────────────────────────────
+
+describe('resolveSourceKind: subagent_error', () => {
+  it('maps subagent error to subagent_error', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      isSubagentError: true,
+    };
+    expect(resolveSourceKind(obs)).toBe('subagent_error');
+  });
+});
+
+// ── Unknown: unknown ──────────────────────────────────────────────────────
+
+describe('resolveSourceKind: unknown', () => {
+  it('maps unknown detection source to unknown', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      detectionSource: 'something_else',
+      isGfiTriggered: false,
+    };
+    expect(resolveSourceKind(obs)).toBe('unknown');
+  });
+
+  it('maps empty observation to unknown', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+    };
+    expect(resolveSourceKind(obs)).toBe('unknown');
+  });
+});
+
+// ── Priority Tests (field precedence) ─────────────────────────────────────
+
+describe('resolveSourceKind: field precedence', () => {
+  it('GFI triggered takes precedence over detection source prefix', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      detectionSource: 'llm_paralysis',
+      isGfiTriggered: true,
+    };
+    expect(resolveSourceKind(obs)).toBe('gfi_threshold');
+  });
+
+  it('manual entry takes precedence over other fields', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      isManualEntry: true,
+      toolName: 'read',
+      failureSource: 'tool_failure',
+    };
+    expect(resolveSourceKind(obs)).toBe('owner_reported');
+  });
+
+  it('gate block takes precedence over tool failure', () => {
+    const obs: RawObservation = {
+      observedAt: new Date().toISOString(),
+      isGateBlock: true,
+      toolName: 'write',
+      failureSource: 'tool_failure',
+    };
+    expect(resolveSourceKind(obs)).toBe('rulehost_block');
+  });
+});

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'),
         }),
       }),
     );