principles-disciple 1.34.2 → 1.35.0

package/src/index.ts

@@ -16,9 +16,7 @@ import type {
   PluginHookSubagentSpawningResult,
   PluginHookSubagentContext,
 } from './openclaw-sdk.js';
-import * as crypto from 'crypto';
 import * as path from 'path';
-import type { WorkerProfile } from './core/model-deployment-registry.js';
 import { classifyTask } from './core/local-worker-routing.js';
 import { completeShadowObservation, recordShadowRouting } from './core/shadow-observation-registry.js';
 import { getCommandDescription } from './i18n/commands.js';
@@ -59,83 +57,25 @@ import { migrateDirectoryStructure } from './core/migration.js';
 import { SystemLogger } from './core/system-logger.js';
 import { createDeepReflectTool } from './tools/deep-reflect.js';
 import { createWritePainFlagTool } from './tools/write-pain-flag.js';
-import { PathResolver, resolveWorkspaceDirFromApi } from './core/path-resolver.js';
-import { validateWorkspaceDir } from './core/workspace-dir-validation.js';
-import { resolveRequiredWorkspaceDir, resolveWorkspaceDir, type WorkspaceResolutionContext } from './core/workspace-dir-service.js';
+import { PathResolver } from './core/path-resolver.js';
 import { createPrinciplesConsoleRoute } from './http/principles-console-route.js';
 import { extractAgentIdFromSessionKey } from './utils/session-key.js';
+import { resolveCommandWorkspaceDir, resolveToolHookWorkspaceDirSafe } from './utils/workspace-resolver.js';
+import { computeRuntimeShadowTaskFingerprint, PD_LOCAL_PROFILES } from './utils/shadow-fingerprint.js';
+import type { WorkerProfile } from './core/model-deployment-registry.js';
+import { validateWorkspaceDir } from './core/workspace-dir-validation.js';
+import { resolveWorkspaceDirFromApi } from './core/path-resolver.js';
+import { resolveRequiredWorkspaceDir } from './core/workspace-dir-service.js';
 
 // Track initialization to avoid repeated calls
 let workspaceInitialized = false;
 // Track started evolution workers — one per workspace
 const startedWorkspaces = new Set<string>();
 
-/**
- * Resolve workspaceDir for slash commands.
- * Chain: ctx.workspaceDir → resolveWorkspaceDirFromApi (official OpenClaw API + env vars)
- * 
- * CRITICAL: Throws if workspaceDir cannot be resolved. Silent failures are dangerous
- * because commands might operate on the wrong directory.
- */
-function resolveCommandWorkspaceDir(
-  api: OpenClawPluginApi,
-  ctx: { workspaceDir?: string },
-): string {
-  // 1. Direct from command context (most reliable — set by OpenClaw for current session)
-  if (ctx.workspaceDir) {
-    const issue = validateWorkspaceDir(ctx.workspaceDir);
-    if (!issue) return ctx.workspaceDir;
-    api.logger.error(`[PD:Command] ctx.workspaceDir="${ctx.workspaceDir}" is invalid: ${issue}`);
-  }
-
-  // 2. Official OpenClaw API → env vars → config file
-  const resolved = resolveWorkspaceDirFromApi(api);
-  if (resolved) return resolved;
-
-  // CRITICAL FAILURE: Cannot determine workspace directory
-  const errorMsg = `[PD:Command] CRITICAL: Cannot resolve workspace directory. ` +
-    `ctx.workspaceDir="${ctx.workspaceDir}" is invalid, and all fallbacks failed. ` +
-    `Commands will NOT execute to prevent data corruption.`;
-  api.logger.error(errorMsg);
-  
-  throw new Error(errorMsg);
-}
-
 // Map from childSessionKey → shadowObservationId
 // Used to complete shadow observations when subagent ends
 const pendingShadowObservations = new Map<string, string>();
 
-// PD local worker profiles that are managed by the shadow routing policy
-const PD_LOCAL_PROFILES = new Set<WorkerProfile>(['local-reader', 'local-editor']);
-
-function computeRuntimeShadowTaskFingerprint(event: PluginHookSubagentSpawningEvent): string {
-  const payload = {
-    childSessionKey: event.childSessionKey,
-    agentId: event.agentId,
-    label: event.label ?? '',
-    mode: event.mode,
-    threadRequested: event.threadRequested,
-    requesterChannel: event.requester?.channel ?? '',
-    requesterThreadId: event.requester?.threadId ?? '',
-  };
-  return crypto.createHash('sha256').update(JSON.stringify(payload)).digest('hex').slice(0, 16);
-}
-
-function _resolveCommandWorkspaceDirStrict(
-  api: OpenClawPluginApi,
-  ctx: WorkspaceResolutionContext,
-): string {
-  return resolveRequiredWorkspaceDir(api, ctx, { source: 'command' });
-}
-
-function resolveToolHookWorkspaceDirSafe(
-  ctx: WorkspaceResolutionContext,
-  api: OpenClawPluginApi,
-  source: string,
-): string | undefined {
-  return resolveWorkspaceDir(api, ctx, { source });
-}
-
 const plugin = {
   name: "Principles Disciple",
   description: "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
@@ -421,7 +361,7 @@ const plugin = {
 
     // ── Slash Commands ──
     // Register command with optional short alias
-    // eslint-disable-next-line @typescript-eslint/max-params, @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const registerCommandWithAlias = (name: string, alias: string | null, desc: string, handler: any, opts?: { acceptsArgs?: boolean }) => {
       const base = {
         name,

package/src/service/central-sync-service.ts

@@ -7,18 +7,13 @@
 
 import type { OpenClawPluginService, OpenClawPluginServiceContext, PluginLogger } from '../openclaw-sdk.js';
 import { CentralDatabase } from './central-database.js';
+import { WORKFLOW_TTL_MS } from '../config/defaults/runtime.js';
 
 let syncInterval: ReturnType<typeof setInterval> | null = null;
 let logger: PluginLogger | undefined = undefined;
 let centralDb: CentralDatabase | null = null;
 
-/**
- * Default sync interval: 5 minutes.
- * Can be overridden via config: intervals.central_sync_ms
- */
-const DEFAULT_SYNC_INTERVAL_MS = 5 * 60 * 1000;
-
-    // eslint-disable-next-line complexity -- complexity 12, refactor candidate
+     
 async function runSyncCycle(): Promise<void> {
   if (!centralDb) {
     logger?.warn?.('[PD:CentralSync] CentralDatabase not initialized, skipping sync');
@@ -51,7 +46,7 @@ export const CentralSyncService: OpenClawPluginService = {
     logger = ctxLogger;
 
     const { intervals } = config as { intervals?: { central_sync_ms?: number } };
-    const intervalMs = intervals?.central_sync_ms ?? DEFAULT_SYNC_INTERVAL_MS;
+    const intervalMs = intervals?.central_sync_ms ?? WORKFLOW_TTL_MS;
 
     // Initialize CentralDatabase
     centralDb = new CentralDatabase();

package/src/service/correction-observer-workflow-manager.ts

@@ -22,11 +22,11 @@ import type {
     CorrectionObserverPayload,
     CorrectionObserverResult,
 } from './correction-observer-types.js';
+import { WORKFLOW_TTL_MS } from '../config/defaults/runtime.js';
 
 const WORKFLOW_SESSION_PREFIX = 'agent:main:subagent:workflow-correction-';
 
 const DEFAULT_TIMEOUT_MS = 30_000;
-const DEFAULT_TTL_MS = 5 * 60 * 1000;
 
 // ── Options ─────────────────────────────────────────────────────────────────
 
@@ -162,7 +162,7 @@ export class CorrectionObserverWorkflowManager extends WorkflowManagerBase {
             workflowType: 'correction_observer',
             sessionPrefix: WORKFLOW_SESSION_PREFIX,
             defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
-            defaultTtlMs: DEFAULT_TTL_MS,
+            defaultTtlMs: WORKFLOW_TTL_MS,
         });
     }
 

package/src/service/evolution-worker.ts

@@ -16,10 +16,11 @@ import { getEvolutionLogger } from '../core/evolution-logger.js';
 import type { TaskKind, TaskPriority } from '../core/trajectory-types.js';
 export type { TaskKind, TaskPriority } from '../core/trajectory-types.js';
 import { LockUnavailableError } from '../config/index.js';
+import { PAIN_QUEUE_DEDUP_WINDOW_MS } from '../config/defaults/runtime.js';
 import { checkWorkspaceIdle, checkCooldown } from './nocturnal-runtime.js';
 import { loadNocturnalConfig } from './nocturnal-config.js';
 import { WorkflowStore } from './subagent-workflow/workflow-store.js';
-import type { WorkflowRow } from './subagent-workflow/types.js';
+import type { WorkflowRow, RecentPainContext } from './subagent-workflow/types.js';
 import { EmpathyObserverWorkflowManager } from './subagent-workflow/empathy-observer-workflow-manager.js';
 import { DeepReflectWorkflowManager } from './subagent-workflow/deep-reflect-workflow-manager.js';
 import { NocturnalWorkflowManager, nocturnalWorkflowSpec } from './subagent-workflow/nocturnal-workflow-manager.js';
@@ -36,8 +37,7 @@ import type { CorrectionObserverPayload } from './correction-observer-types.js';
 import { KeywordOptimizationService } from './keyword-optimization-service.js';
 import { TrajectoryRegistry } from '../core/trajectory.js';
 import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
-
-const WORKFLOW_TTL_MS = 5 * 60 * 1000; // 5 minutes default TTL for helper workflows
+import { WORKFLOW_TTL_MS } from '../config/defaults/runtime.js';
 import { OpenClawTrinityRuntimeAdapter } from '../core/nocturnal-trinity.js';
 
 /**
@@ -209,27 +209,6 @@ let timeoutId: NodeJS.Timeout | null = null;
 export type QueueStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'canceled';
 export type TaskResolution = 'marker_detected' | 'auto_completed_timeout' | 'failed_max_retries' | 'runtime_unavailable' | 'canceled' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'stub_fallback' | 'skipped_thin_violation';
 
-/**
- * Recent pain context attached to sleep_reflection tasks.
- * Carries explicit recent pain signal metadata without being a separate task kind.
- * Used by NocturnalTargetSelector for ranking bias and context enrichment.
- */
-export interface RecentPainContext {
-  /** Most recent unresolved pain event */
-  mostRecent: {
-    score: number;
-    source: string;
-    reason: string;
-    timestamp: string;
-    /** Session ID where the pain occurred */
-    sessionId: string;
-  } | null;
-  /** Count of pain events in the recent window (for signal strength) */
-  recentPainCount: number;
-  /** Highest pain score in the recent window */
-  recentMaxPainScore: number;
-}
-
 export interface EvolutionQueueItem {
     // Core identity
     id: string;
@@ -435,7 +414,6 @@ function buildFallbackNocturnalSnapshot(
     };
 }
 
-const PAIN_QUEUE_DEDUP_WINDOW_MS = 30 * 60 * 1000;
 
 // P0 fix: File lock constants and helper for queue operations (prevents TOCTOU race)
 export const EVOLUTION_QUEUE_LOCK_SUFFIX = '.lock';
@@ -692,7 +670,7 @@ function shouldSkipForDedup(
  * Load and migrate the evolution queue. Returns empty array if file doesn't exist.
  */
 function loadEvolutionQueue(queuePath: string): EvolutionQueueItem[] {
-    // eslint-disable-next-line no-useless-assignment
+     
     let rawQueue: RawQueueItem[] = [];
     try {
         rawQueue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
@@ -2014,10 +1992,14 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                     };
 
                     // Dispatch LLM subagent via CorrectionObserverWorkflowManager
+                    const subagent = api?.runtime?.subagent;
+                    if (!subagent) {
+                        throw new Error('[PD:EvolutionWorker] subagent runtime not available for keyword_optimization');
+                    }
                     const manager = new CorrectionObserverWorkflowManager({
                         workspaceDir: wctx.workspaceDir,
                         logger,
-                        subagent: api?.runtime?.subagent!,
+                        subagent,
                         agentSession: api?.runtime?.agent?.session,
                     });
 
@@ -2031,7 +2013,11 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                         workflowId = handle.workflowId;
                         koTask.resultRef = workflowId;
                     } else {
-                        workflowId = koTask.resultRef!;
+                        // isPolling implies resultRef exists (checked above)
+                        workflowId = koTask.resultRef;
+                        if (!workflowId) {
+                            throw new Error(`[PD:EvolutionWorker] keyword_optimization task ${koTask.id} has no resultRef in polling mode`);
+                        }
                     }
 
                     // Poll workflow state

package/src/service/nocturnal-service.ts

@@ -31,7 +31,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { randomUUID } from 'crypto';
-import type { RecentPainContext } from './evolution-worker.js';
+import type { RecentPainContext } from './subagent-workflow/types.js';
+import type { PluginLogger } from '../openclaw-sdk.js';
 import {
   createNocturnalTrajectoryExtractor,
   computeThinkingModelDelta,
@@ -122,6 +123,7 @@ function incrementGeneratedSampleCount(stateDir: string, principleId: string): v
     state.generatedSampleCount += 1;
     setPrincipleState(stateDir, state);
   } catch (err) {
+    // eslint-disable-next-line no-console -- Non-critical warning in helper function
     console.warn(`[nocturnal-service] Failed to sync generatedSampleCount for ${principleId}:`, err instanceof Error ? err.stack : err);
   }
 }
@@ -268,6 +270,12 @@ export interface NocturnalServiceOptions {
    * When omitted, a deterministic local candidate is synthesized.
    */
   artificerOutputOverride?: string;
+
+  /**
+   * Logger for diagnostic output.
+   * When provided, warnings are logged via logger.warn instead of console.warn.
+   */
+  logger?: PluginLogger;
 }
 
 // ---------------------------------------------------------------------------
@@ -299,16 +307,16 @@ function invokeStubReflector(
   const hasPain = snapshot.stats.totalPainEvents > 0;
   const hasFailures = (snapshot.stats.failureCount ?? 0) > 0;
 
-  // eslint-disable-next-line @typescript-eslint/init-declarations
+   
   let badDecision: string;
-  // eslint-disable-next-line @typescript-eslint/init-declarations
+   
   let betterDecision: string;
-  // eslint-disable-next-line @typescript-eslint/init-declarations
+   
   let rationale: string;
 
   if (hasGateBlocks && snapshot.gateBlocks.length > 0) {
     // Use actual gate block content
-    // eslint-disable-next-line @typescript-eslint/prefer-destructuring
+     
     const block = snapshot.gateBlocks[0];
     const tool = block.toolName ?? 'a tool';
     const file = block.filePath ? ` on ${block.filePath}` : '';
@@ -317,7 +325,7 @@ function invokeStubReflector(
     rationale = `Gate blocks exist for a reason — bypassing them without understanding the underlying constraint risks unintended consequences. The block on ${tool}${file} indicates the operation exceeded allowed thresholds for the current evolution tier.`;
   } else if (hasPain && snapshot.painEvents.length > 0) {
     // Use actual pain event content
-    // eslint-disable-next-line @typescript-eslint/prefer-destructuring
+     
     const pain = snapshot.painEvents[0];
     const painSource = pain.source ?? 'unknown';
     const painReason = pain.reason ? `: ${pain.reason}` : '';
@@ -413,7 +421,7 @@ function buildGateBlockRefs(snapshot: NocturnalSessionSnapshot): string[] {
 }
 
  
-// eslint-disable-next-line @typescript-eslint/max-params
+ 
 function buildDefaultArtificerOutput(
   ruleId: string,
   artifact: NocturnalArtifact,
@@ -463,7 +471,7 @@ function buildDefaultArtificerOutput(
 }
 
  
-// eslint-disable-next-line @typescript-eslint/max-params
+ 
 function persistCodeCandidate(
   workspaceDir: string,
   stateDir: string,
@@ -521,6 +529,7 @@ function persistCodeCandidate(
     try {
       refreshPrincipleLifecycle(workspaceDir, stateDir);
     } catch (err) {
+      // eslint-disable-next-line no-console -- Non-critical warning in helper function
       console.warn('[nocturnal-service] Lifecycle refresh failed after code candidate persistence:', err instanceof Error ? err.stack : err);
     }
     return {
@@ -560,7 +569,7 @@ function persistCodeCandidate(
 }
 
  
-// eslint-disable-next-line @typescript-eslint/max-params
+ 
 function maybePersistArtificerCandidate(
   workspaceDir: string,
   stateDir: string,
@@ -698,6 +707,11 @@ export function executeNocturnalReflection(
   stateDir: string,
   options: NocturnalServiceOptions = {}
 ): NocturnalRunResult {
+  // Use provided logger or fallback to console
+  const logger = options.logger;
+  // eslint-disable-next-line no-console -- Intentional console fallback when no logger provided
+  const warn = logger?.warn?.bind(logger) ?? console.warn.bind(console);
+
   const diagnostics: NocturnalRunDiagnostics = {
     preflight: null,
     selection: null,
@@ -797,18 +811,18 @@ export function executeNocturnalReflection(
   // The async version would be used in real worker integration
   const config = loadNocturnalConfig(stateDir);
   void recordRunStart(stateDir, selectedPrincipleId, config.cooldown_ms).catch((err) => {
-    console.warn(`[nocturnal-service] Failed to record run start: ${String(err)}`);
+    warn(`[nocturnal-service] Failed to record run start: ${String(err)}`);
   });
 
   // -------------------------------------------------------------------------
   // Step 5: Artifact generation (Trinity or single-reflector)
   // -------------------------------------------------------------------------
    
-  // eslint-disable-next-line no-useless-assignment
+   
   let trinityArtifact: TrinityDraftArtifact | null = null;
   let trinityResult: TrinityResult | null = null;
    
-  // eslint-disable-next-line @typescript-eslint/init-declarations
+   
   let rawJson: string;
 
   if (options.skipReflector) {
@@ -834,7 +848,7 @@ export function executeNocturnalReflection(
       // Trinity failed — fail closed (same semantics as production)
       const failures = trinityResult.failures.map((f) => `${f.stage}: ${f.reason}`);
       void recordRunEnd(stateDir, 'failed', { reason: `Trinity override failed: ${failures.join('; ')}` }).catch((err) => {
-        console.warn(`[nocturnal-service] Failed to record run end: ${String(err)}`);
+        warn(`[nocturnal-service] Failed to record run end: ${String(err)}`);
       });
       // Emit threshold signals: malformed Trinity override is a strong signal
       adjustThresholdsFromSignals(stateDir, {
@@ -857,7 +871,7 @@ export function executeNocturnalReflection(
       if (!draftValidation.valid) {
         const {failures} = draftValidation;
         void recordRunEnd(stateDir, 'failed', { reason: `Trinity draft invalid: ${failures.join('; ')}` }).catch((err) => {
-          console.warn(`[nocturnal-service] Failed to record run end: ${String(err)}`);
+          warn(`[nocturnal-service] Failed to record run end: ${String(err)}`);
         });
         // Emit threshold signals: malformed draft content is a strong signal
         adjustThresholdsFromSignals(stateDir, {
@@ -908,7 +922,7 @@ export function executeNocturnalReflection(
           // Trinity draft invalid — fail closed
           const {failures} = draftValidation;
           void recordRunEnd(stateDir, 'failed', { reason: `Trinity draft invalid: ${failures.join('; ')}` }).catch((err) => {
-            console.warn(`[nocturnal-service] Failed to record run end: ${String(err)}`);
+            warn(`[nocturnal-service] Failed to record run end: ${String(err)}`);
           });
           // Emit threshold signals: malformed draft content is a strong signal
           adjustThresholdsFromSignals(stateDir, {
@@ -935,7 +949,7 @@ export function executeNocturnalReflection(
         // Phase 6 requirement: malformed Trinity stage output fails closed
         const failures = trinityResult.failures.map((f) => `${f.stage}: ${f.reason}`);
         void recordRunEnd(stateDir, 'failed', { reason: `Trinity chain failed: ${failures.join('; ')}` }).catch((err) => {
-          console.warn(`[nocturnal-service] Failed to record run end: ${String(err)}`);
+          warn(`[nocturnal-service] Failed to record run end: ${String(err)}`);
         });
         // Emit threshold signals: malformed Trinity is the strongest signal for tightening schema threshold
         adjustThresholdsFromSignals(stateDir, {
@@ -979,7 +993,7 @@ export function executeNocturnalReflection(
   if (!arbiterResult.passed || !arbiterResult.artifact) {
     const failures = arbiterResult.failures.map((f) => f.reason);
     void recordRunEnd(stateDir, 'failed', { reason: failures.join('; ') }).catch((err) => {
-      console.warn(`[nocturnal-service] Failed to record run end (arbiter failed): ${String(err)}`);
+      warn(`[nocturnal-service] Failed to record run end (arbiter failed): ${String(err)}`);
     });
     // Emit threshold signals: arbiter rejection indicates principle alignment issues
     adjustThresholdsFromSignals(stateDir, {
@@ -1005,7 +1019,7 @@ export function executeNocturnalReflection(
   if (!execResult.executable) {
     const failures = execResult.failures.map((f) => f.reason);
     void recordRunEnd(stateDir, 'failed', { reason: failures.join('; ') }).catch((err) => {
-      console.warn(`[nocturnal-service] Failed to record run end (executability failed): ${String(err)}`);
+      warn(`[nocturnal-service] Failed to record run end (executability failed): ${String(err)}`);
     });
     // Emit threshold signals: executability rejection indicates action quality issues
     adjustThresholdsFromSignals(stateDir, {
@@ -1033,7 +1047,7 @@ export function executeNocturnalReflection(
   };
 
    
-  // eslint-disable-next-line @typescript-eslint/init-declarations
+   
   let persistedPath: string;
   try {
     persistedPath = persistArtifact(workspaceDir, artifactWithBoundedAction);
@@ -1041,7 +1055,7 @@ export function executeNocturnalReflection(
     diagnostics.persistedPath = persistedPath;
   } catch (err) {
     void recordRunEnd(stateDir, 'failed', { reason: `persistence error: ${String(err)}` }).catch((e) => {
-      console.warn(`[nocturnal-service] Failed to record run end (persistence failed): ${String(e)}`);
+      warn(`[nocturnal-service] Failed to record run end (persistence failed): ${String(e)}`);
     });
     return {
       success: false,
@@ -1066,7 +1080,7 @@ export function executeNocturnalReflection(
   } catch (err) {
     // Non-fatal: artifact is persisted, registry is secondary.
     // Log but don't fail the run.
-    console.warn(`[nocturnal-service] Failed to register sample in dataset registry: ${String(err)}`);
+    warn(`[nocturnal-service] Failed to register sample in dataset registry: ${String(err)}`);
   }
 
   try {
@@ -1084,7 +1098,7 @@ export function executeNocturnalReflection(
       createdAt: arbiterResult.artifact.createdAt,
     });
   } catch (err) {
-    console.warn(`[nocturnal-service] Failed to append behavioral artifact lineage: ${String(err)}`);
+    warn(`[nocturnal-service] Failed to append behavioral artifact lineage: ${String(err)}`);
   }
 
   diagnostics.artificer = maybePersistArtificerCandidate(
@@ -1101,7 +1115,7 @@ export function executeNocturnalReflection(
   // Step 9: Record run success
   // -------------------------------------------------------------------------
   void recordRunEnd(stateDir, 'success', { sampleCount: 1 }).catch((err) => {
-    console.warn(`[nocturnal-service] Failed to record run end (success): ${String(err)}`);
+    warn(`[nocturnal-service] Failed to record run end (success): ${String(err)}`);
   });
 
   // -------------------------------------------------------------------------
@@ -1161,7 +1175,7 @@ export async function executeNocturnalReflectionAsync(
   // If runtime adapter is provided, use async Trinity path
   if (options.runtimeAdapter) {
      
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+     
     return executeNocturnalReflectionWithAdapter(workspaceDir, stateDir, options);
   }
 
@@ -1178,6 +1192,11 @@ async function executeNocturnalReflectionWithAdapter(
   stateDir: string,
   options: NocturnalServiceOptions
 ): Promise<NocturnalRunResult> {
+  // Use provided logger or fallback to console
+  const logger = options.logger;
+  // eslint-disable-next-line no-console -- Intentional console fallback when no logger provided
+  const warn = logger?.warn?.bind(logger) ?? console.warn.bind(console);
+
   const diagnostics: NocturnalRunDiagnostics = {
     preflight: null,
     selection: null,
@@ -1219,13 +1238,13 @@ async function executeNocturnalReflectionWithAdapter(
 
   // Step 2: Target selection (or use override to skip)
    
-  // eslint-disable-next-line @typescript-eslint/init-declarations
+   
   let selectedPrincipleId: string | undefined;
    
-  // eslint-disable-next-line @typescript-eslint/init-declarations
+   
   let selectedSessionId: string | undefined;
    
-  // eslint-disable-next-line no-useless-assignment
+   
   let snapshot: NocturnalSessionSnapshot | null = null;
 
   if (options.principleIdOverride && options.snapshotOverride) {
@@ -1248,7 +1267,7 @@ async function executeNocturnalReflectionWithAdapter(
     // Skip Selector: use provided principleId and snapshot directly
     selectedPrincipleId = options.principleIdOverride;
     selectedSessionId = snapshotValidation.snapshot.sessionId;
-    // eslint-disable-next-line @typescript-eslint/prefer-destructuring
+     
     snapshot = snapshotValidation.snapshot;
     // Calculate violation density from snapshot stats for meaningful diagnostics
     const snapStats = snapshotValidation.snapshot.stats;
@@ -1305,10 +1324,10 @@ async function executeNocturnalReflectionWithAdapter(
     }
 
      
-    // eslint-disable-next-line @typescript-eslint/prefer-destructuring
+     
     selectedPrincipleId = selection.selectedPrincipleId;
      
-    // eslint-disable-next-line @typescript-eslint/prefer-destructuring
+     
     selectedSessionId = selection.selectedSessionId;
 
     if (!selectedPrincipleId || !selectedSessionId) {
@@ -1338,16 +1357,16 @@ async function executeNocturnalReflectionWithAdapter(
   // Step 3: Record run start
   const config = loadNocturnalConfig(stateDir);
   void recordRunStart(stateDir, selectedPrincipleId, config.cooldown_ms).catch((err) => {
-    console.warn(`[nocturnal-service] Failed to record run start: ${String(err)}`);
+    warn(`[nocturnal-service] Failed to record run start: ${String(err)}`);
   });
 
   // Step 4: Trinity execution via adapter (async)
    
-  // eslint-disable-next-line no-useless-assignment
+   
   let trinityArtifact: TrinityDraftArtifact | null = null;
   let trinityResult: TrinityResult | null = null;
    
-  // eslint-disable-next-line @typescript-eslint/init-declarations
+   
   let rawJson: string;
 
   if (options.skipReflector) {
@@ -1370,7 +1389,7 @@ async function executeNocturnalReflectionWithAdapter(
     if (!trinityResult.success) {
       const failures = trinityResult.failures.map((f) => `${f.stage}: ${f.reason}`);
       void recordRunEnd(stateDir, 'failed', { reason: `Trinity override failed: ${failures.join('; ')}` }).catch((err) => {
-        console.warn(`[nocturnal-service] Failed to record run end: ${String(err)}`);
+        warn(`[nocturnal-service] Failed to record run end: ${String(err)}`);
       });
       adjustThresholdsFromSignals(stateDir, { malformedRate: 1.0, arbiterRejectRate: 0.0, executabilityRejectRate: 0.0, qualityDelta: 0.0 });
       return { success: false, noTargetSelected: false, validationFailed: true, validationFailures: [`Trinity override failed: ${failures.join('; ')}`], snapshot, diagnostics };
@@ -1397,7 +1416,7 @@ async function executeNocturnalReflectionWithAdapter(
         if (!draftValidation.valid) {
           const {failures} = draftValidation;
           void recordRunEnd(stateDir, 'failed', { reason: `Trinity draft invalid: ${failures.join('; ')}` }).catch((err) => {
-            console.warn(`[nocturnal-service] Failed to record run end: ${String(err)}`);
+            warn(`[nocturnal-service] Failed to record run end: ${String(err)}`);
           });
           adjustThresholdsFromSignals(stateDir, { malformedRate: 1.0, arbiterRejectRate: 0.0, executabilityRejectRate: 0.0, qualityDelta: 0.0 });
           return { success: false, noTargetSelected: false, validationFailed: true, validationFailures: failures, snapshot, diagnostics };
@@ -1408,7 +1427,7 @@ async function executeNocturnalReflectionWithAdapter(
       } else {
         const failures = trinityResult.failures.map((f) => `${f.stage}: ${f.reason}`);
         void recordRunEnd(stateDir, 'failed', { reason: `Trinity chain failed: ${failures.join('; ')}` }).catch((err) => {
-          console.warn(`[nocturnal-service] Failed to record run end: ${String(err)}`);
+          warn(`[nocturnal-service] Failed to record run end: ${String(err)}`);
         });
         adjustThresholdsFromSignals(stateDir, { malformedRate: 1.0, arbiterRejectRate: 0.0, executabilityRejectRate: 0.0, qualityDelta: 0.0 });
         return { success: false, noTargetSelected: false, validationFailed: true, validationFailures: [`Trinity chain failed: ${failures.join('; ')}`], snapshot, diagnostics };
@@ -1433,7 +1452,7 @@ async function executeNocturnalReflectionWithAdapter(
   if (!arbiterResult.passed || !arbiterResult.artifact) {
     const failures = arbiterResult.failures.map((f) => f.reason);
     void recordRunEnd(stateDir, 'failed', { reason: failures.join('; ') }).catch((err) => {
-      console.warn(`[nocturnal-service] Failed to record run end (arbiter failed): ${String(err)}`);
+      warn(`[nocturnal-service] Failed to record run end (arbiter failed): ${String(err)}`);
     });
     adjustThresholdsFromSignals(stateDir, { malformedRate: 0.0, arbiterRejectRate: 1.0, executabilityRejectRate: 0.0, qualityDelta: 0.0 });
     return { success: false, noTargetSelected: false, validationFailed: true, validationFailures: failures, diagnostics };
@@ -1444,7 +1463,7 @@ async function executeNocturnalReflectionWithAdapter(
   if (!execResult.executable) {
     const failures = execResult.failures.map((f) => f.reason);
     void recordRunEnd(stateDir, 'failed', { reason: failures.join('; ') }).catch((err) => {
-      console.warn(`[nocturnal-service] Failed to record run end (executability failed): ${String(err)}`);
+      warn(`[nocturnal-service] Failed to record run end (executability failed): ${String(err)}`);
     });
     adjustThresholdsFromSignals(stateDir, { malformedRate: 0.0, arbiterRejectRate: 0.0, executabilityRejectRate: 1.0, qualityDelta: 0.0 });
     return { success: false, noTargetSelected: false, validationFailed: true, validationFailures: failures, diagnostics };
@@ -1454,7 +1473,7 @@ async function executeNocturnalReflectionWithAdapter(
   // Step 7: Persist artifact
   const artifactWithBoundedAction = { ...arbiterResult.artifact, boundedAction: execResult.boundedAction };
    
-  // eslint-disable-next-line @typescript-eslint/init-declarations
+   
   let persistedPath: string;
   try {
     persistedPath = persistArtifact(workspaceDir, artifactWithBoundedAction);
@@ -1462,7 +1481,7 @@ async function executeNocturnalReflectionWithAdapter(
     diagnostics.persistedPath = persistedPath;
   } catch (err) {
     void recordRunEnd(stateDir, 'failed', { reason: `persistence error: ${String(err)}` }).catch((e) => {
-      console.warn(`[nocturnal-service] Failed to record run end (persistence failed): ${String(e)}`);
+      warn(`[nocturnal-service] Failed to record run end (persistence failed): ${String(e)}`);
     });
     return { success: false, noTargetSelected: false, validationFailed: true, validationFailures: [`Failed to persist artifact: ${String(err)}`], snapshot, diagnostics };
   }
@@ -1474,7 +1493,7 @@ async function executeNocturnalReflectionWithAdapter(
       incrementGeneratedSampleCount(stateDir, arbiterResult.artifact.principleId);
     }
   } catch (err) {
-    console.warn(`[nocturnal-service] Failed to register sample in dataset registry: ${String(err)}`);
+    warn(`[nocturnal-service] Failed to register sample in dataset registry: ${String(err)}`);
   }
 
   try {
@@ -1492,7 +1511,7 @@ async function executeNocturnalReflectionWithAdapter(
       createdAt: arbiterResult.artifact.createdAt,
     });
   } catch (err) {
-    console.warn(`[nocturnal-service] Failed to append behavioral artifact lineage: ${String(err)}`);
+    warn(`[nocturnal-service] Failed to append behavioral artifact lineage: ${String(err)}`);
   }
 
   diagnostics.artificer = maybePersistArtificerCandidate(
@@ -1507,7 +1526,7 @@ async function executeNocturnalReflectionWithAdapter(
 
   // Step 9: Record run success
   void recordRunEnd(stateDir, 'success', { sampleCount: 1 }).catch((err) => {
-    console.warn(`[nocturnal-service] Failed to record run end (success): ${String(err)}`);
+    warn(`[nocturnal-service] Failed to record run end (success): ${String(err)}`);
   });
 
   // Step 10: Adaptive threshold adjustment