principles-disciple 1.71.0 → 1.73.0

package/src/hooks/prompt.ts

@@ -1,4 +1,4 @@
- 
+ 
  
 import * as fs from 'fs';
 import * as path from 'path';
@@ -8,33 +8,29 @@ import { WorkspaceContext } from '../core/workspace-context.js';
 import type { ContextInjectionConfig} from '../types.js';
 import { defaultContextConfig } from '../types.js';
 import { classifyTask, type RoutingInput } from '../core/local-worker-routing.js';
+import { detectApprovalMarker, setConfirmFirstApproval, setConfirmFirstDirective, hydrateFromStore, pruneStoreStaleRows, setConfirmFirstStore, resetConfirmFirst } from '../core/confirm-first-gate.js';
 import { extractSummary, getHistoryVersions, parseWorkingMemorySection, workingMemoryToInjection, autoCompressFocus, safeReadCurrentFocus } from '../core/focus-history.js';
-import { EmpathyObserverWorkflowManager, empathyObserverWorkflowSpec, isExpectedSubagentError } from '../service/subagent-workflow/index.js';
 import { PathResolver } from '../core/path-resolver.js';
 import { selectPrinciplesForInjection, DEFAULT_PRINCIPLE_BUDGET } from '../core/principle-injection.js';
-import { isSubagentRuntimeAvailable } from '../utils/subagent-probe.js';
-import { getPendingDiagnosticianTasks } from '../core/diagnostician-task-store.js';
+import { getCachedMaskedPrincipleSet, WorkflowFunnelLoader, PiAiRuntimeAdapter, EmpathyObserver, AgentScheduler, SqliteConfirmFirstStateStore, SqliteConnection } from '@principles/core/runtime-v2';
+import { truncateInjectionToBudget } from '@principles/core/prompt-builder';
+import { PromptActivationReader, RUNTIME_V2_PRINCIPLE_BUDGET } from '../core/runtime-v2-prompt-activation-reader.js';
 import {
   matchEmpathyKeywords,
   loadKeywordStore,
   saveKeywordStore,
-  shouldTriggerOptimization,
   getKeywordStoreSummary,
 } from '../core/empathy-keyword-matcher.js';
 import { severityToPenalty, DEFAULT_EMPATHY_KEYWORD_CONFIG } from '../core/empathy-types.js';
+import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
+import { emitPainDetectedEvent, buildTrajectoryEvidence } from './pain.js';
 import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
-import { EventLogService } from '../core/event-log.js';
-import type { PluginRuntimeSubagent } from '../service/subagent-workflow/runtime-direct-driver.js';
-
-/**
- * Type assertion: OpenClaw SDK subagent -> workflow manager subagent type.
- * Both types are structurally identical but come from different import paths.
- */
-function toWorkflowSubagent(
-  subagent: NonNullable<OpenClawPluginApi['runtime']>['subagent']
-): PluginRuntimeSubagent {
-  return subagent as unknown as PluginRuntimeSubagent;
-}
+import {
+  buildAttitudeDirective,
+  detectCorrectionCue as coreDetectCorrectionCue,
+  extractMessageContent,
+  isMinimalTrigger,
+} from '@principles/core/prompt-builder';
 
 // ---------------------------------------------------------------------------
 // Static file cache — avoids re-reading rarely-changing files every message
@@ -81,6 +77,7 @@ function cachedReadFile(filePath: string): string {
 // Module-level empathy state — shared across calls to avoid per-turn I/O
 let _empathyTurnCounter = 0;
 let _empathyKeywordCache: { store: ReturnType<typeof loadKeywordStore>; lang: string } | null = null;
+let _confirmFirstHydrationCounter = 0;
 
 /**
  * Model configuration with primary model and optional fallback models
@@ -129,43 +126,7 @@ interface PromptHookApi {
 }
 
 function getTextContent(message: unknown): string {
-  if (!message || typeof message !== 'object') return '';
-  const record = message as { content?: unknown };
-  if (typeof record.content === 'string') return record.content;
-  if (Array.isArray(record.content)) {
-    return record.content
-      .filter((part: unknown) => part && typeof part === 'object' && (part as { type?: unknown }).type === 'text')
-      .map((part) => String((part as { text?: unknown }).text ?? ''))
-      .join('\n')
-      .trim();
-  }
-  return '';
-}
-
-function detectCorrectionCue(text: string): string | null {
-  const normalized = text
-    .trim()
-    .toLowerCase()
-    .replace(/[.,!?;:，。！？；：]/g, '');
-  const cues = [
-    '不是这个',
-    '不对',
-    '错了',
-    '搞错了',
-    '理解错了',
-    '你理解错了',
-    '重新来',
-    '再试一次',
-    'you are wrong',
-    'wrong file',
-    'not this',
-    'redo',
-    'try again',
-    'again',
-    'please redo',
-    'please try again',
-  ];
-  return cues.find((cue) => normalized.includes(cue)) ?? null;
+  return extractMessageContent(message);
 }
 
 /**
@@ -297,64 +258,25 @@ export function getDiagnosticianModel(api: PromptHookApi | null, logger?: Plugin
 /**
  * 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;
-    
-    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) userMessages.unshift(text.substring(0, 500));
-  }
-  
-  return userMessages;
-}
+
 
 /**
  * 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
-`;
+
+
+function ensureConfirmFirstStore(workspaceDir: string): void {
+  if (!_confirmFirstStoreInitialized) {
+    try {
+      const connection = new SqliteConnection({ workspaceDir, readonly: false });
+      setConfirmFirstStore(new SqliteConfirmFirstStateStore(connection));
+      _confirmFirstStoreInitialized = true;
+    } catch (err) {
+      console.warn(`[PD:ConfirmFirst] Failed to initialize store: ${String(err)}`);
+    }
+  }
 }
+let _confirmFirstStoreInitialized = false;
 
 export async function handleBeforePromptBuild(
   event: PluginHookBeforePromptBuildEvent,
@@ -364,23 +286,29 @@ export async function handleBeforePromptBuild(
   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`);
+    logger?.warn?.(`[PD:Prompt] workspaceDir is missing — skipping PD context injection`);
     return;
   }
 
-  // ──── DEBUG: Verify subagent availability in this context ────
-  const subagent = ctx.api?.runtime?.subagent;
-  logger?.info?.(`[PD:DEBUG:SubagentCheck] trigger=${ctx.trigger}, subagent_exists=${!!subagent}, subagent.run_exists=${!!subagent?.run}`);
-  if (subagent?.run) {
-    logger?.info?.('[PD:DEBUG:SubagentCheck] run entrypoint is callable');
-  }
-
   const wctx = WorkspaceContext.fromHookContext(ctx);
-  const { trigger, sessionId, api } = ctx;
+  const { trigger, sessionId } = ctx as { trigger: string | undefined; sessionId: string | undefined };
+  const api = ctx.api;
   if (sessionId) {
     wctx.trajectory?.recordSession?.({ sessionId });
   }
 
+  if (sessionId) {
+    ensureConfirmFirstStore(workspaceDir);
+    hydrateFromStore(sessionId);
+    _confirmFirstHydrationCounter++;
+    if (_confirmFirstHydrationCounter % 100 === 0) {
+      const pruned = pruneStoreStaleRows();
+      if (pruned > 0) {
+        logger?.info?.(`[PD:ConfirmFirst] Pruned ${pruned} stale rows from confirm_first_state`);
+      }
+    }
+  }
+
   if (sessionId && trigger === 'user' && Array.isArray(event.messages) && event.messages.length > 0) {
     const latestUserIndex = [...event.messages]
       .map((message, index) => ({ message, index }))
@@ -389,6 +317,26 @@ export async function handleBeforePromptBuild(
 
     if (latestUserIndex) {
       const userText = getTextContent(latestUserIndex.message);
+
+      // ── Confirm-first approval detection ──
+      // If user sends approval language, mark session as approved for confirm-first gate
+      if (sessionId && detectApprovalMarker(userText)) {
+        setConfirmFirstApproval(sessionId);
+        // P2: Emit approval telemetry for observability (ERR-002)
+        try {
+          wctx.eventLog.recordConfirmFirstGateApproved({
+            sessionId,
+            workspaceDir: wctx.workspaceDir,
+            toolName: '(approval)',
+            reason: 'user_approval_detected',
+            principleId: 'confirm-first',
+            nextAction: 'mutating tools now permitted',
+          });
+        } catch (logErr) {
+          logger?.warn?.(`[PD:ConfirmFirst] Failed to emit approval event: ${String(logErr)}`);
+        }
+      }
+
       // Use CorrectionCueLearner for detection — supports learned keywords, not just hardcoded list
       let correctionCue: string | null = null;
       try {
@@ -406,7 +354,7 @@ export async function handleBeforePromptBuild(
         }
       } catch (learnerErr) {
         // Fallback to hardcoded detection if learner fails — log for observability
-        correctionCue = detectCorrectionCue(userText);
+        correctionCue = coreDetectCorrectionCue(userText);
         logger?.warn?.(`[PD:Prompt] CorrectionCueLearner.match() failed (${String(learnerErr)}), fallback=${correctionCue ? `matched="${correctionCue}"` : 'no-match'}`);
       }
       let referencesAssistantTurnId: number | null = null;
@@ -432,10 +380,10 @@ export async function handleBeforePromptBuild(
   }
 
   // Load context injection configuration
-  const contextConfig = loadContextInjectionConfig(workspaceDir);
+  const contextConfig = loadContextInjectionConfig(wctx.workspaceDir);
 
   // Minimal mode: heartbeat and subagents skip most context to reduce tokens
-  const isMinimalMode = trigger === "heartbeat" || trigger === "cron" || sessionId?.includes(":subagent:") === true;
+  const isMinimalMode = isMinimalTrigger(trigger as string | undefined, sessionId as string | undefined);
 
   const session = sessionId ? getSession(sessionId) : undefined;
 
@@ -449,6 +397,8 @@ export async function handleBeforePromptBuild(
   let prependSystemContext: string;
   let prependContext = '';
   let appendSystemContext = '';
+  // Tracks pending diagnostician task count for diagnostician-priority mode in size guard
+  let pendingDiagTaskCount = 0;
 
   // ──── 0. Manual Pain Clearance ────
   if (trigger === 'user' && sessionId && session && session.currentGfi >= 100) {
@@ -533,7 +483,9 @@ The empathy observer subagent handles pain detection independently.
 
   const isUserInteraction = trigger === 'user' || trigger === 'api' || !trigger;
 
+  // Empathy Observer: keyword fast-path + optional LLM deep analysis (zero latency async dispatch)
   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}`);
 
   // Track if we should inject behavioral constraints (will be added to appendSystemContext later)
@@ -562,23 +514,6 @@ The empathy observer subagent handles pain detection independently.
         _empathyTurnCounter++;
         const turnCount = _empathyTurnCounter;
 
-        // Decision: should we call subagent?
-        let shouldCallSubagent = false;
-        let samplingReason = '';
-
-        if (matchResult.score >= 0.8) {
-          // High confidence — keyword match is reliable, no subagent needed
-          shouldCallSubagent = false;
-        } else if (matchResult.score >= 0.3) {
-          // Boundary case — 30% sampling for subagent verification
-          shouldCallSubagent = Math.random() < 0.3;
-          samplingReason = 'boundary_verification';
-        } else {
-          // No keyword hit — 5% random sampling to discover new expressions
-          shouldCallSubagent = Math.random() < 0.05;
-          samplingReason = 'random_discovery';
-        }
-
         if (matchResult.matched) {
           const penalty = severityToPenalty(matchResult.severity, DEFAULT_EMPATHY_KEYWORD_CONFIG);
           // trackFriction signature: (sessionId, deltaF: number, hash: string, workspaceDir?, options?)
@@ -586,93 +521,194 @@ 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(' + (matchResult.score >= 0.3 ? 'boundary_sampling' : 'random_discovery') + ')'}`);
-        } else {
-          // Log unmatched messages periodically for coverage analysis
-          if (turnCount > 0 && turnCount % 50 === 0) {
-            const sampleMsg = latestUserMessage.substring(0, 80).replace(/\n/g, ' ');
-            logger?.debug?.(`[PD:Empathy] NO_MATCH: "${sampleMsg}" (turn ${turnCount}, keywords_in_store=${Object.keys(keywordStore.terms).length})`);
-          }
-        }
-
-        // Trigger subagent for sampling cases (Finding #1: use shared manager to avoid leaks)
-        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.
-          // Create a fresh manager per invocation to ensure clean state.
-          const empathyManager = new EmpathyObserverWorkflowManager({
-            workspaceDir,
-            logger: api.logger ?? console,
-             
-            subagent: toWorkflowSubagent(runtimeSubagent),
-          });
-          empathyManager.startWorkflow(empathyObserverWorkflowSpec, {
-            parentSessionId: sessionId,
-            workspaceDir,
-            taskInput: latestUserMessage,
-          }).catch((err) => {
-            if (!isExpectedSubagentError(err)) {
-              api.logger?.warn?.(`[PD:Empathy] subagent sample failed: ${String(err)}`);
-            }
-          });
-        }
+          logger?.info?.(`[PD:Empathy] MATCH: "${matchResult.matchedTerms.join(', ')}" → severity=${matchResult.severity}, score=${matchResult.score.toFixed(2)}, penalty=${penalty}`);
+
+          const currentSession = getSession(sessionId);
+          const currentGfi = currentSession?.currentGfi ?? 0;
+          const painTrigger = wctx.config.get('thresholds.pain_trigger') || 40;
+          const highGfiThreshold = Math.max(wctx.config.get('severity_thresholds.high') || 70, painTrigger + 30);
+
+          if (currentGfi >= highGfiThreshold) {
+            const gfiPainScore = Math.min(Math.round(currentGfi), 60);
+            logger?.info?.(`[PD:Empathy] GFI-TRIGGERED: currentGfi=${currentGfi.toFixed(1)} >= highGfi=${highGfiThreshold}, emitting pain signal (score=${gfiPainScore})`);
+
+            const gate = evaluatePainDiagnosticGate({
+              source: 'user_empathy',
+              score: gfiPainScore,
+              currentGfi,
+              consecutiveErrors: currentSession?.consecutiveErrors ?? 0,
+              sessionId,
+              errorHash: 'empathy_gfi_threshold',
+              thresholds: {
+                painTrigger,
+                highSeverity: wctx.config.get('severity_thresholds.high') || 70,
+                semanticPain: Math.max(painTrigger, 60),
+              },
+            });
 
-        // Helper: build summary string (Finding #2: avoid duplication)
-        const buildSummary = (): string => {
-          const s = getKeywordStoreSummary(keywordStore);
-          const highFP = s.highFalsePositiveTerms.slice(0, 5).map(t => `${t.term}(${t.falsePositiveRate.toFixed(2)})`).join(', ');
-          return `SUMMARY(turn=${turnCount}): terms=${s.totalTerms}, hits=${keywordStore.stats.totalHits}, zero_hit=${s.totalTerms - (s.seedTerms + s.discoveredTerms)}, high_fp=[${highFP}]`;
-        };
+            wctx.eventLog.recordPainSignal(sessionId, {
+              score: gfiPainScore,
+              source: 'user_empathy',
+              reason: `Accumulated GFI (${currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Matched: ${matchResult.matchedTerms.join(', ')}`,
+              isRisky: false,
+            });
 
-        // Check if keyword optimization should be triggered
-        if (shouldTriggerOptimization(keywordStore, turnCount)) {
-          logger?.info?.(`[PD:Empathy] OPTIMIZATION_TRIGGER: turns=${turnCount}, last_optimized=${keywordStore.lastOptimizedAt}`);
-          logger?.info?.(`[PD:Empathy] STATS: ${buildSummary()}`);
+            if (gate.shouldDiagnose) {
+              logger?.info?.(`[PD:Empathy] Gate approved, calling emitPainDetectedEvent...`);
+              try {
+                const evidence = buildTrajectoryEvidence(wctx, sessionId);
+                await emitPainDetectedEvent(wctx, {
+                  ts: new Date().toISOString(),
+                  type: 'pain_detected',
+                  data: {
+                    painId: `empathy_gfi_${Date.now()}`,
+                    painType: 'user_frustration',
+                    source: 'user_empathy',
+                    reason: `Accumulated GFI (${currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Matched: ${matchResult.matchedTerms.join(', ')}`,
+                    score: gfiPainScore,
+                    sessionId,
+                    agentId: 'main',
+                    provenance: 'openclaw_context_bound',
+                    evidence,
+                  },
+                });
+                logger?.info?.(`[PD:Empathy] emitPainDetectedEvent completed (GFI-triggered)`);
+              } catch (emitErr) {
+                console.error(`[PD:Empathy] FAILED to emit GFI-triggered pain event: ${String(emitErr)}`);
+                logger?.warn?.(`[PD:Empathy] Failed to emit GFI-triggered pain event: ${String(emitErr)}`);
+              }
+            } else {
+              logger?.info?.(`[PD:Empathy] GFI-triggered gate rejected: ${gate.detail}`);
+            }
+          }
 
-          // 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,
-               
-              subagent: toWorkflowSubagent(api.runtime.subagent),
+          // Trigger asynchronous background Empathy Observer deep analysis (Zero Latency)
+          const observer = resolveEmpathyObserver(wctx, logger);
+          if (observer) {
+            const scheduler = new AgentScheduler();
+            scheduler.register({
+              agentId: 'empathy-observer',
+              mode: 'realtime',
+              runner: observer,
             });
+
+            logger?.info?.(`[PD:Empathy] Triggering background Empathy Observer deep analysis for message: "${msgPreview}"`);
             
-            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)}`);
-            }
+            void scheduler.dispatch('empathy-observer', { userMessage: latestUserMessage })
+              .then(async (result) => {
+                if (result.damageDetected) {
+                  logger?.info?.(`[PD:Empathy] Background Empathy Observer detected damage. Severity: ${result.severity}, Reason: ${result.reason}`);
+
+                  // ── Persistence Contract ──
+                  const painScore = scoreFromSeverityForSpec(result.severity, wctx);
+                  
+                  trackFriction(
+                    sessionId,
+                    painScore,
+                    `observer_empathy_${result.severity}`,
+                    workspaceDir,
+                    { source: 'user_empathy' }
+                  );
+
+                  const eventId = `emp_obs_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+                  wctx.eventLog.recordPainSignal(sessionId, {
+                    score: painScore,
+                    source: 'user_empathy',
+                    reason: result.reason || 'Empathy observer detected likely user frustration.',
+                    isRisky: false,
+                    origin: 'system_infer',
+                    severity: result.severity,
+                    confidence: result.confidence,
+                    detection_mode: 'structured',
+                    deduped: false,
+                    trigger_text_excerpt: latestUserMessage.substring(0, 120),
+                    raw_score: painScore,
+                    calibrated_score: painScore,
+                    eventId,
+                  });
+
+                  try {
+                    wctx.trajectory?.recordPainEvent?.({
+                      sessionId,
+                      source: 'user_empathy',
+                      score: painScore,
+                      reason: result.reason || 'Empathy observer detected likely user frustration.',
+                      severity: result.severity,
+                      origin: 'system_infer',
+                      confidence: result.confidence,
+                      text: latestUserMessage,
+                    });
+                  } catch (error) {
+                    logger?.warn?.(`[PD:Empathy] Failed to persist trajectory: ${String(error)}`);
+                  }
+
+                  // Check if GFI triggers a pain event post-LLM validation
+                  const freshSession = getSession(sessionId);
+                  const freshGfi = freshSession?.currentGfi ?? 0;
+                  if (freshGfi >= highGfiThreshold) {
+                    const freshGfiPainScore = Math.min(Math.round(freshGfi), 60);
+                    const gate = evaluatePainDiagnosticGate({
+                      source: 'user_empathy',
+                      score: freshGfiPainScore,
+                      currentGfi: freshGfi,
+                      consecutiveErrors: freshSession?.consecutiveErrors ?? 0,
+                      sessionId,
+                      errorHash: 'empathy_gfi_threshold',
+                      thresholds: {
+                        painTrigger,
+                        highSeverity: wctx.config.get('severity_thresholds.high') || 70,
+                        semanticPain: Math.max(painTrigger, 60),
+                      },
+                    });
+
+                    if (gate.shouldDiagnose) {
+                      logger?.info?.(`[PD:Empathy] GFI threshold crossed after background observer. Emitting pain signal...`);
+                      try {
+                        const evidence = buildTrajectoryEvidence(wctx, sessionId);
+                        await emitPainDetectedEvent(wctx, {
+                          ts: new Date().toISOString(),
+                          type: 'pain_detected',
+                          data: {
+                            painId: `empathy_gfi_${Date.now()}`,
+                            painType: 'user_frustration',
+                            source: 'user_empathy',
+                            reason: `Accumulated GFI (${freshGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Verified by Empathy Observer.`,
+                            score: freshGfiPainScore,
+                            sessionId,
+                            agentId: 'main',
+                            provenance: 'openclaw_context_bound',
+                            evidence,
+                          },
+                        });
+                      } catch (emitErr) {
+                        logger?.error?.(`[PD:Empathy] FAILED to emit observer-triggered pain event: ${String(emitErr)}`);
+                      }
+                    }
+                  }
+                } else {
+                  logger?.info?.(`[PD:Empathy] Background Empathy Observer did not detect any damage.`);
+                }
+              })
+              .catch((err) => {
+                logger?.warn?.(`[PD:Empathy] Background analysis failed or rejected: ${String(err)}`);
+              });
+          }
+        } else {
+          // Log unmatched messages periodically for coverage analysis
+          if (turnCount > 0 && turnCount % 50 === 0) {
+            const sampleMsg = latestUserMessage.substring(0, 80).replace(/\n/g, ' ');
+            logger?.debug?.(`[PD:Empathy] NO_MATCH: "${sampleMsg}" (turn ${turnCount}, keywords_in_store=${Object.keys(keywordStore.terms).length})`);
           }
         }
 
         // Periodic summary (every 100 turns)
         if (turnCount > 0 && turnCount % 100 === 0) {
-          logger?.info?.(`[PD:Empathy] ${buildSummary()}`);
+          const s = getKeywordStoreSummary(keywordStore);
+          const highFP = s.highFalsePositiveTerms.slice(0, 5).map(t => `${t.term}(${t.falsePositiveRate.toFixed(2)})`).join(', ');
+          logger?.info?.(`[PD:Empathy] SUMMARY(turn=${turnCount}): terms=${s.totalTerms}, hits=${keywordStore.stats.totalHits}, zero_hit=${s.totalTerms - (s.seedTerms + s.discoveredTerms)}, high_fp=[${highFP}]`);
         }
 
-        // 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.
+        // Save keyword store on every match
         if (matchResult.matched) {
           saveKeywordStore(wctx.stateDir, keywordStore);
           const {totalHits} = keywordStore.stats;
@@ -683,21 +719,6 @@ The empathy observer subagent handles pain detection independently.
       }
     }
 
-    // Empathy Observer: analyze user message for frustration signals (legacy, disabled)
-    // The keyword matching approach above is now the primary empathy detection method.
-    // The subagent-based observer is kept for periodic keyword optimization only.
-    // if (workspaceDir) {
-    //   const empathyManager = new EmpathyObserverWorkflowManager({
-    //     workspaceDir,
-    //     logger: api.logger,
-    //     subagent: api.runtime.subagent as any,
-    //   });
-    //   empathyManager.startWorkflow(empathyObserverWorkflowSpec, {
-    //     parentSessionId: sessionId,
-    //     workspaceDir,
-    //     taskInput: latestUserMessage,
-    //   }).catch((err) => api.logger.warn(`[PD:Empathy] workflow failed: ${String(err)}`));
-    // }
   }
 
   // ──── 4. Heartbeat-specific checklist (also fires for cron-triggered sessions) ────
@@ -720,95 +741,18 @@ The empathy observer subagent handles pain detection independently.
         const heartbeatChecklist = fs.readFileSync(heartbeatPath, 'utf8');
         prependContext += `<heartbeat_checklist>
 ${heartbeatChecklist}
-
-// HEARTBEAT_OK removed - tasks must always be processed
 </heartbeat_checklist>\n`;
       } catch (e) {
         logger?.error(`[PD:Prompt] Failed to read HEARTBEAT: ${String(e)}`);
       }
     }
 
-    // ──── 4b. Inject pending diagnostician tasks ────
-    // FIX (#283): The evolution worker writes pain diagnosis tasks to
-    // diagnostician_tasks.json. The heartbeat prompt hook must read and inject
-    // them so the LLM (acting as diagnostician) can process them.
-    try {
-      const pendingTasks = getPendingDiagnosticianTasks(wctx.stateDir);
-      if (pendingTasks.length > 0) {
-        const taskBlocks = pendingTasks
-          .slice(0, 3)
-          .map(({ id, task }) => `<diagnostician_task id="${id}">\n${task.prompt}\n</diagnostician_task>`)
-          .join('\n\n');
-
-        const pendingCount = pendingTasks.length;
-        const processingNote = pendingCount > 3
-          ? `\n\nNOTE: ${pendingCount - 3} more tasks are queued. Process these 3 first; remaining tasks will be handled on subsequent heartbeats.`
-          : '';
-
-        prependContext += `<diagnostician_tasks pending="${pendingCount}">
-You are acting as a **Pain Diagnostician**. Process the following task(s) by:
-1. Analyzing the pain signal and its context
-2. Identifying the root cause and violated principles
-3. Writing a completion marker file: .evolution_complete_<TASK_ID>
-4. Writing a diagnostic report: .diagnostician_report_<TASK_ID>.json
-
-${taskBlocks}${processingNote}
-</diagnostician_tasks>\n`;
-
-        logger?.info?.(`[PD:Prompt] Injected ${Math.min(pendingCount, 3)}/${pendingCount} pending diagnostician task(s) into heartbeat prompt`);
-
-        // C: Record heartbeat_diagnosis event for observability
-        try {
-          const eventLog = EventLogService.get(wctx.stateDir, logger);
-          eventLog.recordHeartbeatDiagnosis({
-            taskCount: pendingCount,
-            taskIds: pendingTasks.slice(0, 3).map(t => t.id),
-            trigger: 'heartbeat',
-          });
-        } catch (evErr) {
-          logger?.warn?.(`[PD:Prompt] Failed to record heartbeat_diagnosis event: ${String(evErr)}`);
-        }
-      }
-    } catch (e) {
-      logger?.warn?.(`[PD:Prompt] Failed to read diagnostician tasks: ${String(e)}`);
-    }
   }
 
   // ──── 6. Dynamic Attitude Matrix (based on GFI) ────
-   
-   
-  let attitudeDirective: string;
+
   const currentGfi = session?.currentGfi || 0;
-  
-  if (currentGfi >= 70) {
-    attitudeDirective = `
-### 【SYSTEM_MODE: HUMBLE_RECOVERY】
-**CURRENT STATUS**: Severe system friction / User frustration detected (GFI: ${currentGfi.toFixed(0)}).
-**BEHAVIORAL OVERRIDE**:
-- You have failed to meet expectations. Humility is your primary directive.
-- **STOP** aggressive file modifications.
-- **START** every response with a sincere, non-defensive apology.
-- **ACTION**: Explain why you failed, and propose a highly cautious recovery plan.
-`;
-  } else if (currentGfi >= 40) {
-    attitudeDirective = `
-### 【SYSTEM_MODE: CONCILIATORY】
-**CURRENT STATUS**: Moderate friction detected (GFI: ${currentGfi.toFixed(0)}).
-**BEHAVIORAL OVERRIDE**:
-- User is frustrated. Be more explanatory and cautious.
-- Before executing any tool, clearly state what you intend to do and **WAIT** for implicit or explicit user consent.
-- Avoid technical jargon; focus on the business/project value of your changes.
-`;
-  } else {
-    attitudeDirective = `
-### 【SYSTEM_MODE: EFFICIENT】
-**CURRENT STATUS**: System healthy (GFI: ${currentGfi.toFixed(0)}).
-**BEHAVIORAL OVERRIDE**:
-- Maintain peak efficiency.
-- Be concise. Prefer action over long explanations.
-- Follow the "Principles > Directives" rule strictly.
-`;
-  }
+  const attitudeDirective = buildAttitudeDirective(currentGfi);
 
   // ──── 7. appendSystemContext: Principles + Thinking OS + reflection_log + project_context ────
   // NOTE: Principles is ALWAYS injected (not configurable)
@@ -884,7 +828,7 @@ ${taskBlocks}${processingNote}
             projectContextContent = extractSummary(finalContent, 30);
           } else {
             // Full mode: current version + recent history (3 versions)
-            const historyVersions = getHistoryVersions(focusPath, 3);
+            const historyVersions = await getHistoryVersions(focusPath, 3);
             if (historyVersions.length > 0) {
               const historySections = historyVersions.map((v, i) =>
                 `\n---\n\n**历史版本 v${historyVersions.length - i}**\n\n${v}`
@@ -909,13 +853,33 @@ ${taskBlocks}${processingNote}
     const allActive = reducer.getActivePrinciples();
     const allProbation = reducer.getProbationPrinciples();
 
+    // Pruning mask: exclude principles whose latest review is archive-candidate
+    let maskedIds = new Set<string>();
+    try {
+      maskedIds = getCachedMaskedPrincipleSet(wctx.workspaceDir);
+    } catch (err) {
+      // Safe degradation: if review log unreadable, inject all principles
+      const msg = err instanceof Error ? err.message : String(err);
+      if (logger?.info) {
+        logger.info(`[PD:Pruning] Failed to read review log — all principles injected: ${msg}`);
+      } else {
+        console.error(`[PD:Pruning] Failed to read review log — all principles injected: ${msg}`);
+      }
+    }
+
     // Budget-aware selection: prioritize P0>P1>P2 and recency
-    const activeSelection = selectPrinciplesForInjection(allActive, DEFAULT_PRINCIPLE_BUDGET);
+    const activeSelection = selectPrinciplesForInjection(
+      allActive.filter(p => !maskedIds.has(p.id)),
+      DEFAULT_PRINCIPLE_BUDGET,
+    );
     const active = activeSelection.selected;
 
     // Probation principles get a smaller sub-budget (1000 chars)
     const probationBudget = 1000;
-    const probationSelection = selectPrinciplesForInjection(allProbation, probationBudget);
+    const probationSelection = selectPrinciplesForInjection(
+      allProbation.filter(p => !maskedIds.has(p.id)),
+      probationBudget,
+    );
     const probation = probationSelection.selected;
 
     if (activeSelection.wasTruncated || probationSelection.wasTruncated) {
@@ -952,13 +916,105 @@ ${taskBlocks}${processingNote}
     logger?.warn?.(`[PD:Prompt] Failed to load evolution principles: ${String(e)}`);
   }
 
+  let runtimeV2PrinciplesContent = '';
+  const runtimeV2PrincipleIds = new Set<string>();
+  // Hoisted so the owner_approved_behavior_directives section can access them
+  let dedupedV2: Array<{ principleId: string; text: string; artifactId: string; activationId: string }> = [];
+  try {
+    const reader = new PromptActivationReader(wctx.workspaceDir, { logger });
+    const v2Result = await reader.readActivatedPrinciples();
+
+    if (v2Result.warnings.length > 0) {
+      logger?.info?.(`[PD:RuntimeV2] Activation read warnings: ${v2Result.warnings.join('; ')}`);
+    }
+
+    const legacyActiveIds = new Set<string>();
+    try {
+      const legacyActive = wctx.evolutionReducer.getActivePrinciples();
+      for (const p of legacyActive) {
+        legacyActiveIds.add(p.id);
+      }
+      const legacyProbation = wctx.evolutionReducer.getProbationPrinciples();
+      for (const p of legacyProbation) {
+        legacyActiveIds.add(p.id);
+      }
+    } catch {
+      // best-effort dedup
+    }
+
+    dedupedV2 = v2Result.principles.filter((p) => !legacyActiveIds.has(p.principleId));
+
+    if (dedupedV2.length > 0) {
+      let remaining = RUNTIME_V2_PRINCIPLE_BUDGET;
+      const lines: string[] = [];
+      lines.push('Runtime V2 activated principles (owner-approved):');
+      remaining -= 'Runtime V2 activated principles (owner-approved):'.length;
+
+      for (const p of dedupedV2) {
+        const entry = `- [${escapeXml(p.principleId)}] ${escapeXml(p.text)}`;
+        if (remaining < entry.length + 1) {
+          logger?.info?.(`[PD:RuntimeV2] Principle budget reached (${RUNTIME_V2_PRINCIPLE_BUDGET}c) — truncating after ${lines.length - 1} principles`);
+          break;
+        }
+        lines.push(entry);
+        remaining -= entry.length + 1;
+        runtimeV2PrincipleIds.add(p.principleId);
+      }
+      runtimeV2PrinciplesContent = lines.join('\n');
+    }
+
+    // ── Emit structured observability event ──
+    try {
+      const eventLog = wctx.eventLog;
+      eventLog.recordRuntimeV2ActivationsInjected({
+        sessionId: sessionId ?? 'unknown',
+        workspaceDir: wctx.workspaceDir,
+        principleIds: [...runtimeV2PrincipleIds],
+        activationIds: dedupedV2.map((p) => p.activationId),
+        artifactIds: dedupedV2.map((p) => p.artifactId),
+        injectedCount: runtimeV2PrincipleIds.size,
+        skippedWarnings: v2Result.warnings,
+        injectedCharCount: runtimeV2PrinciplesContent.length,
+        budget: RUNTIME_V2_PRINCIPLE_BUDGET,
+        ...(runtimeV2PrincipleIds.size === 0
+          ? {
+              skipReason: v2Result.principles.length === 0
+                ? 'no_validated_activations'
+                : 'all_deduped_against_legacy',
+              nextAction: v2Result.principles.length === 0
+                ? 'check activations table for prompt channel rows with validated artifacts'
+                : 'legacy evolution reducer already contains these principle IDs',
+            }
+          : {}),
+      });
+    } catch (logErr) {
+      logger?.warn?.(`[PD:RuntimeV2] Failed to emit activation observability event: ${String(logErr)}`);
+    }
+
+    // ── Set confirm-first directive state for gate enforcement ──
+    if (sessionId) {
+      const cfPrinciple = dedupedV2.find(
+        (p) =>
+          p.principleId === 'princ-mvp-acceptance-confirm-first' ||
+          (p.text.toLowerCase().includes('confirm requirements') &&
+           p.text.toLowerCase().includes('owner approval')),
+      );
+      setConfirmFirstDirective(sessionId, !!cfPrinciple, cfPrinciple?.principleId);
+    }
+  } catch (e) {
+    logger?.warn?.(`[PD:RuntimeV2] Failed to read Runtime V2 prompt activations: ${String(e)}`);
+    if (sessionId) {
+      resetConfirmFirst(sessionId);
+    }
+  }
+
   // Build appendSystemContext with recency effect
   // Content order (most important last): behavioral_constraints -> project_context -> working_memory -> reflection_log -> thinking_os -> principles
   const appendParts: string[] = [];
 
   // 0. Behavioral Constraints (empathy observer coordination)
   // Injected here (appendSystemContext) instead of prependContext to hide from WebUI users.
-  // See: https://github.com/csuzngjh/principles/issues/XXX
+  // Behavioral constraints: empathy observer coordination
   if (shouldInjectBehavioralConstraints) {
     appendParts.push(`<behavioral_constraints>
 ${empathySilenceConstraint}
@@ -980,11 +1036,35 @@ ${empathySilenceConstraint}
     appendParts.push(`<thinking_os>\n${thinkingOsContent}\n</thinking_os>`);
   }
 
-  // 3. Evolution Loop principles (active/probation)
+  // 3. Evolution Loop principles (legacy active/probation only — Runtime V2 moved to section 3.5)
   if (evolutionPrinciplesContent) {
     appendParts.push(`<evolution_principles>\n${evolutionPrinciplesContent}\n</evolution_principles>`);
   }
 
+  // 3.5. Owner-Approved Behavior Directives (Runtime V2 activated principles)
+  // PLACED IN prependSystemContext (before gateway system prompt) for highest LLM attention.
+  // These are owner-reviewed, validated behavior constraints — not background context.
+  if (runtimeV2PrincipleIds.size > 0) {
+    const directiveLines: string[] = [];
+    directiveLines.push('');
+    directiveLines.push('## 【OWNER-APPROVED BEHAVIOR DIRECTIVES】');
+    directiveLines.push('');
+    directiveLines.push('Owner-approved behavior directives are active operating constraints learned from prior owner corrections.');
+    directiveLines.push('These directives are mandatory for this session unless they conflict with safety, security, or higher-priority system policy.');
+    directiveLines.push('For ambiguous coding or file-changing tasks, follow these directives before using mutating tools.');
+    directiveLines.push('');
+    for (const p of dedupedV2) {
+      if (!runtimeV2PrincipleIds.has(p.principleId)) continue;
+      directiveLines.push(`<directive id="${escapeXml(p.principleId)}" source="runtime_v2_activation">`);
+      directiveLines.push(`MANDATORY: ${escapeXml(p.text)}`);
+      directiveLines.push('Apply this as an active behavior constraint. Do not treat this as background context.');
+      directiveLines.push('</directive>');
+      directiveLines.push('');
+    }
+    directiveLines.push('Note: These directives do not override safety, security, or core system policy.');
+    prependSystemContext += directiveLines.join('\n');
+  }
+
   // Routing Guidance (section 5 — injected between evolution principles and core principles)
   // Inject delegation guidance when task is bounded + deployment allowed + not high-entropy.
   // This is a non-authoritative suggestion — the main agent decides whether to follow.
@@ -1013,7 +1093,6 @@ ${empathySilenceConstraint}
         const routingInput: RoutingInput = {
           taskIntent: toolMatches[0] ?? undefined,
           taskDescription: latestUserText.trim(),
-          requestedTools: toolMatches.length > 0 ? toolMatches : undefined,
           requestedFiles: fileMatches.length > 0 ? fileMatches : undefined,
         };
 
@@ -1124,36 +1203,36 @@ ${attitudeDirective}
   }
 
   // ──── 8. SIZE GUARD ────
-  // Truncation happens within appendSystemContext (not prependContext)
-  const totalSize = prependSystemContext.length + prependContext.length + appendSystemContext.length;
-  const MAX_SIZE = 10000;
-
-  if (totalSize > MAX_SIZE) {
-    const originalSize = totalSize;
-    const truncationLog: string[] = [];
-
-    // 1. Truncate project_context in appendSystemContext
-    if (projectContextContent && appendSystemContext.includes('<project_context>')) {
-      const lines = projectContextContent.split('\n');
-      if (lines.length > 20) {
-        const truncated = lines.slice(0, 20).join('\n') + '\n...[truncated]';
-        appendSystemContext = appendSystemContext.replace(
-          `<project_context>\n${projectContextContent}\n</project_context>`,
-          `<project_context>\n${truncated}\n</project_context>`
-        );
-        truncationLog.push('project_context');
-      }
+  // Delegates to @principles/core/prompt-builder/truncateInjectionToBudget
+  // which handles priority stripping: project_context → thinking_os →
+  // evolution_principles → reflection_log → reason: truncation → fallback.
+  const result = truncateInjectionToBudget(
+    prependSystemContext,
+    prependContext,
+    appendSystemContext,
+    {
+      diagnosticianMode: pendingDiagTaskCount > 0,
+      blocks: { projectContextContent, thinkingOsContent, evolutionPrinciplesContent },
     }
-
-    // 2. Final check
-    let newSize = prependSystemContext.length + prependContext.length + appendSystemContext.length;
-    if (newSize > MAX_SIZE) {
-      // NOTE: We still return the content even if over limit, as truncating more
-      // could lose critical context like principles or evolution directives.
-      logger?.error(`[PD:Prompt] Cannot reduce injection size below limit. Current: ${newSize}, Limit: ${MAX_SIZE}`);
+  );
+
+  prependSystemContext = result.prependSystemContext;
+  prependContext = result.prependContext;
+  appendSystemContext = result.appendSystemContext;
+
+  if (result.truncated) {
+    const logEntry = result.truncationLog.join(', ');
+    if (result.appendSystemContext.includes('[WARNING: Context sections stripped')) {
+      logger?.error(
+        `[PD:Prompt] PROMPT OVER LIMIT AFTER ALL REDUCTIONS — using fallback. ` +
+        `Diagnostician mode: ${pendingDiagTaskCount > 0}. Stripped: ${logEntry}.`
+      );
+    } else {
+      logger?.warn(
+        `[PD:Prompt] Injection size exceeded budget, truncated: ${logEntry || 'none'}, ` +
+        `diagnostician mode: ${pendingDiagTaskCount > 0}`
+      );
     }
-
-    logger?.warn(`[PD:Prompt] Injection size exceeded: ${originalSize} chars (limit: ${MAX_SIZE}), truncated: ${truncationLog.join(', ') || 'none'}, new size: ${newSize} chars`);
   }
 
   return {
@@ -1162,3 +1241,54 @@ ${attitudeDirective}
     appendSystemContext
   };
 }
+
+// ── Empathy Observer Hybrid Deep Analysis Helpers (Unified SDK Migration) ──
+
+function scoreFromSeverityForSpec(severity: string | undefined, wctx: WorkspaceContext): number {
+  if (severity === 'severe') return Number(wctx.config.get('empathy_engine.penalties.severe') ?? 40);
+  if (severity === 'moderate') return Number(wctx.config.get('empathy_engine.penalties.moderate') ?? 25);
+  return Number(wctx.config.get('empathy_engine.penalties.mild') ?? 10);
+}
+
+function resolveEmpathyObserver(wctx: WorkspaceContext, logger?: Pick<PluginLogger, 'info' | 'warn' | 'error' | 'debug'>): EmpathyObserver | null {
+  try {
+    const loader = new WorkflowFunnelLoader(wctx.stateDir);
+    const funnel = loader.getFunnel('pd-empathy-observer');
+    const policy = funnel?.policy;
+    if (!policy || policy.runtimeKind !== 'pi-ai') {
+      logger?.debug?.('[PD:Empathy] workflows.yaml pd-empathy-observer policy not found. Falling back to environment variables.');
+      const provider = process.env.PD_EMPATHY_PROVIDER || 'anthropic';
+      const model = process.env.PD_EMPATHY_MODEL || 'anthropic/claude-3-5-sonnet';
+      const apiKeyEnv = process.env.PD_EMPATHY_API_KEY_ENV || 'ANTHROPIC_API_KEY';
+      const baseUrl = process.env.PD_EMPATHY_BASE_URL;
+
+      if (!process.env[apiKeyEnv]) {
+        logger?.debug?.(`[PD:Empathy] Empathy observer API key env ${apiKeyEnv} is not set. Background analysis disabled.`);
+        return null;
+      }
+
+      const adapter = new PiAiRuntimeAdapter({
+        provider,
+        model,
+        apiKeyEnv,
+        baseUrl,
+        workspace: wctx.workspaceDir,
+      });
+      return new EmpathyObserver({ runtimeAdapter: adapter });
+    }
+
+    const adapter = new PiAiRuntimeAdapter({
+      provider: String(policy.provider),
+      model: String(policy.model),
+      apiKeyEnv: String(policy.apiKeyEnv),
+      maxRetries: policy.maxRetries,
+      timeoutMs: policy.timeoutMs ?? 30_000,
+      baseUrl: policy.baseUrl,
+      workspace: wctx.workspaceDir,
+    });
+    return new EmpathyObserver({ runtimeAdapter: adapter }, { timeoutMs: policy.timeoutMs });
+  } catch (err) {
+    logger?.warn?.(`[PD:Empathy] Failed to resolve EmpathyObserver: ${String(err)}`);
+    return null;
+  }
+}