principles-disciple 1.54.0 → 1.56.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.54.0",
+  "version": "1.56.0",
   "skills": [
     "./skills"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.54.0",
+  "version": "1.56.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",
@@ -67,6 +67,7 @@
     }
   },
   "dependencies": {
+    "@principles/core": "^0.1.0",
     "@sinclair/typebox": "^0.34.48",
     "better-sqlite3": "^12.9.0",
     "lucide-react": "^1.7.0",

package/src/core/event-log.ts

@@ -51,6 +51,9 @@ export class EventLog {
   private currentEventsFile: string | undefined;
   private currentDate: string | undefined;
 
+  // Pain score sum per date (for avgScore calculation)
+  private readonly painScoreSums: Map<string, number> = new Map();
+
   constructor(stateDir: string, logger?: PluginLogger) {
     this.logsDir = path.join(stateDir, 'logs');
     if (!fs.existsSync(this.logsDir)) {
@@ -156,6 +159,10 @@ export class EventLog {
   recordEvolutionTask(data: EvolutionTaskEventData): void {
     this.record('evolution_task', 'enqueued', undefined, data);
   }
+
+  recordEvolutionTaskCompleted(data: EvolutionTaskEventData): void {
+    this.record('evolution_task', 'completed', undefined, data);
+  }
   
   recordDeepReflection(sessionId: string | undefined, data: DeepReflectionEventData): void {
     const category = data.passed ? 'passed' : data.timeout ? 'failure' : 'completed';
@@ -238,6 +245,18 @@ export class EventLog {
       stats.pain.signalsDetected++;
       stats.pain.maxScore = Math.max(stats.pain.maxScore, data.score);
 
+      // Track signals by source
+      if (data.source) {
+        stats.pain.signalsBySource[data.source] = (stats.pain.signalsBySource[data.source] || 0) + 1;
+      }
+
+      // Accumulate score for avg calculation
+      const currentSum = this.painScoreSums.get(entry.date) ?? 0;
+      this.painScoreSums.set(entry.date, currentSum + (data.score || 0));
+      stats.pain.avgScore = stats.pain.signalsDetected > 0
+        ? Math.round((currentSum + (data.score || 0)) / stats.pain.signalsDetected)
+        : 0;
+
       // Update empathy stats for user_empathy source
       if (data.source === 'user_empathy') {
         if (data.deduped) {
@@ -291,6 +310,20 @@ export class EventLog {
       const data = entry.data as unknown as EmpathyRollbackEventData;
       stats.empathy.rollbackCount++;
       stats.empathy.rolledBackScore += data.originalScore || 0;
+    } else if (entry.type === 'rule_match') {
+      const data = entry.data as unknown as RuleMatchEventData;
+      if (data.ruleId) {
+        stats.pain.rulesMatched[data.ruleId] = (stats.pain.rulesMatched[data.ruleId] || 0) + 1;
+      }
+    } else if (entry.type === 'rule_promotion') {
+      stats.pain.candidatesPromoted++;
+      stats.evolution.rulesPromoted++;
+    } else if (entry.type === 'evolution_task') {
+      if (entry.category === 'completed') {
+        stats.evolution.tasksCompleted++;
+      } else if (entry.category === 'enqueued') {
+        stats.evolution.tasksEnqueued++;
+      }
     }
   }
 

package/src/core/evolution-types.ts

@@ -470,7 +470,7 @@ export type EvolutionLoopEvent =
 
 // V2 Queue Types (moved from evolution-worker.ts for shared use)
 export type QueueStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'canceled';
-export type TaskResolution = 'marker_detected' | 'auto_completed_timeout' | 'failed_max_retries' | 'runtime_unavailable' | 'canceled' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'stub_fallback' | 'skipped_thin_violation' | 'success' | 'failure' | 'skipped';
+export type TaskResolution = 'marker_detected' | 'auto_completed_timeout' | 'failed_max_retries' | 'runtime_unavailable' | 'canceled' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'stub_fallback' | 'skipped_thin_violation' | 'success' | 'failure' | 'skipped' | 'noise_classified';
 
 export interface EvolutionQueueItem {
   id: string;

package/src/core/observability.ts

@@ -235,7 +235,7 @@ function persistBaselines(stateDir: string, baselines: ObservabilityBaselines):
       fs.mkdirSync(dir, { recursive: true });
     }
     atomicWriteFileSync(filePath, JSON.stringify(baselines, null, 2));
-  } catch (err) {
+  } catch {
     // Baselines persistence is best-effort — don't crash the caller
     // (the SystemLogger call above already logged the values)
   }

package/src/core/pain-context-extractor.ts

@@ -15,7 +15,7 @@
  * SAFETY:
  * - Never load entire file (tail-only, max 512KB)
  * - Skip lines > 100KB (real files have 11MB single lines)
- * - Cap total output at 1500 chars
+ * - Cap total output at 2000 chars
  * - All errors caught silently — return empty string on failure
  */
 
@@ -35,9 +35,9 @@ const TAIL_READ_SIZE = 512_000; // 512KB
 /** Max turns to extract */
 const MAX_TURNS = 8;
 /** Max chars per turn entry */
-const MAX_TURN_CHARS = 250;
+const MAX_TURN_CHARS = 400;
 /** Max total output */
-const MAX_OUTPUT_CHARS = 1500;
+const MAX_OUTPUT_CHARS = 2000;
 
 /** Valid characters for session IDs and agent IDs — prevents path traversal */
 const SAFE_ID_REGEX = /^[a-zA-Z0-9_-]+$/;
@@ -155,19 +155,24 @@ function extractTurn(msg: ParsedMessage): string | null {
   }
 
   if (msg.role === 'assistant') {
-    // Priority 1: final text reply
+    const parts: string[] = [];
+    
+    // Priority 1: final text reply (if present)
     if (msg.textParts.length > 0) {
       const text = msg.textParts.join(' ').trim();
-      if (text) return `[Assistant]: ${text.substring(0, MAX_TURN_CHARS)}`;
+      if (text) parts.push(`[Assistant]: ${text.substring(0, MAX_TURN_CHARS)}`);
     }
-    // Priority 2: tool call summary (what operations were performed)
+    
+    // Priority 2: tool call summary (always include if present, for context)
     if (msg.toolCalls.length > 0) {
       const tools = msg.toolCalls.map(tc => tc.name).filter(Boolean);
       const uniqueTools = [...new Set(tools)];
       if (uniqueTools.length > 0) {
-        return `[Assistant → ${uniqueTools.join(', ')}]`;
+        parts.push(`[Assistant → ${uniqueTools.join(', ')}]`);
       }
     }
+    
+    return parts.length > 0 ? parts.join(' ') : null;
   }
 
   if (msg.role === 'toolResult') {

package/src/service/event-log-auditor.ts

@@ -179,8 +179,16 @@ export async function auditEventLogs(
         recentEntries: recent,
       });
 
-      // Determine primary path (workspace-main or most recent)
-      if (filePath.includes('workspace-main') || filePath.includes('workspace-main')) {
+      // Determine primary path - prefer configured workspace over workspace-main
+      // The configured workspace path is {openclawDir}/workspace (without -main suffix)
+      const workspaceDir = path.join(openclawDir, 'workspace') + path.sep;
+      const workspaceMainDir = path.join(openclawDir, 'workspace-main') + path.sep;
+      
+      if (filePath.startsWith(workspaceDir)) {
+        // Configured workspace (e.g., ~/.openclaw/workspace/) takes priority
+        primaryPath = filePath;
+      } else if (!primaryPath && filePath.startsWith(workspaceMainDir)) {
+        // Fallback to workspace-main only if no configured workspace found yet
         primaryPath = filePath;
       }
     } catch {

package/src/service/evolution-queue-migration.ts

@@ -26,7 +26,8 @@ export type TaskResolution =
     | 'late_marker_principle_created'
     | 'late_marker_no_principle'
     | 'stub_fallback'
-    | 'skipped_thin_violation';
+    | 'skipped_thin_violation'
+    | 'noise_classified';
 
 /**
  * Recent pain context for sleep_reflection tasks.

package/src/service/evolution-worker.ts

@@ -109,7 +109,7 @@ let timeoutId: NodeJS.Timeout | null = null;
  * Old queue items (without taskKind) are migrated to pain_diagnosis for compatibility.
  */
 export type QueueStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'canceled';
-export type TaskResolution = 'marker_detected' | 'auto_completed_timeout' | 'failed_max_retries' | 'runtime_unavailable' | 'canceled' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'stub_fallback' | 'skipped_thin_violation';
+export type TaskResolution = 'marker_detected' | 'auto_completed_timeout' | 'failed_max_retries' | 'runtime_unavailable' | 'canceled' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'stub_fallback' | 'skipped_thin_violation' | 'noise_classified';
 
 export interface EvolutionQueueItem {
     // Core identity
@@ -926,6 +926,21 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                 if (fs.existsSync(reportPath)) {
                     try {
                         const reportData = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+
+                        // ── Step 3: Noise Classification Filter ──
+                        // Skip principle creation for low-value noise categories that don't represent
+                        // systemic failures or behavioral issues worth encoding as principles.
+                        const classification = reportData?.classification;
+                        const noiseCategories: Record<string, boolean> = {
+                            'development_transient': true, // CRLF drift, duplicate match, self-resolved dev issues
+                            'user_error': true,           // User mistakes, wrong file, bad input
+                        };
+                        if (classification?.category && noiseCategories[classification.category]) {
+                            if (logger) logger.info(`[PD:EvolutionWorker] Skipping principle for noise category "${classification.category}" — pain was ${classification.severity || 'low'} severity, not a systemic failure`);
+                            task.status = 'completed';
+                            task.completed_at = new Date().toISOString();
+                            task.resolution = 'noise_classified';
+                        } else {
                         // Check ALL known nesting paths — matches subagent.ts parseDiagnosticianReport
                         const principle = reportData?.principle
                             || reportData?.phases?.principle_extraction?.principle
@@ -1017,6 +1032,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                         } else {
                             logger.warn(`[PD:EvolutionWorker] Diagnostician report for task ${task.id} missing principle fields — diagnostician did not produce a principle`);
                         }
+                        }
                     } catch (err) {
                         logger.warn(`[PD:EvolutionWorker] Failed to parse diagnostician report for task ${task.id}: ${String(err)}`);
                     }
@@ -1051,6 +1067,13 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                     durationMs,
                 });
 
+                // Record task completion in event stats
+                eventLog.recordEvolutionTaskCompleted({
+                    taskId: task.id,
+                    taskType: task.source || 'unknown',
+                    reason: task.reason || '',
+                });
+
                 // Update evolution_tasks table
                 wctx.trajectory?.updateEvolutionTask?.(task.id, {
                     status: 'completed',
@@ -1139,6 +1162,13 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                     durationMs: age,
                 });
 
+                // Record task completion in event stats (for timeout path too)
+                eventLog.recordEvolutionTaskCompleted({
+                    taskId: task.id,
+                    taskType: task.source || 'unknown',
+                    reason: task.reason || '',
+                });
+
                 // Update evolution_tasks table - use task.resolution, not hardcoded value
                 wctx.trajectory?.updateEvolutionTask?.(task.id, {
                     status: 'completed',

package/src/tools/write-pain-flag.ts

@@ -1,6 +1,5 @@
 import type { OpenClawPluginApi } from '../openclaw-sdk.js';
 import { Type } from '@sinclair/typebox';
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 import { buildPainFlag } from '../core/pain.js';
 import { resolveWorkspaceDirFromApi } from '../core/path-resolver.js';
 import { TrajectoryRegistry } from '../core/trajectory.js';

package/tests/core/event-log.test.ts

@@ -179,4 +179,78 @@ describe('EventLog', () => {
       expect(stats.totalPenaltyScore).toBe(12);
     });
   });
+
+  describe('Evolution and rule stats', () => {
+    it('should count evolution_task enqueued events', () => {
+      eventLog.recordEvolutionTask({ taskId: 't1', taskType: 'pain_diagnosis', reason: 'test' });
+      eventLog.recordEvolutionTask({ taskId: 't2', taskType: 'pain_diagnosis', reason: 'test' });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      expect(stats.evolution.tasksEnqueued).toBe(2);
+      expect(stats.evolution.tasksCompleted).toBe(0);
+    });
+
+    it('should count evolution_task completed events', () => {
+      // First enqueue
+      eventLog.recordEvolutionTask({ taskId: 't1', taskType: 'pain_diagnosis', reason: 'test' });
+      // Then complete
+      eventLog.recordEvolutionTaskCompleted({ taskId: 't1', taskType: 'pain_diagnosis', reason: 'test' });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      expect(stats.evolution.tasksEnqueued).toBe(1);
+      expect(stats.evolution.tasksCompleted).toBe(1);
+    });
+
+    it('should track rule_match events in rulesMatched', () => {
+      eventLog.recordRuleMatch('s1', { ruleId: 'edit-exact-match', layer: 'L2', severity: 0.8, textPreview: 'test' });
+      eventLog.recordRuleMatch('s1', { ruleId: 'edit-exact-match', layer: 'L2', severity: 0.8, textPreview: 'test' });
+      eventLog.recordRuleMatch('s1', { ruleId: 'path-traversal', layer: 'L1', severity: 0.9, textPreview: 'test2' });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      expect(stats.pain.rulesMatched['edit-exact-match']).toBe(2);
+      expect(stats.pain.rulesMatched['path-traversal']).toBe(1);
+    });
+
+    it('should track rule_promotion events', () => {
+      eventLog.recordRulePromotion({ fingerprint: 'fp1', ruleId: 'r1', phrase: 'test', sampleCount: 5, avgSimilarity: 0.9 });
+      eventLog.recordRulePromotion({ fingerprint: 'fp2', ruleId: 'r2', phrase: 'test2', sampleCount: 3, avgSimilarity: 0.8 });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      expect(stats.pain.candidatesPromoted).toBe(2);
+      expect(stats.evolution.rulesPromoted).toBe(2);
+    });
+
+    it('should track pain signals by source', () => {
+      eventLog.recordPainSignal('s1', { source: 'tool_failure', score: 50, reason: 'edit failed' });
+      eventLog.recordPainSignal('s2', { source: 'tool_failure', score: 60, reason: 'read failed' });
+      eventLog.recordPainSignal('s3', { source: 'user_empathy', score: 10, reason: 'user frustrated' });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      expect(stats.pain.signalsBySource['tool_failure']).toBe(2);
+      expect(stats.pain.signalsBySource['user_empathy']).toBe(1);
+      expect(stats.pain.signalsDetected).toBe(3);
+    });
+
+    it('should calculate avgScore for pain signals', () => {
+      eventLog.recordPainSignal('s1', { source: 'tool_failure', score: 50, reason: 'test' });
+      eventLog.recordPainSignal('s2', { source: 'tool_failure', score: 70, reason: 'test' });
+      eventLog.recordPainSignal('s3', { source: 'tool_failure', score: 60, reason: 'test' });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      expect(stats.pain.avgScore).toBe(60); // (50+70+60)/3 = 60
+      expect(stats.pain.maxScore).toBe(70);
+    });
+  });
 });

package/tests/core/pain-context-extractor.test.ts

@@ -1,8 +1,9 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 
-const TEST_AGENTS_DIR = path.join('/tmp', 'pd-test-agents-' + Date.now());
+const TEST_AGENTS_DIR = path.join(os.tmpdir(), 'pd-test-agents-' + Date.now());
 
 // Set env before module load
 process.env.PD_TEST_AGENTS_DIR = TEST_AGENTS_DIR;

package/tests/core/pain-lifecycle.test.ts

@@ -1,11 +1,12 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 import { clearPainFlag, PAIN_FLAG_FILENAME } from '../../src/core/pain-lifecycle.js';
 import { resolvePdPath } from '../../src/core/paths.js';
 
 describe('PainLifecycle', () => {
-    const workspaceDir = fs.mkdtempSync(path.join(fs.realpathSync('/tmp'), 'pain-lifecycle-test-'));
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pain-lifecycle-test-'));
     const painFlagPath = resolvePdPath(workspaceDir, 'PAIN_FLAG');
 
     beforeEach(() => {

package/tests/integration/pain-lifecycle-e2e.test.ts

@@ -1,11 +1,12 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 import { clearPainFlag } from '../../src/core/pain-lifecycle.js';
 import { resolvePdPath } from '../../src/core/paths.js';
 
 describe('Pain Lifecycle E2E', () => {
-    const workspaceDir = fs.mkdtempSync(path.join(fs.realpathSync('/tmp'), 'pain-lifecycle-e2e-'));
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pain-lifecycle-e2e-'));
     const painFlagPath = resolvePdPath(workspaceDir, 'PAIN_FLAG');
     const stateDir = path.dirname(painFlagPath);
 

package/tests/commands/evolver.test.ts

@@ -1,22 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { handleEvolveTask } from '../../src/commands/evolver';
-
-describe('Evolver Synergy Module', () => {
-  it('should handle /evolve-task command', () => {
-    const mockCtx = { 
-        workspaceDir: '/mock/workspace',
-        commandBody: '/evolve-task',
-        channel: 'cli',
-        isAuthorizedSender: true,
-        config: {} as any,
-        args: 'Fix tests'
-    };
-
-    const result = handleEvolveTask(mockCtx as any);
-
-    expect(result).toBeDefined();
-    expect(result.text).toContain('Evolver Handoff Requested');
-    expect(result.text).toContain('sessions_spawn');
-    expect(result.text).toContain('Fix tests');
-  });
-});