principles-disciple 1.30.0 → 1.32.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.30.0",
+  "version": "1.32.0",
   "skills": [
     "./skills"
   ],
@@ -76,8 +76,8 @@
     }
   },
   "buildFingerprint": {
-    "gitSha": "25bfc2bb209f",
-    "bundleMd5": "b735aa483374dd2c7071295b11161676",
-    "builtAt": "2026-04-13T14:25:24.799Z"
+    "gitSha": "15c19a4dc3f2",
+    "bundleMd5": "684e47fd5c521d722150a93813fddd02",
+    "builtAt": "2026-04-14T03:01:11.396Z"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.30.0",
+  "version": "1.32.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",

package/src/service/evolution-worker.ts

@@ -1722,6 +1722,9 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                                 taskId: sleepTask.id,
                                 painContext: sleepTask.recentPainContext,
                                 triggerSource: sleepTask.source,
+                                // #297: Configure which preflight gates to skip.
+                                // sleep_reflection uses periodic trigger which bypasses idle by design.
+                                skipPreflightGates: ['idle'],
                             },
                         });
                         sleepTask.resultRef = workflowHandle.workflowId;
@@ -2166,8 +2169,8 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
                     shouldTrySleepReflection = true;
                 }
 
-                // Path 2: Periodic trigger (bypasses idle requirement — for debugging)
-                if (!idleResult.isIdle && sleepConfig.trigger_mode === 'periodic') {
+                // Path 2: Periodic trigger (fires regardless of idle state)
+                if (sleepConfig.trigger_mode === 'periodic') {
                     if (heartbeatCounter >= sleepConfig.period_heartbeats) {
                         logger?.info?.(`[PD:EvolutionWorker] Periodic trigger: heartbeatCounter=${heartbeatCounter} >= period_heartbeats=${sleepConfig.period_heartbeats}`);
                         shouldTrySleepReflection = true;
@@ -2179,6 +2182,7 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
 
                 if (shouldTrySleepReflection) {
                     const cooldown = checkCooldown(wctx.stateDir, undefined, {
+                        globalCooldownMs: sleepConfig.cooldown_ms,
                         maxRunsPerWindow: sleepConfig.max_runs_per_day,
                         quotaWindowMs: 24 * 60 * 60 * 1000,
                     });

package/src/service/nocturnal-runtime.ts

@@ -436,10 +436,12 @@ export function checkCooldown(
  *
  * @param stateDir - State directory
  * @param principleId - Target principle ID for this run
+ * @param cooldownMs - Global cooldown duration in ms (default: 1 hour)
  */
 export async function recordRunStart(
     stateDir: string,
-    principleId: string
+    principleId: string,
+    cooldownMs: number = DEFAULT_GLOBAL_COOLDOWN_MS
 ): Promise<void> {
     const state = await readState(stateDir);
     const now = new Date().toISOString();
@@ -450,8 +452,8 @@ export async function recordRunStart(
         status: 'skipped', // Will be updated on completion
     };
 
-    // Set global cooldown
-    const cooldownUntil = new Date(Date.now() + DEFAULT_GLOBAL_COOLDOWN_MS).toISOString();
+    // Set global cooldown (use configured value, not hardcoded default)
+    const cooldownUntil = new Date(Date.now() + cooldownMs).toISOString();
     state.globalCooldownUntil = cooldownUntil;
 
     // Add to recent runs for quota tracking

package/src/service/nocturnal-service.ts

@@ -96,6 +96,7 @@ import {
   type IdleCheckResult,
   type PreflightCheckResult,
 } from './nocturnal-runtime.js';
+import { loadNocturnalConfig } from './nocturnal-config.js';
 import { NocturnalPathResolver } from '../core/nocturnal-paths.js';
 import { registerSample } from '../core/nocturnal-dataset.js';
 import { getPrincipleState, setPrincipleState } from '../core/principle-training-state.js';
@@ -721,7 +722,8 @@ export function executeNocturnalReflection(
   if (!preflight.canRun) {
     return {
       success: false,
-      noTargetSelected: false,
+      noTargetSelected: true,
+      skipReason: 'preflight_blocked',
       validationFailed: false,
       validationFailures: [],
       diagnostics,
@@ -784,7 +786,8 @@ export function executeNocturnalReflection(
   // -------------------------------------------------------------------------
   // Note: We use a sync approximation here since this is called from sync context
   // The async version would be used in real worker integration
-  void recordRunStart(stateDir, selectedPrincipleId).catch((err) => {
+  const config = loadNocturnalConfig(stateDir);
+  void recordRunStart(stateDir, selectedPrincipleId, config.cooldown_ms).catch((err) => {
     console.warn(`[nocturnal-service] Failed to record run start: ${String(err)}`);
   });
 
@@ -1195,7 +1198,14 @@ async function executeNocturnalReflectionWithAdapter(
   diagnostics.preflight = preflight;
 
   if (!preflight.canRun) {
-    return { success: false, noTargetSelected: false, validationFailed: false, validationFailures: [], diagnostics };
+    return { 
+      success: false, 
+      noTargetSelected: true, 
+      skipReason: 'preflight_blocked',
+      validationFailed: false, 
+      validationFailures: [], 
+      diagnostics 
+    };
   }
 
   // Step 2: Target selection (or use override to skip)
@@ -1317,7 +1327,8 @@ async function executeNocturnalReflectionWithAdapter(
   }
 
   // Step 3: Record run start
-  void recordRunStart(stateDir, selectedPrincipleId).catch((err) => {
+  const config = loadNocturnalConfig(stateDir);
+  void recordRunStart(stateDir, selectedPrincipleId, config.cooldown_ms).catch((err) => {
     console.warn(`[nocturnal-service] Failed to record run start: ${String(err)}`);
   });
 

package/src/service/nocturnal-target-selector.ts

@@ -63,7 +63,8 @@ export type SkipReason =
   | 'workspace_not_idle'            // Workspace is active, nocturnal not allowed
   | 'quota_exhausted'              // Max runs per quota window reached
   | 'insufficient_snapshot_data'    // Sessions exist but lack tool calls / events
-  | 'global_cooldown_active';       // Global cooldown is in effect
+  | 'global_cooldown_active'        // Global cooldown is in effect
+  | 'preflight_blocked';            // Preflight check blocked (idle/cooldown/quota)
 
 export interface SelectionDiagnostics {
   /** Total evaluable principles found */

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

@@ -260,10 +260,9 @@ export class NocturnalWorkflowManager implements WorkflowManager {
                         },
                         // Pass painContext for Selector ranking bias
                         painContext,
-                        // #244: Only skip preflight idle gate for manual/test triggers.
-                        // Automatic triggers must go through normal idle check.
-                        ...(((options.metadata)?.triggerSource === 'manual' ||
-                            (options.metadata)?.triggerSource === 'test')
+                        // #244: Skip preflight gates as configured by caller (e.g. manual/test/sleep_reflection).
+                        // Gates not in skipPreflightGates go through normal checks.
+                        ...(((options.metadata)?.skipPreflightGates as string[] | undefined)?.includes('idle')
                           ? {
                               idleCheckOverride: {
                                   isIdle: true,
@@ -272,7 +271,7 @@ export class NocturnalWorkflowManager implements WorkflowManager {
                                   userActiveSessions: 0,
                                   abandonedSessionIds: [],
                                   trajectoryGuardrailConfirmsIdle: true,
-                                  reason: 'manual/test override',
+                                  reason: 'skipPreflightGates override',
                               },
                             }
                           : {}),
@@ -293,7 +292,28 @@ export class NocturnalWorkflowManager implements WorkflowManager {
                     this.completedWorkflows.set(workflowId, Date.now());
                 } else {
                     const reason = result.noTargetSelected ? 'no_target_selected' : 'validation_failed';
-                    this.logger.warn(`[PD:NocturnalWorkflow] [${workflowId}] Pipeline failed: reason=${reason}, noTargetSelected=${result.noTargetSelected}, skipReason=${result.skipReason ?? 'none'}, validationFailures=${result.validationFailures?.length ?? 0}`);
+                    const failuresSummary = result.validationFailures?.length > 0 
+                        ? result.validationFailures.join('; ') 
+                        : (result.skipReason ?? 'none');
+                    this.logger.warn(`[PD:NocturnalWorkflow] [${workflowId}] Pipeline failed: reason=${reason}, noTargetSelected=${result.noTargetSelected}, skipReason=${result.skipReason ?? 'none'}, validationFailures=${result.validationFailures?.length ?? 0}, details=${failuresSummary}`);
+                    
+                    // Log full result structure for debugging
+                    this.logger.warn(`[PD:NocturnalWorkflow] [${workflowId}] Full result: success=${result.success}, validationFailed=${result.validationFailed}, noTargetSelected=${result.noTargetSelected}`);
+                    
+                    // Log diagnostics for debugging
+                    if (result.diagnostics?.trinityResult) {
+                        this.logger.warn(`[PD:NocturnalWorkflow] [${workflowId}] Trinity result: success=${result.diagnostics.trinityResult.success}, chainMode=${result.diagnostics.chainModeUsed ?? 'unknown'}`);
+                        if (!result.diagnostics.trinityResult.success) {
+                            this.logger.warn(`[PD:NocturnalWorkflow] [${workflowId}] Trinity failures: ${result.diagnostics.trinityResult.failures.map(f => `${f.stage}: ${f.reason}`).join('; ')}`);
+                        }
+                    }
+                    if (result.diagnostics?.arbiterResult) {
+                        this.logger.warn(`[PD:NocturnalWorkflow] [${workflowId}] Arbiter result: passed=${result.diagnostics.arbiterResult.passed}, failures=${result.diagnostics.arbiterResult.failures.map(f => f.reason).join('; ')}`);
+                    }
+                    if (result.diagnostics?.selection) {
+                        this.logger.warn(`[PD:NocturnalWorkflow] [${workflowId}] Selection: decision=${result.diagnostics.selection.decision}, principleId=${result.diagnostics.selection.selectedPrincipleId ?? 'none'}, sessionId=${result.diagnostics.selection.selectedSessionId ?? 'none'}`);
+                    }
+                    
                     this.store.updateWorkflowState(workflowId, 'terminal_error');
                     this.store.recordEvent(workflowId, 'nocturnal_failed', null, 'terminal_error', reason, {
                         failures: result.validationFailures,