principles-disciple 1.51.0 → 1.53.0

package/src/hooks/prompt.ts

@@ -11,6 +11,7 @@ import { classifyTask, type RoutingInput } from '../core/local-worker-routing.js
 import { extractSummary, getHistoryVersions, parseWorkingMemorySection, workingMemoryToInjection, autoCompressFocus, safeReadCurrentFocus } from '../core/focus-history.js';
 import { EmpathyObserverWorkflowManager, empathyObserverWorkflowSpec, isExpectedSubagentError } from '../service/subagent-workflow/index.js';
 import { PathResolver } from '../core/path-resolver.js';
+import { selectPrinciplesForInjection, DEFAULT_PRINCIPLE_BUDGET } from '../core/principle-injection.js';
 import { isSubagentRuntimeAvailable } from '../utils/subagent-probe.js';
 import { getPendingDiagnosticianTasks } from '../core/diagnostician-task-store.js';
 import {
@@ -533,8 +534,11 @@ The empathy observer subagent handles pain detection independently.
 
   const empathyEnabled = wctx.config.get('empathy_engine.enabled') !== false;
   logger?.info?.(`[PD:Empathy] Conditions: enabled=${empathyEnabled}, isUser=${isUserInteraction}, sessionId=${!!sessionId}, api=${!!api}, !agentToAgent=${!isAgentToAgent}, workspaceDir=${!!workspaceDir}, hasMessage=${!!latestUserMessage}`);
+
+  // Track if we should inject behavioral constraints (will be added to appendSystemContext later)
+  let shouldInjectBehavioralConstraints = false;
   if (empathyEnabled && isUserInteraction && sessionId && api && !isAgentToAgent) {
-    prependContext = '### BEHAVIORAL_CONSTRAINTS\n' + empathySilenceConstraint + '\n\n' + prependContext;
+    shouldInjectBehavioralConstraints = true;
 
     // ── Empathy Hybrid Matching (keyword + subagent sampling) ──
     // Fast keyword scan on every turn, with strategic subagent sampling
@@ -898,12 +902,26 @@ ${taskBlocks}${processingNote}
   }
 
 
-  // Evolution principles injection (active + probation summary)
+  // Evolution principles injection — budget-aware selection (SDK-QUAL-04)
   let evolutionPrinciplesContent = '';
   try {
     const reducer = wctx.evolutionReducer;
-    const active = reducer.getActivePrinciples().slice(-3);
-    const probation = reducer.getProbationPrinciples().slice(0, 5);
+    const allActive = reducer.getActivePrinciples();
+    const allProbation = reducer.getProbationPrinciples();
+
+    // Budget-aware selection: prioritize P0>P1>P2 and recency
+    const activeSelection = selectPrinciplesForInjection(allActive, DEFAULT_PRINCIPLE_BUDGET);
+    const active = activeSelection.selected;
+
+    // Probation principles get a smaller sub-budget (1000 chars)
+    const probationBudget = 1000;
+    const probationSelection = selectPrinciplesForInjection(allProbation, probationBudget);
+    const probation = probationSelection.selected;
+
+    if (activeSelection.wasTruncated || probationSelection.wasTruncated) {
+      logger?.info?.(`[PD:Prompt] Principles truncated: active=${activeSelection.breakdown.p0 + activeSelection.breakdown.p1 + activeSelection.breakdown.p2}/${allActive.length} (${activeSelection.totalChars}c), probation=${probation.length}/${allProbation.length} (${probationSelection.totalChars}c)`);
+    }
+
     if (ctx.sessionId) {
       if (probation.length > 0) {
         setInjectedProbationIds(ctx.sessionId, probation.map((p) => p.id), workspaceDir);
@@ -935,9 +953,18 @@ ${taskBlocks}${processingNote}
   }
 
   // Build appendSystemContext with recency effect
-  // Content order (most important last): project_context -> working_memory -> reflection_log -> thinking_os -> principles
+  // Content order (most important last): behavioral_constraints -> project_context -> working_memory -> reflection_log -> thinking_os -> principles
   const appendParts: string[] = [];
 
+  // 0. Behavioral Constraints (empathy observer coordination)
+  // Injected here (appendSystemContext) instead of prependContext to hide from WebUI users.
+  // See: https://github.com/csuzngjh/principles/issues/XXX
+  if (shouldInjectBehavioralConstraints) {
+    appendParts.push(`<behavioral_constraints>
+${empathySilenceConstraint}
+</behavioral_constraints>`);
+  }
+
   // 1. Project Context (lowest priority, goes first)
   if (projectContextContent) {
     appendParts.push(`<project_context>\n${projectContextContent}\n</project_context>`);
@@ -1087,6 +1114,7 @@ The sections below are ordered by priority. When conflicts arise, **later sectio
 ---
 
 **【EXECUTION RULES】** (Priority: Low → High):
+- \`<behavioral_constraints>\` - Output format restrictions (hide diagnostic JSON)
 - \`<project_context>\` - Current priorities (can be overridden)
 - \`<reflection_log>\` - Past lessons (inform your approach)
 - \`<thinking_os>\` - Thinking models (guide your reasoning)

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

@@ -1,9 +1,9 @@
 /**
- * EventLog Auditor — Search and verify events across all .state directories
- * 
+ * EventLog Auditor - Search and verify events across all .state directories
+ *
  * This tool addresses a common debugging issue where hook events may be
  * written to the wrong .state directory due to workspaceDir resolution bugs.
- * 
+ *
  * Usage:
  *   const report = await auditEventLogs(openclawDir, ['after_tool_call', 'before_tool_call']);
  *   console.log(report.summary);
@@ -42,7 +42,7 @@ interface AuditReport {
  */
 function findEventLogs(baseDir: string, maxDepth = 4): string[] {
   const results: string[] = [];
-  
+
   function scan(dir: string, depth: number): void {
     if (depth > maxDepth) return;
     try {
@@ -58,37 +58,50 @@ function findEventLogs(baseDir: string, maxDepth = 4): string[] {
       // Permission denied or directory doesn't exist
     }
   }
-  
+
   scan(baseDir, 0);
   return results;
 }
 
 /**
  * Find events.jsonl in well-known locations.
+ * Dynamically discovers workspace directories instead of hardcoding names.
  */
 function findKnownEventLogPaths(): string[] {
   const homeDir = os.homedir();
   const candidates: string[] = [];
-  
-  // Common patterns
-  const patterns = [
+
+  // Common patterns (legacy, non-workspace paths)
+  const legacyPatterns = [
     path.join(homeDir, '.state', 'logs', 'events.jsonl'),
     path.join(homeDir, '.openclaw', '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', 'workspace-main', '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', 'workspace-builder', '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', 'workspace-pm', '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', 'workspace-hr', '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', 'workspace-repair', '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', 'workspace-research', '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', 'workspace-scout', '.state', 'logs', 'events.jsonl'),
   ];
-  
-  for (const p of patterns) {
+
+  for (const p of legacyPatterns) {
     if (fs.existsSync(p)) {
       candidates.push(p);
     }
   }
-  
+
+  // Dynamically discover workspace directories under ~/.openclaw/
+  const openclawDir = path.join(homeDir, '.openclaw');
+  if (fs.existsSync(openclawDir)) {
+    try {
+      const entries = fs.readdirSync(openclawDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        // Skip known non-workspace directories
+        if (entry.name.startsWith('.') || entry.name === 'extensions' || entry.name === 'memory') continue;
+        const eventLogPath = path.join(openclawDir, entry.name, '.state', 'logs', 'events.jsonl');
+        if (fs.existsSync(eventLogPath)) {
+          candidates.push(eventLogPath);
+        }
+      }
+    } catch {
+      // Directory read failed, skip dynamic discovery
+    }
+  }
+
   return candidates;
 }
 
@@ -133,25 +146,25 @@ function countAllHooks(filePath: string): Record<string, number> {
 
 /**
  * Audit all events.jsonl files.
- * 
+ *
  * @param openclawDir - Base OpenClaw directory (e.g., ~/.openclaw)
  * @param expectedToolHooks - Hook names that should appear in the primary workspace
  */
-     
+
 export async function auditEventLogs(
   openclawDir: string,
   expectedToolHooks: string[] = ['before_tool_call', 'after_tool_call'],
 ): Promise<AuditReport> {
   const homeDir = os.homedir();
-  
+
   // Find all event logs
   const knownPaths = findKnownEventLogPaths();
   const scannedPaths = findEventLogs(homeDir, 4);
   const allPaths = [...new Set([...knownPaths, ...scannedPaths])];
-  
+
   const locations: LocationReport[] = [];
   let primaryPath: string | null = null;
-  
+
   for (const filePath of allPaths) {
     try {
       const stat = fs.statSync(filePath);
@@ -165,7 +178,7 @@ export async function auditEventLogs(
         hookCounts: allCounts,
         recentEntries: recent,
       });
-      
+
       // Determine primary path (workspace-main or most recent)
       if (filePath.includes('workspace-main') || filePath.includes('workspace-main')) {
         primaryPath = filePath;
@@ -174,7 +187,7 @@ export async function auditEventLogs(
       // Skip unreadable files
     }
   }
-  
+
   // If no primary found, use most recent
   if (!primaryPath && locations.length > 0) {
     locations.sort((a, b) => {
@@ -184,21 +197,21 @@ export async function auditEventLogs(
     });
     primaryPath = locations[0].path;
   }
-  
+
   // Detect misplaced tool hook events
   const misplacedEvents: { path: string; entries: EventLogEntry[] }[] = [];
   for (const loc of locations) {
     if (loc.path === primaryPath) continue;
-    
-    const toolHookEntries = loc.recentEntries.filter(e => 
+
+    const toolHookEntries = loc.recentEntries.filter(e =>
       e.type === 'hook_execution' && expectedToolHooks.includes(e.data?.hook as string)
     );
-    
+
     if (toolHookEntries.length > 0) {
       misplacedEvents.push({ path: loc.path, entries: toolHookEntries });
     }
   }
-  
+
   return {
     searchedPaths: allPaths,
     locations,
@@ -210,37 +223,37 @@ export async function auditEventLogs(
 /**
  * Format audit report for display.
  */
-     
+
 export function formatAuditReport(report: AuditReport): string {
   const lines: string[] = [];
-  
+
   lines.push('=== Event Log Audit Report ===\n');
-  
+
   lines.push(`Searched ${report.searchedPaths.length} paths:\n`);
   for (const p of report.searchedPaths) {
     lines.push(`  ${p}`);
   }
   lines.push('');
-  
+
   lines.push(`Primary: ${report.primaryPath ?? 'NOT FOUND'}\n`);
-  
+
   for (const loc of report.locations) {
     const isPrimary = loc.path === report.primaryPath;
     lines.push(`─── ${isPrimary ? '[PRIMARY]' : '[OTHER]   '}${loc.path}`);
     lines.push(`    Last modified: ${loc.lastModified?.toISOString() ?? 'never'}`);
     lines.push(`    Hook counts:`);
-    
+
     const hooks = Object.entries(loc.hookCounts).sort((a, b) => b[1] - a[1]);
     for (const [hook, count] of hooks) {
       lines.push(`      ${hook}: ${count}`);
     }
-    
+
     if (hooks.length === 0) {
       lines.push(`      (no hooks recorded)`);
     }
     lines.push('');
   }
-  
+
   if (report.misplacedEvents.length > 0) {
     lines.push('⚠️  MISPLACED tool hook events detected:');
     for (const me of report.misplacedEvents) {
@@ -258,6 +271,6 @@ export function formatAuditReport(report: AuditReport): string {
   } else {
     lines.push('✅ No misplaced tool hook events detected.');
   }
-  
+
   return lines.join('\n');
 }

package/src/service/evolution-worker.ts

@@ -18,6 +18,7 @@ import type { TaskKind, TaskPriority } from '../core/trajectory-types.js';
 import type { PrincipleEvaluability } from '../types/principle-tree-schema.js';
 export type { TaskKind, TaskPriority } from '../core/trajectory-types.js';
 import { atomicWriteFileSync } from '../utils/io.js';
+import { validatePainSignal, type PainSignalValidationResult } from '../core/pain-signal.js';
 
 // Re-export queue I/O (extracted to queue-io.ts)
 export { loadEvolutionQueue, saveEvolutionQueue, withQueueLock, acquireQueueLock, requireQueueLock } from './queue-io.js';
@@ -330,6 +331,26 @@ async function doEnqueuePainTask(
         return result;
     }
 
+    // Validate pain signal through TypeBox schema before enqueuing.
+    // Malformed signals are logged and skipped — they never enter the queue.
+    const signalInput = {
+        source: v.source,
+        score: v.score,
+        timestamp: new Date().toISOString(),
+        reason: v.reason,
+        sessionId: v.sessionId || '',
+        agentId: v.agentId || '',
+        traceId: v.traceId || '',
+        triggerTextPreview: v.preview,
+    };
+    const validation: PainSignalValidationResult = validatePainSignal(signalInput);
+    if (!validation.valid) {
+        result.skipped_reason = `invalid_pain_signal (${validation.errors.join('; ')})`;
+        if (logger) logger.warn(`[PD:EvolutionWorker] Pain signal validation failed, skipping enqueue: ${validation.errors.join('; ')}`);
+        SystemLogger.log(wctx.workspaceDir, 'PAIN_SIGNAL_INVALID', `Validation errors: ${validation.errors.join('; ')} | source=${v.source} score=${v.score}`);
+        return result;
+    }
+
     const queuePath = wctx.resolve('EVOLUTION_QUEUE');
     const releaseLock = await requireQueueLock(queuePath, logger, 'checkPainFlag');
     try {
@@ -763,9 +784,38 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
         }
 
         // V2: Migrate queue to current schema if needed
-        const queue: EvolutionQueueItem[] = migrateQueueToV2(rawQueue) as unknown as EvolutionQueueItem[];
+        let queue: EvolutionQueueItem[] = migrateQueueToV2(rawQueue) as unknown as EvolutionQueueItem[];
+
+        // Validate queue items — filter out malformed entries before processing.
+        // Malformed items are logged + skipped; they never crash the evolution cycle.
+        const beforeValidation = queue.length;
+        queue = queue.filter((item) => {
+            const errors: string[] = [];
+            if (!item.id || typeof item.id !== 'string') errors.push('missing/invalid id');
+            if (!item.source || typeof item.source !== 'string') errors.push('missing/invalid source');
+            if (typeof item.score !== 'number') errors.push('missing/invalid score');
+            if (!item.status || typeof item.status !== 'string') errors.push('missing/invalid status');
+            if (!item.taskKind || typeof item.taskKind !== 'string') errors.push('missing/invalid taskKind');
+            else {
+                const validTaskKinds = ['pain_diagnosis', 'sleep_reflection', 'model_eval', 'keyword_optimization'];
+                if (!validTaskKinds.includes(item.taskKind)) {
+                    errors.push(`invalid taskKind value '${item.taskKind}' (expected one of: ${validTaskKinds.join(', ')})`);
+                }
+            }
+            if (typeof item.retryCount !== 'number') errors.push('missing/invalid retryCount');
+            if (typeof item.maxRetries !== 'number') errors.push('missing/invalid maxRetries');
+            if (errors.length > 0) {
+                logger?.warn?.(`[PD:EvolutionWorker] Skipping malformed queue item: ${errors.join(', ')} | ${JSON.stringify(item).slice(0, 200)}`);
+                SystemLogger.log(wctx.workspaceDir, 'QUEUE_ITEM_MALFORMED', `Skipped: ${errors.join(', ')} | id=${item.id || 'N/A'}`);
+                return false;
+            }
+            return true;
+        });
+        if (queue.length < beforeValidation) {
+            logger?.info?.(`[PD:EvolutionWorker] Filtered ${beforeValidation - queue.length} malformed queue item(s)`);
+        }
 
-        let queueChanged = rawQueue.some(isLegacyQueueItem);
+        let queueChanged = rawQueue.some(isLegacyQueueItem) || queue.length < beforeValidation;
 
         // Guard: Skip keyword_optimization if one is already pending/in-progress (CORR-08)
         if (hasPendingTask(queue, 'keyword_optimization')) {

package/tests/core/evolution-hook.test.ts

@@ -0,0 +1,123 @@
+import { describe, it, expect } from 'vitest';
+import type { EvolutionHook, PrincipleCreatedEvent, PrinciplePromotedEvent } from '../../src/core/evolution-hook.js';
+import { noOpEvolutionHook } from '../../src/core/evolution-hook.js';
+import type { PainSignal } from '../../src/core/pain-signal.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function validPainSignal(overrides: Partial<PainSignal> = {}): PainSignal {
+  return {
+    source: 'tool_failure',
+    score: 75,
+    timestamp: '2026-04-17T00:00:00.000Z',
+    reason: 'File not found',
+    sessionId: 'session-001',
+    agentId: 'main',
+    traceId: 'trace-001',
+    triggerTextPreview: 'File not found: test.ts',
+    domain: 'coding',
+    severity: 'high',
+    context: {},
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('EvolutionHook', () => {
+  it('implements all 3 methods', () => {
+    const calls: string[] = [];
+    const hook: EvolutionHook = {
+      onPainDetected(signal: PainSignal): void { calls.push(`pain:${signal.source}`); },
+      onPrincipleCreated(event: PrincipleCreatedEvent): void { calls.push(`created:${event.id}`); },
+      onPrinciplePromoted(event: PrinciplePromotedEvent): void { calls.push(`promoted:${event.id}`); },
+    };
+
+    hook.onPainDetected(validPainSignal());
+    hook.onPrincipleCreated({ id: 'p-1', text: 'Test principle', trigger: 'tool failure' });
+    hook.onPrinciplePromoted({ id: 'p-1', from: 'candidate', to: 'active' });
+
+    expect(calls).toEqual(['pain:tool_failure', 'created:p-1', 'promoted:p-1']);
+  });
+
+  it('onPainDetected receives a PainSignal', () => {
+    let received: PainSignal | undefined;
+    const hook: EvolutionHook = {
+      ...noOpEvolutionHook,
+      onPainDetected(signal: PainSignal): void { received = signal; },
+    };
+
+    const signal = validPainSignal();
+    hook.onPainDetected(signal);
+    expect(received).toEqual(signal);
+  });
+
+  it('onPrincipleCreated receives a PrincipleCreatedEvent', () => {
+    let received: PrincipleCreatedEvent | undefined;
+    const hook: EvolutionHook = {
+      ...noOpEvolutionHook,
+      onPrincipleCreated(event: PrincipleCreatedEvent): void { received = event; },
+    };
+
+    const event = { id: 'p-1', text: 'Test principle', trigger: 'tool failure' };
+    hook.onPrincipleCreated(event);
+    expect(received).toEqual(event);
+  });
+
+  it('onPrinciplePromoted receives a PrinciplePromotedEvent', () => {
+    let received: PrinciplePromotedEvent | undefined;
+    const hook: EvolutionHook = {
+      ...noOpEvolutionHook,
+      onPrinciplePromoted(event: PrinciplePromotedEvent): void { received = event; },
+    };
+
+    const event = { id: 'p-1', from: 'candidate', to: 'active' };
+    hook.onPrinciplePromoted(event);
+    expect(received).toEqual(event);
+  });
+});
+
+describe('noOpEvolutionHook', () => {
+  it('implements all 3 methods as no-ops', () => {
+    expect(() => {
+      noOpEvolutionHook.onPainDetected(validPainSignal());
+      noOpEvolutionHook.onPrincipleCreated({ id: 'p-1', text: 'Test', trigger: 'test' });
+      noOpEvolutionHook.onPrinciplePromoted({ id: 'p-1', from: 'candidate', to: 'active' });
+    }).not.toThrow();
+  });
+
+  it('can be spread to override individual methods', () => {
+    const calls: string[] = [];
+    const hook: EvolutionHook = {
+      ...noOpEvolutionHook,
+      onPainDetected(_signal: PainSignal): void { calls.push('pain'); },
+    };
+
+    hook.onPainDetected(validPainSignal());
+    hook.onPrincipleCreated({ id: 'p-1', text: 'Test', trigger: 'test' });
+
+    expect(calls).toEqual(['pain']);
+  });
+});
+
+describe('PrincipleCreatedEvent', () => {
+  it('has required fields: id, text, trigger', () => {
+    const event: PrincipleCreatedEvent = { id: 'p-1', text: 'Always verify', trigger: 'tool failure' };
+    expect(event.id).toBe('p-1');
+    expect(event.text).toBe('Always verify');
+    expect(event.trigger).toBe('tool failure');
+  });
+});
+
+describe('PrinciplePromotedEvent', () => {
+  it('has required fields: id, from, to', () => {
+    const event: PrinciplePromotedEvent = { id: 'p-1', from: 'candidate', to: 'active' };
+    expect(event.id).toBe('p-1');
+    expect(event.from).toBe('candidate');
+    expect(event.to).toBe('active');
+  });
+});