create-principles-disciple 1.92.0 → 1.94.0

package/plugin/dist/hooks/trajectory-collector.js

@@ -1,127 +1,79 @@
 /**
  * Trajectory Collector - message write trajectory recording
  *
- * Records message data to memory/trajectories/ JSONL files.
- * PRI-347 removed tool_call and llm_output JSONL writers (no consumers).
- * PRI-346 will repurpose handleBeforeMessageWrite for SQLite collection.
+ * Fallback trajectory collection when llm_output is blocked by missing
+ * allowConversationAccess. before_message_write is NOT in
+ * CONVERSATION_HOOK_NAMES so OpenClaw always delivers it.
+ *
+ * SQLite writes are enqueued to an async queue because before_message_write is
+ * a SYNCHRONOUS OpenClaw hook — the handler must return immediately. better-sqlite3
+ * is synchronous, so calling it directly would block the message-write main path.
+ * Trade-off: in degradation mode the last few queued writes may be lost on
+ * process exit; this is acceptable because degradation mode is already caused
+ * by a config problem (missing allowConversationAccess), and the primary
+ * llm_output path is authoritative when authorized.
+ *
+ * JSONL writing was removed (no consumers — verified zero readers across the
+ * codebase; PRI-347 already removed tool_call/llm_output JSONL writers).
+ *
+ * ERR-002: fallback errors are logged, never silent.
+ * ERR-001/005: content is sanitized before persisting.
  */
-import * as fs from 'fs';
-import * as path from 'path';
 import { MAX_STRING_LENGTH } from '../config/defaults/runtime.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { SystemLogger } from '../core/system-logger.js';
 import { sanitizeForEvidence } from './message-sanitize.js';
 import { checkConversationAccessConfig } from '../core/config-health.js';
-const TRAJECTORY_DIR = 'memory/trajectories/';
-// 敏感字段匹配正则
-const SENSITIVE_KEY_PATTERN = /password|token|authorization|secret|api[_-]?key|credential|cookie|session/i;
-/**
- * 递归脱敏处理：遍历对象/数组，移除敏感字段值
- */
-function scrubSensitive(obj, depth = 0) {
-    // 防止无限递归
-    if (depth > 10)
-        return '[MAX_DEPTH]';
-    // 处理 null/undefined
-    if (obj == null)
-        return obj;
-    // 处理基本类型
-    if (typeof obj !== 'object') {
-        if (typeof obj === 'string' && obj.length > MAX_STRING_LENGTH) {
-            return obj.slice(0, MAX_STRING_LENGTH) + '...[truncated]';
-        }
-        return obj;
-    }
-    // 处理数组
-    if (Array.isArray(obj)) {
-        return obj.map(item => scrubSensitive(item, depth + 1));
-    }
-    // 处理对象
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        if (SENSITIVE_KEY_PATTERN.test(key)) {
-            result[key] = '[REDACTED]';
-        }
-        else {
-            result[key] = scrubSensitive(value, depth + 1);
-        }
-    }
-    return result;
-}
 /**
- * 异步写入队列 - 确保有序、非阻塞写入
+ * Async write queue — ensures ordered, non-blocking execution of SQLite writes.
+ * before_message_write is a sync hook; SQLite I/O must not block it.
+ *
+ * Tasks are deferred to the microtask queue via `queueMicrotask` so the sync
+ * hook handler returns before any synchronous better-sqlite3 work runs.
  */
 class AsyncWriteQueue {
     queue = [];
     processing = false;
-    async enqueue(task) {
+    enqueue(task) {
         this.queue.push(task);
         if (!this.processing) {
-            this.processNext();
+            this.processing = true;
+            queueMicrotask(() => { void this.processNext(); });
         }
     }
     async processNext() {
-        if (this.queue.length === 0) {
-            this.processing = false;
-            return;
-        }
-        this.processing = true;
-        const task = this.queue.shift();
-        if (!task) {
-            this.processing = false;
-            return;
+        while (this.queue.length > 0) {
+            const task = this.queue.shift();
+            if (!task)
+                break;
+            try {
+                await task();
+            }
+            catch (err) {
+                // EP-03/ERR-002: safety net — tasks should catch their own errors with
+                // structured logging. This catches bugs where a task's try/catch is
+                // missing or re-throws. Never silently swallow (ERR-002).
+                console.warn('[PD:trajectory-queue] uncaught task error:', err);
+            }
         }
-        try {
-            await task();
-        }
-        catch {
-            // Silently fail - trajectory collection should not block main functionality
-        }
-        // 处理下一个任务
-        this.processNext();
+        this.processing = false;
     }
 }
-// 全局写入队列实例
 const writeQueue = new AsyncWriteQueue();
-// 目录缓存（避免重复检查）
-const dirCache = new Map();
 /**
- * 确保轨迹目录存在（异步）
+ * Extract text content from a message (string or content-part array).
  */
-async function ensureTrajectoryDirAsync(workspaceDir) {
-    const dir = path.join(workspaceDir, TRAJECTORY_DIR);
-    if (dirCache.get(dir)) {
-        return dir;
-    }
-    try {
-        await fs.promises.mkdir(dir, { recursive: true });
-        dirCache.set(dir, true);
+function extractContent(content) {
+    if (typeof content === 'string') {
+        return content;
     }
-    catch {
-        // 目录可能已存在，忽略错误
-        dirCache.set(dir, true);
+    if (Array.isArray(content)) {
+        return content
+            .filter((part) => part && typeof part === 'object' && part.type === 'text')
+            .map((part) => part.text)
+            .join('\n');
     }
-    return dir;
-}
-/**
- * 获取今日轨迹文件名
- */
-function getTodayFilename() {
-    const now = new Date();
-    const year = now.getUTCFullYear();
-    const month = String(now.getUTCMonth() + 1).padStart(2, '0');
-    return `${year}-${month}-${String(now.getUTCDate()).padStart(2, '0')}.jsonl`;
-}
-/**
- * 写入轨迹记录（JSON Lines 格式）- 异步版本
- */
-function writeTrajectoryRecord(workspaceDir, record) {
-    const line = JSON.stringify(record) + '\n';
-    writeQueue.enqueue(async () => {
-        const dir = await ensureTrajectoryDirAsync(workspaceDir);
-        const filepath = path.join(dir, getTodayFilename());
-        await fs.promises.appendFile(filepath, line, 'utf8');
-    });
+    return '';
 }
 /**
  * PRI-346: Message write hook with SQLite fallback trajectory recording.
@@ -131,7 +83,9 @@ function writeTrajectoryRecord(workspaceDir, record) {
  * CONVERSATION_HOOK_NAMES, so it always fires — making it the natural fallback.
  *
  * De-duplication: only writes to SQLite when llm_output is blocked (unauthorized).
- * When llm_output is working (authorized), this hook degrades to JSONL-only.
+ * When llm_output is working (authorized), this hook is a no-op.
+ *
+ * SQLite writes are async-queued (see file header) to avoid blocking the sync hook.
  *
  * ERR-002: structured observability when fallback fires.
  * ERR-001/005: content is sanitized before persisting.
@@ -146,73 +100,58 @@ export function handleBeforeMessageWrite(event, ctx) {
     // Only record user and assistant messages
     if (msg.role !== 'user' && msg.role !== 'assistant')
         return;
-    // Extract text content (consistent with existing implementation)
-    let content = '';
-    if (typeof msg.content === 'string') {
-        content = msg.content;
-    }
-    else if (Array.isArray(msg.content)) {
-        content = msg.content
-            .filter((part) => part && typeof part === 'object' && part.type === 'text')
-            .map((part) => part.text)
-            .join('\n');
-    }
-    // Sanitize content preview for JSONL
-    const sanitizedPreview = scrubSensitive(content.slice(0, 200));
-    // Existing JSONL write (always, for backward compatibility)
-    writeTrajectoryRecord(workspaceDir, {
-        type: 'message',
-        timestamp: new Date().toISOString(),
-        sessionId: event.sessionKey || event.sessionId || 'unknown',
-        role: msg.role,
-        contentLength: content.length,
-        contentPreview: typeof sanitizedPreview === 'string' ? sanitizedPreview : '[sanitized]',
-        agentId: event.agentId || null,
-        fallback: 'before_message_write',
-    });
     // ── SQLite fallback (PRI-346): only when conversation hooks are blocked ──
     const accessCheck = checkConversationAccessConfig(ctx.pluginConfig);
     if (accessCheck.authorized) {
         // llm_output is working — do NOT duplicate write to SQLite (de-dup, case D)
         return;
     }
-    // Conversation hooks blocked — this hook is the fallback trajectory writer
+    // Conversation hooks blocked — this hook is the fallback trajectory writer.
+    // Enqueue SQLite writes to avoid blocking the sync before_message_write hook.
+    const logger = ctx.logger;
+    const content = extractContent(msg.content);
+    const sessionId = event.sessionKey ?? ctx.sessionId ?? 'unknown';
+    const createdAt = new Date().toISOString();
     if (msg.role === 'assistant') {
-        try {
-            const wctx = WorkspaceContext.fromHookContext({ workspaceDir, logger: ctx.logger });
-            const sanitized = sanitizeForEvidence(content.slice(0, MAX_STRING_LENGTH), workspaceDir);
-            const sessionId = event.sessionKey ?? ctx.sessionId ?? 'unknown';
-            wctx.trajectory?.recordAssistantTurn?.({
-                sessionId,
-                runId: 'before_message_write_fallback',
-                provider: 'unknown',
-                model: 'unknown',
-                rawText: content,
-                sanitizedText: sanitized,
-                usageJson: {},
-                empathySignalJson: { detected: false, severity: 'mild', confidence: 1 },
-                createdAt: new Date().toISOString(),
-            });
-        }
-        catch (err) {
-            ctx.logger?.warn?.(`[PD:before_message_write] SQLite fallback write failed: ${String(err)}`);
-        }
+        writeQueue.enqueue(async () => {
+            try {
+                const wctx = WorkspaceContext.fromHookContext({ workspaceDir, logger });
+                const sanitized = sanitizeForEvidence(content.slice(0, MAX_STRING_LENGTH), workspaceDir);
+                wctx.trajectory?.recordAssistantTurn?.({
+                    sessionId,
+                    runId: 'before_message_write_fallback',
+                    provider: 'unknown',
+                    model: 'unknown',
+                    rawText: content,
+                    sanitizedText: sanitized,
+                    usageJson: {},
+                    empathySignalJson: { detected: false, severity: 'mild', confidence: 1 },
+                    createdAt,
+                });
+            }
+            catch (err) {
+                // EP-03/ERR-002: observable degradation, never silent
+                logger?.warn?.(`[PD:before_message_write] SQLite fallback write failed: ${String(err)}`);
+            }
+        });
     }
     else if (msg.role === 'user') {
-        try {
-            const wctx = WorkspaceContext.fromHookContext({ workspaceDir, logger: ctx.logger });
-            const sessionId = event.sessionKey ?? ctx.sessionId ?? 'unknown';
-            wctx.trajectory?.recordUserTurn?.({
-                sessionId,
-                turnIndex: 0,
-                rawText: content.slice(0, MAX_STRING_LENGTH),
-                correctionDetected: false,
-                createdAt: new Date().toISOString(),
-            });
-        }
-        catch (err) {
-            ctx.logger?.warn?.(`[PD:before_message_write] SQLite user turn fallback failed: ${String(err)}`);
-        }
+        writeQueue.enqueue(async () => {
+            try {
+                const wctx = WorkspaceContext.fromHookContext({ workspaceDir, logger });
+                wctx.trajectory?.recordUserTurn?.({
+                    sessionId,
+                    turnIndex: 0,
+                    rawText: content.slice(0, MAX_STRING_LENGTH),
+                    correctionDetected: false,
+                    createdAt,
+                });
+            }
+            catch (err) {
+                // EP-03/ERR-002: observable degradation, never silent
+                logger?.warn?.(`[PD:before_message_write] SQLite user turn fallback failed: ${String(err)}`);
+            }
+        });
     }
     // ERR-002: Structured observability — no silent fallback
     SystemLogger.log(workspaceDir, 'CONVERSATION_HOOK_BLOCKED', JSON.stringify({

package/plugin/dist/hooks/triage-adapter.js

@@ -42,38 +42,18 @@ export { resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObserv
  * - Falling back to existing behavior when the flag is off
  */
 export function evaluateEvidenceTriage(sourceKind, score, options) {
+    // PRI-446: the risky high-score and repeated-failure upgrade rules now live
+    // in core triage-policy.ts (single source of truth). The adapter passes the
+    // context flags straight through; core decides whether to upgrade.
     const input = {
         sourceKind,
         score,
         isUnsafeHighConfidence: options?.isUnsafeHighConfidence,
         provenance: options?.provenance,
+        isRisky: options?.isRisky,
+        consecutiveErrors: options?.consecutiveErrors,
     };
-    let result = evaluateTriage(input);
-    // PEAT-B1 upgrade logic: risky high-score overrides evidence_only
-    // Matches PainDiagnosticGate.risky_high_score: isRisky && score >= 70 → admit
-    if (result.decision === 'evidence_only' &&
-        options?.isRisky === true &&
-        score >= 70) {
-        result = {
-            ...result,
-            decision: 'admit',
-            reason: 'Risky high-score operation overrides evidence-only decision. Immediate diagnosis required.',
-            nextAction: 'create_diagnostic_task',
-        };
-    }
-    // PEAT-B1 upgrade logic: repeated failures override evidence_only
-    // Threshold: 4 consecutive failures (matches PainDiagnosticGate.repeatedFailure)
-    if (result.decision === 'evidence_only' &&
-        options?.consecutiveErrors !== undefined &&
-        options.consecutiveErrors >= 4) {
-        result = {
-            ...result,
-            decision: 'admit',
-            reason: 'Repeated failures override evidence-only decision. Pattern suggests systemic issue requiring diagnosis.',
-            nextAction: 'create_diagnostic_task',
-        };
-    }
-    return result;
+    return evaluateTriage(input);
 }
 // ── High-Confidence Unsafe Action Detection ──────────────────────────────────
 /**

package/plugin/dist/hooks/trigger-cooldown-tracker.d.ts

@@ -28,3 +28,15 @@ export declare function clearCooldownState(cooldownMap: Map<string, number>): vo
  * Get the cooldown timestamp for a given episode (for tests).
  */
 export declare function getCooldownTimestamp(source: string, sessionId: string | undefined, errorHash: string | undefined, cooldownMap: ReadonlyMap<string, number>): number | undefined;
+/**
+ * Check whether cooldown is currently active using the shared Map.
+ */
+export declare function isSharedCooldownActive(source: string, sessionId: string | undefined, errorHash: string | undefined): boolean;
+/**
+ * Mark an episode as diagnosed using the shared Map.
+ */
+export declare function markSharedEpisodeAsDiagnosed(source: string, sessionId: string | undefined, errorHash: string | undefined): void;
+/**
+ * Clear all shared cooldown state (for tests).
+ */
+export declare function resetSharedCooldownForTest(): void;

package/plugin/dist/hooks/trigger-cooldown-tracker.js

@@ -53,3 +53,28 @@ export function getCooldownTimestamp(source, sessionId, errorHash, cooldownMap)
     const episodeKey = buildEpisodeKey(source, sessionId, errorHash);
     return cooldownMap.get(episodeKey);
 }
+// ── Shared Cooldown Map (PRI-454) ───────────────────────────────────────────
+//
+// Module-level singleton Map shared across all Gate B paths.
+// Replaces the per-file TRIGGER_COOLDOWN_MAP in after-tool-call-helpers.ts.
+// All paths (gate-block, llm, empathy, manual pain) use this single Map
+// to ensure unified cooldown state.
+const SHARED_COOLDOWN_MAP = new Map();
+/**
+ * Check whether cooldown is currently active using the shared Map.
+ */
+export function isSharedCooldownActive(source, sessionId, errorHash) {
+    return isCooldownActive(source, sessionId, errorHash, SHARED_COOLDOWN_MAP);
+}
+/**
+ * Mark an episode as diagnosed using the shared Map.
+ */
+export function markSharedEpisodeAsDiagnosed(source, sessionId, errorHash) {
+    markEpisodeAsDiagnosed(source, sessionId, errorHash, SHARED_COOLDOWN_MAP);
+}
+/**
+ * Clear all shared cooldown state (for tests).
+ */
+export function resetSharedCooldownForTest() {
+    SHARED_COOLDOWN_MAP.clear();
+}

package/plugin/dist/index.js

@@ -266,6 +266,9 @@ const plugin = {
             }
         }));
         // ── Hook: Pain & Trust ──
+        // timeoutMs=10s: OpenClaw has no default timeout for after_tool_call; without
+        // this a stuck SQLite write (busy_timeout=5000ms) leaks the handler promise.
+        // 10s gives 2x headroom over busy_timeout. fail-open means agent is unaffected.
         api.on('after_tool_call', guardHook('hook:after_tool_call', api.logger, (event, ctx) => {
             const wsResult = resolveHookWorkspaceDir(ctx, api, 'after_tool_call');
             if (!wsResult.ok) {
@@ -294,8 +297,10 @@ const plugin = {
                 }, { flushImmediately: true });
                 api.logger.error(`[PD:EmpathyObserver] Error in after_tool_call: ${String(err)}`);
             }
-        }));
+        }), { timeoutMs: 10_000 });
         // ── Hook: LLM Analysis ──
+        // timeoutMs=10s: OpenClaw has no default timeout for llm_output; without
+        // this a stuck SQLite write leaks the handler promise. See after_tool_call.
         api.on('llm_output', guardHook('hook:llm_output', api.logger, (event, ctx) => {
             const wsResult = resolveHookWorkspaceDir(ctx, api, 'llm_output');
             if (!wsResult.ok) {
@@ -325,7 +330,7 @@ const plugin = {
                 });
                 api.logger.error(`[PD] Error in llm_output: ${String(err)}`);
             }
-        }));
+        }), { timeoutMs: 10_000 });
         // ── Hook: Lifecycle ──
         api.on('before_reset', guardHook('hook:before_reset', api.logger, (event, ctx) => {
             const wsResult = resolveHookWorkspaceDir(ctx, api, 'before_reset');

package/plugin/dist/openclaw-sdk.d.ts

@@ -151,7 +151,10 @@ export interface OpenClawPluginApi {
             text: (content: string, code?: number) => void;
         }) => boolean | Promise<boolean>;
     }) => void;
-    on: (event: string, handler: (...args: any[]) => unknown) => void;
+    on: (event: string, handler: (...args: any[]) => unknown, opts?: {
+        priority?: number;
+        timeoutMs?: number;
+    }) => void;
 }
 export interface PluginHookBeforePromptBuildEvent {
     agentId?: string;

package/plugin/dist/service/evolution-worker.js

@@ -1,8 +1,8 @@
 /* global NodeJS */
 import * as fs from 'fs';
 import * as path from 'path';
-import { DictionaryService } from '../core/dictionary-service.js';
-import { DetectionService } from '../core/detection-service.js';
+// DetectionService + DictionaryService imports removed — their only consumer
+// (processDetectionQueue) was dead code retired in PRI-451 Wave 1.
 import { ensureStateTemplates, ensureCorePrinciples } from '../core/init.js';
 import { SystemLogger } from '../core/system-logger.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
@@ -93,7 +93,8 @@ export function purgeStaleFailedTasks(queue, logger) {
     // Remove purged items from the queue (mutates in place)
     const purgedIds = new Set(purged.map((t) => t.id));
     for (let i = queue.length - 1; i >= 0; i--) {
-        if (purgedIds.has(queue[i].id))
+        const task = queue[i];
+        if (task && purgedIds.has(task.id))
             queue.splice(i, 1);
     }
     const summary = Object.entries(byReason)
@@ -350,59 +351,8 @@ async function processEvolutionQueue(wctx, logger, _eventLog, _api) {
         }
     }
 }
-async function processDetectionQueue(wctx, api, eventLog) {
-    const { logger } = api;
-    try {
-        const funnel = DetectionService.get(wctx.stateDir);
-        const queue = funnel.flushQueue();
-        if (queue.length === 0)
-            return;
-        if (logger)
-            logger.info(`[PD:EvolutionWorker] Processing ${queue.length} items from detection funnel.`);
-        const dictionary = DictionaryService.get(wctx.stateDir);
-        for (const text of queue) {
-            const match = dictionary.match(text);
-            if (match) {
-                if (eventLog) {
-                    eventLog.recordRuleMatch(undefined, {
-                        ruleId: match.ruleId,
-                        layer: 'L2',
-                        severity: match.severity,
-                        textPreview: text.substring(0, 100)
-                    });
-                }
-            }
-            else {
-                // L3 semantic search via trajectory database FTS5 (MEM-04)
-                if (wctx.trajectory) {
-                    const searchResults = wctx.trajectory.searchPainEvents(text, 5);
-                    if (searchResults.length > 0) {
-                        // Found similar pain events - record as L3 semantic hit
-                        if (eventLog) {
-                            eventLog.recordRuleMatch(undefined, {
-                                ruleId: 'l3_semantic',
-                                layer: 'L3',
-                                severity: searchResults[0].score,
-                                textPreview: text.substring(0, 100)
-                            });
-                        }
-                        // Update detection funnel cache with L3 hit result
-                        funnel.updateCache(text, { detected: true, severity: searchResults[0].score });
-                        // Don't track as candidate - this is a confirmed L3 hit
-                        if (logger)
-                            logger.info(`[PD:EvolutionWorker] L3 semantic hit: found ${searchResults.length} similar pain events for "${text.substring(0, 50)}..."`);
-                        continue;
-                    }
-                }
-                // No L3 hit — pain candidate tracking removed (D-05)
-            }
-        }
-    }
-    catch (err) {
-        if (logger)
-            logger.warn(`[PD:EvolutionWorker] Detection queue failed: ${String(err)}`);
-    }
-}
+// processDetectionQueue removed (PRI-451 Wave 1): dead code. Its only effects
+// were recordRuleMatch (dead) and searchPainEvents (dead) — see PRI-451.
 // PAIN_CANDIDATES system removed (D-05, D-06): trackPainCandidate and processPromotion deleted
 // Evolution queue is now the single active pain→principle path
 export async function registerEvolutionTaskSession(workspaceResolve, taskId, sessionKey, logger) {
@@ -540,9 +490,7 @@ export const EvolutionWorkerService = {
                 cycleResult.queue = queueResult.queue;
                 if (queueResult.errors)
                     cycleResult.errors.push(...queueResult.errors);
-                if (api) {
-                    await processDetectionQueue(wctx, api, eventLog);
-                }
+                // processDetectionQueue removed (PRI-451 Wave 1) — was dead code.
                 // processPromotion removed (D-06) — promotion via PAIN_CANDIDATES no longer needed
                 // Correction Observer extracted to independent service (PRI-293) — no longer runs on EvolutionWorker heartbeat
                 try {
@@ -626,9 +574,7 @@ export const EvolutionWorkerService = {
                 if (queueResult.errors.length > 0) {
                     queueResult.errors.forEach((e) => logger?.error?.(`[PD:EvolutionWorker] Startup cycle error: ${e}`));
                 }
-                if (api) {
-                    await processDetectionQueue(wctx, api, eventLog);
-                }
+                // processDetectionQueue removed (PRI-451 Wave 1) — was dead code.
                 // processPromotion removed (D-06)
                 timeoutId = setTimeout(runCycle, interval);
                 timeoutId.unref();

package/plugin/dist/service/internalization-auto-consumer-service.js

@@ -1,4 +1,5 @@
-import { createRuntimeStateHandle, InternalizationOrchestrator, DreamerRunner, DefaultDreamerValidator, PiAiRuntimeAdapter, L2AgentLoopAdapter, buildL2PrincipleReaderFromLedger, loadLedger, OpenClawCliRuntimeAdapter, storeEmitter, resolveRuntimeConfigFromPdConfig, isRuntimeConfigError, computeConsumerDecision, InternalizationQueueReadModel, MVP_CORE_TASK_KINDS, } from '@principles/core/runtime-v2';
+import { createRuntimeStateHandle, InternalizationOrchestrator, DreamerRunner, DefaultDreamerValidator, PiAiRuntimeAdapter, L2AgentLoopAdapter, buildL2PrincipleReaderFromLedger, OpenClawCliRuntimeAdapter, storeEmitter, resolveRuntimeConfigFromPdConfig, isRuntimeConfigError, computeConsumerDecision, InternalizationQueueReadModel, MVP_CORE_TASK_KINDS, } from '@principles/core/runtime-v2';
+import { loadLedger } from '@principles/core/principle-tree-ledger';
 import { loadPdConfigForPlugin, loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
 import { SystemLogger } from '../core/system-logger.js';
 const INTERNALIZATION_AUTO_CONSUMER_INTERVAL_MS = 120_000;

package/plugin/dist/service/runtime-summary-service.d.ts

@@ -82,8 +82,6 @@ export interface RuntimeSummary {
         eligibilitySource: 'runtime_truth';
     };
     pain: {
-        activeFlag: boolean;
-        activeFlagSource: string | null;
         candidates: number | null;
         lastSignal: RuntimePainSignal | null;
     };

package/plugin/dist/service/runtime-summary-service.js

@@ -1,7 +1,6 @@
 import * as fs from 'fs';
 import Database from 'better-sqlite3';
 import * as path from 'path';
-import { readPainFlagData } from '../core/pain.js';
 import { listSessions } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { evaluatePhase3Inputs } from './phase3-input-filter.js';
@@ -130,7 +129,6 @@ export class RuntimeSummaryService {
         const directive = this.readJsonFile(wctx.resolve('EVOLUTION_DIRECTIVE'), warnings, false);
         const queueStats = this.buildQueueStats(queue);
         const directiveSummary = this.buildDirectiveSummary(queue, directive, generatedAt, warnings);
-        const painFlag = readPainFlagData(workspaceDir);
         const painCandidates = this.readJsonFile(wctx.resolve('PAIN_CANDIDATES'), warnings, false);
         const phase3Inputs = evaluatePhase3Inputs(queue ?? []);
         const lastPainSignal = this.findLastPainSignal(events, selectedSessionId);
@@ -239,8 +237,6 @@ export class RuntimeSummaryService {
                 eligibilitySource: 'runtime_truth',
             },
             pain: {
-                activeFlag: Object.keys(painFlag).length > 0,
-                activeFlagSource: painFlag.source || null,
                 candidates: painCandidates?.candidates && typeof painCandidates.candidates === 'object'
                     ? Object.keys(painCandidates.candidates).length
                     : null,
@@ -290,7 +286,10 @@ export class RuntimeSummaryService {
         if (sessions.length === 0) {
             return { session: null, reason: 'none' };
         }
-        return { session: sessions[0], reason: 'latest_active' };
+        const session = sessions[0];
+        if (!session)
+            return { session: null, reason: 'none' };
+        return { session, reason: 'latest_active' };
     }
     static mergeSessionSnapshots(persistedSessions, workspaceDir) {
         const merged = new Map();
@@ -392,6 +391,8 @@ export class RuntimeSummaryService {
                         if (!m)
                             continue;
                         const fileDate = m[1];
+                        if (!fileDate)
+                            continue;
                         if (fileDate > newestDate) {
                             newestDate = fileDate;
                             bestFile = path.join(dir, file);
@@ -463,6 +464,8 @@ export class RuntimeSummaryService {
     static findLastPainSignal(events, sessionId) {
         for (let i = events.length - 1; i >= 0; i--) {
             const entry = events[i];
+            if (!entry)
+                continue;
             if (entry.type !== 'pain_signal')
                 continue;
             if (sessionId && entry.sessionId !== sessionId)

package/plugin/dist/service/workflow-watchdog.js

@@ -32,7 +32,8 @@ export async function runWorkflowWatchdog(wctx, api, logger) {
                     const ageMin = Math.round((now - wf.created_at) / 60000);
                     details.push(`stale_active: ${wf.workflow_id} (${wf.workflow_type}, ${ageMin}min old)`);
                     const events = store.getEvents(wf.workflow_id);
-                    const lastEventReason = events.length > 0 ? events[events.length - 1].reason : 'unknown';
+                    const lastEvent = events[events.length - 1];
+                    const lastEventReason = lastEvent ? lastEvent.reason : 'unknown';
                     if (isExpectedSubagentError(lastEventReason)) {
                         logger?.debug?.(`[PD:Watchdog] Skipping stale active workflow ${wf.workflow_id}: expected subagent error (${lastEventReason})`);
                         continue;

package/plugin/dist/types/event-types.d.ts

@@ -1,2 +1,2 @@
-export type { EventType, EventCategory, EventLogEntry, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, HeartbeatDiagnosisEventData, DiagnosisTaskEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData, ToolCallStats, ErrorStats, PainStats, EmpathyEventStats, GfiStats, EvolutionStats as EventEvolutionStats, HookStats, DailyStats, } from '@principles/core/runtime-v2';
+export type { EventType, EventCategory, EventLogEntry, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, HeartbeatDiagnosisEventData, DiagnosisTaskEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData, ToolCallStats, ErrorStats, EmpathyEventStats, GfiStats, EvolutionStats as EventEvolutionStats, HookStats, DailyStats, } from '@principles/core/runtime-v2';
 export { createEmptyDailyStats, } from '@principles/core/runtime-v2';