principles-disciple 1.47.0 → 1.48.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.47.0",
+  "version": "1.48.0",
   "skills": [
     "./skills"
   ],

package/package.json

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

package/src/service/evolution-worker.ts

@@ -607,11 +607,23 @@ export async function processCompilationBackfill(
             );
             if (hasActiveImpl) {
                 // Already compiled — mark as done
-                updatePrinciple(wctx.stateDir, principleId, { compilationRetryCount: undefined });
+                try {
+                    updatePrinciple(wctx.stateDir, principleId, { compilationRetryCount: undefined });
+                } catch (err) {
+                    SystemLogger.log(wctx.workspaceDir, 'BACKFILL_UPDATE_FAILED',
+                        `Failed to mark principle ${principleId} as done: ${String(err)}`);
+                    continue;
+                }
             } else {
                 // Needs compilation — queue it
-                updatePrinciple(wctx.stateDir, principleId, { compilationRetryCount: 0 });
-                backfillQueued++;
+                try {
+                    updatePrinciple(wctx.stateDir, principleId, { compilationRetryCount: 0 });
+                    backfillQueued++;
+                } catch (err) {
+                    SystemLogger.log(wctx.workspaceDir, 'BACKFILL_UPDATE_FAILED',
+                        `Failed to queue principle ${principleId}: ${String(err)}`);
+                    continue;
+                }
             }
         }
         if (backfillQueued > 0) {
@@ -619,7 +631,12 @@ export async function processCompilationBackfill(
                 `Queued ${backfillQueued} old principles for compilation`);
         }
         // Write marker so we don't backfill again in this process
-        atomicWriteFileSync(backfillMarkerPath, new Date().toISOString());
+        try {
+            atomicWriteFileSync(backfillMarkerPath, new Date().toISOString());
+        } catch (err) {
+            SystemLogger.log(wctx.workspaceDir, 'BACKFILL_MARKER_WRITE_FAILED',
+                `Failed to write backfill marker: ${String(err)}`);
+        }
     }
 
     // ── Phase 2: Retry pending compilations ───────────────────────────────────
@@ -642,21 +659,21 @@ export async function processCompilationBackfill(
         try {
             const result = compiler.compileOne(principleId);
             if (result.success) {
-                safeUpdateRetryCount(wctx.stateDir, wctx.workspaceDir, principleId, undefined);
+                tryUpdateRetryCount(wctx.stateDir, wctx.workspaceDir, principleId, undefined);
                 SystemLogger.log(wctx.workspaceDir, 'COMPILE_SUCCESS',
                     `Principle ${principleId} compiled successfully (attempt ${count + 1})`);
             } else {
                 const nextCount = count + 1;
                 if (nextCount >= 5) {
                     // Exhausted: single write to set manual_only (no intermediate count write)
-                    safeUpdatePrinciple(wctx.stateDir, wctx.workspaceDir, principleId, {
+                    tryUpdatePrinciple(wctx.stateDir, wctx.workspaceDir, principleId, {
                         evaluability: 'manual_only',
                         compilationRetryCount: undefined,
                     });
                     SystemLogger.log(wctx.workspaceDir, 'COMPILE_EXHAUSTED',
                         `Principle ${principleId} compilation exhausted after 5 attempts: ${result.reason ?? 'unknown'}`);
                 } else {
-                    safeUpdateRetryCount(wctx.stateDir, wctx.workspaceDir, principleId, nextCount);
+                    tryUpdateRetryCount(wctx.stateDir, wctx.workspaceDir, principleId, nextCount);
                     SystemLogger.log(wctx.workspaceDir, 'COMPILE_FAILED',
                         `Principle ${principleId} compile failed: ${result.reason ?? 'unknown'} (attempt ${nextCount}/5)`);
                 }
@@ -665,14 +682,14 @@ export async function processCompilationBackfill(
             const nextCount = count + 1;
             if (nextCount >= 5) {
                 // Exhausted: single write to set manual_only (no intermediate count write)
-                safeUpdatePrinciple(wctx.stateDir, wctx.workspaceDir, principleId, {
+                tryUpdatePrinciple(wctx.stateDir, wctx.workspaceDir, principleId, {
                     evaluability: 'manual_only',
                     compilationRetryCount: undefined,
                 });
                 SystemLogger.log(wctx.workspaceDir, 'COMPILE_EXHAUSTED',
                     `Principle ${principleId} compilation exhausted after 5 attempts: threw ${String(compileErr)}`);
             } else {
-                safeUpdateRetryCount(wctx.stateDir, wctx.workspaceDir, principleId, nextCount);
+                tryUpdateRetryCount(wctx.stateDir, wctx.workspaceDir, principleId, nextCount);
                 SystemLogger.log(wctx.workspaceDir, 'COMPILE_FAILED',
                     `Principle ${principleId} compile threw: ${String(compileErr)} (attempt ${nextCount}/5)`);
             }
@@ -681,11 +698,11 @@ export async function processCompilationBackfill(
 }
 
 /**
- * Wrapper for updatePrinciple in the retry loop — logs but does not propagate errors.
- * If update fails, the principle stays in its current retry state and will be
- * picked up again on the next heartbeat.
+ * Wrapper for updateRetryCount — logs but does not propagate errors.
+ * Errors are silently swallowed: if update fails, the principle stays in its
+ * current retry state and will be picked up again on the next heartbeat.
  */
-function safeUpdateRetryCount(stateDir: string, workspaceDir: string, principleId: string, count: number | undefined): void {
+function tryUpdateRetryCount(stateDir: string, workspaceDir: string, principleId: string, count: number | undefined): void {
     try {
         updatePrinciple(stateDir, principleId, { compilationRetryCount: count });
     } catch (err) {
@@ -696,8 +713,10 @@ function safeUpdateRetryCount(stateDir: string, workspaceDir: string, principleI
 
 /**
  * Wrapper for updatePrinciple with multiple fields — logs but does not propagate errors.
+ * Errors are silently swallowed: if update fails, the principle stays in its
+ * current state and will be picked up again on the next heartbeat.
  */
-function safeUpdatePrinciple(
+function tryUpdatePrinciple(
     stateDir: string,
     workspaceDir: string,
     principleId: string,
@@ -915,7 +934,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                                 } else {
                                     logger.info(`[PD:EvolutionWorker] Creating principle from report for task ${task.id}`);
                                     const principleId = wctx.evolutionReducer.createPrincipleFromDiagnosis({
-                                        painId: task.id,
+                                        painId: task.painEventId !== undefined ? String(task.painEventId) : task.id,
                                         painType: task.source === 'Human Intervention' ? 'user_frustration' : 'tool_failure',
                                         triggerPattern: principle.trigger_pattern,
                                         action: principle.action,
@@ -1013,7 +1032,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                                 logger.info(`[PD:EvolutionWorker] Diagnostician marked principle as duplicate: ${principle.duplicate_of || 'unknown'} — skipping for task ${task.id}`);
                             } else {
                                 const principleId = wctx.evolutionReducer.createPrincipleFromDiagnosis({
-                                    painId: task.id,
+                                    painId: task.painEventId !== undefined ? String(task.painEventId) : task.id,
                                     painType: task.source === 'Human Intervention' ? 'user_frustration' : 'tool_failure',
                                     triggerPattern: principle.trigger_pattern,
                                     action: principle.action,

package/tests/integration/pain-id-chain-e2e.test.ts

@@ -0,0 +1,253 @@
+/**
+ * E2E Test: Pain ID Chain — pain event → createPrincipleFromDiagnosis → compile → RuleHost
+ *
+ * Tests the complete chain:
+ *   1. recordPainEvent() returns AUTOINCREMENT row ID as number
+ *   2. createPrincipleFromDiagnosis(painId: String(painEventId))
+ *   3. derivedFromPainIds stores the stringified numeric ID
+ *   4. PrincipleCompiler.compileOne() succeeds (registers active implementation)
+ *   5. RuleHost.evaluate(matching input) → block
+ *   6. RuleHost.evaluate(non-matching input) → undefined (passthrough)
+ *
+ * Pain ID chain fixed in commits 4b0dce59 and 0146bbb7:
+ *   - recordPainEvent() now returns real AUTOINCREMENT ID (was -1)
+ *   - derivedFromPainIds now stores String(painId) correctly
+ *   - LedgerPrinciple.derivedFromPainIds used by compiler reflection
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { TrajectoryDatabase } from '../../src/core/trajectory.js';
+import { PrincipleCompiler } from '../../src/core/principle-compiler/compiler.js';
+import { RuleHost } from '../../src/core/rule-host.js';
+import { EvolutionReducerImpl } from '../../src/core/evolution-reducer.js';
+import {
+  loadLedger,
+} from '../../src/core/principle-tree-ledger.js';
+import type { RuleHostInput } from '../../src/core/rule-host-types.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+interface TestWorkspace {
+  workspaceDir: string;
+  stateDir: string;
+  trajectory: TrajectoryDatabase;
+  reducer: EvolutionReducerImpl;
+}
+
+function createTestWorkspace(): TestWorkspace {
+  const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-pain-chain-e2e-'));
+  const stateDir = path.join(workspaceDir, '.state');
+  fs.mkdirSync(stateDir, { recursive: true });
+
+  const trajectory = new TrajectoryDatabase({ workspaceDir });
+  const reducer = new EvolutionReducerImpl({ workspaceDir, stateDir });
+
+  return { workspaceDir, stateDir, trajectory, reducer };
+}
+
+function disposeTestWorkspace(ws: TestWorkspace): void {
+  ws.trajectory.dispose();
+  fs.rmSync(ws.workspaceDir, { recursive: true, force: true });
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('Pain ID Chain E2E: pain event → principle → compile → RuleHost', () => {
+  let ws: TestWorkspace;
+
+  beforeEach(() => {
+    ws = createTestWorkspace();
+  });
+
+  afterEach(() => {
+    disposeTestWorkspace(ws);
+  });
+
+  it('full chain: pain event ID → createPrincipleFromDiagnosis → derivedFromPainIds → compile → block', () => {
+    const sessionId = 'session-pain-chain-001';
+
+    // ── Step 1: Record tool call + pain event, capture the returned AUTOINCREMENT ID ──
+    ws.trajectory.recordToolCall({
+      sessionId,
+      toolName: 'bash',
+      outcome: 'failure',
+      errorType: 'command_not_found',
+      errorMessage: 'heartbeat: command not found',
+      paramsJson: { command: 'heartbeat --status' },
+    });
+
+    // recordPainEvent() returns the real AUTOINCREMENT row ID as a number (fix from 4b0dce59)
+    const painEventId = ws.trajectory.recordPainEvent({
+      sessionId,
+      source: 'gate_block',
+      score: 80,
+      reason: 'Blocked bash heartbeat command due to unsafe operation',
+      severity: 'moderate',
+      origin: 'system_infer',
+    });
+
+    // Verify painEventId is a positive integer (real AUTOINCREMENT, not -1)
+    expect(typeof painEventId).toBe('number');
+    expect(painEventId).toBeGreaterThan(0);
+
+    // ── Step 2: Create principle via createPrincipleFromDiagnosis with stringified pain ID ──
+    const triggerPattern = 'heartbeat.*bash';
+    const action = 'Block heartbeat commands in bash';
+    const painIdStr = String(painEventId);
+
+    const principleId = ws.reducer.createPrincipleFromDiagnosis({
+      painId: painIdStr,
+      painType: 'tool_failure',
+      triggerPattern,
+      action,
+      source: 'pain-id-chain-e2e',
+      evaluability: 'deterministic',
+    });
+
+    expect(principleId).not.toBeNull();
+    expect(typeof principleId).toBe('string');
+
+    // ── Step 3: Verify derivedFromPainIds in the ledger contains the stringified pain ID ──
+    const ledger = loadLedger(ws.stateDir);
+    const ledgerPrinciple = ledger.tree.principles[principleId!];
+    expect(ledgerPrinciple).toBeDefined();
+    expect(ledgerPrinciple!.derivedFromPainIds).toContain(painIdStr);
+
+    // ── Step 4: Compile the principle (registers active implementation) ──
+    const compiler = new PrincipleCompiler(ws.stateDir, ws.trajectory);
+    const compileResult = compiler.compileOne(principleId!);
+
+    expect(compileResult.success).toBe(true);
+    expect(compileResult.principleId).toBe(principleId);
+    expect(compileResult.code).toBeDefined();
+    expect(compileResult.code).toContain('heartbeat');
+    expect(compileResult.ruleId).toBeDefined();
+    expect(compileResult.implementationId).toBeDefined();
+
+    // Verify implementation is active
+    const updatedLedger = loadLedger(ws.stateDir);
+    const impl = updatedLedger.tree.implementations[compileResult.implementationId!];
+    expect(impl.lifecycleState).toBe('active');
+
+    // ── Step 5: RuleHost.evaluate(matching input) → block ──
+    const host = new RuleHost(ws.stateDir, { warn: () => {} });
+
+    const matchingInput: RuleHostInput = {
+      action: {
+        toolName: 'bash',
+        normalizedPath: null,
+        paramsSummary: { command: 'heartbeat --status' },
+      },
+      workspace: {
+        isRiskPath: false,
+        planStatus: 'NONE',
+        hasPlanFile: false,
+      },
+      session: {
+        sessionId: 'session-eval-001',
+        currentGfi: 50,
+        recentThinking: false,
+      },
+      evolution: {
+        epTier: 0,
+      },
+      derived: {
+        estimatedLineChanges: 0,
+        bashRisk: 'unknown',
+      },
+    };
+
+    const blockResult = host.evaluate(matchingInput);
+
+    expect(blockResult).toBeDefined();
+    expect(blockResult!.decision).toBe('block');
+    expect(blockResult!.matched).toBe(true);
+    expect(blockResult!.reason).toContain(principleId);
+
+    // ── Step 6: RuleHost.evaluate(non-matching input) → undefined (passthrough) ──
+    const nonMatchingInput: RuleHostInput = {
+      action: {
+        toolName: 'Read',
+        normalizedPath: '/some/file.txt',
+        paramsSummary: {},
+      },
+      workspace: {
+        isRiskPath: false,
+        planStatus: 'NONE',
+        hasPlanFile: false,
+      },
+      session: {
+        sessionId: 'session-eval-002',
+        currentGfi: 50,
+        recentThinking: false,
+      },
+      evolution: {
+        epTier: 0,
+      },
+      derived: {
+        estimatedLineChanges: 0,
+        bashRisk: 'unknown',
+      },
+    };
+
+    const passResult = host.evaluate(nonMatchingInput);
+    expect(passResult).toBeUndefined();
+  });
+
+  it('compileOne returns failure for non-existent principle ID', () => {
+    const compiler = new PrincipleCompiler(ws.stateDir, ws.trajectory);
+    const badResult = compiler.compileOne('non-existent-principle-id');
+    expect(badResult.success).toBe(false);
+  });
+
+  it('recordPainEvent returns sequential IDs for multiple events', () => {
+    const sessionId = 'session-seq-001';
+
+    ws.trajectory.recordToolCall({
+      sessionId,
+      toolName: 'bash',
+      outcome: 'failure',
+      errorType: 'command_not_found',
+      errorMessage: 'test error 1',
+      paramsJson: { command: 'test1' },
+    });
+
+    const id1 = ws.trajectory.recordPainEvent({
+      sessionId,
+      source: 'gate_block',
+      score: 50,
+      reason: 'First pain event',
+      severity: 'low',
+      origin: 'system_infer',
+    });
+
+    ws.trajectory.recordToolCall({
+      sessionId,
+      toolName: 'bash',
+      outcome: 'failure',
+      errorType: 'command_not_found',
+      errorMessage: 'test error 2',
+      paramsJson: { command: 'test2' },
+    });
+
+    const id2 = ws.trajectory.recordPainEvent({
+      sessionId,
+      source: 'gate_block',
+      score: 60,
+      reason: 'Second pain event',
+      severity: 'moderate',
+      origin: 'system_infer',
+    });
+
+    expect(id2).toBeGreaterThan(id1);
+    expect(typeof id1).toBe('number');
+    expect(typeof id2).toBe('number');
+  });
+});