create-principles-disciple 1.91.0 → 1.93.0

package/plugin/dist/hooks/after-tool-call-helpers.js

@@ -25,6 +25,68 @@ import { resolveSourceKind, buildToolFailureObservation } from './raw-observatio
 import { evaluateEvidenceTriage } from './triage-adapter.js';
 import { evaluateTriggerController } from '@principles/core/runtime-v2';
 import { buildTrajectoryEvidence } from './trajectory-evidence.js';
+const RESULT_PREVIEW_MAX_LENGTH = 500;
+/**
+ * Extract a preview string from tool call result for diagnostic evidence.
+ * Pure function — no I/O, no side effects. ERR-001 / ERR-014 compliant.
+ */
+export function extractToolResultPreview(result) {
+    if (result === null || result === undefined)
+        return null;
+    try {
+        // String result: truncate directly
+        if (typeof result === 'string') {
+            return result.length > RESULT_PREVIEW_MAX_LENGTH
+                ? `${result.slice(0, RESULT_PREVIEW_MAX_LENGTH - 3)}...`
+                : result;
+        }
+        // Object with content array (e.g., Anthropic content blocks)
+        if (typeof result === 'object' && !Array.isArray(result)) {
+            const obj = result;
+            if (Array.isArray(obj.content)) {
+                const textParts = [];
+                for (const block of obj.content) {
+                    if (block && typeof block === 'object' && !Array.isArray(block)) {
+                        const blockObj = block;
+                        if (blockObj.type === 'text' && typeof blockObj.text === 'string') {
+                            textParts.push(blockObj.text);
+                        }
+                    }
+                }
+                if (textParts.length > 0) {
+                    const joined = textParts.join('\n');
+                    return joined.length > RESULT_PREVIEW_MAX_LENGTH
+                        ? `${joined.slice(0, RESULT_PREVIEW_MAX_LENGTH - 3)}...`
+                        : joined;
+                }
+            }
+            // Object without content array: JSON.stringify with depth limiter (ERR-014)
+            const serialized = JSON.stringify(obj, (_key, value) => {
+                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                    const keys = Object.keys(value);
+                    if (keys.length > 10) {
+                        const truncated = {};
+                        for (const k of keys.slice(0, 10)) {
+                            truncated[k] = value[k];
+                        }
+                        truncated['__truncated__'] = true;
+                        return truncated;
+                    }
+                }
+                return value;
+            }, 2);
+            if (serialized && serialized !== '{}') {
+                return serialized.length > RESULT_PREVIEW_MAX_LENGTH
+                    ? `${serialized.slice(0, RESULT_PREVIEW_MAX_LENGTH - 3)}...`
+                    : serialized;
+            }
+        }
+        return null;
+    }
+    catch {
+        return '[result_preview_extraction_failed]';
+    }
+}
 // ── Stage 1: Classify ───────────────────────────────────────────────────────
 /**
  * Classify the outcome of a tool call event.
@@ -150,6 +212,7 @@ export function handleFrictionTrackingForFailure(sessionId, event, outcome, obse
         gfiBefore,
         gfiAfter: updatedState.currentGfi,
         paramsJson: sanitizeToolParamsForEvidence(event.params, workspaceDir),
+        resultPreview: extractToolResultPreview(event.result),
     });
     return updatedState;
 }
@@ -188,6 +251,7 @@ export function handleFrictionTrackingForSuccess(sessionId, event, outcome, obse
         gfiBefore,
         gfiAfter: resetState.currentGfi,
         paramsJson: sanitizeToolParamsForEvidence(event.params, workspaceDir),
+        resultPreview: extractToolResultPreview(event.result),
     });
     wctx.eventLog.recordToolCall(sessionId, {
         toolName: event.toolName,

package/plugin/dist/hooks/llm.d.ts

@@ -8,6 +8,14 @@ export interface EmpathySignal {
 }
 export declare function extractEmpathySignal(text: string): EmpathySignal;
 export declare function isEmpathyAuditPayload(text: string): boolean;
+/**
+ * Extract enhanced fields from lastAssistant (complete AssistantMessage) in hook payload.
+ * Pure function — no I/O, no side effects. ERR-001 compliant.
+ */
+export declare function extractAssistantEnhancedFields(lastAssistant: unknown): {
+    stopReason: string | null;
+    thinkingBlocksCount: number | null;
+};
 export declare function handleLlmOutput(event: PluginHookLlmOutputEvent, ctx: PluginHookAgentContext & {
     workspaceDir?: string;
 }): void;

package/plugin/dist/hooks/llm.js

@@ -124,6 +124,33 @@ export function isEmpathyAuditPayload(text) {
         return true;
     return false;
 }
+/**
+ * Extract enhanced fields from lastAssistant (complete AssistantMessage) in hook payload.
+ * Pure function — no I/O, no side effects. ERR-001 compliant.
+ */
+export function extractAssistantEnhancedFields(lastAssistant) {
+    if (!lastAssistant || typeof lastAssistant !== 'object' || Array.isArray(lastAssistant)) {
+        return { stopReason: null, thinkingBlocksCount: null };
+    }
+    const obj = lastAssistant;
+    // stopReason: typeof guard
+    const stopReason = typeof obj.stopReason === 'string' ? obj.stopReason : null;
+    // thinkingBlocksCount: iterate content array, count thinking/redacted_thinking blocks
+    let thinkingBlocksCount = null;
+    if (Array.isArray(obj.content)) {
+        let count = 0;
+        for (const block of obj.content) {
+            if (block && typeof block === 'object' && !Array.isArray(block)) {
+                const blockType = block.type;
+                if (blockType === 'thinking' || blockType === 'redacted_thinking') {
+                    count++;
+                }
+            }
+        }
+        thinkingBlocksCount = count;
+    }
+    return { stopReason, thinkingBlocksCount };
+}
 export function handleLlmOutput(event, ctx) {
     if (!ctx.workspaceDir || !ctx.sessionId)
         return;
@@ -142,6 +169,7 @@ export function handleLlmOutput(event, ctx) {
         return;
     const text = event.assistantTexts.join('\n');
     const signal = extractEmpathySignal(text);
+    const enhancedFields = extractAssistantEnhancedFields(event.lastAssistant);
     const createdAt = new Date().toISOString();
     let assistantTurnId = null;
     try {
@@ -154,6 +182,8 @@ export function handleLlmOutput(event, ctx) {
             sanitizedText: sanitizeAssistantText(text),
             usageJson: event.usage || {},
             empathySignalJson: signal,
+            stopReason: enhancedFields.stopReason,
+            thinkingBlocksCount: enhancedFields.thinkingBlocksCount,
             createdAt,
         });
     }

package/plugin/dist/hooks/trajectory-collector.d.ts

@@ -1,9 +1,23 @@
 /**
  * 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 type { PluginHookAgentContext, PluginHookBeforeMessageWriteEvent } from '../openclaw-sdk.js';
 /**
@@ -14,7 +28,9 @@ import type { PluginHookAgentContext, PluginHookBeforeMessageWriteEvent } from '
  * 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.

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/trajectory-evidence.js

@@ -41,9 +41,11 @@ export function buildTrajectoryEvidence(wctx, sessionId) {
             if (evidence.length >= MAX_EVIDENCE_ENTRIES)
                 break;
             const sanitizedNote = sanitizeAssistantText((turn.sanitizedText ?? '').slice(0, MAX_EVIDENCE_NOTE_CHARS));
+            // Enhanced: append truncation warning when stop_reason=length
+            const truncationWarning = turn.stopReason === 'length' ? ' [TRUNCATED: output cut off by length limit]' : '';
             evidence.push({
                 sourceRef: `agent_turn:${turn.createdAt}`,
-                note: sanitizedNote,
+                note: sanitizedNote + truncationWarning,
             });
         }
     }
@@ -62,7 +64,9 @@ export function buildTrajectoryEvidence(wctx, sessionId) {
         for (const tc of failedToolCalls) {
             if (evidence.length >= MAX_EVIDENCE_ENTRIES)
                 break;
-            const note = `Tool ${tc.toolName} failed: ${tc.errorType ?? 'unknown'} (exitCode: ${tc.exitCode ?? 'N/A'})`;
+            // Enhanced: append resultPreview when available
+            const previewSuffix = tc.resultPreview ? ` | ${tc.resultPreview.slice(0, 200)}` : '';
+            const note = `Tool ${tc.toolName} failed: ${tc.errorType ?? 'unknown'} (exitCode: ${tc.exitCode ?? 'N/A'})${previewSuffix}`;
             evidence.push({
                 sourceRef: `tool_call_failure:${tc.createdAt}`,
                 note: sanitizeAssistantText(note.slice(0, MAX_EVIDENCE_NOTE_CHARS)),

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;
@@ -231,6 +234,7 @@ export interface PluginHookLlmOutputEvent {
     usage?: TokenUsage;
     assistantTexts?: string[];
     trigger?: string;
+    lastAssistant?: unknown;
     [key: string]: unknown;
 }
 export interface PluginHookSubagentSpawningEvent {

package/plugin/dist/service/evolution-worker.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)
@@ -377,17 +378,20 @@ async function processDetectionQueue(wctx, api, eventLog) {
                 if (wctx.trajectory) {
                     const searchResults = wctx.trajectory.searchPainEvents(text, 5);
                     if (searchResults.length > 0) {
+                        const topResult = searchResults[0];
+                        if (!topResult)
+                            continue;
                         // Found similar pain events - record as L3 semantic hit
                         if (eventLog) {
                             eventLog.recordRuleMatch(undefined, {
                                 ruleId: 'l3_semantic',
                                 layer: 'L3',
-                                severity: searchResults[0].score,
+                                severity: topResult.score,
                                 textPreview: text.substring(0, 100)
                             });
                         }
                         // Update detection funnel cache with L3 hit result
-                        funnel.updateCache(text, { detected: true, severity: searchResults[0].score });
+                        funnel.updateCache(text, { detected: true, severity: topResult.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)}..."`);

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.js

@@ -290,7 +290,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 +395,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 +468,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;