principles-disciple 1.60.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.60.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.60.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/diagnostician-task-store.ts

@@ -37,6 +37,8 @@ export interface DiagnosticianTask {
   prompt: string;
   createdAt: string;
   status: 'pending' | 'completed';
+  /** Number of times task was retried due to marker exists but JSON report missing (#366) */
+  reportMissingRetries?: number;
 }
 
 export interface DiagnosticianTaskStore {
@@ -86,10 +88,12 @@ export async function addDiagnosticianTask(
      
      
     const store = readTaskStoreSync(filePath);
+    const existing = store.tasks[taskId];
     store.tasks[taskId] = {
       prompt,
-      createdAt: new Date().toISOString(),
+      createdAt: existing?.createdAt ?? new Date().toISOString(),
       status: 'pending',
+      reportMissingRetries: existing?.reportMissingRetries ?? 0,
     };
     atomicWriteFileSync(filePath, JSON.stringify(store, null, 2));
   });
@@ -153,3 +157,36 @@ export function hasPendingDiagnosticianTasks(stateDir: string): boolean {
   const store = readTaskStore(stateDir);
   return Object.values(store.tasks).some(t => t.status === 'pending');
 }
+
+/**
+ * Re-queue a diagnostician task with an incremented reportMissingRetries counter.
+ * Used when a task has a marker file but no JSON report — the worker re-injects
+ * the task for the LLM to retry (up to MAX_REPORT_MISSING_RETRIES times).
+ *
+ * Idempotent: if the task doesn't exist, does nothing.
+ */
+export async function requeueDiagnosticianTask(
+  stateDir: string,
+  taskId: string,
+  maxRetries = 3,
+): Promise<{ requeued: boolean; maxRetriesReached: boolean }> {
+  const filePath = resolveTasksPath(stateDir);
+  return withLockAsync(filePath, async () => {
+    const store = readTaskStoreSync(filePath);
+    const existing = store.tasks[taskId];
+    if (!existing) {
+      return { requeued: false, maxRetriesReached: false };
+    }
+    const retries = (existing.reportMissingRetries ?? 0) + 1;
+    if (retries > maxRetries) {
+      return { requeued: false, maxRetriesReached: true };
+    }
+    store.tasks[taskId] = {
+      ...existing,
+      status: 'pending',
+      reportMissingRetries: retries,
+    };
+    atomicWriteFileSync(filePath, JSON.stringify(store, null, 2));
+    return { requeued: true, maxRetriesReached: false };
+  });
+}

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';
@@ -197,7 +205,14 @@ export class EventLog {
   }
 
   recordDiagnosticianReport(data: DiagnosticianReportEventData): void {
-    this.record('diagnostician_report', data.success ? 'completed' : 'failure', undefined, data);
+    // Map three-state category to EventCategory
+    // Both missing_json and incomplete_fields map to 'failure' in EventCategory
+    const categoryMap: Record<DiagnosticianReportEventData['category'], EventCategory> = {
+      success: 'completed',
+      missing_json: 'failure',
+      incomplete_fields: 'failure',
+    };
+    this.record('diagnostician_report', categoryMap[data.category], undefined, data);
   }
 
   recordPrincipleCandidate(data: PrincipleCandidateEventData): void {
@@ -208,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, 
@@ -356,14 +397,57 @@ export class EventLog {
     } else if (entry.type === 'heartbeat_diagnosis') {
       stats.evolution.heartbeatsInjected++;
     } else if (entry.type === 'diagnostician_report') {
-      if (entry.category === 'completed') {
-        stats.evolution.diagnosticianReportsWritten++;
+      // Backward compat: handle old events with success:boolean and new events with category:string
+      // 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'
+        // 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 (cat === 'missing_json') {
+          stats.evolution.reportsMissingJson++;
+        }
+        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

@@ -12,7 +12,7 @@ import { SystemLogger } from '../core/system-logger.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import type { EventLog } from '../core/event-log.js';
 import { initPersistence, flushAllSessions } from '../core/session-tracker.js';
-import { addDiagnosticianTask, completeDiagnosticianTask } from '../core/diagnostician-task-store.js';
+import { addDiagnosticianTask, completeDiagnosticianTask, requeueDiagnosticianTask } from '../core/diagnostician-task-store.js';
 import { getEvolutionLogger } from '../core/evolution-logger.js';
 import type { TaskKind, TaskPriority } from '../core/trajectory-types.js';
 import type { PrincipleEvaluability } from '../types/principle-tree-schema.js';
@@ -923,12 +923,59 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
 
                 let principlesGenerated = 0;
                 // C: Track report success for event recording
+                // FIX: Use reportParsed flag so reportSuccess=false when JSON is missing/garbled
                 let reportSuccess = false;
+                let reportParsed = false;
                 // Create principle from the diagnostician's JSON report.
                 const reportPath = path.join(wctx.stateDir, `.diagnostician_report_${task.id}.json`);
                 if (fs.existsSync(reportPath)) {
                     try {
-                        const reportData = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+                        const raw = fs.readFileSync(reportPath, 'utf8');
+                        if (!raw || raw.trim().length === 0) {
+                            throw new Error('Report file is empty');
+                        }
+                        const reportData = JSON.parse(raw);
+                        if (!reportData) {
+                            throw new Error('JSON parsed but content is null/undefined');
+                        }
+                        // Report is valid JSON — mark as parsed
+                        reportParsed = true;
+
+                        // FIX: Validate phase completeness before accepting the report
+                        // A report missing critical phases is considered failed (not silently accepted).
+                        // The diagnostician must produce all 4 diagnostic phases.
+                        const phases = reportData?.phases || reportData?.diagnosis_report?.phases || {};
+                        const requiredPhases = [
+                            'evidence_gathering',
+                            'causal_chain',
+                            'root_cause_classification',
+                            'principle_extraction',
+                        ];
+                        const presentPhases = requiredPhases.filter(p =>
+                            phases && Object.keys(phases).length > 0 && phases[p]
+                        );
+                        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
+                            try { fs.unlinkSync(completeMarker); } catch { /* ignore if already gone */ }
+                            task.status = 'pending';
+                            task.resolution = undefined;
+                            queueChanged = true;
+                            continue;
+                        }
 
                         // ── Step 3: Noise Classification Filter ──
                         // Skip principle creation for low-value noise categories that don't represent
@@ -1048,15 +1095,52 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                     } catch (err) {
                         logger.warn(`[PD:EvolutionWorker] Failed to parse diagnostician report for task ${task.id}: ${String(err)}`);
                     }
-                    // C: Report was found and processed (try block succeeded or had non-fatal issues)
-                    reportSuccess = true;
+                    // FIX: Only mark success if JSON was actually parsed and non-empty
+                    // If JSON was missing, garbled, or empty — reportSuccess stays false
+                    reportSuccess = reportParsed;
                 } else {
-                    logger.warn(`[PD:EvolutionWorker] No diagnostician report found for completed task ${task.id} (expected: .diagnostician_report_${task.id}.json)`);
+                    // ── #366: Marker exists but JSON report missing — retry logic ──
+                    // Do NOT mark completed yet. Re-inject the task for the next heartbeat cycle.
+                    // Read retry count from marker file content.
+                    const MAX_REPORT_MISSING_RETRIES = 3;
+                    let markerRetries = 0;
+                    try {
+                        const markerContent = fs.readFileSync(completeMarker, 'utf8');
+                        const match = markerContent.match(/report_missing_retries:(\d+)/);
+                        if (match) markerRetries = parseInt(match[1], 10);
+                    } catch { /* marker may not be readable, use 0 */ }
+
+                    if (markerRetries < MAX_REPORT_MISSING_RETRIES) {
+                        // Re-inject: keep task in queue (don't mark completed), update marker with incremented count
+                        const newRetries = markerRetries + 1;
+                        if (logger) logger.info(`[PD:EvolutionWorker] Task ${task.id}: marker found but report missing — re-queuing (retry ${newRetries}/${MAX_REPORT_MISSING_RETRIES})`);
+                        // FIX: Update store's reportMissingRetries BEFORE deleting the marker.
+                        // This ensures the store's retry count is persisted even if the
+                        // diagnostician session crashes before re-adding the task.
+                        await requeueDiagnosticianTask(wctx.stateDir, task.id, MAX_REPORT_MISSING_RETRIES);
+                        // Also update the task in the main queue to keep it alive
+                        task.status = 'pending';
+                        task.resolution = undefined;
+                        queueChanged = true;
+                        // Delete the marker so the next heartbeat sees no marker
+                        // and re-processes the task as a fresh diagnostician run.
+                        try {
+                            fs.unlinkSync(completeMarker);
+                        } catch { /* ignore if already deleted */ }
+                        // Skip the completion/unlink block below — task is still pending
+                        continue;
+                    } else {
+                        // Max retries reached — accept that no report was produced
+                        if (logger) logger.warn(`[PD:EvolutionWorker] Task ${task.id}: max retries (${MAX_REPORT_MISSING_RETRIES}) reached — marking as failed_max_retries`);
+                        task.status = 'completed';
+                        task.completed_at = new Date().toISOString();
+                        task.resolution = 'failed_max_retries';
+                    }
                 }
 
-                task.status = 'completed';
-                task.completed_at = new Date().toISOString();
-                // resolution already set by each branch (noise_classified | marker_detected)
+                // Only reached if JSON existed or max retries reached:
+                task.status = task.status || 'completed';
+                task.completed_at = task.completed_at || new Date().toISOString();
                 if (!task.resolution) task.resolution = 'marker_detected';
                 try {
                     fs.unlinkSync(completeMarker);
@@ -1073,10 +1157,16 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
 
                 // C: Record diagnostician_report event for observability
                 if (eventLog) {
+                    // Map to three-state category:
+                    // - reportSuccess=true → 'success' (JSON exists, parsed, principle found)
+                    // - reportSuccess=false, reportParsed=true → 'incomplete_fields' (JSON existed but principle missing)
+                    // - reportSuccess=false, reportParsed=false → 'missing_json' (JSON never existed)
+                    const reportCategory: 'success' | 'missing_json' | 'incomplete_fields' =
+                        reportSuccess ? 'success' : reportParsed ? 'incomplete_fields' : 'missing_json';
                     eventLog.recordDiagnosticianReport({
                         taskId: task.id,
                         reportPath,
-                        success: reportSuccess,
+                        category: reportCategory,
                     });
                 }
 

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/runtime-summary-service.ts

@@ -69,6 +69,10 @@ export interface RuntimeSummary {
     tasksWrittenToday: number;
     /** Total diagnostician reports written (today from event log) */
     reportsWrittenToday: number;
+    /** Total diagnostician reports that were missing JSON (category=missing_json) */
+    reportsMissingJsonToday: number;
+    /** Total diagnostician reports with incomplete fields (category=incomplete_fields) */
+    reportsIncompleteFieldsToday: number;
     /** Total principle candidates created from heartbeat chain (today from event log) */
     candidatesCreatedToday: number;
     /** Heartbeats that injected diagnostician tasks (today from event log) */
@@ -194,6 +198,8 @@ export class RuntimeSummaryService {
       evolution?: {
         diagnosisTasksWritten?: number;
         diagnosticianReportsWritten?: number;
+        reportsMissingJson?: number;
+        reportsIncompleteFields?: number;
         principleCandidatesCreated?: number;
         heartbeatsInjected?: number;
         [key: string]: unknown;
@@ -265,6 +271,8 @@ export class RuntimeSummaryService {
       pendingTasks: pendingDiagTasks.length,
       tasksWrittenToday: diagDailyStats?.diagnosisTasksWritten ?? 0,
       reportsWrittenToday: diagDailyStats?.diagnosticianReportsWritten ?? 0,
+      reportsMissingJsonToday: diagDailyStats?.reportsMissingJson ?? 0,
+      reportsIncompleteFieldsToday: diagDailyStats?.reportsIncompleteFields ?? 0,
       candidatesCreatedToday: diagDailyStats?.principleCandidatesCreated ?? 0,
       heartbeatsInjectedToday: diagDailyStats?.heartbeatsInjected ?? 0,
     };

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.
@@ -209,7 +221,12 @@ export interface DiagnosisTaskEventData {
 export interface DiagnosticianReportEventData {
   taskId: string;
   reportPath: string;
-  success: boolean;
+  /** Three-state category replacing boolean success field.
+   * - 'success': JSON exists and has principle field
+   * - 'missing_json': marker exists but JSON does not (Issue #366, LLM output truncation)
+   * - 'incomplete_fields': JSON exists but missing principle field
+   */
+  category: 'success' | 'missing_json' | 'incomplete_fields';
 }
 
 /**
@@ -232,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 {
@@ -326,8 +414,19 @@ export interface EvolutionStats {
   diagnosisTasksWritten: number;
   heartbeatsInjected: number;
   diagnosticianReportsWritten: number;
+  reportsMissingJson: number;
+  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 {
@@ -490,8 +589,19 @@ export function createEmptyDailyStats(date: string): DailyStats {
       diagnosisTasksWritten: 0,
       heartbeatsInjected: 0,
       diagnosticianReportsWritten: 0,
+      reportsMissingJson: 0,
+      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/templates/langs/en/skills/pd-diagnostician/SKILL.md

@@ -6,7 +6,7 @@ disable-model-invocation: true
 
 # Diagnostician - Root Cause Analysis Agent
 
-You are a professional root cause analysis expert. You MUST strictly follow the **five-phase protocol** (Phase 0 optional + Phase 1-4 mandatory) below to execute analysis and output **JSON format** results.
+You are a professional root cause analysis expert. You MUST strictly follow the **six-phase protocol** (Phase 0 optional + Phase 1-5 mandatory) below to execute analysis and **immediately write results to the report file after each Phase completes**.
 
 ---
 
@@ -106,6 +106,20 @@ You are a professional root cause analysis expert. You MUST strictly follow the
 }
 ```
 
+**⚠️ Write Report File Immediately After Phase 1**:
+Once Phase 1 is complete, **immediately** write the result to the report file (do NOT wait until the end):
+```
+write: .state/.diagnostician_report_<TASK_ID>.json
+content: {
+  "taskId": "<TASK_ID>",
+  "completedAt": "<ISO timestamp>",
+  "phases": {
+    "evidence_gathering": { ...Phase 1 result... }
+  }
+}
+```
+If the file already exists (a previous Phase was already written), read the existing content, merge the new Phase result into it, then overwrite.
+
 ---
 
 ### Phase 2: Causal Chain Construction [Required]
@@ -145,6 +159,9 @@ You are a professional root cause analysis expert. You MUST strictly follow the
 }
 ```
 
+**⚠️ Write Report File Immediately After Phase 2**:
+Once Phase 2 is complete, **immediately** merge the result into the report file (overwrite, do not lose Phase 1 content).
+
 ---
 
 ### Phase 3: Root Cause Classification [Required]
@@ -178,6 +195,9 @@ You are a professional root cause analysis expert. You MUST strictly follow the
 }
 ```
 
+**⚠️ Write Report File Immediately After Phase 3**:
+Once Phase 3 is complete, **immediately** merge the result into the report file.
+
 ---
 
 ### Phase 4: Principle Extraction [Required]
@@ -264,9 +284,32 @@ You are a professional root cause analysis expert. You MUST strictly follow the
 - "External dependency availability must be validated before invocation"
 - "Code modifications must go through Issue process, ensuring traceability and rollback"
 
-**Reference Existing Principle Styles** (you'll see existing principle entries in HEARTBEAT.md, keep consistent style):
-- P-10: Process as Authority — "When having technical capability to execute operations directly, must check if agreed-upon process exists"
-- P-11: Pre-write Validation — "Before writing to any high-risk path, first read to confirm file's current actual content"
+**Phase 4 Output Fields** (also write immediately after completing Phase 4 — merge with previous Phases):
+```json
+{
+  "taskId": "<TASK_ID>",
+  "completedAt": "<ISO timestamp>",
+  "phases": {
+    "context_extraction": { ... Phase 0 result ... },
+    "evidence_gathering": { ... Phase 1 result ... },
+    "causal_chain": { ... Phase 2 result ... },
+    "root_cause_classification": { ... Phase 3 result ... },
+    "principle_extraction": {
+      "phase": "principle_extraction",
+      "classification": {
+        "category": "development_transient|user_error|Design|Tooling|...",
+        "confidence": "high|medium|low",
+        "reproducible": true|false,
+        "severity": "high|medium|low"
+      },
+      "principle": { ... }
+    }
+  }
+}
+```
+
+**⚠️ Write Report File Immediately After Phase 4**:
+Once Phase 4 is complete, **immediately** merge the result (with `classification` and `principle`) into the report file. This is the final write — all Phases must now be present.
 
 ---
 
@@ -285,20 +328,27 @@ Your diagnostic report will be **auto-parsed as JSON**. Any format errors will c
 
 **Self-check method**: Before outputting, mentally verify: every `"` must have matching `"` after it, if content contains `"` it must be escaped as `\"`.
 
-Merge outputs from all four phases into one JSON object:
+The final report (written incrementally by each Phase) should look like:
 
 ```json
 {
-  "diagnosis_report": {
-    "task_id": "...",
-    "timestamp": "2026-03-24T...",
-    "summary": "One-sentence summary of root cause",
-    "phases": {
-      "context_extraction": { "session_id": "...", "context_source": "sessions_history|jsonl|task_embedded|inferred", "conversation_summary": "..." },
-      "evidence_gathering": { ... },
-      "causal_chain": { ... },
-      "root_cause_classification": { ... },
-      "principle_extraction": { ... }
+  "taskId": "<TASK_ID>",
+  "completedAt": "2026-03-24T10:30:00Z",
+  "phases": {
+    "context_extraction": { "phase": "context_extraction", "session_id": "...", "context_source": "...", "conversation_summary": "..." },
+    "evidence_gathering": { "phase": "evidence_gathering", "evidence": { ... } },
+    "causal_chain": { "phase": "causal_chain", "chain": [...], "terminated_at": 3, "termination_reason": "..." },
+    "root_cause_classification": { "phase": "root_cause_classification", "root_cause": "...", "category": "Design", "guardrail_analysis": { ... } },
+    "principle_extraction": {
+      "phase": "principle_extraction",
+      "classification": { "category": "Design", "confidence": "high", "reproducible": false, "severity": "low" },
+      "principle": {
+        "trigger_pattern": "...",
+        "action": "...",
+        "abstracted_principle": "...",
+        "duplicate": false,
+        "coreAxiomId": "T-02"
+      }
     }
   }
 }
@@ -306,6 +356,38 @@ Merge outputs from all four phases into one JSON object:
 
 ---
 
+## ✅ Completion Protocol
+
+### ✅ Checklist (ALL must be satisfied before writing marker)
+
+Before writing the marker file, you MUST confirm all of the following:
+
+1. **Report file exists**: `.diagnostician_report_<TASK_ID>.json` has been written to disk
+2. **All Phase fields present**:
+   - [ ] `phases.context_extraction` ✅
+   - [ ] `phases.evidence_gathering` ✅
+   - [ ] `phases.causal_chain` ✅
+   - [ ] `phases.root_cause_classification` ✅
+   - [ ] `phases.principle_extraction` ✅
+3. **Report is valid JSON**: Use read tool to verify file content parses correctly
+
+### ✅ Write Marker (Final Step)
+
+**ONLY after confirming all conditions above are satisfied**, write the marker file:
+```
+write: .state/.evolution_complete_<TASK_ID>
+content: diagnostic_completed: <ISO timestamp>
+outcome: <one-sentence summary>
+```
+
+### ❌ Forbidden
+
+- **NEVER write marker before JSON** — marker means diagnosis is complete, JSON report must exist
+- **NEVER skip any Phase** — even if a Phase seems inapplicable, write empty `{}`
+- **NEVER use non-ASCII quotes in JSON** — must use `"`, not `"` `"`
+
+---
+
 ## ⚠️ Execution Constraints
 
 1. **NO skipping phases**: MUST attempt Phase 0 (context acquisition), then execute Phase 1 → 2 → 3 → 4 in order
@@ -313,6 +395,7 @@ Merge outputs from all four phases into one JSON object:
 3. **NO vague conclusions**: Root cause must be specific and fixable
 4. **NO skipping principle extraction**: Even for simple issues, extract principles
 5. **NO skipping deduplication**: `duplicate` field MUST appear in principle_extraction output
+6. **NO writing marker before all Phases complete**: Marker comes LAST, only after every Phase is written to JSON
 
 ---
 

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();
   });
 
   // ═══════════════════════════════════════════════════════════════════════════