principles-disciple 1.22.0 → 1.24.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.22.0",
+  "version": "1.24.0",
   "skills": [
     "./skills"
   ],
@@ -76,8 +76,8 @@
     }
   },
   "buildFingerprint": {
-    "gitSha": "bce835db37a0",
-    "bundleMd5": "9e44177badb37ac423669fd187bf2667",
-    "builtAt": "2026-04-10T14:01:23.050Z"
+    "gitSha": "ebbaa40d6e3a",
+    "bundleMd5": "7c84860901894f7c049b54028d489ed4",
+    "builtAt": "2026-04-12T15:51:34.724Z"
   }
 }

package/package.json

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

package/scripts/diagnose-nocturnal.mjs

@@ -0,0 +1,393 @@
+#!/usr/bin/env node
+
+/**
+ * Nocturnal Pipeline Diagnostic Script
+ * ======================================
+ * Checks every link in the Nocturnal reflection chain:
+ *   Heartbeat → Idle Detection → Queue → Snapshot → Workflow → Trinity → Arbiter → Persistence
+ *
+ * Usage:
+ *   node scripts/diagnose-nocturnal.mjs [--workspace /path/to/workspace]
+ *
+ * Output: Structured report with pass/fail for each checkpoint.
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PLUGIN_DIR = join(__dirname, '..');
+
+// ─── Argument parsing ───
+function parseArgs() {
+  let workspaceDir = null;
+  const argv = process.argv.slice(2);
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--workspace' && argv[i + 1]) {
+      workspaceDir = argv[++i];
+    }
+  }
+  // Auto-detect workspace from current git working directory
+  if (!workspaceDir) {
+    try {
+      const gitRoot = execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' }).trim();
+      workspaceDir = gitRoot;
+    } catch {
+      workspaceDir = process.cwd();
+    }
+  }
+  return { workspaceDir };
+}
+
+// ─── Report helpers ───
+const results = [];
+let checksPassed = 0;
+let checksFailed = 0;
+let checksWarned = 0;
+
+function check(name, fn) {
+  try {
+    const result = fn();
+    if (result && result.status === 'warn') {
+      checksWarned++;
+      results.push({ name, status: 'warn', detail: result.detail || '' });
+    } else {
+      checksPassed++;
+      results.push({ name, status: 'pass', detail: typeof result === 'string' ? result : '' });
+    }
+  } catch (err) {
+    checksFailed++;
+    results.push({ name, status: 'fail', detail: err.message || String(err) });
+  }
+}
+
+function printReport() {
+  console.log('\n' + '='.repeat(60));
+  console.log('  NOCTURNAL PIPELINE DIAGNOSTIC REPORT');
+  console.log('  ' + new Date().toISOString());
+  console.log('='.repeat(60));
+
+  for (const r of results) {
+    const icon = r.status === 'pass' ? '✅' : r.status === 'warn' ? '⚠️ ' : '❌';
+    console.log(`\n${icon} ${r.name}`);
+    if (r.detail) {
+      console.log(`   ${r.detail}`);
+    }
+  }
+
+  console.log('\n' + '-'.repeat(60));
+  console.log(`  Summary: ${checksPassed} passed, ${checksWarned} warnings, ${checksFailed} failed`);
+  console.log('-'.repeat(60) + '\n');
+
+  if (checksFailed > 0) {
+    process.exitCode = 1;
+  }
+}
+
+// ─── Main ───
+function main() {
+  const { workspaceDir } = parseArgs();
+  const stateDir = join(workspaceDir, '.state');
+
+  console.log(`\n🔍 Diagnosing Nocturnal pipeline for workspace: ${workspaceDir}`);
+
+  // ─────────────────────────────────────────────────────────
+  // CHECKPOINT 1: State directory structure
+  // ─────────────────────────────────────────────────────────
+  check('1. State directory structure', () => {
+    // All state dirs are inside .state/
+    const required = ['sessions', 'logs', 'nocturnal', 'nocturnal/samples'];
+    const missing = [];
+    for (const rel of required) {
+      if (!existsSync(join(stateDir, rel))) missing.push(rel);
+    }
+    if (missing.length > 0) throw new Error(`Missing directories: ${missing.join(', ')}`);
+    return 'All required directories present';
+  });
+
+  // ─────────────────────────────────────────────────────────
+  // CHECKPOINT 2: Session tracker persistence
+  // ─────────────────────────────────────────────────────────
+  check('2. Session tracker persistence', () => {
+    const sessionsDir = join(stateDir, 'sessions');
+    if (!existsSync(sessionsDir)) throw new Error('sessions/ directory missing');
+    const files = readdirSync(sessionsDir).filter(f => f.endsWith('.json'));
+    if (files.length === 0) {
+      return { status: 'warn', detail: 'No session files found — idle check will report idle immediately' };
+    }
+    // Verify at least one session file is valid JSON
+    let validSessions = 0;
+    for (const f of files) {
+      try {
+        const data = JSON.parse(readFileSync(join(sessionsDir, f), 'utf-8'));
+        if (data.sessionId && data.lastActivityAt) validSessions++;
+      } catch { /* corrupted, skip */ }
+    }
+    return `${files.length} session files, ${validSessions} valid with sessionId+lastActivityAt`;
+  });
+
+  // ─────────────────────────────────────────────────────────
+  // CHECKPOINT 3: Idle detection logic
+  // ─────────────────────────────────────────────────────────
+  check('3. Idle detection (checkWorkspaceIdle)', () => {
+    // Functions are minified — check for unique string markers instead.
+    const bundlePath = join(PLUGIN_DIR, 'dist', 'bundle.js');
+    const content = readFileSync(bundlePath, 'utf-8');
+
+    // Stable markers: log messages, object fields, event strings that survive minification.
+    const markers = [
+      { name: 'Workspace not idle', reason: 'preflight idle check log message' },
+      { name: 'trigger', reason: 'system session detection (checks trigger field)' },
+      { name: 'abandonedSessionIds', reason: 'IdleCheckResult field (preserved in object literal)' },
+      { name: 'trajectoryGuardrailConfirmsIdle', reason: 'IdleCheckResult field' },
+    ];
+    const missing = markers.filter(m => !content.includes(m.name));
+    if (missing.length > 0) {
+      throw new Error(`Idle detection markers missing: ${missing.map(m => m.name).join(', ')}`);
+    }
+
+    // Check PR #256 fix: legacy session temporal guard
+    // The fix adds `lastActivityAt` comparison before treating sessions as system sessions.
+    // In minified code this appears as a comparison involving `lastActivityAt`.
+    if (!content.includes('lastActivityAt')) {
+      return { status: 'warn', detail: 'lastActivityAt reference not found — temporal guard for legacy sessions may be missing' };
+    }
+    return 'Idle detection functions present (verified via stable string markers)';
+  });
+
+  // ─────────────────────────────────────────────────────────
+  // CHECKPOINT 4: Evolution queue
+  // ─────────────────────────────────────────────────────────
+  check('4. Evolution queue', () => {
+    const queuePath = join(stateDir, 'evolution_queue.json');
+    if (!existsSync(queuePath)) {
+      return { status: 'warn', detail: 'No evolution queue — idle check has not yet enqueued a task' };
+    }
+    const queue = JSON.parse(readFileSync(queuePath, 'utf-8'));
+    const sleepTasks = queue.filter(t => t.taskKind === 'sleep_reflection');
+    const pending = sleepTasks.filter(t => t.status === 'pending' || t.status === 'in_progress');
+    const completed = sleepTasks.filter(t => t.status === 'completed');
+    const failed = sleepTasks.filter(t => t.status === 'failed');
+
+    if (pending.length > 0) return `${pending.length} pending sleep_reflection task(s) awaiting processing`;
+    if (completed.length > 0) return `${completed.length} completed, ${failed.length} failed (total ${sleepTasks.length} tasks)`;
+    return { status: 'warn', detail: `Queue exists with ${queue.length} items but no sleep_reflection tasks` };
+  });
+
+  // ─────────────────────────────────────────────────────────
+  // CHECKPOINT 5: Nocturnal samples (artifacts)
+  // ─────────────────────────────────────────────────────────
+  check('5. Nocturnal artifact persistence', () => {
+    const samplesDir = join(stateDir, 'nocturnal', 'samples');
+    if (!existsSync(samplesDir)) {
+      return { status: 'warn', detail: 'No samples directory — no reflections have been persisted yet' };
+    }
+    const files = readdirSync(samplesDir).filter(f => f.endsWith('.json'));
+    if (files.length === 0) return { status: 'warn', detail: 'samples/ directory exists but is empty' };
+
+    // Validate most recent artifact
+    const sorted = files
+      .map(f => ({ name: f, mtime: statSync(join(samplesDir, f)).mtimeMs }))
+      .sort((a, b) => b.mtime - a.mtime);
+    const latest = sorted[0].name;
+    const artifact = JSON.parse(readFileSync(join(samplesDir, latest), 'utf-8'));
+    const hasRequired = artifact.artifactId && artifact.badDecision && artifact.betterDecision && artifact.rationale;
+    if (!hasRequired) {
+      return { status: 'warn', detail: `Latest artifact ${latest} is missing required fields` };
+    }
+    return `${files.length} artifact(s), latest: ${latest} (${artifact.principleId || 'unknown principle'})`;
+  });
+
+  // ─────────────────────────────────────────────────────────
+  // CHECKPOINT 6: Workflow store
+  // ─────────────────────────────────────────────────────────
+  check('6. Nocturnal workflow store', () => {
+    const workflowsPath = join(stateDir, 'nocturnal', 'workflows.json');
+    if (!existsSync(workflowsPath)) {
+      return { status: 'warn', detail: 'No workflows.json — no nocturnal workflows have been started' };
+    }
+    const workflows = JSON.parse(readFileSync(workflowsPath, 'utf-8'));
+    if (!Array.isArray(workflows) || workflows.length === 0) {
+      return { status: 'warn', detail: 'workflows.json is empty — no workflows recorded' };
+    }
+    const active = workflows.filter(w => w.state === 'active');
+    const completed = workflows.filter(w => w.state === 'completed');
+    const errored = workflows.filter(w => w.state === 'terminal_error');
+    const expired = workflows.filter(w => w.state === 'expired');
+
+    if (active.length > 0) {
+      return { status: 'warn', detail: `${active.length} workflow(s) still active — may be in progress or stuck. IDs: ${active.map(w => w.workflow_id).join(', ')}` };
+    }
+    return `${workflows.length} total: ${completed} completed, ${errored} errored, ${expired} expired`;
+  });
+
+  // ─────────────────────────────────────────────────────────
+  // CHECKPOINT 7: Nocturnal runtime state (cooldown/quota)
+  // ─────────────────────────────────────────────────────────
+  check('7. Nocturnal runtime state (cooldown/quota)', () => {
+    const runtimePath = join(stateDir, 'nocturnal-runtime.json');
+    if (!existsSync(runtimePath)) {
+      return 'No runtime state — no cooldown or quota restrictions';
+    }
+    const state = JSON.parse(readFileSync(runtimePath, 'utf-8'));
+    const issues = [];
+
+    if (state.globalCooldownUntil) {
+      const cooldownEnd = new Date(state.globalCooldownUntil).getTime();
+      if (cooldownEnd > Date.now()) {
+        const remainingMin = Math.round((cooldownEnd - Date.now()) / 60000);
+        issues.push(`global cooldown active (${remainingMin}min remaining)`);
+      }
+    }
+
+    if (state.recentRunTimestamps) {
+      const windowStart = Date.now() - 24 * 60 * 60 * 1000;
+      const recentRuns = state.recentRunTimestamps
+        .map(ts => new Date(ts).getTime())
+        .filter(ts => ts > windowStart);
+      if (recentRuns.length >= 3) {
+        issues.push(`quota exhausted (${recentRuns.length}/3 runs used in 24h)`);
+      }
+    }
+
+    if (issues.length > 0) {
+      return { status: 'warn', detail: issues.join('; ') };
+    }
+    return 'No active cooldown or quota restrictions';
+  });
+
+  // ─────────────────────────────────────────────────────────
+  // CHECKPOINT 8: Bundle health
+  // ─────────────────────────────────────────────────────────
+  check('8. Plugin bundle health', () => {
+    const bundlePath = join(PLUGIN_DIR, 'dist', 'bundle.js');
+    if (!existsSync(bundlePath)) throw new Error('dist/bundle.js missing — run build first');
+
+    const content = readFileSync(bundlePath, 'utf-8');
+
+    // Use a mix of exported symbols and stable string markers.
+    // Class names and exported symbols survive minification; internal function names don't.
+    const markers = [
+      'EvolutionWorkerService',       // exported class
+      'checkPainFlag',                 // exported function
+      'processEvolutionQueue',         // function reference
+      'NocturnalWorkflowManager',      // exported class
+      'executeNocturnalReflectionAsync', // used in log messages
+      'nocturnal_started',             // event type string
+      'nocturnal_completed',           // event type string
+      'nocturnal_failed',              // event type string
+      'nocturnal_expired',             // event type string
+    ];
+    const missing = markers.filter(m => !content.includes(m));
+    if (missing.length > 0) throw new Error(`Missing critical symbols in bundle: ${missing.join(', ')}`);
+
+    return `Bundle OK (${Math.round(content.length / 1024)}KB), all ${markers.length} critical markers present`;
+  });
+
+  // ─────────────────────────────────────────────────────────
+  // CHECKPOINT 9: Git state — uncommitted changes that could break pipeline
+  // ─────────────────────────────────────────────────────────
+  check('9. Git state (uncommitted changes)', () => {
+    try {
+      const status = execSync('git status --porcelain', { encoding: 'utf-8', timeout: 5000, cwd: PLUGIN_DIR }).trim();
+      if (!status) return 'Working tree clean';
+      const changedFiles = status.split('\n').length;
+      return { status: 'warn', detail: `${changedFiles} uncommitted change(s) in plugin directory` };
+    } catch {
+      return { status: 'warn', detail: 'Could not check git status' };
+    }
+  });
+
+  // ─────────────────────────────────────────────────────────
+  // CHECKPOINT 10: Pain flag state
+  // ─────────────────────────────────────────────────────────
+  check('10. Pain flag state', () => {
+    const painFlagPath = join(stateDir, '.pain_flag');
+    if (!existsSync(painFlagPath)) {
+      return 'No active pain flag';
+    }
+    const content = readFileSync(painFlagPath, 'utf-8');
+    const lines = content.split('\n');
+    const fields = {};
+    for (const line of lines) {
+      const colonIdx = line.indexOf(':');
+      if (colonIdx > 0) {
+        fields[line.substring(0, colonIdx).trim()] = line.substring(colonIdx + 1).trim();
+      }
+    }
+    if (!fields.score || !fields.reason) {
+      return { status: 'warn', detail: 'Pain flag exists but is missing required fields (score, reason)' };
+    }
+    return `Pain flag active (score: ${fields.score}, source: ${fields.source || 'unknown'}, session: ${fields.session_id || 'none'})`;
+  });
+
+  // ─────────────────────────────────────────────────────────
+  // CHECKPOINT 11: Trajectory data
+  // ─────────────────────────────────────────────────────────
+  check('11. Trajectory data availability', () => {
+    const trajectoryPath = join(stateDir, 'trajectory.json');
+    const trajectoryDir = join(stateDir, 'trajectory');
+    const trajectoryDb = join(stateDir, 'trajectory.db');
+    if (!existsSync(trajectoryPath) && !existsSync(trajectoryDir) && !existsSync(trajectoryDb)) {
+      return { status: 'warn', detail: 'No trajectory data — snapshot extraction will use pain context fallback or fail' };
+    }
+    if (existsSync(trajectoryDb)) {
+      const stat = statSync(trajectoryDb);
+      return `Trajectory SQLite database present (${Math.round(stat.size / 1024)}KB)`;
+    }
+    // Check trajectory content
+    if (existsSync(trajectoryPath)) {
+      try {
+        const data = JSON.parse(readFileSync(trajectoryPath, 'utf-8'));
+        const entryCount = Array.isArray(data) ? data.length : Object.keys(data).length;
+        return `${entryCount} trajectory entries available`;
+      } catch {
+        return { status: 'warn', detail: 'trajectory.json exists but is corrupted' };
+      }
+    }
+    if (existsSync(trajectoryDir)) {
+      const files = readdirSync(trajectoryDir).filter(f => f.endsWith('.json'));
+      return `${files.length} trajectory file(s) available`;
+    }
+    return { status: 'warn', detail: 'Trajectory storage not found in expected locations' };
+  });
+
+  // ─────────────────────────────────────────────────────────
+  // CHECKPOINT 12: Principle training state
+  // ─────────────────────────────────────────────────────────
+  check('12. Principle training state', () => {
+    // Check multiple possible locations
+    const candidates = [
+      join(stateDir, 'nocturnal', 'training_store.json'),
+      join(stateDir, 'principle_training_state.json'),
+    ];
+    let trainingPath = null;
+    for (const c of candidates) {
+      if (existsSync(c)) { trainingPath = c; break; }
+    }
+    if (!trainingPath) {
+      return { status: 'warn', detail: 'No training_store.json or principle_training_state.json — NocturnalTargetSelector may not find evaluable principles' };
+    }
+    try {
+      const store = JSON.parse(readFileSync(trainingPath, 'utf-8'));
+      const principles = Object.keys(store.principles || store);
+      if (principles.length === 0) {
+        return { status: 'warn', detail: 'Training store exists but has no principles' };
+      }
+      const evaluable = principles.filter(p => {
+        const pr = store.principles ? store.principles[p] : store[p];
+        return pr && pr.evaluability !== 'manual_only';
+      });
+      return `${principles.length} principle(s) in training store, ${evaluable.length} evaluable`;
+    } catch {
+      return { status: 'warn', detail: 'Training store exists but is corrupted' };
+    }
+  });
+
+  printReport();
+}
+
+main();

package/scripts/sync-plugin.mjs

@@ -372,6 +372,7 @@ function verifyBundleContents() {
         { name: 'EvolutionWorkerService', reason: 'main plugin service export' },
         { name: 'checkPainFlag',          reason: 'pain flag detection' },
         { name: 'processEvolutionQueue',  reason: 'queue processing' },
+        { name: 'acquireQueueLock',       reason: 'queue lock for pd-reflect and worker' },
     ];
 
     const missing = [];

package/src/core/nocturnal-arbiter.ts

@@ -623,11 +623,12 @@ export function validateArtifact(
   // Rule 11: Quality threshold gate — reject low-signal artifacts
   // A reflection artifact must show positive cognitive improvement (thinkingModelDelta > 0).
   // planningRatioGain must not show catastrophic regression (< -0.5).
+  // #244: Use strict < so thinkingModelDelta=threshold passes (thin violations allowed at boundary)
   if (
     options.qualityThresholds?.thinkingModelDeltaMin !== undefined &&
     thinkingModelDelta !== undefined &&
     typeof thinkingModelDelta === 'number' &&
-    thinkingModelDelta <= options.qualityThresholds.thinkingModelDeltaMin
+    thinkingModelDelta < options.qualityThresholds.thinkingModelDeltaMin
   ) {
     failures.push({
       reason: `thinkingModelDelta (${thinkingModelDelta}) does not meet minimum quality threshold (${options.qualityThresholds.thinkingModelDeltaMin}) — reflection shows no cognitive improvement`,

package/src/hooks/subagent.ts

@@ -1,6 +1,7 @@
 import type { PluginHookSubagentEndedEvent, PluginHookSubagentContext, PluginLogger, OpenClawPluginApi } from '../openclaw-sdk.js';
 import { buildPainFlag, writePainFlag } from '../core/pain.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
+import { extractAgentIdFromSessionKey } from '../utils/session-key.js';
 // No longer needed — diagnostician runs via HEARTBEAT, not subagent
 import { recordEvolutionSuccess } from '../core/evolution-engine.js';
 import { WorkflowStore } from '../service/subagent-workflow/workflow-store.js';
@@ -81,18 +82,6 @@ function emitSubagentPainEvent(
     }
 }
 
-
-function extractAgentIdFromSessionKey(sessionKey: string | undefined): string | undefined {
-    // sessionKey format: "agent:{agentId}:{type}:{uuid}" or "agent:{agentId}:{uuid}"
-    if (!sessionKey) return undefined;
-    const match = /^agent:([^:]+):/.exec(sessionKey);
-    return match ? match[1] : undefined;
-}
-
-
-
-
-
 type SubagentEndedHookContext = PluginHookSubagentContext & {
     api?: OpenClawPluginApi;
     workspaceDir?: string;

package/src/index.ts

@@ -61,6 +61,7 @@ import { PathResolver, resolveWorkspaceDirFromApi } from './core/path-resolver.j
 import { validateWorkspaceDir } from './core/workspace-dir-validation.js';
 import { resolveRequiredWorkspaceDir, resolveWorkspaceDir, type WorkspaceResolutionContext } from './core/workspace-dir-service.js';
 import { createPrinciplesConsoleRoute } from './http/principles-console-route.js';
+import { extractAgentIdFromSessionKey } from './utils/session-key.js';
 
 // Track initialization to avoid repeated calls
 let workspaceInitialized = false;
@@ -423,11 +424,13 @@ const plugin = {
     registerCommandWithAlias('pd-thinking', 'pdt', getCommandDescription('pd-thinking', language), (ctx: any) => handleThinkingOs(ctx), { acceptsArgs: true });
     registerCommandWithAlias('pd-reflect', 'pdrl', getCommandDescription('pd-reflect', language), (ctx: any) => {
       try {
-        const workspaceDir = resolveCommandWorkspaceDirStrict(api, ctx);
-        return handlePdReflect.handler({ ...ctx, api, workspaceDir } as any);
+        // Resolve agentId from sessionKey (if available), fallback to 'main'
+        const agentId = extractAgentIdFromSessionKey(ctx.sessionKey) ?? 'main';
+        const workspaceDir = resolveRequiredWorkspaceDir(api, { ...ctx, agentId }, { source: 'pd-reflect', fallbackAgentId: 'main' });
+        return handlePdReflect.handler({ ...ctx, api, workspaceDir });
       } catch (err) {
-        api.logger.error(`[PD] Command /pd-reflect failed: ${String(err)}`);
-        return { text: language === 'zh' ? "命令执行失败，请检查日志。" : "Command failed. Check logs." };
+        api.logger.error(`[PD:pd-reflect] Command failed: ${String(err)}`);
+        return { text: language === 'zh' ? '命令执行失败，请查看日志。' : 'Command failed. Check logs.' };
       }
     });
     registerCommandWithAlias('pd-daily', 'pdd', getCommandDescription('pd-daily', language), () => ({

package/src/service/evolution-worker.ts

@@ -71,6 +71,17 @@ async function runWorkflowWatchdog(
         for (const wf of staleActive) {
           const ageMin = Math.round((now - wf.created_at) / 60000);
           details.push(`stale_active: ${wf.workflow_id} (${wf.workflow_type}, ${ageMin}min old)`);
+
+          // #257: Check if the last recorded event reason indicates expected subagent unavailability.
+          // If so, skip marking as terminal_error — the workflow is stale because the subagent
+          // was expectedly unavailable (daemon mode, process isolation), not due to a hard failure.
+          const events = store.getEvents(wf.workflow_id);
+          const lastEventReason = events.length > 0 ? events[events.length - 1].reason : 'unknown';
+          if (isExpectedSubagentError(lastEventReason)) {
+            logger?.debug?.(`[PD:Watchdog] Skipping stale active workflow ${wf.workflow_id}: expected subagent error (${lastEventReason})`);
+            continue;
+          }
+
           store.updateWorkflowState(wf.workflow_id, 'terminal_error');
           store.recordEvent(wf.workflow_id, 'watchdog_timeout', 'active', 'terminal_error', `Stale active > ${staleThreshold / 60000}s`, { ageMs: now - wf.created_at });
 
@@ -1596,6 +1607,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                                 snapshot: snapshotData,
                                 taskId: sleepTask.id,
                                 painContext: sleepTask.recentPainContext,
+                                triggerSource: sleepTask.source,
                             },
                         });
                         sleepTask.resultRef = workflowHandle.workflowId;

package/src/service/nocturnal-runtime.ts

@@ -60,6 +60,20 @@ function isSystemSession(state: SessionState): boolean {
     if (sessionId?.startsWith('boot-')) return true;
     if (sessionId?.startsWith('probe-')) return true;
 
+    // CRITICAL FIX: Legacy sessions from persistence may have missing trigger/sessionKey
+    // If both are missing AND the session is old (inactive > abandoned threshold),
+    // treat as legacy/orphan to avoid blocking idle detection with unknown sessions.
+    // Recent sessions without trigger/sessionKey are likely real user sessions still
+    // being enriched — do NOT classify them as system sessions.
+    const ABANDONED_THRESHOLD_MS = 2 * 60 * 60 * 1000; // 2 hours
+    if (!trigger && !sessionKey) {
+        const inactiveFor = Date.now() - state.lastActivityAt;
+        if (inactiveFor > ABANDONED_THRESHOLD_MS) {
+            return true; // Legacy/orphan session — don't block idle detection
+        }
+        // Recent session without metadata — likely a real user session, let it through
+    }
+
     return false;
 }
 

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

@@ -210,7 +210,7 @@ export class NocturnalWorkflowManager implements WorkflowManager {
 
         // Extract snapshot and principleId from taskInput.metadata (NOC-07: Trinity async path)
         const snapshotValidation = validateNocturnalSnapshotIngress(options.metadata?.snapshot);
-        const snapshot = snapshotValidation.snapshot;
+        const {snapshot} = snapshotValidation;
         const principleId = options.metadata?.principleId as string | undefined;
         // Extract painContext for Selector ranking bias
         const painContext = options.metadata?.painContext as RecentPainContext | undefined;
@@ -254,6 +254,22 @@ 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')
+                          ? {
+                              idleCheckOverride: {
+                                  isIdle: true,
+                                  mostRecentActivityAt: Date.now() - 1800000,
+                                  idleForMs: 1800000,
+                                  userActiveSessions: 0,
+                                  abandonedSessionIds: [],
+                                  trajectoryGuardrailConfirmsIdle: true,
+                                  reason: 'manual/test override',
+                              },
+                            }
+                          : {}),
                         // Skip Selector if principleId and snapshot are provided
                         ...(principleId && snapshot ? {
                             principleIdOverride: principleId,

package/src/utils/session-key.ts

@@ -0,0 +1,17 @@
+/**
+ * Session key parsing utilities.
+ *
+ * Session key format: "agent:{agentId}:{type}:{uuid}" or "agent:{agentId}:{uuid}"
+ */
+
+/**
+ * Extract agentId from a sessionKey.
+ * Returns `undefined` if sessionKey is missing, malformed, or has whitespace-only agentId.
+ */
+export function extractAgentIdFromSessionKey(sessionKey: string | undefined): string | undefined {
+    if (!sessionKey) return undefined;
+    const match = /^agent:([^:]+):/.exec(sessionKey);
+    if (!match) return undefined;
+    const agentId = match[1].trim();
+    return agentId || undefined;
+}

package/tests/core/nocturnal-arbiter.test.ts

@@ -491,4 +491,61 @@ describe('Nocturnal Arbiter', () => {
       expect(result.artifact?.sourceSnapshotRef).toBe('');
     });
   });
+
+  // -------------------------------------------------------------------------
+  // Tests: quality threshold gates (Rule 10/11)
+  // -------------------------------------------------------------------------
+
+  describe('quality threshold gates', () => {
+    const defaultThresholds = { thinkingModelDeltaMin: 0.05, planningRatioGainMin: -0.5 };
+
+    it('rejects when thinkingModelDelta is below threshold', () => {
+      const artifact = makeValidArtifact({ thinkingModelDelta: 0.03 });
+      const result = validateArtifact(artifact, { qualityThresholds: defaultThresholds });
+      expect(result.passed).toBe(false);
+      expect(result.failures).toHaveLength(1);
+      expect(result.failures[0].field).toBe('thinkingModelDelta');
+    });
+
+    it('passes when thinkingModelDelta equals threshold exactly (boundary value)', () => {
+      const artifact = makeValidArtifact({ thinkingModelDelta: 0.05 });
+      const result = validateArtifact(artifact, { qualityThresholds: defaultThresholds });
+      expect(result.passed).toBe(true);
+    });
+
+    it('passes when thinkingModelDelta exceeds threshold', () => {
+      const artifact = makeValidArtifact({ thinkingModelDelta: 0.15 });
+      const result = validateArtifact(artifact, { qualityThresholds: defaultThresholds });
+      expect(result.passed).toBe(true);
+    });
+
+    it('passes when thinkingModelDelta is absent (optional field)', () => {
+      const artifact = makeValidArtifact();
+      delete artifact.thinkingModelDelta;
+      const result = validateArtifact(artifact, { qualityThresholds: defaultThresholds });
+      expect(result.passed).toBe(true);
+    });
+
+    it('rejects when planningRatioGain is below threshold', () => {
+      const artifact = makeValidArtifact({ planningRatioGain: -0.6 });
+      const result = validateArtifact(artifact, { qualityThresholds: defaultThresholds });
+      expect(result.passed).toBe(false);
+      expect(result.failures.some(f => f.field === 'planningRatioGain')).toBe(true);
+    });
+
+    it('passes when planningRatioGain equals threshold exactly (boundary value)', () => {
+      const artifact = makeValidArtifact({ planningRatioGain: -0.5 });
+      const result = validateArtifact(artifact, { qualityThresholds: defaultThresholds });
+      expect(result.passed).toBe(true);
+    });
+
+    it('rejects both quality thresholds simultaneously', () => {
+      const artifact = makeValidArtifact({ thinkingModelDelta: 0.01, planningRatioGain: -0.8 });
+      const result = validateArtifact(artifact, { qualityThresholds: defaultThresholds });
+      expect(result.passed).toBe(false);
+      expect(result.failures.length).toBeGreaterThanOrEqual(2);
+      expect(result.failures.some(f => f.field === 'thinkingModelDelta')).toBe(true);
+      expect(result.failures.some(f => f.field === 'planningRatioGain')).toBe(true);
+    });
+  });
 });

package/tests/service/evolution-worker.nocturnal.test.ts

@@ -35,18 +35,22 @@ vi.mock('../../src/service/subagent-workflow/nocturnal-workflow-manager.js', ()
 
 const { mockGetNocturnalSessionSnapshot, mockListRecentNocturnalCandidateSessions } = vi.hoisted(() => ({
   mockGetNocturnalSessionSnapshot: vi.fn(),
-  mockListRecentNocturnalCandidateSessions: vi.fn(() => []),
+  mockListRecentNocturnalCandidateSessions: vi.fn(() => [] as Array<{ sessionId: string; startedAt: string; failureCount: number; painEventCount: number; gateBlockCount: number }>),
 }));
+
+// Create a shared mock extractor instance so spy calls are tracked correctly
+const mockExtractorInstance = {
+  getNocturnalSessionSnapshot: mockGetNocturnalSessionSnapshot,
+  listRecentNocturnalCandidateSessions: mockListRecentNocturnalCandidateSessions,
+};
+
 vi.mock('../../src/core/nocturnal-trajectory-extractor.js', async () => {
   const actual = await vi.importActual<typeof import('../../src/core/nocturnal-trajectory-extractor.js')>(
     '../../src/core/nocturnal-trajectory-extractor.js'
   );
   return {
     ...actual,
-    createNocturnalTrajectoryExtractor: vi.fn(() => ({
-      getNocturnalSessionSnapshot: mockGetNocturnalSessionSnapshot,
-      listRecentNocturnalCandidateSessions: mockListRecentNocturnalCandidateSessions,
-    })),
+    createNocturnalTrajectoryExtractor: vi.fn(() => mockExtractorInstance),
   };
 });
 
@@ -55,6 +59,17 @@ import { WorkspaceContext } from '../../src/core/workspace-context.js';
 import { handlePdReflect } from '../../src/commands/pd-reflect.js';
 import { safeRmDir } from '../test-utils.js';
 
+// Helper to create a mock API for E2E tests
+function createMockApi() {
+  return {
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+    runtime: { agent: { runEmbeddedPiAgent: vi.fn() } },
+  } as any;
+}
+
+// Helper config for fast poll cycle
+const fastPollConfig = { get: (k: string) => k === 'intervals.worker_poll_ms' ? 100 : undefined };
+
 function readQueue(stateDir: string) {
   return JSON.parse(fs.readFileSync(path.join(stateDir, 'evolution_queue.json'), 'utf8'));
 }
@@ -93,11 +108,11 @@ session_id: explicit-session-from-pain
 
     try {
       const context = readRecentPainContext(wctx);
-      
+
       // Verify the session_id was extracted from the pain flag file
       expect(context.mostRecent).toBeDefined();
-      expect(context.mostRecent.sessionId).toBe('explicit-session-from-pain');
-      expect(context.mostRecent.score).toBe(80);
+      expect(context.mostRecent!.sessionId).toBe('explicit-session-from-pain');
+      expect(context.mostRecent!.score).toBe(80);
       expect(context.recentPainCount).toBe(1);
     } finally {
       safeRmDir(workspaceDir);
@@ -155,9 +170,9 @@ session_id: pain-session-abc
 
     // Contract: session_id must be extracted from the pain flag
     expect(painContext.mostRecent).toBeDefined();
-    expect(painContext.mostRecent.sessionId).toBe('pain-session-abc');
-    expect(painContext.mostRecent.score).toBe(70);
-    expect(painContext.mostRecent.source).toBe('tool_failure');
+    expect(painContext.mostRecent!.sessionId).toBe('pain-session-abc');
+    expect(painContext.mostRecent!.score).toBe(70);
+    expect(painContext.mostRecent!.source).toBe('tool_failure');
 
     // Now simulate what the worker does: attach this context to a queued task
     const simulatedTask = {
@@ -167,7 +182,7 @@ session_id: pain-session-abc
     };
 
     // Verify the contract holds end-to-end
-    expect(simulatedTask.recentPainContext.mostRecent.sessionId).toBe('pain-session-abc');
+    expect(simulatedTask.recentPainContext.mostRecent!.sessionId).toBe('pain-session-abc');
   });
 
   it('e2e: /pd-reflect command writes to workspace/.state, never to HOME/.state', async () => {
@@ -214,4 +229,359 @@ session_id: pain-session-abc
       safeRmDir(workspaceDir);
     }
   });
+
+  // === Nocturnal E2E Pipeline Tests (from PR #243) ===
+
+  it('does not start a nocturnal workflow when only an empty fallback snapshot is available', async () => {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-empty-'));
+    const stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
+    fs.mkdirSync(path.join(stateDir, 'logs'), { recursive: true });
+
+    mockGetNocturnalSessionSnapshot.mockReturnValue(null);
+
+    fs.writeFileSync(
+      path.join(stateDir, 'evolution_queue.json'),
+      JSON.stringify([
+        {
+          id: 'sleep-empty',
+          taskKind: 'sleep_reflection',
+          priority: 'medium',
+          score: 50,
+          source: 'nocturnal',
+          reason: 'Sleep reflection',
+          timestamp: '2026-04-10T00:00:00.000Z',
+          enqueued_at: '2026-04-10T00:00:00.000Z',
+          status: 'pending',
+          retryCount: 0,
+          maxRetries: 1,
+          recentPainContext: {
+            mostRecent: null,
+            recentPainCount: 0,
+            recentMaxPainScore: 0,
+          },
+        },
+      ], null, 2),
+      'utf8'
+    );
+
+    const mockApi = createMockApi();
+    EvolutionWorkerService.api = mockApi;
+
+    try {
+      EvolutionWorkerService.start({
+        workspaceDir,
+        stateDir,
+        logger: mockApi.logger,
+        config: fastPollConfig,
+        api: mockApi,
+      } as any);
+
+      await vi.advanceTimersByTimeAsync(6000);
+
+      const queue = readQueue(stateDir);
+      expect(queue[0].status).toBe('failed');
+      expect(queue[0].lastError).toContain('invalid_snapshot_ingress');
+      expect(queue[0].lastError).toContain('fallback snapshot must contain at least one pain signal');
+      expect(queue[0].resultRef).toBeFalsy();
+      expect(mockStartWorkflow).not.toHaveBeenCalled();
+    } finally {
+      EvolutionWorkerService.stop!({ workspaceDir, stateDir, logger: console } as any);
+      safeRmDir(workspaceDir);
+    }
+  });
+
+  it('uses stub_fallback for expected gateway-only background unavailability', async () => {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-gateway-'));
+    const stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
+    fs.mkdirSync(path.join(stateDir, 'logs'), { recursive: true });
+
+    mockGetNocturnalSessionSnapshot.mockReturnValue({
+      sessionId: 'sleep-gateway',
+      startedAt: '2026-04-10T00:00:00.000Z',
+      updatedAt: '2026-04-10T00:01:00.000Z',
+      assistantTurns: [],
+      userTurns: [],
+      toolCalls: [],
+      painEvents: [],
+      gateBlocks: [],
+      stats: { totalAssistantTurns: 1, totalToolCalls: 1, totalPainEvents: 0, totalGateBlocks: 0, failureCount: 0 },
+    });
+    mockStartWorkflow.mockResolvedValue({ workflowId: 'wf-1', childSessionKey: 'child-1', state: 'active' });
+    mockGetWorkflowDebugSummary.mockResolvedValue({
+      state: 'terminal_error',
+      metadata: {},
+      recentEvents: [{ reason: 'Error: Plugin runtime subagent methods are only available during a gateway request.', payload: {} }],
+    });
+
+    fs.writeFileSync(
+      path.join(stateDir, 'evolution_queue.json'),
+      JSON.stringify([
+        {
+          id: 'sleep-gateway',
+          taskKind: 'sleep_reflection',
+          priority: 'medium',
+          score: 50,
+          source: 'nocturnal',
+          reason: 'Sleep reflection',
+          timestamp: '2026-04-10T00:00:00.000Z',
+          enqueued_at: '2026-04-10T00:00:00.000Z',
+          status: 'pending',
+          retryCount: 0,
+          maxRetries: 1,
+          recentPainContext: {
+            mostRecent: { source: 'test', score: 50, reason: 'test', timestamp: '2026-04-10T00:00:00.000Z', sessionId: 'sleep-gateway' },
+            recentPainCount: 1,
+            recentMaxPainScore: 50,
+          },
+        },
+      ], null, 2),
+      'utf8'
+    );
+
+    const mockApi = createMockApi();
+    EvolutionWorkerService.api = mockApi;
+
+    try {
+      EvolutionWorkerService.start({
+        workspaceDir,
+        stateDir,
+        logger: mockApi.logger,
+        config: fastPollConfig,
+        api: mockApi,
+      } as any);
+
+      await vi.advanceTimersByTimeAsync(6000);
+
+      const queue = readQueue(stateDir);
+      expect(queue[0].status).toBe('completed');
+      expect(queue[0].resolution).toBe('stub_fallback');
+    } finally {
+      EvolutionWorkerService.stop!({ workspaceDir, stateDir, logger: console } as any);
+      safeRmDir(workspaceDir);
+    }
+  });
+
+  it('uses stub_fallback for expected subagent runtime unavailability', async () => {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-subagent-'));
+    const stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
+    fs.mkdirSync(path.join(stateDir, 'logs'), { recursive: true });
+
+    mockGetNocturnalSessionSnapshot.mockReturnValue({
+      sessionId: 'sleep-subagent',
+      startedAt: '2026-04-10T00:00:00.000Z',
+      updatedAt: '2026-04-10T00:01:00.000Z',
+      assistantTurns: [],
+      userTurns: [],
+      toolCalls: [],
+      painEvents: [],
+      gateBlocks: [],
+      stats: { totalAssistantTurns: 1, totalToolCalls: 1, totalPainEvents: 0, totalGateBlocks: 0, failureCount: 0 },
+    });
+    mockStartWorkflow.mockRejectedValue(new Error('NocturnalWorkflowManager: subagent runtime unavailable'));
+
+    fs.writeFileSync(
+      path.join(stateDir, 'evolution_queue.json'),
+      JSON.stringify([
+        {
+          id: 'sleep-subagent',
+          taskKind: 'sleep_reflection',
+          priority: 'medium',
+          score: 50,
+          source: 'nocturnal',
+          reason: 'Sleep reflection',
+          timestamp: '2026-04-10T00:00:00.000Z',
+          enqueued_at: '2026-04-10T00:00:00.000Z',
+          status: 'pending',
+          retryCount: 0,
+          maxRetries: 1,
+          recentPainContext: {
+            mostRecent: { source: 'test', score: 50, reason: 'test', timestamp: '2026-04-10T00:00:00.000Z', sessionId: 'sleep-subagent' },
+            recentPainCount: 1,
+            recentMaxPainScore: 50,
+          },
+        },
+      ], null, 2),
+      'utf8'
+    );
+
+    const mockApi = createMockApi();
+    EvolutionWorkerService.api = mockApi;
+
+    try {
+      EvolutionWorkerService.start({
+        workspaceDir,
+        stateDir,
+        logger: mockApi.logger,
+        config: fastPollConfig,
+        api: mockApi,
+      } as any);
+
+      await vi.advanceTimersByTimeAsync(6000);
+
+      const queue = readQueue(stateDir);
+      expect(queue[0].status).toBe('completed');
+      expect(queue[0].resolution).toBe('stub_fallback');
+    } finally {
+      EvolutionWorkerService.stop!({ workspaceDir, stateDir, logger: console } as any);
+      safeRmDir(workspaceDir);
+    }
+  });
+
+  it('prioritizes pain signal session ID for snapshot extraction', async () => {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-pain-session-'));
+    const stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
+    fs.mkdirSync(path.join(stateDir, 'logs'), { recursive: true });
+
+    const painSessionId = 'pain-signal-session-123';
+
+    mockGetNocturnalSessionSnapshot.mockImplementation((sessionId: string) => {
+      if (sessionId === painSessionId) {
+        return {
+          sessionId: painSessionId,
+          startedAt: '2026-04-09T23:00:00.000Z',
+          updatedAt: '2026-04-09T23:01:00.000Z',
+          assistantTurns: [],
+          userTurns: [],
+          toolCalls: [],
+          painEvents: [{ source: 'tool_failure', score: 70, severity: null, reason: 'test', createdAt: '2026-04-09T23:00:00.000Z' }],
+          gateBlocks: [],
+          stats: { totalAssistantTurns: 1, totalToolCalls: 1, failureCount: 1, totalPainEvents: 1, totalGateBlocks: 0 },
+        };
+      }
+      return null;
+    });
+    mockStartWorkflow.mockResolvedValue({ workflowId: 'wf-pain', childSessionKey: 'child-pain', state: 'active' });
+
+    fs.writeFileSync(
+      path.join(stateDir, 'evolution_queue.json'),
+      JSON.stringify([
+        {
+          id: 'sleep-pain-priority',
+          taskKind: 'sleep_reflection',
+          priority: 'medium',
+          score: 50,
+          source: 'nocturnal',
+          reason: 'Sleep reflection',
+          timestamp: '2026-04-10T00:00:00.000Z',
+          enqueued_at: '2026-04-10T00:00:00.000Z',
+          status: 'pending',
+          retryCount: 0,
+          maxRetries: 1,
+          recentPainContext: {
+            mostRecent: { source: 'tool_failure', score: 70, reason: 'test', timestamp: '2026-04-10T00:00:00.000Z', sessionId: painSessionId },
+            recentPainCount: 1,
+            recentMaxPainScore: 70,
+          },
+        },
+      ], null, 2),
+      'utf8'
+    );
+
+    const mockApi = createMockApi();
+    EvolutionWorkerService.api = mockApi;
+
+    try {
+      EvolutionWorkerService.start({
+        workspaceDir,
+        stateDir,
+        logger: mockApi.logger,
+        config: fastPollConfig,
+        api: mockApi,
+      } as any);
+
+      await vi.advanceTimersByTimeAsync(6000);
+
+      expect(mockStartWorkflow).toHaveBeenCalledTimes(1);
+      const metadata = mockStartWorkflow.mock.calls[0][1].metadata;
+      expect(metadata.snapshot.sessionId).toBe(painSessionId);
+    } finally {
+      EvolutionWorkerService.stop!({ workspaceDir, stateDir, logger: console } as any);
+      safeRmDir(workspaceDir);
+    }
+  });
+
+  it('e2e: bounded session selection — never picks a session newer than the triggering task', async () => {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-e2e-bounded-'));
+    const stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
+    fs.mkdirSync(path.join(stateDir, 'logs'), { recursive: true });
+
+    const taskTimestamp = '2026-04-10T00:00:00.000Z';
+    const validSessionTimestamp = '2026-04-09T23:00:00.000Z';
+    const invalidSessionTimestamp = '2026-04-10T01:00:00.000Z';
+
+    mockGetNocturnalSessionSnapshot.mockImplementation((sessionId: string) => {
+      if (sessionId === 'valid-session') {
+        return {
+          sessionId: 'valid-session',
+          startedAt: validSessionTimestamp,
+          updatedAt: validSessionTimestamp,
+          assistantTurns: [],
+          userTurns: [],
+          toolCalls: [],
+          painEvents: [{ source: 'tool_failure', score: 50, severity: null, reason: 'test', createdAt: validSessionTimestamp }],
+          gateBlocks: [],
+          stats: { totalAssistantTurns: 1, totalToolCalls: 1, failureCount: 1, totalPainEvents: 1, totalGateBlocks: 0 },
+        };
+      }
+      return null;
+    });
+    mockListRecentNocturnalCandidateSessions.mockReturnValue([
+      { sessionId: 'valid-session', startedAt: validSessionTimestamp, failureCount: 1, painEventCount: 1, gateBlockCount: 0 },
+      { sessionId: 'invalid-session', startedAt: invalidSessionTimestamp, failureCount: 1, painEventCount: 0, gateBlockCount: 0 },
+    ]);
+    mockStartWorkflow.mockResolvedValue({ workflowId: 'wf-bounded', childSessionKey: 'child-bounded', state: 'active' });
+
+    fs.writeFileSync(
+      path.join(stateDir, 'evolution_queue.json'),
+      JSON.stringify([
+        {
+          id: 'sleep-e2e-bounded',
+          taskKind: 'sleep_reflection',
+          priority: 'medium',
+          score: 50,
+          source: 'nocturnal',
+          reason: 'Sleep reflection',
+          timestamp: taskTimestamp,
+          enqueued_at: taskTimestamp,
+          status: 'pending',
+          retryCount: 0,
+          maxRetries: 1,
+          recentPainContext: {
+            mostRecent: { source: 'test', score: 50, reason: 'test', timestamp: taskTimestamp, sessionId: 'pain-session' },
+            recentPainCount: 1,
+            recentMaxPainScore: 50,
+          },
+        },
+      ], null, 2),
+      'utf8'
+    );
+
+    const mockApi = createMockApi();
+    EvolutionWorkerService.api = mockApi;
+
+    try {
+      EvolutionWorkerService.start({
+        workspaceDir,
+        stateDir,
+        logger: mockApi.logger,
+        config: fastPollConfig,
+        api: mockApi,
+      } as any);
+
+      await vi.advanceTimersByTimeAsync(6000);
+
+      expect(mockStartWorkflow).toHaveBeenCalledTimes(1);
+      const metadata = mockStartWorkflow.mock.calls[0][1].metadata;
+      expect(metadata.snapshot.sessionId).toBe('valid-session');
+      expect(new Date(metadata.snapshot.startedAt).getTime()).toBeLessThanOrEqual(new Date(taskTimestamp).getTime());
+    } finally {
+      EvolutionWorkerService.stop!({ workspaceDir, stateDir, logger: console } as any);
+      safeRmDir(workspaceDir);
+    }
+  });
 });