create-principles-disciple 1.93.0 → 1.95.0

package/plugin/dist/hooks/prompt.js

@@ -11,18 +11,49 @@ import { selectPrinciplesForInjection, DEFAULT_PRINCIPLE_BUDGET } from '../core/
 import { getCachedMaskedPrincipleSet, WorkflowFunnelLoader, PiAiRuntimeAdapter, EmpathyObserver, AgentScheduler, RUNTIME_V2_PRINCIPLE_BUDGET, trimToBudget, renderPrinciplesToDirectives } from '@principles/core/runtime-v2';
 import { truncateInjectionToBudget } from '@principles/core/prompt-builder';
 import { PromptActivationReader } from '../core/runtime-v2-prompt-activation-reader.js';
-import { matchEmpathyKeywords, loadKeywordStore, saveKeywordStore, getKeywordStoreSummary, } from '../core/empathy-keyword-matcher.js';
+import { matchEmpathyKeywords, loadKeywordStore, saveKeywordStore, applyKeywordUpdates, 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 { evaluateTriggerController } from '@principles/core/runtime-v2';
+import { isSharedCooldownActive, markSharedEpisodeAsDiagnosed } from './trigger-cooldown-tracker.js';
+import { buildEmpathyObservation, resolveSourceKind } from './raw-observation-adapter.js';
+import { evaluateEvidenceTriage } from './triage-adapter.js';
+import { loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
+import { safeReadIntentDoc, resetIntentDocCacheForTest } from '../core/intent-doc-reader.js';
+import { buildIntentFrictionBlock } from '@principles/core/runtime-v2';
 import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
-import { detectCorrectionCue as coreDetectCorrectionCue, extractMessageContent, isMinimalTrigger, } from '@principles/core/prompt-builder';
+import { detectCorrectionCue as coreDetectCorrectionCue, escapeXml, extractMessageContent, isMinimalTrigger, } from '@principles/core/prompt-builder';
 import { sanitizeForEvidence } from './message-sanitize.js';
+import { buildAgentIdentity, buildEmpathySilenceConstraint, extractUserMessageFromPrompt, assembleHeartbeatChecklist, formatCorePrinciples, formatEvolutionPrinciples, assembleAppendSystemContext, extractPhrasesFromReason, } from './prompt-helpers.js';
 // ---------------------------------------------------------------------------
 // Static file cache — avoids re-reading rarely-changing files every message
 // ---------------------------------------------------------------------------
 const STATIC_FILE_TTL_MS = 60_000; // 1 minute
+/**
+ * Per-workspace file cache. Keyed by workspaceDir to avoid cross-workspace
+ * cache pollution. Previously a module-level Map keyed by filePath only.
+ */
 const _staticFileCache = new Map();
+function getOwnValue(value, key) {
+    if (!Object.hasOwn(value, key))
+        return undefined;
+    return Object.getOwnPropertyDescriptor(value, key)?.value;
+}
+function readErrorCode(error) {
+    if (typeof error !== 'object' || error === null)
+        return undefined;
+    const code = getOwnValue(error, 'code');
+    return typeof code === 'string' ? code : undefined;
+}
+function getFileCache(workspaceDir) {
+    let cache = _staticFileCache.get(workspaceDir);
+    if (!cache) {
+        cache = new Map();
+        _staticFileCache.set(workspaceDir, cache);
+    }
+    return cache;
+}
 /**
  * Reads a file with TTL-based caching.
  * Returns cached content if:
@@ -30,9 +61,10 @@ const _staticFileCache = new Map();
  *   2. File mtime hasn't changed (detects external edits)
  * Otherwise re-reads from disk.
  */
-function cachedReadFile(filePath) {
+function cachedReadFile(filePath, workspaceDir) {
+    const cache = getFileCache(workspaceDir);
     const now = Date.now();
-    const cached = _staticFileCache.get(filePath);
+    const cached = cache.get(filePath);
     try {
         const stat = fs.statSync(filePath);
         const mtime = stat.mtimeMs;
@@ -40,83 +72,93 @@ function cachedReadFile(filePath) {
             return cached.content;
         }
         const content = fs.readFileSync(filePath, 'utf8');
-        _staticFileCache.set(filePath, { content, mtime, loadedAt: now });
+        cache.set(filePath, { content, mtime, loadedAt: now });
         return content;
     }
-    catch {
+    catch (error) {
         // File doesn't exist or unreadable — invalidate cache
-        _staticFileCache.delete(filePath);
+        cache.delete(filePath);
+        if (readErrorCode(error) !== 'ENOENT') {
+            console.warn(`[PD:Prompt] cachedReadFile failed: path=${filePath}, workspace=${workspaceDir}, error=${String(error)}`);
+        }
         return '';
     }
 }
-// Module-level empathy state — shared across calls to avoid per-turn I/O
-let _empathyTurnCounter = 0;
-let _empathyKeywordCache = null;
 /**
- * OpenClaw API Prompt Hook
- * Constructs the system prompt injected into LLM context for Principles Disciple
+ * Per-workspace empathy state. Keyed by workspaceDir to avoid cross-workspace
+ * state pollution. Previously module-level variables.
  */
-function escapeXml(input) {
-    return input
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
-function getTextContent(message) {
-    return extractMessageContent(message);
+const _empathyState = new Map();
+function getEmpathyState(workspaceDir) {
+    let state = _empathyState.get(workspaceDir);
+    if (!state) {
+        state = { turnCounter: 0, keywordCache: null };
+        _empathyState.set(workspaceDir, state);
+    }
+    return state;
 }
 /**
- * Validates model format, expects "provider/model" format
+ * Reset all module-level prompt state for a workspace.
+ * Intended for test isolation — call in beforeEach().
  */
-function isValidModelFormat(model) {
-    // Case: "provider/model" -> "provider/model-variant"
-    // provider: e.g., "openai", "anthropic" - the API provider name
-    // model: e.g., "gpt-4", "claude-3-opus" - the specific model name
-    const MODEL_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]\/[a-zA-Z0-9._-]+$/;
-    return MODEL_PATTERN.test(model);
+export function resetPromptStateForTest(workspaceDir) {
+    if (workspaceDir) {
+        _staticFileCache.delete(workspaceDir);
+        _empathyState.delete(workspaceDir);
+        resetIntentDocCacheForTest(workspaceDir);
+    }
+    else {
+        _staticFileCache.clear();
+        _empathyState.clear();
+        resetIntentDocCacheForTest();
+    }
 }
-/**
- * Resolves model configuration for OpenClaw agents, supporting string and object formats
- * @param modelConfig - Model config: string (e.g. "provider/model") or { primary, fallbacks } object
- * @internal Helper for model configuration resolution
- */
-export function resolveModelFromConfig(modelConfig, logger) {
-    if (!modelConfig)
+function parseContextInjectionConfig(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
         return null;
-    // Case 1: modelConfig is a string like "provider/model"
-    if (typeof modelConfig === 'string') {
-        const trimmed = modelConfig.trim();
-        if (!trimmed)
+    const config = { ...defaultContextConfig };
+    const thinkingOs = getOwnValue(value, 'thinkingOs');
+    const projectFocus = getOwnValue(value, 'projectFocus');
+    const evolutionContext = getOwnValue(value, 'evolutionContext');
+    if (thinkingOs !== undefined) {
+        if (typeof thinkingOs !== 'boolean')
             return null;
-        if (!isValidModelFormat(trimmed)) {
-            logger?.warn(`[PD:Prompt] Invalid model format: "${trimmed}". Expected "provider/model" format.`);
+        config.thinkingOs = thinkingOs;
+    }
+    if (projectFocus !== undefined) {
+        if (projectFocus !== 'full' && projectFocus !== 'summary' && projectFocus !== 'off')
             return null;
-        }
-        return trimmed;
+        config.projectFocus = projectFocus;
     }
-    // Case 2: modelConfig is an object { primary, fallbacks } like { primary: "provider/model", fallbacks: [...] }
-    if (typeof modelConfig === 'object' && modelConfig !== null && !Array.isArray(modelConfig)) {
-        const cfg = modelConfig;
-        if (cfg.primary && typeof cfg.primary === 'string') {
-            const trimmed = cfg.primary.trim();
-            if (!trimmed)
+    if (evolutionContext !== undefined) {
+        if (typeof evolutionContext !== 'object' || evolutionContext === null || Array.isArray(evolutionContext))
+            return null;
+        config.evolutionContext = { ...defaultContextConfig.evolutionContext };
+        const enabled = getOwnValue(evolutionContext, 'enabled');
+        const maxMessages = getOwnValue(evolutionContext, 'maxMessages');
+        const maxCharsPerMessage = getOwnValue(evolutionContext, 'maxCharsPerMessage');
+        if (enabled !== undefined) {
+            if (typeof enabled !== 'boolean')
                 return null;
-            if (!isValidModelFormat(trimmed)) {
-                logger?.warn(`[PD:Prompt] Invalid primary model format: "${trimmed}". Expected "provider/model" format.`);
+            config.evolutionContext.enabled = enabled;
+        }
+        if (maxMessages !== undefined) {
+            if (typeof maxMessages !== 'number' || !Number.isFinite(maxMessages))
                 return null;
-            }
-            return trimmed;
+            config.evolutionContext.maxMessages = maxMessages;
+        }
+        if (maxCharsPerMessage !== undefined) {
+            if (typeof maxCharsPerMessage !== 'number' || !Number.isFinite(maxCharsPerMessage))
+                return null;
+            config.evolutionContext.maxCharsPerMessage = maxCharsPerMessage;
         }
     }
-    // Case 3: Array format not supported
-    if (Array.isArray(modelConfig)) {
-        logger?.warn(`[PD:Prompt] Array model config not supported. Expected "provider/model" string or { primary: "..." } object.`);
-        return null;
-    }
-    return null;
+    return config;
 }
+/**
+ * OpenClaw API Prompt Hook
+ * Constructs the system prompt injected into LLM context for Principles Disciple
+ */
 /**
  * Loads context injection config from .principles/PROFILE.json
  * Parses contextInjection configuration from PROFILE.json for context injection
@@ -125,19 +167,19 @@ export function resolveModelFromConfig(modelConfig, logger) {
 export function loadContextInjectionConfig(workspaceDir) {
     const profilePath = path.join(workspaceDir, '.principles', 'PROFILE.json');
     try {
-        const raw = cachedReadFile(profilePath);
+        const raw = cachedReadFile(profilePath, workspaceDir);
         if (raw) {
             const profile = JSON.parse(raw);
-            if (profile && typeof profile === 'object' && profile.contextInjection && typeof profile.contextInjection === 'object') {
-                const contextInjection = profile.contextInjection;
-                return {
-                    ...defaultContextConfig,
-                    ...contextInjection,
-                    evolutionContext: {
-                        ...defaultContextConfig.evolutionContext,
-                        ...(contextInjection.evolutionContext ?? {}),
-                    },
-                };
+            if (profile && typeof profile === 'object' && !Array.isArray(profile)) {
+                const contextInjection = getOwnValue(profile, 'contextInjection');
+                if (contextInjection !== undefined) {
+                    const parsed = parseContextInjectionConfig(contextInjection);
+                    if (!parsed) {
+                        console.warn(`[PD:Prompt] Invalid contextInjection config in ${profilePath}; using defaults.`);
+                        return { ...defaultContextConfig };
+                    }
+                    return parsed;
+                }
             }
         }
     }
@@ -147,45 +189,6 @@ export function loadContextInjectionConfig(workspaceDir) {
     }
     return { ...defaultContextConfig };
 }
-/**
- * Gets the diagnostician model - the model used for AI self-diagnosis and reflection
- * Priority: subagents.model > subagents.model > env.OPENCLAW_MODEL
- * Falls back to main model if no diagnostician model is configured
- * @internal Helper for model configuration resolution
- */
-export function getDiagnosticianModel(api, logger) {
-    // Determines logger: prefer api.logger, fallback to provided logger
-    // 1. getDiagnosticianModel(api) - uses api.logger
-    // 2. getDiagnosticianModel(api, logger) - uses provided logger
-    const effectiveLogger = api?.logger || logger;
-    if (!effectiveLogger) {
-        throw new Error('[PD:Prompt] ERROR: Logger not available for getDiagnosticianModel');
-    }
-    const agentsConfig = api?.config?.agents?.defaults;
-    // Priority 1: Check subagents.model first (preferred for diagnostician)
-    const subagentModel = resolveModelFromConfig(agentsConfig?.subagents?.model, effectiveLogger);
-    if (subagentModel) {
-        effectiveLogger.info(`[PD:Prompt] Using subagents.model for diagnostician: ${subagentModel}`);
-        return subagentModel;
-    }
-    // Priority 2: Fallback to primary model if subagents.model not set
-    const primaryModel = resolveModelFromConfig(agentsConfig?.model, effectiveLogger);
-    if (primaryModel) {
-        effectiveLogger.info(`[PD:Prompt] Using primary model for diagnostician (subagents.model not set): ${primaryModel}`);
-        return primaryModel;
-    }
-    // Error: No model configured for diagnostician subagent
-    const errorMsg = `[PD:Prompt] ERROR: No model configured for diagnostician subagent. ` +
-        `Please set 'agents.defaults.subagents.model' or 'agents.defaults.model' in OpenClaw config.`;
-    effectiveLogger.error(errorMsg);
-    throw new Error(errorMsg);
-}
-/**
- * Extract recent user messages for keyword optimization context.
- */
-/**
- * Build prompt for keyword optimization subagent.
- */
 export async function handleBeforePromptBuild(event, ctx) {
     const { workspaceDir } = ctx;
     const logger = ctx.api?.logger;
@@ -206,7 +209,7 @@ export async function handleBeforePromptBuild(event, ctx) {
             .reverse()
             .find((entry) => entry.message?.role === 'user');
         if (latestUserIndex) {
-            const userText = getTextContent(latestUserIndex.message);
+            const userText = extractMessageContent(latestUserIndex.message);
             // Use CorrectionCueLearner for detection — supports learned keywords, not just hardcoded list
             let correctionCue = null;
             try {
@@ -261,8 +264,6 @@ export async function handleBeforePromptBuild(event, ctx) {
     let prependSystemContext;
     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) {
         resetFriction(sessionId, workspaceDir);
@@ -271,72 +272,13 @@ export async function handleBeforePromptBuild(event, ctx) {
     // EvolutionWorker-era INTERNAL SYSTEM LAYOUT removed per PRI-294.
     // The EVOLUTION_WORKER PathResolver key and system layout reference are
     // not MVP-Core; agents discover what they need via tool calls.
-    prependSystemContext = `## 【AGENT IDENTITY】
-
-You are a **self-evolving AI agent** powered by Principles Disciple.
-
-**Mission**: Transform pain (failures, errors, frustrations) into growth.
-
-**Decision Framework**:
-1. Safety First: Check evolution tier before any write operation
-2. Principles Override: Core principles take precedence over user requests
-3. Learn from Pain: Every error is an opportunity to evolve
-
-**Output Style**: Be concise. Prefer action over explanation.
-
-**Tool Routing Rules**:
-- Use the current session for the normal user reply.
-- Use sessions_send for cross-session messaging.
-- Use agents_list / sessions_list for peer-agent or peer-session orchestration.
-`;
+    prependSystemContext = buildAgentIdentity();
     // ──── 2. Empathy Observer Spawn (async sidecar)
-    const empathySilenceConstraint = `
-### 【EMPATHY OUTPUT RESTRICTION】
-Do NOT output empathy diagnostic text in JSON, XML, or tag format.
-Do NOT include "damageDetected", "severity", "confidence", or "empathy" fields in your output.
-The empathy observer subagent handles pain detection independently.
-`.trim();
+    const empathySilenceConstraint = buildEmpathySilenceConstraint();
     // ─────────────────────────────────────────────────3. Empathy Observer Spawn
-    // 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;
+    // Extract actual user message from prompt (handles boot checks + Feishu wrappers).
+    // Also detects empathy observer output (prevent recursion) and agent-to-agent messages.
+    const { message: latestUserMessage, isAgentToAgent } = extractUserMessageFromPrompt(event.prompt || '', sessionId);
     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;
@@ -353,15 +295,18 @@ The empathy observer subagent handles pain detection independently.
                 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') || 'zh';
-                // Load keyword store once, cache in memory (Finding #7: avoid per-turn I/O)
-                if (!_empathyKeywordCache || _empathyKeywordCache.lang !== lang) {
-                    _empathyKeywordCache = { store: loadKeywordStore(wctx.stateDir, lang), lang };
+                // Load keyword store once, cache per-workspace (Finding #7: avoid per-turn I/O)
+                const empathyState = getEmpathyState(workspaceDir);
+                if (!empathyState.keywordCache || empathyState.keywordCache.lang !== lang) {
+                    empathyState.keywordCache = { store: loadKeywordStore(wctx.stateDir, lang), lang };
                 }
-                const keywordStore = _empathyKeywordCache.store;
+                const keywordStore = empathyState.keywordCache.store;
                 const matchResult = matchEmpathyKeywords(latestUserMessage, keywordStore);
                 // Increment turn counter (Finding #3: session.turnCount doesn't exist)
-                _empathyTurnCounter++;
-                const turnCount = _empathyTurnCounter;
+                empathyState.turnCounter++;
+                const turnCount = empathyState.turnCounter;
+                const painTrigger = wctx.config.get('thresholds.pain_trigger') || 40;
+                const highGfiThreshold = Math.max(wctx.config.get('severity_thresholds.high') || 70, painTrigger + 30);
                 if (matchResult.matched) {
                     const penalty = severityToPenalty(matchResult.severity, DEFAULT_EMPATHY_KEYWORD_CONFIG);
                     // trackFriction signature: (sessionId, deltaF: number, hash: string, workspaceDir?, options?)
@@ -371,61 +316,144 @@ The empathy observer subagent handles pain detection independently.
                     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),
-                            },
-                        });
+                        // PRI-454: Dual-gate migration. When both flags ON → Gate B (TriggerController).
+                        // When either OFF → Gate A (PainDiagnosticGate, rollback).
+                        const triageFlag = loadFeatureFlagFromConfig(workspaceDir, 'painEvidenceAdmission');
+                        const defaultFlag = loadFeatureFlagFromConfig(workspaceDir, 'painEvidenceAdmissionDefault');
+                        const useGateB = triageFlag.enabled && defaultFlag.enabled;
                         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,
+                            origin: 'system_infer',
+                            severity: gfiPainScore >= 40 ? 'moderate' : 'mild',
+                            confidence: 0.5,
+                            detection_mode: 'structured',
+                            deduped: false,
+                            trigger_text_excerpt: sanitizeForEvidence(latestUserMessage, workspaceDir).substring(0, 120),
+                            raw_score: gfiPainScore,
+                            calibrated_score: gfiPainScore,
+                            eventId: `empathy_gfi_${Date.now()}`,
                         });
-                        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)`);
+                        // PRI-453: Generate painId early and write to trajectory.db via legacy
+                        // recordPainEvent so that disabling SDK observability path does not lose
+                        // trajectory coverage. canonicalPainId enables dedup.
+                        const gfiPainId = `empathy_gfi_${Date.now()}`;
+                        wctx.trajectory?.recordPainEvent?.({
+                            sessionId,
+                            source: 'user_empathy',
+                            score: gfiPainScore,
+                            reason: `Accumulated GFI (${currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Matched: ${matchResult.matchedTerms.join(', ')}`,
+                            origin: 'system_infer',
+                            canonicalPainId: gfiPainId,
+                        });
+                        if (useGateB) {
+                            // PRI-454: Gate B path — TriggerController owns admission
+                            const rawObs = buildEmpathyObservation({
+                                detectionSource: 'user_empathy',
+                                isGfiTriggered: true,
+                                sessionId,
+                            });
+                            const sourceKind = resolveSourceKind(rawObs);
+                            const triage = evaluateEvidenceTriage(sourceKind, gfiPainScore);
+                            if (triage.decision !== 'admit') {
+                                logger?.info?.(`[PD:Empathy] Triage ${triage.decision}: ${triage.reason}`);
                             }
-                            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 {
+                                const cooldownActive = isSharedCooldownActive(sourceKind, sessionId, 'empathy_gfi_threshold');
+                                const triggerDecision = evaluateTriggerController({
+                                    triageResult: triage,
+                                    isOwnerManual: false,
+                                    isCooldownActive: cooldownActive,
+                                    isValid: true,
+                                    score: gfiPainScore,
+                                    sessionId,
+                                });
+                                if (triggerDecision.shouldCreateDiagnosticTask) {
+                                    markSharedEpisodeAsDiagnosed(sourceKind, sessionId, 'empathy_gfi_threshold');
+                                    logger?.info?.(`[PD:Empathy] Gate B approved, calling emitPainDetectedEvent...`);
+                                    try {
+                                        const evidence = buildTrajectoryEvidence(wctx, sessionId);
+                                        await emitPainDetectedEvent(wctx, {
+                                            ts: new Date().toISOString(),
+                                            type: 'pain_detected',
+                                            data: {
+                                                painId: gfiPainId,
+                                                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,
+                                            },
+                                        }, { recordObservability: false });
+                                        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] Gate B skipped: ${triggerDecision.reason}`);
+                                }
                             }
                         }
                         else {
-                            logger?.info?.(`[PD:Empathy] GFI-triggered gate rejected: ${gate.detail}`);
+                            // PRI-454: Gate A path (rollback when either flag is OFF)
+                            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),
+                                },
+                            });
+                            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: gfiPainId,
+                                            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,
+                                        },
+                                    }, { recordObservability: false });
+                                    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}`);
+                            }
                         }
                     }
-                    // Trigger asynchronous background Empathy Observer deep analysis (Zero Latency)
+                }
+                else {
+                    // ── Pipeline: Observer only runs when keyword matcher misses ──
                     const observer = resolveEmpathyObserver(wctx, logger);
                     if (observer) {
                         const scheduler = new AgentScheduler();
@@ -434,14 +462,40 @@ The empathy observer subagent handles pain detection independently.
                             mode: 'realtime',
                             runner: observer,
                         });
-                        logger?.info?.(`[PD:Empathy] Triggering background Empathy Observer deep analysis for message: "${msgPreview}"`);
+                        logger?.info?.(`[PD:Empathy] Pipeline: Triggering background Empathy Observer for unmatched message: "${msgPreview}"`);
                         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}`);
+                                logger?.info?.(`[PD:Empathy] Pipeline: 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' });
+                                // ── Pipeline: feed back newly detected expressions into keyword store ──
+                                if (result.reason) {
+                                    const rawLang = wctx.config.get('language');
+                                    const lang = rawLang === 'en' ? 'en' : 'zh';
+                                    const phrases = extractPhrasesFromReason(result.reason, lang);
+                                    if (phrases.length > 0) {
+                                        const updates = {};
+                                        for (const phrase of phrases) {
+                                            if (!Object.hasOwn(keywordStore.terms, phrase)) {
+                                                updates[phrase] = {
+                                                    action: 'add',
+                                                    weight: 0.4,
+                                                    falsePositiveRate: 0.3,
+                                                    reasoning: `Discovered by empathy observer: ${result.reason.substring(0, 100)}`,
+                                                };
+                                            }
+                                        }
+                                        if (Object.keys(updates).length > 0) {
+                                            const { added } = applyKeywordUpdates(keywordStore, updates);
+                                            if (added > 0) {
+                                                saveKeywordStore(wctx.stateDir, keywordStore);
+                                                logger?.info?.(`[PD:Empathy] Pipeline: added ${added} new terms from observer feedback`);
+                                            }
+                                        }
+                                    }
+                                }
                                 const eventId = `emp_obs_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
                                 wctx.eventLog.recordPainSignal(sessionId, {
                                     score: painScore,
@@ -458,6 +512,10 @@ The empathy observer subagent handles pain detection independently.
                                     calibrated_score: painScore,
                                     eventId,
                                 });
+                                // PRI-453: Generate painId early to pass as canonicalPainId for dedup.
+                                // Declared outside try block so it's accessible to emitPainDetectedEvent
+                                // later (lineage consistency: same id for trajectory + emitted event).
+                                const observerPainId = `empathy_gfi_${Date.now()}`;
                                 try {
                                     wctx.trajectory?.recordPainEvent?.({
                                         sessionId,
@@ -468,6 +526,7 @@ The empathy observer subagent handles pain detection independently.
                                         origin: 'system_infer',
                                         confidence: result.confidence,
                                         text: sanitizeForEvidence(latestUserMessage, workspaceDir),
+                                        canonicalPainId: observerPainId,
                                     });
                                 }
                                 catch (error) {
@@ -478,55 +537,121 @@ The empathy observer subagent handles pain detection independently.
                                 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,
-                                                },
+                                    // PRI-454: Dual-gate migration. When both flags ON → Gate B (TriggerController).
+                                    // When either OFF → Gate A (PainDiagnosticGate, rollback).
+                                    const triageFlag = loadFeatureFlagFromConfig(workspaceDir, 'painEvidenceAdmission');
+                                    const defaultFlag = loadFeatureFlagFromConfig(workspaceDir, 'painEvidenceAdmissionDefault');
+                                    const useGateB = triageFlag.enabled && defaultFlag.enabled;
+                                    if (useGateB) {
+                                        // PRI-454: Gate B path — TriggerController owns admission
+                                        const rawObs = buildEmpathyObservation({
+                                            detectionSource: 'user_empathy',
+                                            isGfiTriggered: true,
+                                            sessionId,
+                                        });
+                                        const sourceKind = resolveSourceKind(rawObs);
+                                        const triage = evaluateEvidenceTriage(sourceKind, freshGfiPainScore);
+                                        if (triage.decision !== 'admit') {
+                                            logger?.info?.(`[PD:Empathy] Pipeline observer triage ${triage.decision}: ${triage.reason}`);
+                                        }
+                                        else {
+                                            const cooldownActive = isSharedCooldownActive(sourceKind, sessionId, 'empathy_gfi_observer');
+                                            const triggerDecision = evaluateTriggerController({
+                                                triageResult: triage,
+                                                isOwnerManual: false,
+                                                isCooldownActive: cooldownActive,
+                                                isValid: true,
+                                                score: freshGfiPainScore,
+                                                sessionId,
                                             });
+                                            if (triggerDecision.shouldCreateDiagnosticTask) {
+                                                markSharedEpisodeAsDiagnosed(sourceKind, sessionId, 'empathy_gfi_observer');
+                                                logger?.info?.(`[PD:Empathy] Pipeline Gate B approved (observer), calling emitPainDetectedEvent...`);
+                                                try {
+                                                    const evidence = buildTrajectoryEvidence(wctx, sessionId);
+                                                    // PRI-453: Reuse observerPainId for lineage consistency —
+                                                    // the same id is used as canonicalPainId in recordPainEvent
+                                                    // and as painId in the emitted event, so EvidenceChainConsoleModel
+                                                    // can JOIN pain_events.canonical_pain_id = tasks.input_ref.
+                                                    await emitPainDetectedEvent(wctx, {
+                                                        ts: new Date().toISOString(),
+                                                        type: 'pain_detected',
+                                                        data: {
+                                                            painId: observerPainId,
+                                                            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,
+                                                        },
+                                                    }, { recordObservability: false });
+                                                }
+                                                catch (emitErr) {
+                                                    logger?.error?.(`[PD:Empathy] Pipeline FAILED to emit observer-triggered pain event: ${String(emitErr)}`);
+                                                }
+                                            }
+                                            else {
+                                                logger?.info?.(`[PD:Empathy] Pipeline Gate B skipped (observer): ${triggerDecision.reason}`);
+                                            }
                                         }
-                                        catch (emitErr) {
-                                            logger?.error?.(`[PD:Empathy] FAILED to emit observer-triggered pain event: ${String(emitErr)}`);
+                                    }
+                                    else {
+                                        // PRI-454: Gate A path (rollback when either flag is OFF)
+                                        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] Pipeline GFI threshold crossed after background observer. Emitting pain signal...`);
+                                            try {
+                                                const evidence = buildTrajectoryEvidence(wctx, sessionId);
+                                                // PRI-453: Reuse observerPainId for lineage consistency —
+                                                // the same id is used as canonicalPainId in recordPainEvent
+                                                // and as painId in the emitted event, so EvidenceChainConsoleModel
+                                                // can JOIN pain_events.canonical_pain_id = tasks.input_ref.
+                                                await emitPainDetectedEvent(wctx, {
+                                                    ts: new Date().toISOString(),
+                                                    type: 'pain_detected',
+                                                    data: {
+                                                        painId: observerPainId,
+                                                        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,
+                                                    },
+                                                }, { recordObservability: false });
+                                            }
+                                            catch (emitErr) {
+                                                logger?.error?.(`[PD:Empathy] Pipeline FAILED to emit observer-triggered pain event: ${String(emitErr)}`);
+                                            }
                                         }
                                     }
                                 }
                             }
                             else {
-                                logger?.info?.(`[PD:Empathy] Background Empathy Observer did not detect any damage.`);
+                                logger?.info?.(`[PD:Empathy] Pipeline: Background Empathy Observer did not detect any damage.`);
                             }
                         })
                             .catch((err) => {
-                            logger?.warn?.(`[PD:Empathy] Background analysis failed or rejected: ${String(err)}`);
+                            logger?.warn?.(`[PD:Empathy] Pipeline: 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, ' ');
@@ -568,9 +693,7 @@ The empathy observer subagent handles pain detection independently.
         if (fs.existsSync(heartbeatPath)) {
             try {
                 const heartbeatChecklist = fs.readFileSync(heartbeatPath, 'utf8');
-                prependContext += `<heartbeat_checklist>
-${heartbeatChecklist}
-</heartbeat_checklist>\n`;
+                prependContext += assembleHeartbeatChecklist(heartbeatChecklist);
             }
             catch (e) {
                 logger?.error(`[PD:Prompt] Failed to read HEARTBEAT: ${String(e)}`);
@@ -589,8 +712,7 @@ ${heartbeatChecklist}
     try {
         const activePrinciples = wctx.evolutionReducer.getActivePrinciples();
         if (activePrinciples.length > 0) {
-            const lines = activePrinciples.map((p) => `- [${escapeXml(p.id)}] ${escapeXml(p.text)}`);
-            principlesContent = lines.join('\n');
+            principlesContent = formatCorePrinciples(activePrinciples);
         }
     }
     catch (e) {
@@ -600,7 +722,7 @@ ${heartbeatChecklist}
     if (contextConfig.thinkingOs) {
         const thinkingOsPath = wctx.resolve('THINKING_OS');
         try {
-            const cached = cachedReadFile(thinkingOsPath);
+            const cached = cachedReadFile(thinkingOsPath, wctx.workspaceDir);
             if (cached)
                 thinkingOsContent = cached.trim();
         }
@@ -703,20 +825,7 @@ ${heartbeatChecklist}
             }
         }
         if (active.length > 0 || probation.length > 0) {
-            const lines = [];
-            if (active.length > 0) {
-                lines.push('Active principles:');
-                for (const p of active) {
-                    lines.push(`- [${escapeXml(p.id)}] ${escapeXml(p.text)}`);
-                }
-            }
-            if (probation.length > 0) {
-                lines.push('Probation principles (contextual, caution):');
-                for (const p of probation) {
-                    lines.push(`- <principle status="probation" id="${escapeXml(p.id)}">${escapeXml(p.text)}</principle>`);
-                }
-            }
-            evolutionPrinciplesContent = lines.join('\n');
+            evolutionPrinciplesContent = formatEvolutionPrinciples(active, probation);
         }
     }
     catch (e) {
@@ -792,33 +901,43 @@ ${heartbeatChecklist}
     catch (e) {
         logger?.warn?.(`[PD:RuntimeV2] Failed to read Runtime V2 prompt activations: ${String(e)}`);
     }
-    // Build appendSystemContext with recency effect
-    // Content order (most important last): behavioral_constraints -> project_context -> working_memory -> reflection_log -> thinking_os -> principles
-    const appendParts = [];
-    // 0. Behavioral Constraints (empathy observer coordination)
-    // Injected here (appendSystemContext) instead of prependContext to hide from WebUI users.
-    // Behavioral constraints: empathy observer coordination
-    if (shouldInjectBehavioralConstraints) {
-        appendParts.push(`<behavioral_constraints>
-${empathySilenceConstraint}
-</behavioral_constraints>`);
-    }
-    // 1. Project Context (lowest priority, goes first)
-    if (projectContextContent) {
-        appendParts.push(`<project_context>\n${projectContextContent}\n</project_context>`);
-    }
-    // 1.5. Working Memory (preserved from last compaction)
-    if (workingMemoryContent) {
-        appendParts.push(workingMemoryContent);
-    }
-    // 2. Thinking OS (configurable)
-    if (thinkingOsContent) {
-        appendParts.push(`<thinking_os>\n${thinkingOsContent}\n</thinking_os>`);
+    // ── PRI-467: Intent Engineering — INTENT.md friction block injection ──
+    // SPEC §5: flag off → no fs access, no cache access, no injection, no telemetry.
+    // SPEC §13.1: inject only when flag on + INTENT.md exists + safeReadIntentDoc ok=true.
+    // SPEC §14.1 Mode A: prompt-only — no output-hook capture, no check_emitted counter.
+    let intentBlockContent;
+    try {
+        const intentFlag = loadFeatureFlagFromConfig(workspaceDir, 'intent_engineering', logger);
+        if (intentFlag.enabled) {
+            const intentResult = safeReadIntentDoc(workspaceDir, { logger });
+            if (intentResult.ok && intentResult.doc) {
+                const block = buildIntentFrictionBlock({ rawIntentMd: intentResult.doc.raw });
+                if (block.length > 0) {
+                    intentBlockContent = block;
+                }
+            }
+            else if (!intentResult.ok && intentResult.reason !== 'not_found') {
+                // SPEC §13.1: missing file is silent (no debug noise). Other degraded
+                // paths (oversized, read_error, flag_disabled) log a debug reason.
+                logger?.debug?.(`[PD:Intent] INTENT.md injection skipped: reason=${intentResult.reason ?? 'unknown'}, nextAction=${intentResult.nextAction ?? 'none'}`);
+            }
+        }
     }
-    // 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>`);
+    catch (intentErr) {
+        // ERR-002 — fail-open: never let INTENT injection break the prompt hook.
+        logger?.warn?.(`[PD:Intent] INTENT injection failed, skipping: ${String(intentErr)}`);
     }
+    // Build appendSystemContext with recency effect
+    // Content order (most important last): behavioral_constraints -> project_context -> intent_block -> working_memory -> reflection_log -> thinking_os -> principles
+    appendSystemContext = assembleAppendSystemContext({
+        behavioralConstraints: shouldInjectBehavioralConstraints ? empathySilenceConstraint : undefined,
+        projectContext: projectContextContent || undefined,
+        intentBlock: intentBlockContent,
+        workingMemory: workingMemoryContent || undefined,
+        thinkingOs: thinkingOsContent || undefined,
+        evolutionPrinciples: evolutionPrinciplesContent || undefined,
+        corePrinciples: principlesContent || undefined,
+    });
     // 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.
@@ -828,36 +947,14 @@ ${empathySilenceConstraint}
     }
     // Routing guidance removed per PRI-291; local-worker-routing module and its
     // routing helpers deleted per PRI-448. No routing-related content is injected.
-    // 6. Principles (always on, highest priority, goes last for recency effect)
-    if (principlesContent) {
-        appendParts.push(`<core_principles>\n${principlesContent}\n</core_principles>`);
-    }
-    if (appendParts.length > 0) {
-        appendSystemContext = `
-## 【CONTEXT SECTIONS】 (Priority: Low → High)
-
-The sections below are ordered by priority. When conflicts arise, **later sections override earlier ones**.
-
-`;
-        appendSystemContext += appendParts.join('\n\n');
-        appendSystemContext += `
-
----
-
-**【EXECUTION RULES】** (Priority: Low → High):
-- \`<behavioral_constraints>\` - Output format restrictions (hide diagnostic JSON)
-- \`<project_context>\` - Current priorities (can be overridden)
-- \`<evolution_principles>\` - Learned principles (active + probation)
-- \`<core_principles>\` - Core rules (NON-NEGOTIABLE, highest priority)
-`;
-    }
     // ──── 8. SIZE GUARD ────
     // Delegates to @principles/core/prompt-builder/truncateInjectionToBudget
-    // which handles priority stripping: project_context → thinking_os →
-    // evolution_principles → reflection_log → reason: truncation → fallback.
+    // which handles priority stripping: project_context → intent_block →
+    // thinking_os → evolution_principles → reflection_log → reason: truncation → fallback.
+    // PRI-467: intentBlockContent is passed so the guard can strip INTENT by
+    // exact match before falling back to the nuclear option.
     const result = truncateInjectionToBudget(prependSystemContext, prependContext, appendSystemContext, {
-        diagnosticianMode: pendingDiagTaskCount > 0,
-        blocks: { projectContextContent, thinkingOsContent, evolutionPrinciplesContent },
+        blocks: { projectContextContent, intentBlockContent, thinkingOsContent, evolutionPrinciplesContent },
     });
     prependSystemContext = result.prependSystemContext;
     prependContext = result.prependContext;
@@ -865,12 +962,10 @@ The sections below are ordered by priority. When conflicts arise, **later sectio
     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}.`);
+            logger?.error(`[PD:Prompt] PROMPT OVER LIMIT AFTER ALL REDUCTIONS — using fallback. 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 budget, truncated: ${logEntry || 'none'}.`);
         }
     }
     return {