principles-disciple 1.61.0 → 1.63.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.63.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.63.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-block-helper.ts

@@ -3,7 +3,7 @@
  *
  * PURPOSE: Provide ONE authoritative implementation for gate block persistence.
  *
- * All gate modules (progressive-trust-gate, gfi-gate, etc.) must use this
+ * All gate sources (rule-host) must use this
  * helper to ensure consistent block tracking, event logging, and retry behavior.
  *
  * This eliminates the "multi-truth source" problem where different modules