principles-disciple 1.102.0 → 1.103.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.0",
+  "version": "1.103.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

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

package/src/core/runtime-v2-prompt-activation-reader.ts

@@ -50,9 +50,9 @@ export class PromptActivationReader {
         }
 
         if (artifactRow === null) {
-          const warning = `artifact_not_found: artifactId=${activation.artifactId}; nextAction=check_pi_artifacts_table`;
+          const warning = `artifact_not_found: artifactId=${activation.artifactId}; nextAction=check_pi_artifacts_table_or_remove_stale_activation`;
           warnings.push(warning);
-          this.deps.logger?.warn?.(`[PD:RuntimeV2] ${warning}`);
+          this.deps.logger?.info?.(`[PD:RuntimeV2] ${warning}`);
           continue;
         }
 

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/hooks/runtime-v2-prompt-activation.test.ts

@@ -387,13 +387,13 @@ describe('Runtime V2 prompt activation injection', () => {
 
     await insertPromptActivation({ artifactId, principleId });
 
-    const warnSpy = vi.fn();
+    const infoSpy = vi.fn();
     const ctx = {
       workspaceDir: tempWorkspaceDir,
       trigger: 'user',
       sessionId: 'test-session-v2',
       api: {
-        logger: { info: vi.fn(), warn: warnSpy, error: vi.fn() },
+        logger: { info: infoSpy, warn: vi.fn(), error: vi.fn() },
         runtime: {},
         config: {},
       },
@@ -404,8 +404,8 @@ describe('Runtime V2 prompt activation injection', () => {
 
     expect(result).toBeDefined();
     expect(result?.appendSystemContext).not.toContain(TEST_PRINCIPLE_TEXT);
-    const warnCalls = warnSpy.mock.calls.map((c: unknown[]) => String(c[0]));
-    const hasActivationWarning = warnCalls.some((c: string) => c.includes('artifact_not_found') || c.includes('artifact_query_unexpected') || c.includes('activation'));
+    const infoCalls = infoSpy.mock.calls.map((c: unknown[]) => String(c[0]));
+    const hasActivationWarning = infoCalls.some((c: string) => c.includes('artifact_not_found') || c.includes('artifact_query_unexpected') || c.includes('activation'));
     expect(hasActivationWarning).toBe(true);
   });
 

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);
+    });
+  });
 });