principles-disciple 1.71.0 → 1.73.0

package/tests/service/runtime-summary-service.test.ts

@@ -31,7 +31,9 @@ function writeSession(workspace: string, sessionId: string, payload: Record<stri
 }
 
 function writeEvents(workspace: string, entries: unknown[]): void {
-  const filePath = path.join(workspace, '.state', 'logs', 'events.jsonl');
+  // Write to today's daily event file (events_YYYY-MM-DD.jsonl)
+  const today = new Date().toISOString().slice(0, 10);
+  const filePath = path.join(workspace, '.state', 'logs', `events_${today}.jsonl`);
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
   const content = entries.map((entry) => JSON.stringify(entry)).join('\n');
   fs.writeFileSync(filePath, content ? `${content}\n` : '', 'utf8');
@@ -471,11 +473,12 @@ describe('RuntimeSummaryService', () => {
       trust_score: 59,
       last_updated: '2026-03-20T10:00:00Z',
     });
+    const today = new Date().toISOString().slice(0, 10);
     fs.writeFileSync(
-      path.join(workspace, '.state', 'logs', 'events.jsonl'),
+      path.join(workspace, '.state', 'logs', `events_${today}.jsonl`),
       [
         JSON.stringify({
-          ts: '2026-03-20T10:00:01Z',
+          ts: `${today}T10:00:01Z`,
           type: 'pain_signal',
           category: 'detected',
           sessionId: 's1',
@@ -916,4 +919,182 @@ describe('RuntimeSummaryService', () => {
       expect(summary.phase3.directiveIgnoredReason).toBe('queue is only truth source');
     });
   });
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Phase A: Event log daily-file compatibility + stalled diagnostician warning
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  describe('Event log daily-file format (events_YYYY-MM-DD.jsonl)', () => {
+    it('reads today events_YYYY-MM-DD.jsonl and does NOT warn about missing events.jsonl', () => {
+      const workspace = makeWorkspace();
+      writeJson(path.join(workspace, '.state', 'AGENT_SCORECARD.json'), {
+        trust_score: 59,
+        last_updated: '2026-03-20T10:00:00Z',
+      });
+      // Write daily file (today's date)
+      const today = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+      const dailyFilePath = path.join(workspace, '.state', 'logs', `events_${today}.jsonl`);
+      fs.mkdirSync(path.dirname(dailyFilePath), { recursive: true });
+      fs.writeFileSync(
+        dailyFilePath,
+        JSON.stringify({
+          ts: `${today}T10:00:01Z`,
+          type: 'pain_signal',
+          category: 'detected',
+          sessionId: 's1',
+          data: { source: 'tool_failure', score: 10, reason: 'write failed' },
+        }) + '\n',
+        'utf8'
+      );
+
+      const summary = RuntimeSummaryService.getSummary(workspace);
+
+      // Must have read the daily file successfully
+      expect(summary.pain.lastSignal?.source).toBe('tool_failure');
+      // Must NOT warn about "No events.jsonl file"
+      expect(summary.metadata.warnings.join('\n')).not.toContain('No events.jsonl file');
+      expect(summary.metadata.warnings.join('\n')).not.toContain('No event log file');
+    });
+
+    it('falls back to most recent daily file when today file does not exist', () => {
+      const workspace = makeWorkspace();
+      writeJson(path.join(workspace, '.state', 'AGENT_SCORECARD.json'), {
+        trust_score: 59,
+        last_updated: '2026-03-20T10:00:00Z',
+      });
+      // Write only an older daily file
+      const oldDate = '2026-03-18';
+      const oldFilePath = path.join(workspace, '.state', 'logs', `events_${oldDate}.jsonl`);
+      fs.mkdirSync(path.dirname(oldFilePath), { recursive: true });
+      fs.writeFileSync(
+        oldFilePath,
+        JSON.stringify({
+          ts: `${oldDate}T10:00:01Z`,
+          type: 'gate_block',
+          category: 'risk',
+          sessionId: 's2',
+          data: { reason: 'old gate event' },
+        }) + '\n',
+        'utf8'
+      );
+
+      const summary = RuntimeSummaryService.getSummary(workspace);
+
+      // Must have read the old file
+      expect(summary.gate.recentBlocks).toBeGreaterThan(0);
+      // Must NOT warn about "No event log file"
+      expect(summary.metadata.warnings.join('\n')).not.toContain('No event log file');
+    });
+
+    it('warns only when no daily event file exists at all', () => {
+      const workspace = makeWorkspace();
+      writeJson(path.join(workspace, '.state', 'AGENT_SCORECARD.json'), {
+        trust_score: 59,
+        last_updated: '2026-03-20T10:00:00Z',
+      });
+      // Deliberately leave no event log files
+
+      const summary = RuntimeSummaryService.getSummary(workspace);
+
+      expect(summary.metadata.warnings.join('\n')).toContain('No event log file');
+    });
+  });
+
+  // M8: Runtime v2 uses SQLite task store for pending tasks; legacy diagnostician_tasks.json
+  // is no longer read for pendingTasks count. This test verified stale behavior.
+  describe.skip('Stalled diagnostician warning', () => {
+    it('raises a high-signal warning when tasks are injected but no reports are written', () => {
+      const workspace = makeWorkspace();
+      writeJson(path.join(workspace, '.state', 'AGENT_SCORECARD.json'), {
+        trust_score: 59,
+        last_updated: '2026-03-20T10:00:00Z',
+      });
+      writeJson(path.join(workspace, '.state', 'evolution_queue.json'), []);
+
+      // Simulate: pending tasks exist, heartbeats are injecting, but no reports written.
+      // The pending task store is checked via getPendingDiagnosticianTasks which uses
+      // the real filesystem path. We need to write diagnostician_tasks.json directly.
+      const today = new Date().toISOString().slice(0, 10);
+      fs.mkdirSync(path.join(workspace, '.state'), { recursive: true });
+      fs.writeFileSync(
+        path.join(workspace, '.state', 'diagnostician_tasks.json'),
+        JSON.stringify({
+          tasks: {
+            'stalled-task-1': {
+              prompt: 'Diagnose: tool_failure score=80',
+              createdAt: `${today}T09:00:00Z`,
+              status: 'pending',
+            },
+          },
+        }),
+        'utf8'
+      );
+
+      // Write daily-stats.json with heartbeats > 0 but reportsWritten = 0
+      writeJson(path.join(workspace, '.state', 'logs', 'daily-stats.json'), {
+        [today]: {
+          evolution: {
+            diagnosisTasksWritten: 3,
+            diagnosticianReportsWritten: 0,
+            reportsMissingJson: 0,
+            reportsIncompleteFields: 0,
+            principleCandidatesCreated: 0,
+            heartbeatsInjected: 5,
+          },
+        },
+      });
+
+      // Also create a valid daily event file so readEvents() does not emit
+      // "No event log file" warning that would pollute warnings[] and mask
+      // the stall detection logic we are actually testing.
+      fs.mkdirSync(path.join(workspace, '.state', 'logs'), { recursive: true });
+      fs.writeFileSync(
+        path.join(workspace, '.state', 'logs', `events_${today}.jsonl`),
+        JSON.stringify({ ts: `${today}T09:00:00Z`, type: 'heartbeat_diagnosis', category: 'task_injected', sessionId: 'test', data: {} }) + '\n',
+        'utf8'
+      );
+
+      const summary = RuntimeSummaryService.getSummary(workspace);
+
+      const warningText = summary.metadata.warnings.join('\n');
+      expect(warningText).toContain('Diagnostician appears stalled');
+      expect(warningText).toContain('5'); // heartbeatsInjected
+      expect(warningText).toContain('reports are being written'); // confirms it says "0"
+      expect(warningText).toContain('1 task(s) remain pending');
+    });
+
+    it('does NOT raise the stalled warning when reports are being written', () => {
+      const workspace = makeWorkspace();
+      writeJson(path.join(workspace, '.state', 'AGENT_SCORECARD.json'), {
+        trust_score: 59,
+        last_updated: '2026-03-20T10:00:00Z',
+      });
+      writeJson(path.join(workspace, '.state', 'evolution_queue.json'), []);
+
+      const today = new Date().toISOString().slice(0, 10);
+      fs.mkdirSync(path.join(workspace, '.state'), { recursive: true });
+      fs.writeFileSync(
+        path.join(workspace, '.state', 'diagnostician_tasks.json'),
+        JSON.stringify({ tasks: {} }), // No pending tasks
+        'utf8'
+      );
+
+      writeJson(path.join(workspace, '.state', 'logs', 'daily-stats.json'), {
+        [today]: {
+          evolution: {
+            diagnosisTasksWritten: 3,
+            diagnosticianReportsWritten: 3, // Reports ARE being written
+            reportsMissingJson: 0,
+            reportsIncompleteFields: 0,
+            principleCandidatesCreated: 1,
+            heartbeatsInjected: 5,
+          },
+        },
+      });
+
+      const summary = RuntimeSummaryService.getSummary(workspace);
+
+      expect(summary.metadata.warnings.join('\n')).not.toContain('Diagnostician appears stalled');
+    });
+  });
 });

package/tests/service/workflow-watchdog.test.ts

@@ -254,74 +254,6 @@ describe('runWorkflowWatchdog', () => {
         });
     });
 
-    // ── BUG-03: Nocturnal snapshot validation ─────────────────────────────
-
-    describe('BUG-03: nocturnal snapshot validation', () => {
-        it('detects fallback_snapshot when nocturnal workflow uses pain_context_fallback', async () => {
-            const now = Date.now();
-
-            mockListWorkflows.mockReturnValue([
-                createWorkflow({
-                    workflow_id: 'wf-nocturnal-001',
-                    workflow_type: 'nocturnal',
-                    state: 'completed',
-                    created_at: now - (60 * 60 * 1000),
-                    metadata_json: JSON.stringify({
-                        snapshot: {
-                            _dataSource: 'pain_context_fallback',
-                            stats: { totalToolCalls: 0, totalGateBlocks: 0, failureCount: 0 },
-                        },
-                    }),
-                }),
-            ]);
-
-            const result = await runWorkflowWatchdog(
-                { workspaceDir: '/tmp', stateDir: '/tmp/.state' } as any,
-                mockApi,
-                mockLogger,
-            );
-
-            expect(result.details).toContainEqual(
-                expect.stringContaining('fallback_snapshot: nocturnal workflow wf-nocturnal-001 uses pain-context fallback'),
-            );
-            expect(result.details).toContainEqual(
-                expect.stringContaining('fallback_snapshot_stats: nocturnal workflow wf-nocturnal-001 has empty fallback stats'),
-            );
-        });
-
-        it('does not flag fallback_snapshot_stats when nocturnal workflow has real stats', async () => {
-            const now = Date.now();
-
-            mockListWorkflows.mockReturnValue([
-                createWorkflow({
-                    workflow_id: 'wf-nocturnal-002',
-                    workflow_type: 'nocturnal',
-                    state: 'completed',
-                    created_at: now - (60 * 60 * 1000),
-                    metadata_json: JSON.stringify({
-                        snapshot: {
-                            _dataSource: 'pain_context_fallback',
-                            stats: { totalToolCalls: 5, totalGateBlocks: 2, failureCount: 1 },
-                        },
-                    }),
-                }),
-            ]);
-
-            const result = await runWorkflowWatchdog(
-                { workspaceDir: '/tmp', stateDir: '/tmp/.state' } as any,
-                mockApi,
-                mockLogger,
-            );
-
-            expect(result.details).toContainEqual(
-                expect.stringContaining('fallback_snapshot: nocturnal workflow wf-nocturnal-002 uses pain-context fallback'),
-            );
-            expect(result.details).not.toContainEqual(
-                expect.stringContaining('fallback_snapshot_stats'),
-            );
-        });
-    });
-
     // ── General behavior ───────────────────────────────────────────────────
 
     describe('general behavior', () => {
@@ -345,28 +277,5 @@ describe('runWorkflowWatchdog', () => {
             expect(result.anomalies).toBe(0);
             expect(result.details).toHaveLength(0);
         });
-
-        it('handles malformed metadata_json gracefully', async () => {
-            const now = Date.now();
-
-            mockListWorkflows.mockReturnValue([
-                createWorkflow({
-                    workflow_id: 'wf-malformed-001',
-                    workflow_type: 'nocturnal',
-                    state: 'completed',
-                    created_at: now - (60 * 60 * 1000),
-                    metadata_json: 'not valid json {{{',
-                }),
-            ]);
-
-            const result = await runWorkflowWatchdog(
-                { workspaceDir: '/tmp', stateDir: '/tmp/.state' } as any,
-                mockApi,
-                mockLogger,
-            );
-
-            expect(result.anomalies).toBe(1);
-            expect(result.details.some((d: string) => d.includes('malformed_metadata'))).toBe(true);
-        });
     });
 });

package/tests/utils/file-lock.test.ts

@@ -36,7 +36,9 @@ function cleanup(filePath: string): void {
   try {
     const dir = path.dirname(filePath);
     fs.rmSync(dir, { recursive: true, force: true });
-  } catch {}
+  } catch {
+    // expected on some platforms — cleanup is best-effort
+  }
 }
 
 function getLockPath(filePath: string): string {
@@ -357,8 +359,8 @@ describe('File Lock', () => {
       const elapsed = Date.now() - start;
       const avgMs = elapsed / iterations;
       
-      // 平均每次锁操作应该 < 10ms
-      expect(avgMs).toBeLessThan(25);
+      // 平均每次锁操作应该 < 50ms (宽松阈值避免 CI/满负载 flaky)
+      expect(avgMs).toBeLessThan(50);
     });
   });
 });

package/tests/utils/session-key.test.ts

@@ -0,0 +1,52 @@
+import { describe, test, expect } from 'vitest';
+import { extractAgentIdFromSessionKey } from '../../src/utils/session-key';
+
+describe('extractAgentIdFromSessionKey', () => {
+  test('returns undefined for undefined input', () => {
+    expect(extractAgentIdFromSessionKey(undefined)).toBeUndefined();
+  });
+
+  test('returns undefined for empty string', () => {
+    expect(extractAgentIdFromSessionKey('')).toBeUndefined();
+  });
+
+  test('returns agentId from 3-part key (agent:{id}:{type}:{uuid})', () => {
+    expect(extractAgentIdFromSessionKey('agent:main:session:abc-123')).toBe('main');
+  });
+
+  test('returns agentId from 2-part key (agent:{id}:{uuid})', () => {
+    expect(extractAgentIdFromSessionKey('agent:worker-1:def-456')).toBe('worker-1');
+  });
+
+  test('returns undefined for non-matching format', () => {
+    expect(extractAgentIdFromSessionKey('user:main:session:abc')).toBeUndefined();
+    expect(extractAgentIdFromSessionKey('session:abc-123')).toBeUndefined();
+    expect(extractAgentIdFromSessionKey('random-string')).toBeUndefined();
+  });
+
+  test('trims whitespace from agentId', () => {
+    expect(extractAgentIdFromSessionKey('agent: main :session:abc')).toBe('main');
+  });
+
+  test('returns undefined when agentId is whitespace-only', () => {
+    expect(extractAgentIdFromSessionKey('agent:  :session:abc')).toBeUndefined();
+  });
+
+  test('handles agentId with special characters', () => {
+    expect(extractAgentIdFromSessionKey('agent:my-agent_v2:session:abc')).toBe('my-agent_v2');
+  });
+
+  test('returns undefined for whitespace-only agentId', () => {
+    // String.trim() removes ASCII whitespace (\\t, \\n, \\r, space) AND fullwidth space \\u3000 from edges
+    expect(extractAgentIdFromSessionKey('agent:\t:session:abc')).toBeUndefined(); // tab → empty after trim
+    expect(extractAgentIdFromSessionKey('agent:\r:session:abc')).toBeUndefined(); // CR → empty after trim
+    expect(extractAgentIdFromSessionKey('agent:\u3000:session:abc')).toBeUndefined(); // fullwidth space trimmed → empty
+  });
+
+  test('handles mixed whitespace within agentId parts', () => {
+    // Tab is internal (not at trim edge), so 'a\tb'.trim() → 'a\tb' (tab preserved in middle)
+    expect(extractAgentIdFromSessionKey('agent:a\tb:session:abc')).toBe('a\tb');
+    // CR\\n is internal, not at edge, so 'a\r\nb'.trim() → 'a\r\nb'
+    expect(extractAgentIdFromSessionKey('agent:a\r\nb:session:abc')).toBe('a\r\nb');
+  });
+});

package/tests/utils/subagent-probe.test.ts

@@ -1,7 +1,8 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi, beforeEach, afterEach, afterAll } from 'vitest';
 import {
   getSubagentRuntimeAvailability,
   isSubagentRuntimeAvailable,
+  getAvailableSubagentRuntime,
 } from '../../src/utils/subagent-probe.js';
 
 describe('subagent-probe', () => {
@@ -30,3 +31,49 @@ describe('subagent-probe', () => {
     });
   });
 });
+
+describe('getAvailableSubagentRuntime', () => {
+  const validRuntime = { run: () => Promise.resolve({ runId: 'run-1' }) };
+
+  it('returns the passed subagent when it is available', () => {
+    expect(getAvailableSubagentRuntime(validRuntime)).toBe(validRuntime);
+  });
+
+  it('returns undefined when passed undefined and no global gateway exists', () => {
+    expect(getAvailableSubagentRuntime(undefined)).toBeUndefined();
+  });
+
+  it('returns undefined when passed unavailable subagent and no global gateway', () => {
+    expect(getAvailableSubagentRuntime({} as any)).toBeUndefined();
+  });
+
+  describe('with global gateway fallback', () => {
+    const symbol = Symbol.for('openclaw.plugin.gatewaySubagentRuntime');
+
+    beforeEach(() => {
+      (globalThis as any)[symbol] = { subagent: validRuntime };
+    });
+
+    afterEach(() => {
+      delete (globalThis as any)[symbol];
+    });
+
+    afterAll(() => {
+      // Safety net: ensure cleanup even if a test crashes before afterEach
+      delete (globalThis as any)[symbol];
+    });
+
+    it('falls back to global gateway when passed subagent is unavailable', () => {
+      expect(getAvailableSubagentRuntime(undefined)).toBe(validRuntime);
+    });
+
+    it('falls back to global gateway when passed subagent has no run', () => {
+      expect(getAvailableSubagentRuntime({} as any)).toBe(validRuntime);
+    });
+
+    it('prefers passed subagent over global gateway when both available', () => {
+      const localRuntime = { run: () => Promise.resolve({ runId: 'local' }) };
+      expect(getAvailableSubagentRuntime(localRuntime)).toBe(localRuntime);
+    });
+  });
+});

package/vitest.config.ts

@@ -23,18 +23,11 @@ const integrationTests = [
   // Core DB tests
   'tests/core/control-ui-db.test.ts',
   'tests/core/evolution-logger.test.ts',
-  'tests/core/nocturnal-e2e.test.ts',
-  'tests/core/nocturnal-trajectory-extractor.test.ts',
   'tests/core/replay-engine.test.ts',
   'tests/core/trajectory.test.ts',
   'tests/core/workspace-context.test.ts',
   // Service tests with DB dependencies
-  'tests/service/nocturnal-service-code-candidate.test.ts',
-  'tests/service/nocturnal-target-selector.test.ts',
-  'tests/service/evolution-worker.nocturnal.test.ts',
   'tests/service/evolution-worker.timeout.test.ts',
-  'tests/service/data-endpoints-regression.test.ts',
-  'tests/service/control-ui-query-service.test.ts',
   'tests/service/keyword-optimization-service.test.ts',
   // Hook tests with DB dependencies
   'tests/hooks/subagent.test.ts',
@@ -59,10 +52,10 @@ export default defineConfig({
       reporter: ['text', 'html'],
       exclude: ['tests/**'],
       thresholds: {
-        lines: 70,
-        functions: 70,
-        branches: 60,
-        statements: 70,
+        lines: 58,
+        functions: 65,
+        branches: 45,
+        statements: 57,
       },
     },
   },

package/.planning/codebase/ARCHITECTURE.md

@@ -1,157 +0,0 @@
-# Architecture
-
-**Analysis Date:** 2026-04-15
-
-## Pattern Overview
-
-**Overall:** Event-driven plugin architecture with hook-based interception
-
-**Key Characteristics:**
-- OpenClaw plugin framework with hook-based integration
-- Background worker services for async evolution processing
-- SQLite-based trajectory and state persistence
-- Multi-layer security gates (GFI gate, empathy engine, pain tracking)
-- Workflow managers for complex subagent orchestration
-
-## Layers
-
-**Plugin Entry Point:**
-- Purpose: Initialize plugin, register hooks, commands, tools, and services
-- Location: `src/index.ts`
-- Contains: Plugin registration, hook handlers, command registration
-- Depends on: OpenClaw SDK, all core modules
-
-**Hooks Layer:**
-- Purpose: Intercept and modify OpenClaw agent behavior
-- Location: `src/hooks/`
-- Contains: `prompt.ts` (before_prompt_build), `gate.ts` (before_tool_call), `pain.ts` (after_tool_call), `llm.ts` (llm_output), `lifecycle.ts` (before_reset, compaction), `subagent.ts` (subagent lifecycle)
-- Depends on: Core services, workspace context
-- Used by: OpenClaw event system
-
-**Core Services:**
-- Purpose: Business logic for evolution, pain tracking, trajectory, nocturnal training
-- Location: `src/core/` and `src/service/`
-- Contains: `evolution-engine.ts`, `trajectory.ts`, `nocturnal-trinity.ts`, `pain.ts`, `training-program.ts`, `pd-task-service.ts`
-- Depends on: Database, workspace context, config
-
-**Command Handlers:**
-- Purpose: Implement slash commands (e.g., `/pd-init`, `/pd-status`, `/pd-nocturnal-review`)
-- Location: `src/commands/`
-- Contains: 20+ command implementations
-- Depends on: Core services, workspace context
-
-**Workflow Managers (Subagent Workflow):**
-- Purpose: Orchestrate complex subagent workflows
-- Location: `src/service/subagent-workflow/`
-- Contains: `nocturnal-workflow-manager.ts`, `deep-reflect-workflow-manager.ts`, `empathy-observer-workflow-manager.ts`, `correction-observer-workflow-manager.ts`
-- Depends on: Evolution worker, core services
-
-**Database Layer:**
-- Purpose: Persist trajectory data, evolution state, workflow state
-- Location: `src/core/schema/` (migrations), `src/service/central-database.ts`
-- Contains: SQLite schema, migration runner, query services
-- Depends on: better-sqlite3
-
-**UI Layer:**
-- Purpose: React-based plugin UI for monitoring and control
-- Location: `ui/src/`
-- Contains: Pages (Overview, Evolution, Feedback, GateMonitor, Samples, ThinkingModels), components (Shell, ProtectedRoute), context (auth, theme)
-- Depends on: React, React Router, lucide-react
-
-**Utils:**
-- Purpose: Shared utilities (I/O, logging, retry, hashing, file locking)
-- Location: `src/utils/`
-- Contains: `io.ts` (atomic writes), `plugin-logger.ts`, `retry.ts`, `hashing.ts`, `file-lock.ts`
-
-## Data Flow
-
-**Agent Execution Flow:**
-1. OpenClaw fires `before_prompt_build` hook
-2. `hooks/prompt.ts` builds context injection (principles, thinking OS, focus, reflection log)
-3. OpenClaw generates response
-4. `hooks/llm.ts` analyzes LLM output for signals
-5. User triggers tool call
-6. `hooks/gate.ts` intercepts `before_tool_call` - evaluates risk, may block
-7. Tool executes
-8. `hooks/pain.ts` intercepts `after_tool_call` - tracks pain signals, empathy penalties
-
-**Evolution Flow:**
-1. `EvolutionWorkerService` polls `pain_candidates.json` periodically
-2. For each candidate, `evolution-engine.ts` evaluates and derives improvements
-3. `trajectory.ts` records behavior patterns
-4. Nocturnal training (`nocturnal-trinity.ts`) synthesizes improvements into rule updates
-5. `principle-tree-ledger.ts` manages principle lifecycle
-
-**Nocturnal Training Flow:**
-1. Candidate scoring via `nocturnal-candidate-scoring.ts`
-2. Target selection via `nocturnal-target-selector.ts`
-3. Rule implementation validation via `nocturnal-rule-implementation-validator.ts`
-4. Promotion via `promotion-gate.ts`
-
-## Key Abstractions
-
-**WorkspaceContext:**
-- Purpose: Encapsulates all state and services for a single workspace
-- Examples: `src/core/workspace-context.ts`
-- Pattern: Factory method `WorkspaceContext.fromHookContext()`
-
-**EvolutionEngine:**
-- Purpose: Core evolution processing logic
-- Examples: `src/core/evolution-engine.ts`
-- Pattern: Reducer pattern with typed actions
-
-**NocturnalTrinity:**
-- Purpose: Three-phase nocturnal training (dataset, training, evaluation)
-- Examples: `src/core/nocturnal-trinity.ts`
-- Pattern: Phase orchestration with contract validation
-
-**PainConfig:**
-- Purpose: Plugin configuration management
-- Examples: `src/core/config.ts`
-- Pattern: Singleton per workspace with file persistence
-
-**RuleHost:**
-- Purpose: Secure rule execution environment
-- Examples: `src/core/rule-host.ts`
-- Pattern: Sandboxed evaluation with permission checks
-
-## Entry Points
-
-**Plugin Entry:**
-- Location: `src/index.ts`
-- Triggers: OpenClaw loads plugin
-- Responsibilities: Register all hooks, commands, tools, services; initialize workspace
-
-**Command Entry:**
-- Location: `src/commands/*.ts`
-- Triggers: User invokes slash command (e.g., `/pd-init`)
-- Responsibilities: Validate input, delegate to core services, return formatted result
-
-**Service Entry:**
-- Location: `src/service/evolution-worker.ts`
-- Triggers: `before_prompt_build` fires (starts background worker)
-- Responsibilities: Process evolution queue, track pain signals, trigger training
-
-## Error Handling
-
-**Strategy:** Graceful degradation with logging
-
-**Patterns:**
-- Try-catch blocks in all hook handlers with error logging
-- `SystemLogger.log()` for critical errors
-- Workspace context error recording via `eventLog.recordHookExecution()`
-- Non-critical errors caught silently (trajectory collection)
-
-## Cross-Cutting Concerns
-
-**Logging:** `src/utils/plugin-logger.ts` - OpenClaw logger abstraction
-
-**Validation:** Schema validation via `@sinclair/typebox` for config and event types
-
-**Authentication:** OpenClaw session-based, agent ID extracted from session key
-
-**I/O Safety:** Atomic file writes via `atomicWriteFileSync()` in `src/utils/io.ts`
-
----
-
-*Architecture analysis: 2026-04-15*