principles-disciple 1.72.0 → 1.74.0

package/src/hooks/gate-block-helper.ts

@@ -10,14 +10,15 @@
  * had their own block persistence implementations.
  */
 
-import { trackBlock } from '../core/session-tracker.js';
+import { getSession, trackBlock } from '../core/session-tracker.js';
 import type { WorkspaceContext } from '../core/workspace-context.js';
 import type { PluginHookBeforeToolCallResult } from '../openclaw-sdk.js';
+import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
+import { emitPainDetectedEvent } from './pain.js';
 import {
   TRAJECTORY_GATE_BLOCK_RETRY_DELAY_MS,
   TRAJECTORY_GATE_BLOCK_MAX_RETRIES
 } from '../config/index.js';
-import { buildPainFlag, writePainFlag } from '../core/pain.js';
 
 /**
  * Block context containing all information needed for block persistence
@@ -99,82 +100,88 @@ export function recordGateBlockAndReturn(
     scheduleTrajectoryGateBlockRetry(wctx, trajectoryPayload, 1, logWarn, logError);
   }
 
-  // 5. Emit pain signal for gate block (#256)
-  // Gate blocks are a strong frustration signal — the agent tried to do something
-  // and was blocked by a principle gate. This should feed into the nocturnal pipeline.
+  // 5. Record gate block pain context. Runtime V2 diagnosis is gated by GFI
+  // so one mild block does not start a long diagnostician run.
   if (sessionId) {
-    const GATE_BLOCK_PAIN_SCORE = 30; // Moderate — not a failure but a blocked intent
-    try {
-      const trajectoryPainId = wctx.trajectory?.recordPainEvent?.({
-        sessionId,
-        source: 'gate_blocked',
-        score: GATE_BLOCK_PAIN_SCORE,
-        reason: `Gate blocked ${toolName} on ${filePath}: ${reason}`,
-        severity: 'mild',
-        origin: 'system_infer',
-      });
+    const GATE_BLOCK_PAIN_SCORE = 45; // Must be >= pain_trigger (40) so single gate block can trigger diagnosis (PRI-274)
+    // Record to trajectory (fire-and-forget, no .pain_flag file needed)
+    wctx.trajectory?.recordPainEvent?.({
+      sessionId,
+      source: 'gate_blocked',
+      score: GATE_BLOCK_PAIN_SCORE,
+      reason: `Gate blocked ${toolName} on ${filePath}: ${reason}`,
+      severity: 'mild',
+      origin: 'system_infer',
+    });
 
-      // Update .pain_flag if score is significant
-      wctx.eventLog.recordPainSignal(sessionId, {
-        source: 'gate_blocked',
-        score: GATE_BLOCK_PAIN_SCORE,
-        reason,
-      });
+    const session = getSession(sessionId);
+    const gate = evaluatePainDiagnosticGate({
+      source: 'gate_blocked',
+      score: GATE_BLOCK_PAIN_SCORE,
+      currentGfi: session?.currentGfi ?? 0,
+      consecutiveErrors: session?.consecutiveErrors ?? 0,
+      sessionId,
+      errorHash: `${toolName}:${filePath}:${reason}`,
+      thresholds: {
+        painTrigger: wctx.config.get('thresholds.pain_trigger') || 40,
+        highSeverity: wctx.config.get('severity_thresholds.high') || 70,
+      },
+    });
 
-      // Write to pain flag file (merge with existing if present)
-      try {
-         
-        const workspaceDir = wctx.workspaceDir;
-        const currentFlag = wctx.eventLog.findLatestPainSignal(sessionId);
-        const currentScore = currentFlag?.score ?? 0;
-        if (currentScore < GATE_BLOCK_PAIN_SCORE) {
-          const flag = buildPainFlag({
-            source: 'gate_blocked',
-            score: String(GATE_BLOCK_PAIN_SCORE),
-            reason: `Gate blocked: ${reason}`,
-            session_id: sessionId,
-            agent_id: 'main',
-            is_risky: false,
-            pain_event_id: trajectoryPainId !== undefined && trajectoryPainId >= 0 ? String(trajectoryPainId) : undefined,
-          });
-          writePainFlag(workspaceDir, flag);
-        }
-      } catch (flagErr) {
-        logWarn(`[PD_GATE] Failed to update pain flag for gate block: ${String(flagErr)}`);
-      }
-    } catch (painErr) {
-      logWarn(`[PD_GATE] Failed to record gate block pain signal: ${String(painErr)}`);
+    if (gate.shouldDiagnose) {
+      void emitPainDetectedEvent(wctx, {
+        ts: new Date().toISOString(),
+        type: 'pain_detected',
+        data: {
+          painId: `gate_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+          painType: 'user_frustration',
+          source: 'gate_blocked',
+          reason: `Gate blocked ${toolName} on ${filePath}: ${reason}`,
+          score: GATE_BLOCK_PAIN_SCORE,
+          sessionId,
+          agentId: 'main',
+        },
+      }).catch((emitErr) => {
+        logWarn(`[PD_GATE] Failed to emit gate block pain event: ${String(emitErr)}`);
+      });
+    } else {
+      logger.info?.(`[PD_GATE] Gate block recorded without Runtime V2 diagnosis: ${gate.detail}`);
     }
   }
 
-  // 6. Return consistent block result with operator guidance
+  // 6. Return consistent block result with contextual operator guidance
+  const blockMessage = buildContextualBlockMessage({ filePath, reason });
+
   return {
     block: true,
-    blockReason: `[Principles Disciple] Security Gate Blocked this action.
+    blockReason: blockMessage,
+  };
+}
+
+/**
+ * Build contextual block message based on block source.
+ * - rule-host: principle-based guidance
+ * - default/gate: generic security gate message
+ */
+function buildContextualBlockMessage({
+  filePath,
+  reason,
+}: {
+  filePath: string;
+  reason: string;
+}): string {
+  // rule-host or generic gate blocks
+  return `[Principles Disciple] Security Gate Blocked this action.
 File: ${filePath}
 Reason: ${reason}
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 📋 How to unblock this operation:
 
-1. Use the plan-script skill to create a PLAN.md:
-   → Invoke: skill:plan-script
-
-2. Fill in the plan with:
-   - Target Files: ${filePath}
-   - Steps: What you want to do (be specific)
-   - Metrics: How to verify success
-   - Active Mental Models: Select 2 relevant models from .principles/THINKING_OS.md
-   - Rollback: How to restore if it fails
-
-3. After completing the plan, set STATUS: READY in PLAN.md
-
-4. Retry the operation
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-This is a mandatory security gate. The operation was blocked because the modification exceeds the allowed threshold for your current evolution tier.
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
-  };
+This action was blocked by a Rule Host principle.
+If the blocked path is correct and safe, explain the reasoning to the owner
+and ask for explicit confirmation to proceed.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`;
 }
 
 /**

package/src/hooks/gate.ts

@@ -9,13 +9,12 @@
  * 2. Rule Host: Dynamic principle-based evaluation (sole gate)
  */
 
-import * as fs from 'fs';
-import * as path from 'path';
-import { normalizePath, planStatus } from '../utils/io.js';
+import { normalizePath } from '../utils/io.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { recordGateBlockAndReturn } from './gate-block-helper.js';
 import { RuleHost } from '../core/rule-host.js';
-import type { RuleHostInput } from '../core/rule-host-types.js';
+import type { RuleHostInput } from '@principles/core/runtime-v2';
+import { validateCorrectionProposal, validateProposedPathBounds } from '@principles/core/runtime-v2';
 import type { PluginHookBeforeToolCallEvent, PluginHookToolContext, PluginHookBeforeToolCallResult, PluginLogger } from '../openclaw-sdk.js';
 import { AGENT_TOOLS, BASH_TOOLS_SET, WRITE_TOOLS } from '../constants/tools.js';
 import { getSession, hasRecentThinking } from '../core/session-tracker.js';
@@ -41,11 +40,11 @@ export function handleBeforeToolCall(
   const wctx = WorkspaceContext.fromHookContext(ctx);
 
   // 2. Resolve the target file path
-  let filePath = event.params.file_path || event.params.path || event.params.file || event.params.target;
+  let filePath = event.params?.file_path || event.params?.path || event.params?.file || event.params?.target;
 
   // Heuristic for bash mutation detection
   if (isBash && !filePath) {
-    const command = String(event.params.command || event.params.args || '');
+    const command = String(event.params?.command || event.params?.args || '');
     const mutationMatch = /(?:>|>>|sed\s+-i|rm|mv|mkdir|touch|cp)\s+(?:-[a-zA-Z]+\s+)*([^\s;&|<>]+)/.exec(command);
 
     if (mutationMatch) {
@@ -56,6 +55,12 @@ export function handleBeforeToolCall(
     }
   }
 
+  // Write tools without a file path must still go through RuleHost evaluation.
+  // Use a synthetic path so RuleHost can evaluate and potentially block.
+  if (!filePath && isWriteTool) {
+    filePath = `<tool:${event.toolName}>`;
+  }
+
   if (typeof filePath !== 'string') return;
 
   const relPath = normalizePath(filePath, ctx.workspaceDir);
@@ -67,12 +72,16 @@ export function handleBeforeToolCall(
       action: {
         toolName: event.toolName,
         normalizedPath: relPath,
-        paramsSummary: _extractParamsSummary(event.params),
+        paramsSummary: _extractParamsSummary(event.params ?? {}),
       },
       workspace: {
         isRiskPath: false, // Rule Host determines risk dynamically
-        planStatus: _getPlanStatus(ctx.workspaceDir),
-        hasPlanFile: _hasPlanFile(ctx.workspaceDir),
+        // DEPRECATED (PRI-286): planStatus/hasPlanFile are legacy compatibility fields.
+        // Live PD no longer reads or manages PLAN.md state. These fields must not be
+        // used for new MVP behavior. Future "plan-first" enforcement must come from
+        // owner-approved RuleHost/code_tool_hook activation, not built-in state.
+        planStatus: 'NONE' as const,
+        hasPlanFile: false,
       },
       session: {
         sessionId: ctx.sessionId,
@@ -83,7 +92,7 @@ export function handleBeforeToolCall(
         epTier: _getEpTier(wctx.workspaceDir),
       },
       derived: {
-        estimatedLineChanges: estimateLineChanges({ toolName: event.toolName, params: event.params }),
+        estimatedLineChanges: estimateLineChanges({ toolName: event.toolName, params: event.params ?? {} }),
         bashRisk: _getBashRisk(event),
       },
     };
@@ -153,8 +162,170 @@ export function handleBeforeToolCall(
         logger?.warn?.(`[PD_GATE] Failed to record rule_enforced/rulehost_requireApproval: ${String(evErr)}`);
       }
     }
+
+    if (hostResult?.decision === 'auto_correct' && hostResult.correctionProposal) {
+      const proposal = hostResult.correctionProposal;
+      let validation: { valid: boolean; errors: string[] };
+      try {
+        validation = validateCorrectionProposal(proposal);
+      } catch (validationError: unknown) {
+        validation = { valid: false, errors: [`Validator threw: ${String(validationError)}`] };
+      }
+
+      try {
+        const eventLog = EventLogService.get(wctx.stateDir, logger as PluginLogger | undefined);
+        const correctedFields = Array.isArray(proposal.correctedFields)
+          ? proposal.correctedFields.map((f: unknown) => typeof f === 'object' && f !== null ? String((f as { field?: string }).field) : String(f))
+          : [];
+        eventLog.recordRuleHostAutoCorrectProposed({
+          toolName: event.toolName,
+          filePath: relPath,
+          ruleId: String(proposal.ruleId ?? 'unknown'),
+          principleId: proposal.principleId != null ? String(proposal.principleId) : undefined,
+          confidence: typeof proposal.confidence === 'number' ? proposal.confidence : 0,
+          reason: hostResult.reason,
+          applicationMode: proposal.applicationMode === 'live' ? 'live' : 'shadow',
+          correctedFields,
+          validationValid: validation.valid,
+        });
+      } catch (evErr) {
+        logger?.warn?.(`[PD_GATE] Failed to record rulehost_auto_correct_proposed: ${String(evErr)}`);
+      }
+
+      if (proposal.applicationMode === 'live' && validation.valid) {
+        if (!event.params) {
+          return;
+        }
+        const originalParams = { ...event.params };
+        const nextParams: Record<string, unknown> = {};
+        const appliedFields: Array<{ field: string; original: unknown; applied: unknown }> = [];
+
+        try {
+          if (!Array.isArray(proposal.correctedFields)) {
+            throw new Error('proposal.correctedFields is not an array');
+          }
+
+          if (!proposal.proposedParams || typeof proposal.proposedParams !== 'object' || Array.isArray(proposal.proposedParams)) {
+            throw new Error('proposal.proposedParams must be an object');
+          }
+
+          const trustedWorkspaceDir = ctx.workspaceDir;
+          if (typeof trustedWorkspaceDir === 'string' && trustedWorkspaceDir.trim().length > 0) {
+            const pathBoundsResult = validateProposedPathBounds(proposal.proposedParams, trustedWorkspaceDir);
+            if (!pathBoundsResult.valid) {
+              throw new Error(`Path boundary violation: ${pathBoundsResult.reason}`);
+            }
+          } else {
+            const hasPathField = Object.keys(proposal.proposedParams).some(k => typeof proposal.proposedParams[k] === 'string' && (k === 'file_path' || k === 'path' || k === 'filePath'));
+            if (hasPathField) {
+              throw new Error('Cannot apply live auto-correction with path fields: no trusted workspace directory available');
+            }
+          }
+
+          for (const cf of proposal.correctedFields) {
+            if (typeof cf !== 'object' || cf === null || typeof cf.field !== 'string') {
+              throw new Error('correctedFields entry must be an object with a string field');
+            }
+            const field = cf.field;
+            if (!Object.hasOwn(event.params, field)) {
+              throw new Error(`Field '${field}' not found in event.params`);
+            }
+            if (!Object.hasOwn(proposal.proposedParams, field)) {
+              throw new Error(`Field '${field}' not found in proposal.proposedParams`);
+            }
+          }
+
+          for (const cf of proposal.correctedFields) {
+            if (typeof cf === 'object' && cf !== null && typeof cf.field === 'string') {
+              const field = cf.field;
+              const originalValue = event.params[field];
+              const appliedValue = proposal.proposedParams[field];
+              nextParams[field] = appliedValue;
+              appliedFields.push({
+                field,
+                original: originalValue,
+                applied: appliedValue,
+              });
+            }
+          }
+
+          Object.assign(event.params, nextParams);
+
+          try {
+            const eventLog = EventLogService.get(wctx.stateDir, logger as PluginLogger | undefined);
+            eventLog.recordRuleHostAutoCorrectApplied({
+              toolName: event.toolName,
+              filePath: relPath,
+              ruleId: String(proposal.ruleId ?? 'unknown'),
+              principleId: proposal.principleId != null ? String(proposal.principleId) : undefined,
+              confidence: typeof proposal.confidence === 'number' ? proposal.confidence : 0,
+              reason: hostResult.reason || proposal.correctedFields?.[0]?.reason || 'auto-correct applied',
+              correctedFields: appliedFields,
+            });
+          } catch (evErr) {
+            logger?.warn?.(`[PD_GATE] Failed to record rulehost_auto_correct_applied: ${String(evErr)}`);
+          }
+
+          if (proposal.notifyAgent === true && appliedFields.length > 0) {
+            const messages = appliedFields.map(f =>
+              `[PD Auto-Correct] Rule ${proposal.ruleId}: ${proposal.correctedFields?.[0]?.reason || 'correction applied'}. Parameter '${f.field}' was adjusted from ${JSON.stringify(f.original)} to ${JSON.stringify(f.applied)}.`
+            );
+            return {
+              toolArgs: event.toolArgs,
+              skipToolCall: false,
+              _pdAutoCorrectWarning: messages.join('\n'),
+            };
+          }
+        } catch (applyError: unknown) {
+          if (event.params) {
+            Object.assign(event.params, originalParams);
+          }
+          const errorMsg = String(applyError);
+          const isPathViolation = errorMsg.includes('Path boundary violation') || errorMsg.includes('no trusted workspace directory');
+          if (isPathViolation) {
+            logger?.warn?.(`[PD_GATE] Live auto-correction rejected — path out of bounds: ${errorMsg}`);
+            try {
+              const eventLog = EventLogService.get(wctx.stateDir, logger as PluginLogger | undefined);
+              eventLog.recordRuleHostAutoCorrectProposed({
+                toolName: event.toolName,
+                filePath: relPath,
+                ruleId: String(proposal.ruleId ?? 'unknown'),
+                principleId: proposal.principleId != null ? String(proposal.principleId) : undefined,
+                confidence: typeof proposal.confidence === 'number' ? proposal.confidence : 0,
+                reason: `Path boundary rejected: ${errorMsg}`,
+                applicationMode: 'shadow',
+                correctedFields: Array.isArray(proposal.correctedFields)
+                  ? proposal.correctedFields.map((f: unknown) => typeof f === 'object' && f !== null ? String((f as { field?: string }).field) : String(f))
+                  : [],
+                validationValid: false,
+              });
+            } catch (evErr) {
+              logger?.warn?.(`[PD_GATE] Failed to record path rejection telemetry: ${String(evErr)}`);
+            }
+          } else {
+            logger?.warn?.(`[PD_GATE] Failed to apply auto-correction, using original params: ${errorMsg}`);
+          }
+        }
+      }
+    } else if (hostResult?.decision === 'auto_correct') {
+      // auto_correct without correctionProposal — emit telemetry for observability
+      try {
+        const eventLog = EventLogService.get(wctx.stateDir, logger as PluginLogger | undefined);
+        eventLog.recordRuleHostAutoCorrectProposed({
+          toolName: event.toolName,
+          filePath: relPath,
+          ruleId: hostResult.ruleId ?? 'unknown',
+          confidence: 0,
+          reason: hostResult.reason ?? 'auto_correct without correctionProposal',
+          applicationMode: 'shadow',
+          correctedFields: [],
+          validationValid: false,
+        });
+      } catch (evErr) {
+        logger?.warn?.(`[PD_GATE] Failed to record rulehost_auto_correct_proposed (no proposal): ${String(evErr)}`);
+      }
+    }
   } catch (hostError: unknown) {
-    // D-08: Conservative degradation — log and allow on Rule Host failure
     logger.warn?.(`[PD_GATE:RULE_HOST] Host evaluation failed, allowing conservatively: ${String(hostError)}`);
   }
 
@@ -177,25 +348,6 @@ function _extractParamsSummary(params: Record<string, unknown>): Record<string,
   return summary;
 }
 
-function _getPlanStatus(workspaceDir: string): 'NONE' | 'DRAFT' | 'READY' | 'UNKNOWN' {
-  try {
-    const status = planStatus(workspaceDir);
-    if (status === 'READY') return 'READY';
-    if (status === 'DRAFT') return 'DRAFT';
-    if (status === '') return 'NONE';
-    return 'UNKNOWN';
-  } catch {
-    return 'UNKNOWN';
-  }
-}
-
-function _hasPlanFile(workspaceDir: string): boolean {
-  try {
-    return fs.existsSync(path.join(workspaceDir, 'PLAN.md'));
-  } catch {
-    return false;
-  }
-}
 
 function _getCurrentGfi(sessionId?: string): number {
   if (!sessionId) return 0;
@@ -227,7 +379,7 @@ function _getEpTier(workspaceDir: string): number {
 function _getBashRisk(event: PluginHookBeforeToolCallEvent): 'safe' | 'normal' | 'dangerous' | 'unknown' {
   if (!BASH_TOOLS_SET.has(event.toolName)) return 'unknown';
   try {
-    const command = String(event.params.command || event.params.args || '');
+    const command = String(event.params?.command || event.params?.args || '');
     const isDangerous = /\brm\s+-rf\b|\bchmod\b|\bchown\b|>\s*\/dev\//.test(command);
     if (isDangerous) return 'dangerous';
     const isMutation = /(?:>|>>|sed|rm|mv|mkdir|touch|cp|npm|yarn|pnpm|pip|cargo)/.test(command);

package/src/hooks/lifecycle.ts

@@ -1,7 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as readline from 'readline';
-import { recordAndWritePainFlag } from '../core/pain.js';
 import { atomicWriteFileSync } from '../utils/io.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { PD_DIRS } from '../core/paths.js';
@@ -10,6 +9,7 @@ import {
   mergeWorkingMemory,
 } from '../core/focus-history.js';
 import type { PluginHookBeforeResetEvent, PluginHookBeforeCompactionEvent, PluginHookAfterCompactionEvent, PluginHookAgentContext } from '../openclaw-sdk.js';
+import { emitPainDetectedEvent } from './pain.js';
 
 export async function handleBeforeReset(
   event: PluginHookBeforeResetEvent,
@@ -66,7 +66,7 @@ export async function extractPainFromSessionFile(sessionFile: string, ctx: Plugi
     return;
   }
 
-  if (ctx.logger) ctx.logger.info(`[Pain Extractor] Scanning session transcript for pain signals: ${sessionFile}`);
+  ctx.logger?.info?.(`[Pain Extractor] Scanning session transcript for pain signals: ${sessionFile}`);
 
   const fileStream = fs.createReadStream(sessionFile);
   const rl = readline.createInterface({
@@ -97,13 +97,13 @@ export async function extractPainFromSessionFile(sessionFile: string, ctx: Plugi
 
         if (msg.openclawAbort?.aborted) {
           const runIdSafe = msg.openclawAbort?.runId || 'unknown';
-          if (ctx.logger) ctx.logger.info(`[Pain Extractor] Detected hard-abort snapshot (runId: ${runIdSafe})`);
+          ctx.logger?.info?.(`[Pain Extractor] Detected hard-abort snapshot (runId: ${runIdSafe})`);
           painPoints.push(`[FATAL INTERCEPT] 动作被沙箱防御机制强制击落。大模型被击落前的思考流 (未遂动机): ${text.substring(0, 250)}...`);
           continue;
         }
 
         if (msg.__openclaw?.truncated && msg.__openclaw?.reason === 'oversized') {
-          if (ctx.logger) ctx.logger.info(`[Pain Extractor] Detected oversized data truncation placeholder`);
+          ctx.logger?.info?.(`[Pain Extractor] Detected oversized data truncation placeholder`);
           painPoints.push(`[COGNITIVE OVERLOAD] 大模型尝试读取极大体积的输入，已被底层守护程序抹除/折叠防爆。请反思是否读取了不当的文件或日志: ${text.substring(0, 150)}...`);
           continue;
         }
@@ -154,21 +154,19 @@ export async function extractPainFromSessionFile(sessionFile: string, ctx: Plugi
 
       const hasFatal = painPoints.some(p => p.includes('[FATAL INTERCEPT]'));
       if (hasFatal) {
-        recordAndWritePainFlag(wctx, {
-          sessionId: ctx.sessionId || 'unknown',
-          source: 'intercept_extraction',
-          score: 100,
-          reason: 'Hard intercept detected in session history compaction.',
-          severity: 'severe',
-          origin: 'system_infer',
-        }, {
-          source: 'intercept_extraction',
-          score: '100',
-          reason: 'Hard intercept detected in session history compaction.',
-          is_risky: true,
-          trigger_text_preview: painPoints.find(p => p.includes('[FATAL INTERCEPT]'))?.substring(0, 150) || 'Fatal intercept',
-          session_id: ctx.sessionId || '',
-          agent_id: ctx.agentId || '',
+        // Emit via the Runtime v2 pain chain — no .pain_flag file written
+        emitPainDetectedEvent(wctx, {
+          ts: new Date().toISOString(),
+          type: 'pain_detected',
+          data: {
+            painId: `intercept_${Date.now()}`,
+            painType: 'tool_failure' as const,
+            source: 'intercept_extraction',
+            reason: 'Hard intercept detected in session history compaction.',
+            score: 100,
+            sessionId: ctx.sessionId || 'unknown',
+            agentId: ctx.agentId,
+          },
         });
       }
     } catch (err) {
@@ -200,13 +198,14 @@ export async function handleBeforeCompaction(
   }
 
   // 提取工作记忆（从 sessionFile）
-  if (event.sessionFile) {
-    await extractPainFromSessionFile(event.sessionFile, ctx);
+  const sessionFile = (event as { sessionFile?: string }).sessionFile;
+  if (sessionFile) {
+    await extractPainFromSessionFile(sessionFile, ctx);
 
     // 新增：提取并保存工作记忆
-     
-     
-    await extractAndSaveWorkingMemory(event.sessionFile, ctx, wctx);
+
+
+    await extractAndSaveWorkingMemory(sessionFile, ctx, wctx);
   }
 }
 
@@ -296,20 +295,18 @@ async function extractAndSaveWorkingMemory(
     // 写入文件
     atomicWriteFileSync(focusPath, updatedContent);
     
-    if (ctx.logger) {
-      ctx.logger.info(`[WorkingMemory] Preserved ${snapshot.artifacts.length} artifacts, ` +
-        `${snapshot.activeProblems.length} problems, ` +
-        `${snapshot.nextActions.length} next actions to CURRENT_FOCUS.md`);
-    }
+    ctx.logger?.info?.(`[WorkingMemory] Preserved ${snapshot.artifacts.length} artifacts, ` +
+      `${snapshot.activeProblems.length} problems, ` +
+      `${snapshot.nextActions.length} next actions to CURRENT_FOCUS.md`);
   } catch (err) {
     ctx.logger?.error?.(`[PD:Lifecycle] Failed to save working memory: ${String(err)}`);
-    
+
     // 尝试恢复备份
     const backupPath = `${focusPath}.wm-backup`;
     if (fs.existsSync(backupPath)) {
       try {
         fs.copyFileSync(backupPath, focusPath);
-        if (ctx.logger) ctx.logger.warn(`[WorkingMemory] Restored from backup after failure`);
+        ctx.logger?.warn?.(`[WorkingMemory] Restored from backup after failure`);
       } catch {
         // 忽略恢复错误
       }
@@ -325,8 +322,9 @@ export async function handleAfterCompaction(
 
   const [dateStrPost] = new Date().toISOString().split('T');
   const checkpointPath = path.join(ctx.workspaceDir, PD_DIRS.MEMORY, `${dateStrPost}.md`);
+  const messageCount = (event as { messageCount?: number }).messageCount ?? 0;
   const log =
-    `- Post-Compaction Complete. Reduced active context to ${event.messageCount} messages.\n`;
+    `- Post-Compaction Complete. Reduced active context to ${messageCount} messages.\n`;
 
   try {
     fs.appendFileSync(checkpointPath, log, 'utf8');