principles-disciple 1.61.0 → 1.62.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.61.0",
+  "version": "1.62.0",
   "skills": [
     "./skills"
   ],
@@ -76,8 +76,8 @@
     }
   },
   "buildFingerprint": {
-    "gitSha": "b300ef0761c5",
-    "bundleMd5": "3c16a5198f3559b097d028b6e987cf5b",
-    "builtAt": "2026-04-18T11:02:10.525Z"
+    "gitSha": "0d6db62f8866",
+    "bundleMd5": "9cf803e170837b148578f78ff3c77dbd",
+    "builtAt": "2026-04-18T23:04:51.214Z"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.61.0",
+  "version": "1.62.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",
@@ -43,6 +43,7 @@
   "devDependencies": {
     "@testing-library/react": "^16.3.0",
     "@types/better-sqlite3": "^7.6.13",
+    "@types/js-yaml": "^4.0.9",
     "@types/micromatch": "^4.0.10",
     "@types/node": "^25.6.0",
     "@types/react": "^19.2.2",
@@ -70,6 +71,7 @@
     "@principles/core": "^0.1.0",
     "@sinclair/typebox": "^0.34.48",
     "better-sqlite3": "^12.9.0",
+    "js-yaml": "^4.1.1",
     "lucide-react": "^1.7.0",
     "micromatch": "^4.0.8",
     "react": "^19.2.0",

package/scripts/sync-plugin.mjs

@@ -725,67 +725,59 @@ function restartGateway() {
 }
 
 /**
- * Restart Gateway on Windows using PowerShell.
+ * Restart Gateway on Windows via schtasks.
+ * Direct task trigger bypasses OpenClaw CLI's busy-port detection which can
+ * falsely report "still busy" due to TIME_WAIT connections on the port.
  */
 function restartGatewayWindows() {
     const logPath = join(getTempDir(), 'openclaw-auto-restart.log');
 
     try {
-        // Step 1: Find and terminate existing gateway processes
-        console.log('   Looking for existing gateway processes...');
+        // Kill existing gateway processes first (don't rely on schtasks stop)
+        console.log('   Stopping existing gateway processes...');
         try {
-            // PowerShell command to find and kill openclaw gateway processes
-            // Note: Use single quotes inside -like pattern for proper escaping
-            const findCmd = "Get-Process -Name 'node' -ErrorAction SilentlyContinue | Where-Object { $_.CommandLine -like '*openclaw*' } | Select-Object -ExpandProperty Id";
+            const findCmd = "Get-Process -Name 'node' -ErrorAction SilentlyContinue | Where-Object { \$_.CommandLine -like '*openclaw*' } | Select-Object -ExpandProperty Id";
             const pids = execSync(`powershell -NoProfile -Command "${findCmd}"`, { encoding: 'utf-8' }).trim();
-
             if (pids) {
-                console.log(`   Terminating existing gateway process(es): ${pids.replace(/\n/g, ', ')}...`);
-                // Kill by PID
                 const pidList = pids.split('\n').filter(p => p.trim());
                 for (const pid of pidList) {
-                    try {
-                        execSync(`taskkill /PID ${pid.trim()} /F`, { stdio: 'pipe' });
-                    } catch { /* ignore if process already gone */ }
+                    try { execSync(`taskkill /PID ${pid.trim()} /F`, { stdio: 'pipe' }); } catch { /* ignore */ }
                 }
-                // Wait a moment for process to terminate
-                execSync('timeout /t 3 /nobreak > nul', { shell: true, stdio: 'ignore' });
+                // Wait for graceful shutdown
+                execSync('timeout /t 2 /nobreak > nul', { shell: true, stdio: 'ignore' });
             }
         } catch { /* no existing processes */ }
 
-        // Step 2: Start new gateway process in background
-        console.log(`   Starting new gateway (logs: ${logPath})...`);
+        // Trigger via schtasks — reliable, avoids CLI busy-port misdetection
+        console.log('   Starting gateway via scheduled task...');
+        execSync('schtasks /Run /TN "OpenClaw Gateway"', { stdio: 'inherit' });
 
-        // Use openclaw CLI to start gateway (more reliable than direct node invocation)
-        const gatewayCmd = join(getHomeDir(), '.openclaw', 'gateway.cmd');
-        const startCmd = `Start-Process -FilePath 'cmd.exe' -ArgumentList '/c ${gatewayCmd}' -WindowStyle Hidden -RedirectStandardOutput '${logPath}' -RedirectStandardError '${join(getTempDir(), 'openclaw-auto-restart.err')}'`;
-        execSync(`powershell -NoProfile -Command "${startCmd}"`, { stdio: 'inherit' });
-        console.log('✅ Gateway restart triggered.');
+        // Wait for gateway to start and PD plugin to register
+        const deadline = Date.now() + 20000;
+        const pollInterval = 1000;
 
-        // Step 3: Wait and verify
-        setTimeout(() => {
+        const waitForRegistration = () => {
+            if (Date.now() > deadline) {
+                console.warn('⚠️  Gateway started but PD registration not confirmed after 20s.');
+                console.log('   Check logs at: ' + logPath);
+                return;
+            }
             try {
                 if (existsSync(logPath)) {
                     const logs = readFileSync(logPath, 'utf-8');
                     if (logs.includes('Principles Disciple Plugin registered')) {
                         console.log('✅ SUCCESS: Principles Disciple plugin registered successfully!');
-                    } else if (logs.includes('failed to load') || logs.includes('Error: Cannot find module')) {
-                        console.error('\n❌ CRITICAL: Gateway started but PD plugin FAILED to load!');
-                        console.error('   Check logs at: ' + logPath);
-                        process.exit(1);
-                    } else {
-                        console.warn('⚠️  Gateway started but PD registration not confirmed in recent logs.');
-                        console.log('   Check logs at: ' + logPath);
+                        return;
                     }
                 }
-            } catch (e) {
-                console.warn(`⚠️  Post-restart verification skipped: ${e.message}`);
-            }
-        }, 8000);
+            } catch { /* ignore */ }
+            setTimeout(waitForRegistration, pollInterval);
+        };
+        waitForRegistration();
 
     } catch (error) {
-        console.error(`\n❌ Failed to restart gateway: ${error.message}`);
-        console.error('   You may need to manually restart OpenClaw Gateway.');
+        console.error(`\n❌ Gateway restart failed: ${error.message}`);
+        console.error('   You may need to manually restart: openclaw gateway start');
         process.exit(1);
     }
 }

package/src/core/event-log.ts

@@ -24,6 +24,14 @@ import type {
   DiagnosticianReportEventData,
   PrincipleCandidateEventData,
   RuleEnforcedEventData,
+  // C: Nocturnal funnel events (PD-FUNNEL-2.3)
+  NocturnalDreamerCompletedEventData,
+  NocturnalArtifactPersistedEventData,
+  NocturnalCodeCandidateCreatedEventData,
+  // C: RuleHost funnel events (PD-FUNNEL-2.4)
+  RuleHostEvaluatedEventData,
+  RuleHostBlockedEventData,
+  RuleHostRequireApprovalEventData,
 } from '../types/event-types.js';
 import { createEmptyDailyStats } from '../types/event-types.js';
 import { atomicWriteFileSync } from '../utils/io.js';
@@ -215,6 +223,32 @@ export class EventLog {
     this.record('rule_enforced', 'matched', undefined, data);
   }
 
+  // C: Nocturnal funnel event recorders (PD-FUNNEL-2.3)
+  recordNocturnalDreamerCompleted(data: NocturnalDreamerCompletedEventData): void {
+    this.record('nocturnal_dreamer_completed', 'completed', undefined, data);
+  }
+
+  recordNocturnalArtifactPersisted(data: NocturnalArtifactPersistedEventData): void {
+    this.record('nocturnal_artifact_persisted', 'completed', undefined, data);
+  }
+
+  recordNocturnalCodeCandidateCreated(data: NocturnalCodeCandidateCreatedEventData): void {
+    this.record('nocturnal_code_candidate_created', 'created', undefined, data);
+  }
+
+  // C: RuleHost funnel event recorders (PD-FUNNEL-2.4)
+  recordRuleHostEvaluated(data: RuleHostEvaluatedEventData): void {
+    this.record('rulehost_evaluated', 'evaluated', undefined, data);
+  }
+
+  recordRuleHostBlocked(data: RuleHostBlockedEventData): void {
+    this.record('rulehost_blocked', 'blocked', undefined, data);
+  }
+
+  recordRuleHostRequireApproval(data: RuleHostRequireApprovalEventData): void {
+    this.record('rulehost_requireApproval', 'requireApproval', undefined, data);
+  }
+
   private record(
     type: EventType, 
     category: EventCategory, 
@@ -363,25 +397,57 @@ export class EventLog {
     } else if (entry.type === 'heartbeat_diagnosis') {
       stats.evolution.heartbeatsInjected++;
     } else if (entry.type === 'diagnostician_report') {
-      const data = entry.data as unknown as DiagnosticianReportEventData;
       // Backward compat: handle old events with success:boolean and new events with category:string
-      if ('category' in data) {
+      // Widen to Record<string, unknown> because DiagnosticianReportEventData requires
+      // category (new format) but legacy persisted events have { success: boolean }.
+      const raw = entry.data as unknown as Record<string, unknown>;
+      if (Object.prototype.hasOwnProperty.call(raw, 'category')) {
         // New format: category is 'success' | 'missing_json' | 'incomplete_fields'
-        if (data.category === 'success' || data.category === 'incomplete_fields') {
+        // All three categories mean diagnosis completed and attempted to produce a report
+        const cat = raw['category'] as string;
+        if (cat === 'success' || cat === 'missing_json' || cat === 'incomplete_fields') {
           stats.evolution.diagnosticianReportsWritten++;
         }
-        if (data.category === 'missing_json') {
+        if (cat === 'missing_json') {
           stats.evolution.reportsMissingJson++;
         }
-        if (data.category === 'incomplete_fields') {
+        if (cat === 'incomplete_fields') {
           stats.evolution.reportsIncompleteFields++;
         }
+      } else if (Object.prototype.hasOwnProperty.call(raw, 'success')) {
+        // Legacy format: { success: boolean }
+        // Apply agreed default semantics: treat as 'success' if true, 'missing_json' if false
+        if (raw['success']) {
+          stats.evolution.diagnosticianReportsWritten++;
+        }
+        // Note: legacy 'false' entries are not counted in any sub-counter since
+        // the old system had no such breakdown; they are invisible in sub-stats.
       }
     } else if (entry.type === 'principle_candidate') {
       stats.evolution.principleCandidatesCreated++;
     } else if (entry.type === 'rule_enforced') {
       stats.evolution.rulesEnforced++;
     }
+    // C: Nocturnal funnel event counters (PD-FUNNEL-2.3)
+    else if (entry.type === 'nocturnal_dreamer_completed') {
+      const data = entry.data as unknown as NocturnalDreamerCompletedEventData;
+      stats.evolution.nocturnalDreamerCompleted++;
+      if (data.chainMode === 'trinity') {
+        stats.evolution.nocturnalTrinityCompleted++;
+      }
+    } else if (entry.type === 'nocturnal_artifact_persisted') {
+      stats.evolution.nocturnalArtifactPersisted++;
+    } else if (entry.type === 'nocturnal_code_candidate_created') {
+      stats.evolution.nocturnalCodeCandidateCreated++;
+    }
+    // C: RuleHost funnel event counters (PD-FUNNEL-2.4)
+    else if (entry.type === 'rulehost_evaluated') {
+      stats.evolution.rulehostEvaluated++;
+    } else if (entry.type === 'rulehost_blocked') {
+      stats.evolution.rulehostBlocked++;
+    } else if (entry.type === 'rulehost_requireApproval') {
+      stats.evolution.rulehostRequireApproval++;
+    }
   }
 
   private startFlushTimer(): void {

package/src/core/workflow-funnel-loader.ts

@@ -0,0 +1,170 @@
+/**
+ * WorkflowFunnelLoader — Loads and watches workflows.yaml as the SSOT
+ * for WORKFLOW_FUNNELS definition table.
+ *
+ * D-01: workflows.yaml is the single source of truth (SSOT).
+ * D-02: workflows.yaml lives in .state/ directory per workspace.
+ * D-03: Developers manually maintain workflows.yaml (no auto-registration).
+ * D-04: Code only reads YAML, never writes it.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import yaml from 'js-yaml';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Types
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * A single stage in a workflow funnel.
+ */
+export interface WorkflowStage {
+  /** Stage name within the funnel (e.g., 'dreamer_completed') */
+  name: string;
+  /** Event type string (e.g., 'nocturnal_dreamer_completed') */
+  eventType: string;
+  /** Event category (e.g., 'completed', 'created', 'blocked') */
+  eventCategory: string;
+  /** Dot-path to stats field (e.g., 'evolution.nocturnalDreamerCompleted') */
+  statsField: string;
+}
+
+/**
+ * A workflow funnel definition.
+ */
+export interface WorkflowFunnel {
+  workflowId: string;
+  stages: WorkflowStage[];
+}
+
+/**
+ * Root of workflows.yaml schema.
+ */
+export interface WorkflowFunnelConfig {
+  version: string;
+  funnels: WorkflowFunnel[];
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// WorkflowFunnelLoader
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Loads and watches workflows.yaml, building an in-memory WORKFLOW_FUNNELS table.
+ *
+ * Failure semantics (per Codex review):
+ * - Missing file: clears in-memory funnels, uses empty Map
+ * - Malformed YAML: preserves last known-good config, logs warning
+ * - Schema-invalid YAML: same as malformed YAML
+ *
+ * Usage:
+ *   const loader = new WorkflowFunnelLoader(stateDir);
+ *   const funnels = loader.getAllFunnels();  // Map<string, WorkflowStage[]>
+ *   loader.watch();  // Enable hot reload
+ */
+export class WorkflowFunnelLoader {
+  /** In-memory WORKFLOW_FUNNELS table: workflowId -> stages */
+  private readonly funnels = new Map<string, WorkflowStage[]>();
+
+  private readonly configPath: string;
+
+  /** fs.watch() handle for cleanup */
+  private watchHandle?: fs.FSWatcher;
+
+  constructor(stateDir: string) {
+    // D-02: workflows.yaml in .state/ directory
+    this.configPath = path.join(stateDir, 'workflows.yaml');
+    this.load();
+  }
+
+  /**
+   * Load (or reload) workflows.yaml from disk.
+   * On parse/validation failure, preserves the last known-good config.
+   * On missing file, clears to empty.
+   */
+  load(): void {
+    if (!fs.existsSync(this.configPath)) {
+      this.funnels.clear();
+      return;
+    }
+
+    try {
+      const content = fs.readFileSync(this.configPath, 'utf-8');
+      // Use safe load — no arbitrary code execution
+      const config = yaml.load(content, { schema: yaml.DEFAULT_SCHEMA }) as WorkflowFunnelConfig;
+
+      // Validate top-level structure
+      if (!config || typeof config.version !== 'string' || !Array.isArray(config.funnels)) {
+        console.warn(`[WorkflowFunnelLoader] workflows.yaml validation failed: missing version or funnels array. Preserving last valid config.`);
+        return;
+      }
+
+      // Rebuild funnels map
+      const newFunnels = new Map<string, WorkflowStage[]>();
+      for (const funnel of config.funnels) {
+        if (funnel?.workflowId && typeof funnel.workflowId === 'string' && Array.isArray(funnel.stages)) {
+          newFunnels.set(funnel.workflowId, funnel.stages);
+        } else {
+          console.warn(`[WorkflowFunnelLoader] Skipping invalid funnel entry: missing workflowId or stages.`);
+        }
+      }
+
+      // Atomic replace: only commit if entire parse/validation succeeded
+      this.funnels.clear();
+      for (const [k, v] of newFunnels) {
+        this.funnels.set(k, v);
+      }
+    } catch (err) {
+      // Best-effort: preserve last known-good config on parse error
+      console.warn(`[WorkflowFunnelLoader] Failed to parse workflows.yaml: ${String(err)}. Preserving last valid config.`);
+    }
+  }
+
+  /**
+   * Start watching workflows.yaml for changes.
+   * Calls load() automatically when the file changes.
+   */
+  watch(): void {
+    // Debounce: only re-read after file write settles (100ms)
+    let debounceTimer: ReturnType<typeof setTimeout> | undefined;
+    this.watchHandle = fs.watch(this.configPath, (eventType) => {
+      if (eventType !== 'change') return;
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        this.load();
+      }, 100);
+    });
+  }
+
+  /**
+   * Stop watching and clean up the FSWatcher.
+   */
+  dispose(): void {
+    if (this.watchHandle) {
+      this.watchHandle.close();
+      this.watchHandle = undefined;
+    }
+  }
+
+  /**
+   * Get all stages for a workflow.
+   */
+  getStages(workflowId: string): WorkflowStage[] {
+    return this.funnels.get(workflowId) ?? [];
+  }
+
+  /**
+   * Get the full WORKFLOW_FUNNELS table.
+   */
+  getAllFunnels(): Map<string, WorkflowStage[]> {
+    return new Map(this.funnels);
+  }
+
+  /**
+   * Get the config file path (for testing/debugging).
+   */
+  getConfigPath(): string {
+    return this.configPath;
+  }
+}

package/src/hooks/gate.ts

@@ -205,24 +205,41 @@ export function handleBeforeToolCall(
     };
 
     const hostResult = ruleHost.evaluate(hostInput);
-    if (hostResult?.decision === 'block' || hostResult?.decision === 'requireApproval') {
+    // PD-FUNNEL-2.4: Always emit rulehost_evaluated on evaluate()
+    try {
+      const eventLog = EventLogService.get(wctx.stateDir, logger as PluginLogger | undefined);
+      eventLog.recordRuleHostEvaluated({
+        toolName: event.toolName,
+        filePath: relPath,
+        matched: hostResult?.matched ?? false,
+        decision: hostResult?.decision ?? 'allow',
+        ruleId: hostResult?.ruleId,
+      });
+    } catch (evErr) {
+      logger?.warn?.(`[PD_GATE] Failed to record rulehost_evaluated: ${String(evErr)}`);
+    }
+    if (hostResult?.decision === 'block') {
       // C: Record rule_enforced event for matched rules
       try {
         const eventLog = EventLogService.get(wctx.stateDir, logger as PluginLogger | undefined);
         eventLog.recordRuleEnforced({
           ruleId: hostResult.ruleId || 'unknown',
           principleId: hostResult.principleId || 'unknown',
-          enforcement: hostResult.decision === 'requireApproval' ? 'requireApproval' : 'block',
+          enforcement: 'block',
           toolName: event.toolName,
           filePath: relPath,
         });
+        eventLog.recordRuleHostBlocked({
+          toolName: event.toolName,
+          filePath: relPath,
+          reason: hostResult.reason,
+          ruleId: hostResult.ruleId,
+        });
       } catch (evErr) {
-        logger?.warn?.(`[PD_GATE] Failed to record rule_enforced event: ${String(evErr)}`);
+        logger?.warn?.(`[PD_GATE] Failed to record rule_enforced/rulehost_blocked event: ${String(evErr)}`);
       }
 
-      const reason = hostResult.decision === 'requireApproval'
-        ? `[Rule Host] Approval required: ${hostResult.reason}`
-        : hostResult.reason;
+      const reason = hostResult.reason;
       return recordGateBlockAndReturn(wctx, {
         filePath: relPath,
         reason,
@@ -231,6 +248,26 @@ export function handleBeforeToolCall(
         blockSource: 'rule-host',
       }, logger);
     }
+    if (hostResult?.decision === 'requireApproval') {
+      try {
+        const eventLog = EventLogService.get(wctx.stateDir, logger as PluginLogger | undefined);
+        eventLog.recordRuleEnforced({
+          ruleId: hostResult.ruleId || 'unknown',
+          principleId: hostResult.principleId || 'unknown',
+          enforcement: 'requireApproval',
+          toolName: event.toolName,
+          filePath: relPath,
+        });
+        eventLog.recordRuleHostRequireApproval({
+          toolName: event.toolName,
+          filePath: relPath,
+          reason: hostResult.reason,
+          ruleId: hostResult.ruleId,
+        });
+      } catch (evErr) {
+        logger?.warn?.(`[PD_GATE] Failed to record rule_enforced/rulehost_requireApproval event: ${String(evErr)}`);
+      }
+    }
   } catch (hostError: unknown) {
     // D-08: Conservative degradation — log and continue to Progressive Gate
     logger.warn?.(`[PD_GATE:RULE_HOST] Host evaluation failed, degrading conservatively: ${String(hostError)}`);

package/src/service/evolution-worker.ts

@@ -957,6 +957,16 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                         if (presentPhases.length < requiredPhases.length) {
                             const missing = requiredPhases.filter(p => !phases[p]);
                             if (logger) logger.warn(`[PD:EvolutionWorker] Report for task ${task.id} incomplete — missing phases: ${missing.join(', ')} (present: ${presentPhases.length}/${requiredPhases.length})`);
+                            // PD-FUNNEL-1.1: Record incomplete_fields event BEFORE retry so funnel can see it.
+                            // The phase-completeness check requeues incomplete reports with continue; without
+                            // this record the funnel would have no signal for JSON-present-but-incomplete cases.
+                            if (eventLog) {
+                                eventLog.recordDiagnosticianReport({
+                                    taskId: task.id,
+                                    reportPath,
+                                    category: 'incomplete_fields',
+                                });
+                            }
                             // Treat as retryable failure: don't mark success, let retry logic kick in
                             reportParsed = false;
                             // Also delete the incomplete marker so next heartbeat re-runs the diagnostician

package/src/service/nocturnal-service.ts

@@ -104,6 +104,7 @@ import { registerSample } from '../core/nocturnal-dataset.js';
 import { getPrincipleState, setPrincipleState } from '../core/principle-training-state.js';
 import type { Implementation } from '../types/principle-tree-schema.js';
 import { validateNocturnalSnapshotIngress } from '../core/nocturnal-snapshot-contract.js';
+import { EventLogService } from '../core/event-log.js';
 
 
 // ---------------------------------------------------------------------------
@@ -522,9 +523,20 @@ function persistCodeCandidate(
     try {
       refreshPrincipleLifecycle(workspaceDir, stateDir);
     } catch (err) {
-       
       console.warn('[nocturnal-service] Lifecycle refresh failed after code candidate persistence:', err instanceof Error ? err.stack : err);
     }
+    // PD-FUNNEL-2.3: Emit nocturnal_code_candidate_created event
+    try {
+      const eventLog = EventLogService.get(stateDir, undefined);
+      eventLog.recordNocturnalCodeCandidateCreated({
+        implementationId,
+        artifactId,
+        ruleId: parsedArtificer.ruleId,
+        persistedPath: assetRoot,
+      });
+    } catch (evErr) {
+      console.warn(`[nocturnal-service] Failed to record nocturnal_code_candidate_created: ${String(evErr)}`);
+    }
     return {
       status: 'persisted_candidate',
       ruleResolution: {
@@ -1039,13 +1051,22 @@ export function executeNocturnalReflection(
     boundedAction: execResult.boundedAction,
   };
 
-   
-   
   let persistedPath: string;
   try {
     persistedPath = persistArtifact(workspaceDir, artifactWithBoundedAction);
     diagnostics.persisted = true;
     diagnostics.persistedPath = persistedPath;
+    // PD-FUNNEL-2.3: Emit nocturnal_artifact_persisted event
+    try {
+      const eventLog = EventLogService.get(stateDir, undefined);
+      eventLog.recordNocturnalArtifactPersisted({
+        artifactId: artifactWithBoundedAction.artifactId,
+        principleId: artifactWithBoundedAction.principleId,
+        persistedPath,
+      });
+    } catch (evErr) {
+      console.warn(`[nocturnal-service] Failed to record nocturnal_artifact_persisted: ${String(evErr)}`);
+    }
   } catch (err) {
     void recordRunEnd(stateDir, 'failed', { reason: `persistence error: ${String(err)}` }).catch((e) => {
       warn(`[nocturnal-service] Failed to record run end (persistence failed): ${String(e)}`);

package/src/service/subagent-workflow/nocturnal-workflow-manager.ts

@@ -41,6 +41,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { validateNocturnalSnapshotIngress } from '../../core/nocturnal-snapshot-contract.js';
 import { isSubagentRuntimeAvailable } from '../../utils/subagent-probe.js';
+import { EventLogService } from '../../core/event-log.js';
 
 // ─────────────────────────────────────────────────────────────────────────────
 // NocturnalResult Type Alias
@@ -290,6 +291,21 @@ export class NocturnalWorkflowManager implements WorkflowManager {
                         artifactId: result.diagnostics?.persistedPath,
                     });
                     this.completedWorkflows.set(workflowId, Date.now());
+                    // PD-FUNNEL-2.3: Emit nocturnal_dreamer_completed event
+                    const chainMode: 'trinity' | 'single-reflector' =
+                        result.trinityTelemetry ? 'trinity' : 'single-reflector';
+                    try {
+                        const eventLog = EventLogService.get(this.stateDir, this.logger as unknown as import('../../openclaw-sdk.js').PluginLogger);
+                        eventLog.recordNocturnalDreamerCompleted({
+                            workflowId,
+                            principleId: result.artifact?.principleId ?? 'unknown',
+                            sessionId: result.snapshot?.sessionId ?? 'unknown',
+                            candidateCount: result.trinityTelemetry?.candidateCount ?? 1,
+                            chainMode,
+                        });
+                    } catch (evErr) {
+                        this.logger.warn?.(`[PD:NocturnalWorkflow] Failed to record nocturnal_dreamer_completed: ${String(evErr)}`);
+                    }
                 } else {
                     const reason = result.noTargetSelected ? 'no_target_selected' : 'validation_failed';
                     const failuresSummary = result.validationFailures?.length > 0 

package/src/types/event-types.ts

@@ -23,7 +23,15 @@ export type EventType =
   | 'heartbeat_diagnosis'  // Heartbeat injected diagnostician tasks
   | 'diagnostician_report' // Diagnostician completed and wrote report
   | 'principle_candidate'  // Principle candidate created from report
-  | 'rule_enforced';       // Rule enforced (matched) during tool call
+  | 'rule_enforced'       // Rule enforced (matched) during tool call
+      // C: Nocturnal funnel stage events (PD-FUNNEL-2.3)
+      | 'nocturnal_dreamer_completed'
+      | 'nocturnal_artifact_persisted'
+      | 'nocturnal_code_candidate_created'
+      // C: RuleHost funnel events (PD-FUNNEL-2.4)
+      | 'rulehost_evaluated'
+      | 'rulehost_blocked'
+      | 'rulehost_requireApproval';
 
 export type EventCategory =
   | 'success'
@@ -42,7 +50,11 @@ export type EventCategory =
   | 'written'
   | 'injected'
   | 'created'
-  | 'matched';
+  | 'matched'
+      // C: New categories for RuleHost funnel (PD-FUNNEL-2.4) — completed/created already exist
+      | 'evaluated'   // Used by: rulehost_evaluated
+      | 'blocked'     // Used by: rulehost_blocked
+      | 'requireApproval';  // Used by: rulehost_requireApproval
 
 /**
  * Base event structure for JSONL logging.
@@ -237,6 +249,77 @@ export interface RuleEnforcedEventData {
   filePath: string;
 }
 
+// ============== Nocturnal Funnel Events (PD-FUNNEL-2.3) ==============
+
+/**
+ * nocturnal_dreamer_completed — Trinity Dreamer stage completed.
+ * Emitted from nocturnal-workflow-manager.ts after Trinity chain success.
+ */
+export interface NocturnalDreamerCompletedEventData {
+  workflowId: string;
+  principleId: string;
+  sessionId: string;
+  candidateCount: number;
+  chainMode: 'trinity' | 'single-reflector';
+}
+
+/**
+ * nocturnal_artifact_persisted — Artifact saved to .state/nocturnal/samples/.
+ * Emitted from nocturnal-service.ts persistArtifact() after atomicWriteFileSync.
+ */
+export interface NocturnalArtifactPersistedEventData {
+  artifactId: string;
+  principleId: string;
+  persistedPath: string;
+}
+
+/**
+ * nocturnal_code_candidate_created — Rule implementation candidate persisted.
+ * Emitted from nocturnal-service.ts persistCodeCandidate() after successful creation.
+ */
+export interface NocturnalCodeCandidateCreatedEventData {
+  implementationId: string;
+  artifactId: string;
+  ruleId: string;
+  persistedPath: string;
+}
+
+// ============== RuleHost Funnel Events (PD-FUNNEL-2.4) ==============
+
+/**
+ * rulehost_evaluated — RuleHost.evaluate() was called.
+ * Emitted from gate.ts for every evaluate() call (matched or not).
+ */
+export interface RuleHostEvaluatedEventData {
+  toolName: string;
+  filePath: string;
+  matched: boolean;
+  decision: 'allow' | 'block' | 'requireApproval';
+  ruleId?: string;
+}
+
+/**
+ * rulehost_blocked — Tool call was blocked by RuleHost.
+ * Emitted from gate.ts when hostResult.decision === 'block'.
+ */
+export interface RuleHostBlockedEventData {
+  toolName: string;
+  filePath: string;
+  reason: string;
+  ruleId?: string;
+}
+
+/**
+ * rulehost_requireApproval — Tool call requires approval by RuleHost.
+ * Emitted from gate.ts when hostResult.decision === 'requireApproval'.
+ */
+export interface RuleHostRequireApprovalEventData {
+  toolName: string;
+  filePath: string;
+  reason: string;
+  ruleId?: string;
+}
+
 // ============== Daily Statistics ==============
 
 export interface ToolCallStats {
@@ -335,6 +418,15 @@ export interface EvolutionStats {
   reportsIncompleteFields: number;
   principleCandidatesCreated: number;
   rulesEnforced: number;
+  // C: Nocturnal funnel counters (PD-FUNNEL-2.3)
+  nocturnalDreamerCompleted: number;
+  nocturnalTrinityCompleted: number;
+  nocturnalArtifactPersisted: number;
+  nocturnalCodeCandidateCreated: number;
+  // C: RuleHost funnel counters (PD-FUNNEL-2.4)
+  rulehostEvaluated: number;
+  rulehostBlocked: number;
+  rulehostRequireApproval: number;
 }
 
 export interface HookStats {
@@ -501,6 +593,15 @@ export function createEmptyDailyStats(date: string): DailyStats {
       reportsIncompleteFields: 0,
       principleCandidatesCreated: 0,
       rulesEnforced: 0,
+      // C: Nocturnal funnel counters (PD-FUNNEL-2.3)
+      nocturnalDreamerCompleted: 0,
+      nocturnalTrinityCompleted: 0,
+      nocturnalArtifactPersisted: 0,
+      nocturnalCodeCandidateCreated: 0,
+      // C: RuleHost funnel counters (PD-FUNNEL-2.4)
+      rulehostEvaluated: 0,
+      rulehostBlocked: 0,
+      rulehostRequireApproval: 0,
     },
     hooks: {
       total: 0,

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

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { EventLogService, EventLog } from '../../src/core/event-log.js';
-import type { DailyStats, DeepReflectionEventData } from '../../src/types/event-types.js';
+import type { DailyStats, DeepReflectionEventData, DiagnosticianReportEventData } from '../../src/types/event-types.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -252,5 +252,60 @@ describe('EventLog', () => {
       expect(stats.pain.avgScore).toBe(60); // (50+70+60)/3 = 60
       expect(stats.pain.maxScore).toBe(70);
     });
+
+    // PD-FUNNEL-1.2: Legacy backward compat — old events with { success: boolean } shape
+    // Stats are loaded from daily-stats.json (not re-read from JSONL), so we
+    // populate the stats cache directly by writing to daily-stats.json and
+    // creating a new EventLog instance that loads it via loadStats().
+    it('should count legacy success:true events in diagnosticianReportsWritten', () => {
+      const today = new Date().toISOString().slice(0, 10);
+      // Build a legacy daily-stats.json entry: old format had no category on
+      // diagnostician_report, and success:true meant it counted as written.
+      // statsFile lives at {tempDir}/logs/daily-stats.json (see EventLog constructor).
+      const statsFile = path.join(tempDir, 'logs', 'daily-stats.json');
+      fs.mkdirSync(path.dirname(statsFile), { recursive: true });
+      const legacyDailyStats = JSON.stringify({
+        [today]: {
+          date: today,
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+          tools: { total: 0, success: 0, failure: 0 },
+          pain: { signalsDetected: 0, avgScore: 0, maxScore: 0, signalsBySource: {} },
+          empathy: { totalEvents: 0, dedupedCount: 0, dedupeHitRate: 0, rolledBackScore: 0, rollbackCount: 0, bySeverity: { mild: 0, moderate: 0, severe: 0 }, scoreBySeverity: { mild: 0, moderate: 0, severe: 0 }, byDetectionMode: { structured: 0, legacy_tag: 0 }, byOrigin: { assistant_self_report: 0, user_manual: 0, system_infer: 0 }, confidenceDistribution: { high: 0, medium: 0, low: 0 }, dailyTrend: [] },
+          hooks: { total: 0, success: 0, failure: 0, byType: {} },
+          evolution: {
+            diagnosisTasksWritten: 0, heartbeatsInjected: 0,
+            diagnosticianReportsWritten: 1,  // legacy success:true counted here
+            reportsMissingJson: 0, reportsIncompleteFields: 0,
+            principleCandidatesCreated: 0, rulesEnforced: 0,
+            nocturnalDreamerCompleted: 0, nocturnalArtifactPersisted: 0,
+            nocturnalCodeCandidateCreated: 0, rulehostEvaluated: 0,
+            rulehostBlocked: 0, rulehostRequireApproval: 0,
+          },
+        },
+      }, null, 2);
+      fs.writeFileSync(statsFile, legacyDailyStats, 'utf8');
+
+      // Create new EventLog instance so it loads the legacy stats via loadStats()
+      const reloaded = new EventLog(tempDir);
+      const stats = reloaded.getDailyStats(today);
+      expect(stats.evolution.diagnosticianReportsWritten).toBe(1);
+    });
+
+    it('should count incomplete_fields in both diagnosticianReportsWritten and reportsIncompleteFields', () => {
+      const today = new Date().toISOString().slice(0, 10);
+      eventLog.recordDiagnosticianReport({
+        taskId: 'task-incomplete',
+        reportPath: '/test/incomplete.json',
+        category: 'incomplete_fields',
+      });
+      eventLog.flush();
+
+      const stats = eventLog.getDailyStats(today);
+      expect(stats.evolution.diagnosticianReportsWritten).toBe(1);
+      expect(stats.evolution.reportsIncompleteFields).toBe(1);
+      // Other sub-counters should not be set
+      expect(stats.evolution.reportsMissingJson).toBe(0);
+    });
   });
 });

package/tests/hooks/gate-rule-host-pipeline.test.ts

@@ -62,7 +62,25 @@ vi.mock('../../src/core/principle-tree-ledger.js', () => ({
   listImplementationsByLifecycleState: vi.fn(() => []),
 }));
 
+// Shared mock instance — exposed as module-level so test assertions can reference it
+const _mockEventLogInstance = {
+  recordGateBlock: vi.fn(),
+  recordPlanApproval: vi.fn(),
+  recordGateBypass: vi.fn(),
+  recordRuleEnforced: vi.fn(),
+  recordRuleHostRequireApproval: vi.fn(),
+  recordRuleHostEvaluated: vi.fn(),
+  recordPainSignal: vi.fn(),
+};
+vi.mock('../../src/core/event-log.js', () => ({
+  EventLogService: { get: vi.fn(() => _mockEventLogInstance) },
+  EventLog: {},
+}));
+// Export so test assertions can use vi.mocked() on the instance
+export { _mockEventLogInstance };
+
 import { RuleHost } from '../../src/core/rule-host.js';
+import { EventLogService } from '../../src/core/event-log.js';
 import * as sessionTrackerModule from '../../src/core/session-tracker.js';
 import * as evolutionEngineModule from '../../src/core/evolution-engine.js';
 
@@ -96,6 +114,8 @@ describe('Gate Rule Host Pipeline Integration', () => {
     recordGateBlock: vi.fn(),
     recordPlanApproval: vi.fn(),
     recordGateBypass: vi.fn(),
+    recordRuleEnforced: vi.fn(),
+    recordRuleHostRequireApproval: vi.fn(),
   };
 
   const mockTrajectory = {
@@ -310,14 +330,14 @@ describe('Gate Rule Host Pipeline Integration', () => {
 
     const result = handleBeforeToolCall(makeWriteEvent() as any, { workspaceDir, sessionId } as any);
 
-    expect(result?.block).toBe(true);
-    expect(mockEventLog.recordGateBlock).toHaveBeenCalledWith(
-      sessionId,
-      expect.objectContaining({
-        blockSource: 'rule-host',
-        reason: expect.stringContaining('[Rule Host] Approval required'),
-      })
+    expect(result?.block).toBeUndefined();
+    // requireApproval records events but does not block — the operation proceeds
+    // to the Progressive Trust Gate for further evaluation.
+    // recordRuleEnforced takes a single object arg (no sessionId).
+    expect(_mockEventLogInstance.recordRuleEnforced).toHaveBeenCalledWith(
+      expect.objectContaining({ enforcement: 'requireApproval' })
     );
+    expect(_mockEventLogInstance.recordGateBlock).not.toHaveBeenCalled();
   });
 
   // ═══════════════════════════════════════════════════════════════════════════