principles-disciple 1.139.0 → 1.141.0

package/dist/hooks/prompt.js

@@ -16,13 +16,37 @@ import { severityToPenalty, DEFAULT_EMPATHY_KEYWORD_CONFIG } from '../core/empat
 import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
 import { emitPainDetectedEvent, buildTrajectoryEvidence } from './pain.js';
 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, } 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 +54,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 +65,91 @@ 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);
+    }
+    else {
+        _staticFileCache.clear();
+        _empathyState.clear();
+    }
 }
-/**
- * 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 +158,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 +180,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 +200,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 +255,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 +263,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 +286,16 @@ 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;
                 if (matchResult.matched) {
                     const penalty = severityToPenalty(matchResult.severity, DEFAULT_EMPATHY_KEYWORD_CONFIG);
                     // trackFriction signature: (sessionId, deltaF: number, hash: string, workspaceDir?, options?)
@@ -568,9 +502,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 +521,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 +531,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 +634,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) {
@@ -794,31 +712,14 @@ ${heartbeatChecklist}
     }
     // 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>`);
-    }
-    // 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>`);
-    }
+    appendSystemContext = assembleAppendSystemContext({
+        behavioralConstraints: shouldInjectBehavioralConstraints ? empathySilenceConstraint : undefined,
+        projectContext: projectContextContent || undefined,
+        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,35 +729,11 @@ ${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.
     const result = truncateInjectionToBudget(prependSystemContext, prependContext, appendSystemContext, {
-        diagnosticianMode: pendingDiagTaskCount > 0,
         blocks: { projectContextContent, thinkingOsContent, evolutionPrinciplesContent },
     });
     prependSystemContext = result.prependSystemContext;
@@ -865,12 +742,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 {

package/dist/hooks/raw-observation-adapter.d.ts

@@ -1,57 +1,16 @@
 /**
- * Raw Observation Adapter — PRI-362
+ * Raw Observation Adapter — PRI-362 / PRI-446
  *
- * Unified source-kind resolution from RawObservation.
+ * The source-kind resolution logic and RawObservation builders have been
+ * migrated to principles-core (runtime-v2/evidence-triage/observation-resolver.ts).
  *
- * Replaces scattered resolveSourceKindFrom* functions with a single
- * field-driven adapter that maps observation fields to SourceKind.
- *
- * Field precedence (highest to lowest):
- * 1. isManualEntry → owner_reported
- * 2. isGateBlock → rulehost_block
- * 3. isSubagentError → subagent_error
- * 4. isRateLimit → rate_limit (if true)
- * 5. toolName === 'pain' / 'skill:pain' → agent_on_owner_request (with openclaw_context_bound) / owner_reported
- * 6. failureSource → tool_failure / dispatch_error
- * 7. isGfiTriggered → gfi_threshold
- * 8. detectionSource → llm_paralysis / semantic / empathy_inferred / unknown
- * 9. Fallback → unknown
+ * This file is now a thin re-export adapter. It preserves the original export
+ * names (resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation,
+ * RawObservation) so all existing import sites and the source-string
+ * characterization tests keep working without changes.
  *
  * ERR checklist:
- * - ERR-001: Source kind resolved from runtime values, no `as` casts.
- * - ERR-002: Every path returns a valid SourceKind (fallback to 'unknown').
- * - EP-01: Runtime values validated before use.
+ * - ERR-011: re-export adapter, not a local re-definition of migrated logic.
  */
-import type { SourceKind } from '@principles/core/runtime-v2';
-import type { RawObservation } from './raw-observation-types.js';
+export { resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation, } from '@principles/core/runtime-v2';
 export type { RawObservation } from './raw-observation-types.js';
-/**
- * Resolve SourceKind from a unified RawObservation.
- *
- * This function replaces the scattered resolveSourceKindFrom* functions
- * and provides a single entry point for source-kind classification.
- *
- * Field precedence is explicitly defined in the function body to ensure
- * deterministic behavior and make the logic easy to understand and test.
- */
-export declare function resolveSourceKind(observation: RawObservation): SourceKind;
-/**
- * Build a RawObservation for a tool failure context.
- *
- * This replaces classifyToolFailureSource and the inline classification
- * in after-tool-call-helpers. All tool error → dispatch/tool_failure
- * classification is centralized here.
- */
-export declare function buildToolFailureObservation(options: {
-    toolName: string | undefined;
-    error: unknown;
-    exitCode?: number;
-    provenance?: RawObservation['provenance'];
-}): RawObservation;
-/**
- * Build a RawObservation for an LLM detection context.
- */
-export declare function buildLlmDetectionObservation(options: {
-    detectionSource: string;
-    isGfiTriggered: boolean;
-}): RawObservation;