principles-disciple 1.102.1 → 1.104.0

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.102.1",
+  "version": "1.104.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.102.1",
+  "version": "1.104.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",

package/src/hooks/trajectory-evidence.ts

@@ -64,6 +64,28 @@ export function buildTrajectoryEvidence(wctx: WorkspaceContext, sessionId: strin
     }
   }
 
+  // PRI-358: Extract failed tool_calls as evidence
+  try {
+    const allToolCalls = wctx.trajectory.listToolCallsForSession(sessionId) ?? [];
+    const failedToolCalls = allToolCalls.filter(tc => tc.outcome === 'failure').slice(-3);
+    for (const tc of failedToolCalls) {
+      if (evidence.length >= MAX_EVIDENCE_ENTRIES) break;
+      const note = `Tool ${tc.toolName} failed: ${tc.errorType ?? 'unknown'} (exitCode: ${tc.exitCode ?? 'N/A'})`;
+      evidence.push({
+        sourceRef: `tool_call_failure:${tc.createdAt}`,
+        note: sanitizeAssistantText(note.slice(0, MAX_EVIDENCE_NOTE_CHARS)),
+      });
+    }
+  } catch (e) {
+    // Only add unavailable entry when no other evidence exists (avoid noise)
+    if (evidence.length === 0) {
+      evidence.push({
+        sourceRef: 'tool_call_failure:unavailable',
+        note: `trajectory_tool_calls_unavailable: ${String(e).slice(0, 100)}`,
+      });
+    }
+  }
+
   if (evidence.length === 0) {
     evidence.push({
       sourceRef: 'trajectory:empty',

package/tests/core/surface-guard.test.ts

@@ -278,17 +278,17 @@ describe('surface-guard', () => {
       const mockLogger = { info: vi.fn(), debug: vi.fn() };
       const service: OpenClawPluginService = { id: 'test-service' };
 
-      // First registration call: the disabled reason is logged once.
-      const first = guardService('service:trajectory', service, mockLogger);
+      // service:evolution-worker is quiet/disabled — use it for the rate-limit test.
+      const first = guardService('service:evolution-worker', service, mockLogger);
       expect(first).toBeNull();
       expect(mockLogger.info).toHaveBeenCalledTimes(1);
       expect(mockLogger.info).toHaveBeenCalledWith(
-        expect.stringContaining('SKIP service service:trajectory'),
+        expect.stringContaining('SKIP service service:evolution-worker'),
       );
 
       // Subsequent guardService calls for the same surfaceId stay silent.
-      guardService('service:trajectory', service, mockLogger);
-      guardService('service:trajectory', service, mockLogger);
+      guardService('service:evolution-worker', service, mockLogger);
+      guardService('service:evolution-worker', service, mockLogger);
       expect(mockLogger.info).toHaveBeenCalledTimes(1);
     });
   });

package/tests/hooks/trajectory-evidence.test.ts

@@ -23,6 +23,7 @@ describe('buildTrajectoryEvidence', () => {
     mockTrajectory = {
       listUserTurnsForSession: vi.fn(),
       listAssistantTurns: vi.fn(),
+      listToolCallsForSession: vi.fn(),
     };
     mockWctx = {
       trajectory: mockTrajectory as TrajectoryDatabase,
@@ -191,4 +192,89 @@ describe('buildTrajectoryEvidence', () => {
     // Note should be truncated to MAX_EVIDENCE_NOTE_CHARS (1000 from core)
     expect(result[0].note.length).toBeLessThanOrEqual(1000);
   });
+
+  // ── PRI-358: Failed tool_calls evidence ────────────────────────────────────
+
+  describe('PRI-358: failed tool_calls evidence', () => {
+    it('extracts failed tool_calls as evidence entries', () => {
+      vi.mocked(mockTrajectory.listUserTurnsForSession!).mockReturnValue([]);
+      vi.mocked(mockTrajectory.listAssistantTurns!).mockReturnValue([]);
+      vi.mocked(mockTrajectory.listToolCallsForSession!).mockReturnValue([
+        { id: 1, toolName: 'bash', outcome: 'failure', errorType: 'non_zero_exit', exitCode: 1, errorMessage: 'Command failed', filePath: null, durationMs: 500, gfiBefore: null, gfiAfter: null, createdAt: '2024-01-15T10:00:00Z' },
+        { id: 2, toolName: 'write_file', outcome: 'success', errorType: null, exitCode: 0, errorMessage: null, filePath: null, durationMs: 100, gfiBefore: null, gfiAfter: null, createdAt: '2024-01-15T10:01:00Z' },
+        { id: 3, toolName: 'bash', outcome: 'failure', errorType: 'timeout', exitCode: 124, errorMessage: 'Timed out', filePath: null, durationMs: 30000, gfiBefore: null, gfiAfter: null, createdAt: '2024-01-15T10:02:00Z' },
+      ]);
+
+      const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'session-123');
+
+      const failureEntries = result.filter(e => e.sourceRef.startsWith('tool_call_failure:'));
+      expect(failureEntries.length).toBe(2);
+      expect(failureEntries[0].note).toContain('bash');
+      expect(failureEntries[0].note).toContain('non_zero_exit');
+      expect(failureEntries[1].note).toContain('timeout');
+    });
+
+    it('does not add tool_call_failure entries when no failures exist', () => {
+      vi.mocked(mockTrajectory.listUserTurnsForSession!).mockReturnValue([]);
+      vi.mocked(mockTrajectory.listAssistantTurns!).mockReturnValue([]);
+      vi.mocked(mockTrajectory.listToolCallsForSession!).mockReturnValue([
+        { id: 1, toolName: 'bash', outcome: 'success', errorType: null, exitCode: 0, errorMessage: null, filePath: null, durationMs: 100, gfiBefore: null, gfiAfter: null, createdAt: '2024-01-15T10:00:00Z' },
+      ]);
+
+      const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'session-123');
+
+      const failureEntries = result.filter(e => e.sourceRef.startsWith('tool_call_failure:'));
+      expect(failureEntries.length).toBe(0);
+    });
+
+    it('limits failed tool_calls to 3 entries', () => {
+      vi.mocked(mockTrajectory.listUserTurnsForSession!).mockReturnValue([]);
+      vi.mocked(mockTrajectory.listAssistantTurns!).mockReturnValue([]);
+      vi.mocked(mockTrajectory.listToolCallsForSession!).mockReturnValue([
+        { id: 1, toolName: 'bash', outcome: 'failure', errorType: 'err1', exitCode: 1, errorMessage: null, filePath: null, durationMs: 100, gfiBefore: null, gfiAfter: null, createdAt: '2024-01-15T10:00:00Z' },
+        { id: 2, toolName: 'bash', outcome: 'failure', errorType: 'err2', exitCode: 2, errorMessage: null, filePath: null, durationMs: 100, gfiBefore: null, gfiAfter: null, createdAt: '2024-01-15T10:01:00Z' },
+        { id: 3, toolName: 'bash', outcome: 'failure', errorType: 'err3', exitCode: 3, errorMessage: null, filePath: null, durationMs: 100, gfiBefore: null, gfiAfter: null, createdAt: '2024-01-15T10:02:00Z' },
+        { id: 4, toolName: 'bash', outcome: 'failure', errorType: 'err4', exitCode: 4, errorMessage: null, filePath: null, durationMs: 100, gfiBefore: null, gfiAfter: null, createdAt: '2024-01-15T10:03:00Z' },
+      ]);
+
+      const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'session-123');
+
+      const failureEntries = result.filter(e => e.sourceRef.startsWith('tool_call_failure:'));
+      expect(failureEntries.length).toBe(3);
+    });
+
+    it('handles listToolCallsForSession throwing gracefully', () => {
+      vi.mocked(mockTrajectory.listUserTurnsForSession!).mockReturnValue([]);
+      vi.mocked(mockTrajectory.listAssistantTurns!).mockReturnValue([]);
+      vi.mocked(mockTrajectory.listToolCallsForSession!).mockImplementation(() => {
+        throw new Error('DB read error');
+      });
+
+      const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'session-123');
+
+      const unavailableEntry = result.find(e => e.sourceRef === 'tool_call_failure:unavailable');
+      expect(unavailableEntry).toBeDefined();
+      expect(unavailableEntry!.note).toContain('trajectory_tool_calls_unavailable');
+    });
+
+    it('does not add unavailable entry when other evidence exists and tool_calls throws', () => {
+      const mockUserTurn = {
+        createdAt: '2024-01-15T10:00:00Z',
+        correctionDetected: true,
+        rawExcerpt: 'Owner correction',
+      };
+      vi.mocked(mockTrajectory.listUserTurnsForSession!).mockReturnValue([mockUserTurn] as any);
+      vi.mocked(mockTrajectory.listAssistantTurns!).mockReturnValue([]);
+      vi.mocked(mockTrajectory.listToolCallsForSession!).mockImplementation(() => {
+        throw new Error('DB read error');
+      });
+
+      const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'session-123');
+
+      // Should have owner message but NOT a tool_call_failure:unavailable entry
+      // because we already have evidence
+      expect(result.some(e => e.sourceRef.startsWith('owner_message:'))).toBe(true);
+      expect(result.some(e => e.sourceRef === 'tool_call_failure:unavailable')).toBe(false);
+    });
+  });
 });

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 () => {