principles-disciple 1.11.0 → 1.13.0

package/src/hooks/prompt.ts

@@ -3,11 +3,13 @@ import * as path from 'path';
 import type { PluginHookBeforePromptBuildEvent, PluginHookAgentContext, PluginHookBeforePromptBuildResult, PluginLogger, OpenClawPluginApi } from '../openclaw-sdk.js';
 import { clearInjectedProbationIds, getSession, resetFriction, setInjectedProbationIds, trackFriction } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
-import { ContextInjectionConfig, defaultContextConfig } from '../types.js';
+import type { ContextInjectionConfig} from '../types.js';
+import { defaultContextConfig } from '../types.js';
 import { classifyTask, type RoutingInput } from '../core/local-worker-routing.js';
 import { extractSummary, getHistoryVersions, parseWorkingMemorySection, workingMemoryToInjection, autoCompressFocus, safeReadCurrentFocus } from '../core/focus-history.js';
-import { EmpathyObserverWorkflowManager, empathyObserverWorkflowSpec } from '../service/subagent-workflow/index.js';
+import { EmpathyObserverWorkflowManager, empathyObserverWorkflowSpec, isExpectedSubagentError } from '../service/subagent-workflow/index.js';
 import { PathResolver } from '../core/path-resolver.js';
+import { isSubagentRuntimeAvailable } from '../utils/subagent-probe.js';
 import {
   matchEmpathyKeywords,
   loadKeywordStore,
@@ -29,16 +31,6 @@ interface ModelConfigObject {
   fallbacks?: string[];
 }
 
-/**
- * OpenClaw agents model configuration with subagent model override support
- */
-interface AgentsModelConfig {
-  model?: unknown;
-  subagents?: {
-    model?: unknown;
-  };
-}
-
 /**
  * Default model configuration for OpenClaw agents
  */
@@ -64,21 +56,6 @@ function escapeXml(input: string): string {
     .replace(/'/g, ''');
 }
 
-function extractContextSignals(context: { toolName?: string; filePath?: string; userMessage?: string; }): string[] {
-  const signals: string[] = [];
-  if (context.filePath?.endsWith('.ts')) signals.push('typescript');
-  if (context.filePath?.endsWith('.md')) signals.push('markdown');
-  if (context.toolName && ['edit', 'replace', 'write', 'write_file', 'apply_patch'].includes(context.toolName)) signals.push('edit');
-  if (context.toolName && ['run_shell_command', 'bash'].includes(context.toolName)) signals.push('shell');
-  if (context.toolName) signals.push(context.toolName);
-  const msg = (context.userMessage || '').toLowerCase();
-  if (msg.includes('.ts') || msg.includes('typescript')) signals.push('typescript');
-  if (msg.includes('.md') || msg.includes('markdown')) signals.push('markdown');
-  if (msg.includes('edit') || msg.includes('write') || msg.includes('patch')) signals.push('edit');
-  if (msg.includes('shell') || msg.includes('bash')) signals.push('shell');
-  return signals;
-}
-
 interface PromptHookApi {
   config?: {
     agents?: {
@@ -211,7 +188,7 @@ export function loadContextInjectionConfig(workspaceDir: string): ContextInjecti
     }
   } catch (e) {
     // Failed to load config — continue with defaults, but log for diagnostics
-    // eslint-disable-next-line no-console
+     
     console.warn(`[PD:Prompt] Failed to load contextInjection config: ${String(e)}`);
   }
   
@@ -257,37 +234,82 @@ export function getDiagnosticianModel(api: PromptHookApi | null, logger?: Plugin
   throw new Error(errorMsg);
 }
 
-function extractLatestUserMessage(messages: unknown[] | undefined): string {
-  if (!Array.isArray(messages)) return '';
-
-  for (let i = messages.length - 1; i >= 0; i--) {
+/**
+ * Extract recent user messages for keyword optimization context.
+ */
+function extractRecentMessages(messages: unknown[] | undefined, limit: number): string[] {
+  if (!Array.isArray(messages)) return [];
+  const userMessages: string[] = [];
+  
+  for (let i = messages.length - 1; i >= 0 && userMessages.length < limit; i--) {
     const msg = messages[i] as { role?: string; content?: unknown };
     if (msg?.role !== 'user') continue;
-
-    if (typeof msg.content === 'string') return msg.content;
-    if (Array.isArray(msg.content)) {
-      const text = msg.content
-        .filter((part: any) => part && part.type === 'text' && typeof part.text === 'string')
-        .map((part: any) => part.text)
+    
+    let text = '';
+    if (typeof msg.content === 'string') {
+      text = msg.content;
+    } else if (Array.isArray(msg.content)) {
+      text = msg.content
+        .filter((part: unknown) => part && typeof part === 'object' && (part as { type?: string }).type === 'text' && typeof (part as { text?: unknown }).text === 'string')
+        .map((part: unknown) => (part as { text: string }).text)
         .join('\n')
         .trim();
-      if (text) return text;
     }
+    if (text) userMessages.unshift(text.substring(0, 500));
   }
+  
+  return userMessages;
+}
 
-  return '';
+/**
+ * Build prompt for keyword optimization subagent.
+ */
+function buildOptimizationPrompt(
+  keywordStore: ReturnType<typeof loadKeywordStore>,
+  recentMessages: string[],
+): string {
+  const currentTerms = Object.entries(keywordStore.terms)
+    .map(([term, entry]) => `  - "${term}": weight=${entry.weight}, hits=${entry.hitCount || 0}, fp_rate=${entry.falsePositiveRate?.toFixed(2) || '0.10'}`)
+    .join('\n');
+
+  return `You are an empathy keyword optimizer.
+
+## TASK
+Analyze recent user messages and the current empathy keyword store.
+Return STRICT JSON (no markdown):
+
+{"updates": {"TERM": {"action": "add|update|remove", "weight": number, "falsePositiveRate": number, "reasoning": "string"}}}
+
+## Current Keyword Store (${Object.keys(keywordStore.terms).length} terms):
+${currentTerms}
+
+## Recent User Messages (${recentMessages.length} messages):
+${recentMessages.map((m, i) => `${i + 1}. "${m}"`).join('\n')}
+
+## Rules:
+- ADD: If a message contains frustration/empathy signals not in current terms
+- UPDATE: If a term's weight should change (high hits → increase weight, low hits → decrease)
+- REMOVE: If a term has 0 hits after many turns AND high false positive rate (>0.3)
+- Keep reasoning concise (max 100 chars)
+- Weight range: 0.1-0.9
+- falsePositiveRate range: 0.05-0.5
+`;
 }
 
 export async function handleBeforePromptBuild(
   event: PluginHookBeforePromptBuildEvent,
   ctx: PluginHookAgentContext & { api?: PromptHookApi }
 ): Promise<PluginHookBeforePromptBuildResult | void> {
-  const workspaceDir = ctx.workspaceDir;
-  if (!workspaceDir) return;
+  const {workspaceDir} = ctx;
+  const logger = ctx.api?.logger;
+  logger?.info?.(`[PD:Prompt] handleBeforePromptBuild called: workspaceDir=${!!workspaceDir}, trigger=${ctx.trigger}, sessionId=${ctx.sessionId?.substring(0, 20)}`);
+  if (!workspaceDir) {
+    logger?.warn?.(`[PD:Prompt] workspaceDir is missing — skipping empathy processing`);
+    return;
+  }
 
   const wctx = WorkspaceContext.fromHookContext(ctx);
   const { trigger, sessionId, api } = ctx;
-  const logger = api?.logger;
   if (sessionId) {
     wctx.trajectory?.recordSession?.({ sessionId });
   }
@@ -336,6 +358,7 @@ export async function handleBeforePromptBuild(
   // appendSystemContext: Principles + Thinking OS + reflection_log + project_context (cacheable, WebUI-hidden)
   // prependContext: Only short dynamic directives: evolutionDirective + heartbeat
 
+  // eslint-disable-next-line no-useless-assignment -- Reason: initial value unused due to immediate reassignment
   let prependSystemContext = '';
   let prependContext = '';
   let appendSystemContext = '';
@@ -378,13 +401,53 @@ The empathy observer subagent handles pain detection independently.
 `.trim();
 
   // ─────────────────────────────────────────────────3. Empathy Observer Spawn
-  // Skip if this is a subagent session or if the message indicates agent-to-agent communication
-  const latestUserMessage = extractLatestUserMessage(event.messages);
-  const isAgentToAgent = latestUserMessage.includes('sourceSession=agent:') || sessionId?.includes(':subagent:') === true;
+  // event.prompt contains the full prompt text, which may include system/boot instructions
+  // The actual user message from Feishu is embedded in the prompt with various formats:
+  // Format 1: "Sender (untrusted metadata): ```json {...}```  user_message_text"
+  // Format 2: "You are running a boot check. Follow BOOT.md..." (boot check, skip empathy)
+  // Format 3: Clean user message text
+  let latestUserMessage = event.prompt || '';
+
+  // Skip boot check messages — these are system-generated, not real user messages.
+  // buildBootPrompt() in OpenClaw src/gateway/boot.ts always starts with:
+  // "You are running a boot check. Follow BOOT.md instructions exactly."
+  // This exact phrase will never appear in a real user message.
+  if (latestUserMessage.startsWith('You are running a boot check.') ||
+      latestUserMessage.includes('You are running a boot check. Follow BOOT.md')) {
+    latestUserMessage = '';
+  }
+
+  // Try to extract actual user message from Feishu wrapper formats
+  if (latestUserMessage.length > 50) {
+    // Format 1: "Sender (untrusted metadata): ```json {...}```  user_message_text"
+    const senderMatch = /Sender \(untrusted metadata\):[\s\S]*?```json[\s\S]*?```\s*/.exec(latestUserMessage);
+    if (senderMatch) {
+      const afterSender = latestUserMessage.slice(senderMatch.index + senderMatch[0].length).trim();
+      if (afterSender.length > 3) latestUserMessage = afterSender;
+    }
+
+    // Format 2: "Conversation info (untrusted metadata): ```json {...}```  user_message_text"
+    if (latestUserMessage.length > 200 && latestUserMessage.includes('Conversation info')) {
+      const convInfoMatch = /Conversation info[\s\S]*?```json[\s\S]*?```\s*/.exec(latestUserMessage);
+      if (convInfoMatch) {
+        const afterConvInfo = latestUserMessage.slice(convInfoMatch.index + convInfoMatch[0].length).trim();
+        if (afterConvInfo.length > 3) latestUserMessage = afterConvInfo;
+      }
+    }
+  }
+  
+  // #189: Detect empathy observer output to prevent recursive spawn.
+  // The empathy observer runs with parentSessionId (not :subagent:), so its output
+  // would be treated as a user message and re-trigger empathy evaluation.
+  // Match distinctive patterns from the empathy observer prompt/output.
+  const isEmpathyPrompt = /empathy\s*observer/i.test(latestUserMessage) &&
+    /damageDetected|severity|confidence/i.test(latestUserMessage);
+  const isAgentToAgent = latestUserMessage.includes('sourceSession=agent:') || sessionId?.includes(':subagent:') === true || isEmpathyPrompt;
 
   const isUserInteraction = trigger === 'user' || trigger === 'api' || !trigger;
 
   const empathyEnabled = wctx.config.get('empathy_engine.enabled') !== false;
+  logger?.info?.(`[PD:Empathy] Conditions: enabled=${empathyEnabled}, isUser=${isUserInteraction}, sessionId=${!!sessionId}, api=${!!api}, !agentToAgent=${!isAgentToAgent}, workspaceDir=${!!workspaceDir}, hasMessage=${!!latestUserMessage}`);
   if (empathyEnabled && isUserInteraction && sessionId && api && !isAgentToAgent) {
     prependContext = '### BEHAVIORAL_CONSTRAINTS\n' + empathySilenceConstraint + '\n\n' + prependContext;
 
@@ -393,6 +456,8 @@ The empathy observer subagent handles pain detection independently.
     // for boundary cases and random discovery of new expressions.
     if (workspaceDir && latestUserMessage) {
       try {
+        const msgPreview = latestUserMessage.substring(0, 200).replace(/\n/g, ' ');
+        logger?.info?.(`[PD:Empathy] Processing user message: "${msgPreview}" (trigger=${trigger}, promptLen=${latestUserMessage.length})`);
         const lang = (wctx.config.get('language') as 'zh' | 'en') || 'zh';
 
         // Load keyword store once, cache in memory (Finding #7: avoid per-turn I/O)
@@ -431,7 +496,7 @@ The empathy observer subagent handles pain detection independently.
             source: 'user_empathy',
           });
 
-          logger?.info?.(`[PD:Empathy] MATCH: "${matchResult.matchedTerms.join(', ')}" → severity=${matchResult.severity}, score=${matchResult.score.toFixed(2)}, penalty=${penalty}, subagent=${shouldCallSubagent ? samplingReason : 'skipped(high_confidence)'}`);
+          logger?.info?.(`[PD:Empathy] MATCH: "${matchResult.matchedTerms.join(', ')}" → severity=${matchResult.severity}, score=${matchResult.score.toFixed(2)}, penalty=${penalty}, subagent=${shouldCallSubagent ? samplingReason : 'skipped(' + (matchResult.score >= 0.3 ? 'boundary_sampling' : 'random_discovery') + ')'}`);
         } else {
           // Log unmatched messages periodically for coverage analysis
           if (turnCount > 0 && turnCount % 50 === 0) {
@@ -441,7 +506,12 @@ The empathy observer subagent handles pain detection independently.
         }
 
         // Trigger subagent for sampling cases (Finding #1: use shared manager to avoid leaks)
-        if (shouldCallSubagent && api?.runtime?.subagent) {
+        const runtimeSubagent =
+          isSubagentRuntimeAvailable(api?.runtime?.subagent)
+            ? api.runtime.subagent
+            : undefined;
+
+        if (shouldCallSubagent && runtimeSubagent) {
           logger?.info?.(`[PD:Empathy] SUBAGENT_SAMPLE: reason=${samplingReason}, score=${matchResult.score.toFixed(2)}, matched=[${matchResult.matchedTerms.join(',')}]`);
 
           // EmpathyObserverWorkflowManager auto-finalizes via wait poll mechanism.
@@ -449,13 +519,18 @@ The empathy observer subagent handles pain detection independently.
           const empathyManager = new EmpathyObserverWorkflowManager({
             workspaceDir,
             logger: api.logger ?? console,
-            subagent: api.runtime.subagent as any,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Reason: runtimeSubagent has structurally compatible shape but differs from workflow manager's subagent type
+            subagent: runtimeSubagent as any,
           });
           empathyManager.startWorkflow(empathyObserverWorkflowSpec, {
             parentSessionId: sessionId,
             workspaceDir,
             taskInput: latestUserMessage,
-          }).catch((err) => api.logger?.warn?.(`[PD:Empathy] subagent sample failed: ${String(err)}`));
+          }).catch((err) => {
+            if (!isExpectedSubagentError(err)) {
+              api.logger?.warn?.(`[PD:Empathy] subagent sample failed: ${String(err)}`);
+            }
+          });
         }
 
         // Helper: build summary string (Finding #2: avoid duplication)
@@ -469,7 +544,35 @@ The empathy observer subagent handles pain detection independently.
         if (shouldTriggerOptimization(keywordStore, turnCount)) {
           logger?.info?.(`[PD:Empathy] OPTIMIZATION_TRIGGER: turns=${turnCount}, last_optimized=${keywordStore.lastOptimizedAt}`);
           logger?.info?.(`[PD:Empathy] STATS: ${buildSummary()}`);
-          // TODO: Start keyword optimization subagent to update weights and discover new terms
+
+          // Start keyword optimization subagent to update weights and discover new terms
+          try {
+            const recentMessages = extractRecentMessages(event.messages, 10);
+            const optimizationPrompt = buildOptimizationPrompt(keywordStore, recentMessages);
+            
+            logger?.info?.(`[PD:Empathy] Starting optimization subagent with ${recentMessages.length} recent messages`);
+            
+            const empathyManager = new EmpathyObserverWorkflowManager({
+              workspaceDir,
+              logger: api.logger ?? console,
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Reason: api.runtime.subagent has structurally compatible shape but differs from workflow manager's subagent type
+              subagent: api.runtime.subagent as any,
+            });
+            
+            empathyManager.startWorkflow(empathyObserverWorkflowSpec, {
+              parentSessionId: sessionId,
+              workspaceDir,
+              taskInput: { prompt: optimizationPrompt },
+            }).catch((err) => {
+              if (!isExpectedSubagentError(err)) {
+                api.logger?.warn?.(`[PD:Empathy] optimization subagent failed: ${String(err)}`);
+              }
+            });
+          } catch (optErr) {
+            if (!isExpectedSubagentError(optErr)) {
+              logger?.warn?.(`[PD:Empathy] Failed to start optimization subagent: ${String(optErr)}`);
+            }
+          }
         }
 
         // Periodic summary (every 100 turns)
@@ -477,9 +580,13 @@ The empathy observer subagent handles pain detection independently.
           logger?.info?.(`[PD:Empathy] ${buildSummary()}`);
         }
 
-        // Save keyword store periodically (Finding #7: not every turn)
-        if (turnCount % 50 === 0) {
+        // Save keyword store on every match to prevent data loss on restart.
+        // Previously used turnCount % 50 gate which caused hitCount loss because
+        // module-level state resets on plugin reload before reaching turn 50.
+        if (matchResult.matched) {
           saveKeywordStore(wctx.stateDir, keywordStore);
+          const {totalHits} = keywordStore.stats;
+          logger?.info?.(`[PD:Empathy] Keyword store saved after match: terms=${matchResult.matchedTerms.join(',')}, totalHits=${totalHits}`);
         }
       } catch (e) {
         logger?.warn?.(`[PD:Empathy] ERROR: ${String(e)}`);
@@ -521,6 +628,7 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
   }
 
   // ──── 6. Dynamic Attitude Matrix (based on GFI) ────
+  // eslint-disable-next-line no-useless-assignment -- Reason: initial value unused due to immediate reassignment
   let attitudeDirective = '';
   const currentGfi = session?.currentGfi || 0;
   
@@ -621,7 +729,7 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
     if (currentFocus.trim()) {
       try {
         // 🚀 自动压缩门禁：检查文件大小，超过阈值自动压缩
-        const stateDir = wctx.stateDir;
+        const {stateDir} = wctx;
         const compressResult = autoCompressFocus(focusPath, workspaceDir, stateDir);
         if (compressResult.compressed) {
           logger?.info?.(`[PD:Prompt] Auto-compressed CURRENT_FOCUS: ${compressResult.oldLines} → ${compressResult.newLines} lines. Milestones archived: ${compressResult.milestonesArchived}`);
@@ -732,12 +840,12 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
   // Shadow evidence comes from real runtime hooks (subagent_spawning/subagent_ended).
   if (!isMinimalMode && sessionId) {
     try {
-      // Extract RoutingInput from the latest user message
-      const latestUserText = extractLatestUserMessage(event.messages);
+      // Use the already extracted and cleaned user message
+      const latestUserText = latestUserMessage || '';
 
       if (latestUserText && latestUserText.trim().length > 0) {
         // Infer requestedTools and requestedFiles from message content
-        const toolPatterns: Array<{ pattern: RegExp; tool: string }> = [
+        const toolPatterns: { pattern: RegExp; tool: string }[] = [
           { pattern: /\b(edit|replace|write|modify|update|fix|patch|add|remove|delete|insert)\b/gi, tool: 'edit' },
           { pattern: /\b(read|cat|view|show|get|find|search|grep|look|inspect|examine|list|head|tail|diff)\b/gi, tool: 'read' },
           { pattern: /\b(run|execute|exec|bash|shell|command)\b/gi, tool: 'bash' },
@@ -745,9 +853,11 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
         const filePattern = /\b([a-zA-Z]:\\?[^\s,]+\.[a-z]{2,10}|[./][^\s,]+\.[a-z]{2,10})\b/gi;
         const toolMatches = toolPatterns.flatMap(({ pattern, tool }) => {
           const matches: string[] = [];
-          let m;
+          // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in while loop condition
+          let _m;
           const r = new RegExp(pattern.source, pattern.flags);
-          while ((m = r.exec(latestUserText)) !== null) matches.push(tool);
+          /* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars -- Reason: regex exec side effect used, match variable intentionally unused */
+          while ((_m = r.exec(latestUserText)) !== null) matches.push(tool);
           return matches;
         });
         const fileMatches = latestUserText.match(filePattern) ?? [];
@@ -917,4 +1027,3 @@ ${attitudeDirective}
     appendSystemContext
   };
 }
-

package/src/hooks/subagent.ts

@@ -1,5 +1,4 @@
 import type { PluginHookSubagentEndedEvent, PluginHookSubagentContext, PluginLogger, OpenClawPluginApi } from '../openclaw-sdk.js';
-import * as fs from 'fs';
 import { buildPainFlag, writePainFlag } from '../core/pain.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 // No longer needed — diagnostician runs via HEARTBEAT, not subagent
@@ -13,6 +12,7 @@ import type { WorkflowManager } from '../service/subagent-workflow/types.js';
  * Factory to create the appropriate WorkflowManager by workflow_type string.
  * Used by the subagent_ended hook to dispatch lifecycle recovery to the right manager.
  */
+/* eslint-disable @typescript-eslint/max-params -- Reason: Factory function requires workflowType, workspaceDir, logger, and subagent */
 function createWorkflowManagerForType(
     workflowType: string,
     workspaceDir: string,
@@ -23,6 +23,7 @@ function createWorkflowManagerForType(
         info: (m: string) => logger.info(String(m)),
         warn: (m: string) => logger.warn(String(m)),
         error: (m: string) => logger.error(String(m)),
+        // eslint-disable-next-line @typescript-eslint/no-empty-function -- debug logger no-op
         debug: () => {},
     } as unknown as PluginLogger;
 
@@ -84,7 +85,7 @@ 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 = sessionKey.match(/^agent:([^:]+):/);
+    const match = /^agent:([^:]+):/.exec(sessionKey);
     return match ? match[1] : undefined;
 }
 
@@ -104,7 +105,7 @@ export async function handleSubagentEnded(
     ctx: SubagentEndedHookContext
 ): Promise<void> {
     const { outcome, targetSessionKey } = event;
-    const workspaceDir = ctx.workspaceDir;
+    const {workspaceDir} = ctx;
 
     if (!workspaceDir) return;
 
@@ -151,7 +152,7 @@ export async function handleSubagentEnded(
         }
     }
 
-    const config = wctx.config;
+    const {config} = wctx;
 
     // ── Outcome-based EP and Pain Signal handling ──
     // OpenClaw v2026.3.23 fixes: timeout may be false positive (fast-finishing workers)

package/src/hooks/thinking-checkpoint.ts

@@ -40,10 +40,12 @@ export interface ThinkingCheckpointConfig {
  * @param logger - Optional logger for info messages
  * @returns Block result if thinking required, undefined otherwise
  */
+/* eslint-disable @typescript-eslint/max-params -- Reason: Checkpoint function requires event, config, sessionId, and logger */
 export function checkThinkingCheckpoint(
   event: PluginHookBeforeToolCallEvent,
   config: ThinkingCheckpointConfig,
   sessionId: string | undefined,
+  /* eslint-disable no-unused-vars -- Reason: callback parameter in type annotation */
   logger?: { info?: (message: string) => void }
 ): PluginHookBeforeToolCallResult | undefined {
   const enabled = config.enabled ?? false;

package/src/hooks/trajectory-collector.ts

@@ -63,7 +63,7 @@ function scrubSensitive(obj: unknown, depth = 0): unknown {
  * 异步写入队列 - 确保有序、非阻塞写入
  */
 class AsyncWriteQueue {
-  private queue: Array<() => Promise<void>> = [];
+  private readonly queue: (() => Promise<void>)[] = [];
   private processing = false;
   
   async enqueue(task: () => Promise<void>): Promise<void> {
@@ -81,9 +81,14 @@ class AsyncWriteQueue {
     
     this.processing = true;
     const task = this.queue.shift();
-    
+
+    if (!task) {
+      this.processing = false;
+      return;
+    }
+
     try {
-      await task!();
+      await task();
     } catch {
       // Silently fail - trajectory collection should not block main functionality
     }
@@ -151,7 +156,7 @@ export function handleAfterToolCall(
   event: PluginHookAfterToolCallEvent,
   ctx: PluginHookToolContext & { workspaceDir?: string }
 ): void {
-  const workspaceDir = ctx.workspaceDir;
+  const {workspaceDir} = ctx;
   if (!workspaceDir) return;
 
   // 递归脱敏处理所有字段
@@ -186,7 +191,7 @@ export function handleLlmOutput(
   event: PluginHookLlmOutputEvent,
   ctx: PluginHookAgentContext & { workspaceDir?: string }
 ): void {
-  const workspaceDir = ctx.workspaceDir;
+  const {workspaceDir} = ctx;
   if (!workspaceDir) return;
 
   const totalTextLength = event.assistantTexts?.reduce((sum, text) => sum + (text?.length || 0), 0) || 0;
@@ -211,7 +216,7 @@ export function handleBeforeMessageWrite(
   event: PluginHookBeforeMessageWriteEvent,
   ctx: PluginHookAgentContext & { workspaceDir?: string }
 ): void {
-  const workspaceDir = ctx.workspaceDir;
+  const {workspaceDir} = ctx;
   if (!workspaceDir) return;
 
   const msg = event.message;
@@ -223,11 +228,13 @@ export function handleBeforeMessageWrite(
   // 提取文本内容
   let content = '';
   if (typeof msg.content === 'string') {
+    /* eslint-disable @typescript-eslint/prefer-destructuring */
+    // Reason: msg.content is string | ContentPart[]; destructuring would require renaming in the else branch
     content = msg.content;
   } else if (Array.isArray(msg.content)) {
     content = msg.content
-      .filter((part: any) => part?.type === 'text')
-      .map((part: any) => part.text)
+      .filter((part: unknown) => part && typeof part === 'object' && (part as { type?: string }).type === 'text')
+      .map((part: unknown) => (part as { text: string }).text)
       .join('\n');
   }
 
@@ -249,10 +256,6 @@ export function handleBeforeMessageWrite(
  * 脱敏处理：移除敏感参数（保留旧函数签名以兼容）
  * @deprecated 使用 scrubSensitive 替代
  */
-function sanitizeParams(params: Record<string, any>): Record<string, any> {
-  return scrubSensitive(params) as Record<string, any>;
-}
-
 /**
  * 轨迹汇总统计（供 cron 任务调用）
  */