principles-disciple 1.139.0 → 1.140.0

package/dist/hooks/prompt-helpers.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Pure-logic helpers for prompt assembly.
+ *
+ * Extracted from hooks/prompt.ts per PRI-444. These functions contain NO I/O
+ * and NO side effects — they are independently unit-testable.
+ *
+ * I/O helpers (cachedReadFile, loadContextInjectionConfig, resolveEmpathyObserver)
+ * remain in prompt.ts because they depend on module-level cache state and fs.
+ *
+ * Pattern follows after-tool-call-helpers.ts (PRI-326): plugin-internal
+ * decomposition + core pure-function reuse.
+ *
+ * ERR checklist:
+ * EP-01: All unknown inputs use typeof/Object.hasOwn guards, never `as`
+ * EP-03: Pure functions never swallow errors; invalid input returns empty string
+ * EP-09: Pure functions are independently unit-testable without mocks
+ */
+import type { ExtractedUserMessage, CorePrincipleEntry, EvolutionPrincipleEntry, AppendSystemContextParts } from './prompt-types.js';
+/**
+ * Extract the actual user message from the raw prompt text.
+ *
+ * The prompt may contain:
+ * - Boot check messages (system-generated, return empty)
+ * - Feishu wrapper format 1: "Sender (untrusted metadata): ```json {...}```  text"
+ * - Feishu wrapper format 2: "Conversation info (untrusted metadata): ```json {...}```  text"
+ * - Clean user message text
+ *
+ * Also detects empathy observer output (to prevent recursive spawn) and
+ * agent-to-agent messages (to skip empathy evaluation).
+ *
+ * Pure logic — no I/O, no side effects.
+ */
+export declare function extractUserMessageFromPrompt(prompt: string, sessionId: string | undefined): ExtractedUserMessage;
+/**
+ * Build the minimal Agent Identity section for prependSystemContext.
+ *
+ * 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.
+ *
+ * Pure logic — returns a constant string.
+ */
+export declare function buildAgentIdentity(): string;
+/**
+ * Build the empathy output restriction constraint text.
+ *
+ * Pure logic — returns a constant string.
+ */
+export declare function buildEmpathySilenceConstraint(): string;
+/**
+ * Wrap heartbeat checklist content in XML tags.
+ *
+ * Pure logic — no I/O, no side effects.
+ */
+export declare function assembleHeartbeatChecklist(content: string): string;
+/**
+ * Format core principles into prompt-ready text.
+ *
+ * Pure logic — uses escapeXml for safe XML embedding.
+ *
+ * @param principles Active principles from evolution reducer
+ * @returns Formatted lines (empty string if no principles)
+ */
+export declare function formatCorePrinciples(principles: CorePrincipleEntry[]): string;
+/**
+ * Format evolution principles (active + probation) into prompt-ready text.
+ *
+ * Pure logic — uses escapeXml for safe XML embedding.
+ *
+ * @param active Active principles (high priority)
+ * @param probation Probation principles (contextual, caution)
+ * @returns Formatted lines (empty string if no principles)
+ */
+export declare function formatEvolutionPrinciples(active: EvolutionPrincipleEntry[], probation: EvolutionPrincipleEntry[]): string;
+/**
+ * Assemble appendSystemContext from ordered parts.
+ *
+ * Content order (most important last):
+ * behavioral_constraints → project_context → working_memory →
+ * thinking_os → evolution_principles → core_principles
+ *
+ * Pure logic — string assembly only, no I/O.
+ *
+ * @param parts Ordered content parts (empty/undefined parts are skipped)
+ * @returns Assembled appendSystemContext (empty string if no parts)
+ */
+export declare function assembleAppendSystemContext(parts: AppendSystemContextParts): string;

package/dist/hooks/prompt-helpers.js

@@ -0,0 +1,251 @@
+/**
+ * Pure-logic helpers for prompt assembly.
+ *
+ * Extracted from hooks/prompt.ts per PRI-444. These functions contain NO I/O
+ * and NO side effects — they are independently unit-testable.
+ *
+ * I/O helpers (cachedReadFile, loadContextInjectionConfig, resolveEmpathyObserver)
+ * remain in prompt.ts because they depend on module-level cache state and fs.
+ *
+ * Pattern follows after-tool-call-helpers.ts (PRI-326): plugin-internal
+ * decomposition + core pure-function reuse.
+ *
+ * ERR checklist:
+ * EP-01: All unknown inputs use typeof/Object.hasOwn guards, never `as`
+ * EP-03: Pure functions never swallow errors; invalid input returns empty string
+ * EP-09: Pure functions are independently unit-testable without mocks
+ */
+import { escapeXml } from '@principles/core/prompt-builder';
+// ---------------------------------------------------------------------------
+// Block F: User message extraction (boot check + Feishu format parsing)
+// ---------------------------------------------------------------------------
+/**
+ * Extract the actual user message from the raw prompt text.
+ *
+ * The prompt may contain:
+ * - Boot check messages (system-generated, return empty)
+ * - Feishu wrapper format 1: "Sender (untrusted metadata): ```json {...}```  text"
+ * - Feishu wrapper format 2: "Conversation info (untrusted metadata): ```json {...}```  text"
+ * - Clean user message text
+ *
+ * Also detects empathy observer output (to prevent recursive spawn) and
+ * agent-to-agent messages (to skip empathy evaluation).
+ *
+ * Pure logic — no I/O, no side effects.
+ */
+export function extractUserMessageFromPrompt(prompt, sessionId) {
+    let message = 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 (message.startsWith('You are running a boot check.') ||
+        message.includes('You are running a boot check. Follow BOOT.md')) {
+        message = '';
+    }
+    // Try to extract actual user message from Feishu wrapper formats
+    if (message.length > 50) {
+        // Format 1: "Sender (untrusted metadata): ```json {...}```  user_message_text"
+        const senderMatch = /Sender \(untrusted metadata\):[\s\S]*?```json[\s\S]*?```\s*/.exec(message);
+        if (senderMatch) {
+            const afterSender = message.slice(senderMatch.index + senderMatch[0].length).trim();
+            if (afterSender.length > 3)
+                message = afterSender;
+        }
+        // Format 2: "Conversation info (untrusted metadata): ```json {...}```  user_message_text"
+        if (message.length > 200 && message.includes('Conversation info')) {
+            const convInfoMatch = /Conversation info[\s\S]*?```json[\s\S]*?```\s*/.exec(message);
+            if (convInfoMatch) {
+                const afterConvInfo = message.slice(convInfoMatch.index + convInfoMatch[0].length).trim();
+                if (afterConvInfo.length > 3)
+                    message = 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(message) &&
+        /damageDetected|severity|confidence/i.test(message);
+    const isAgentToAgent = message.includes('sourceSession=agent:') ||
+        sessionId?.includes(':subagent:') === true ||
+        isEmpathyPrompt;
+    return { message, isAgentToAgent, isEmpathyPrompt };
+}
+// ---------------------------------------------------------------------------
+// Block D: Agent Identity (static constant)
+// ---------------------------------------------------------------------------
+/**
+ * Build the minimal Agent Identity section for prependSystemContext.
+ *
+ * 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.
+ *
+ * Pure logic — returns a constant string.
+ */
+export function buildAgentIdentity() {
+    return `## 【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.
+`;
+}
+// ---------------------------------------------------------------------------
+// Block E: Empathy output restriction (static constant)
+// ---------------------------------------------------------------------------
+/**
+ * Build the empathy output restriction constraint text.
+ *
+ * Pure logic — returns a constant string.
+ */
+export function buildEmpathySilenceConstraint() {
+    return `
+### 【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();
+}
+// ---------------------------------------------------------------------------
+// Block H: Heartbeat checklist wrapper
+// ---------------------------------------------------------------------------
+/**
+ * Wrap heartbeat checklist content in XML tags.
+ *
+ * Pure logic — no I/O, no side effects.
+ */
+export function assembleHeartbeatChecklist(content) {
+    if (!content.trim())
+        return '';
+    return `<heartbeat_checklist>
+${content}
+</heartbeat_checklist>\n`;
+}
+// ---------------------------------------------------------------------------
+// Block I: Core principles formatting
+// ---------------------------------------------------------------------------
+/**
+ * Format core principles into prompt-ready text.
+ *
+ * Pure logic — uses escapeXml for safe XML embedding.
+ *
+ * @param principles Active principles from evolution reducer
+ * @returns Formatted lines (empty string if no principles)
+ */
+export function formatCorePrinciples(principles) {
+    if (!Array.isArray(principles) || principles.length === 0)
+        return '';
+    const lines = principles.map((p) => `- [${escapeXml(p.id)}] ${escapeXml(p.text)}`);
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Block L: Evolution principles formatting (active + probation)
+// ---------------------------------------------------------------------------
+/**
+ * Format evolution principles (active + probation) into prompt-ready text.
+ *
+ * Pure logic — uses escapeXml for safe XML embedding.
+ *
+ * @param active Active principles (high priority)
+ * @param probation Probation principles (contextual, caution)
+ * @returns Formatted lines (empty string if no principles)
+ */
+export function formatEvolutionPrinciples(active, probation) {
+    if ((!Array.isArray(active) || active.length === 0) &&
+        (!Array.isArray(probation) || probation.length === 0)) {
+        return '';
+    }
+    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>`);
+        }
+    }
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Block N: appendSystemContext assembly
+// ---------------------------------------------------------------------------
+/**
+ * Assemble appendSystemContext from ordered parts.
+ *
+ * Content order (most important last):
+ * behavioral_constraints → project_context → working_memory →
+ * thinking_os → evolution_principles → core_principles
+ *
+ * Pure logic — string assembly only, no I/O.
+ *
+ * @param parts Ordered content parts (empty/undefined parts are skipped)
+ * @returns Assembled appendSystemContext (empty string if no parts)
+ */
+export function assembleAppendSystemContext(parts) {
+    const appendParts = [];
+    // 0. Behavioral Constraints (empathy observer coordination)
+    if (parts.behavioralConstraints) {
+        appendParts.push(`<behavioral_constraints>
+${parts.behavioralConstraints}
+</behavioral_constraints>`);
+    }
+    // 1. Project Context (lowest priority, goes first)
+    if (parts.projectContext) {
+        appendParts.push(`<project_context>\n${parts.projectContext}\n</project_context>`);
+    }
+    // 1.5. Working Memory (preserved from last compaction)
+    if (parts.workingMemory) {
+        appendParts.push(parts.workingMemory);
+    }
+    // 2. Thinking OS (configurable)
+    if (parts.thinkingOs) {
+        appendParts.push(`<thinking_os>\n${parts.thinkingOs}\n</thinking_os>`);
+    }
+    // 3. Evolution Loop principles (legacy active/probation only)
+    if (parts.evolutionPrinciples) {
+        appendParts.push(`<evolution_principles>\n${parts.evolutionPrinciples}\n</evolution_principles>`);
+    }
+    // 6. Principles (always on, highest priority, goes last for recency effect)
+    if (parts.corePrinciples) {
+        appendParts.push(`<core_principles>\n${parts.corePrinciples}\n</core_principles>`);
+    }
+    if (appendParts.length === 0)
+        return '';
+    let result = `
+## 【CONTEXT SECTIONS】 (Priority: Low → High)
+
+The sections below are ordered by priority. When conflicts arise, **later sections override earlier ones**.
+
+`;
+    result += appendParts.join('\n\n');
+    const executionRules = [
+        parts.behavioralConstraints ? '- `<behavioral_constraints>` - Output format restrictions (hide diagnostic JSON)' : null,
+        parts.projectContext ? '- `<project_context>` - Current priorities (can be overridden)' : null,
+        parts.workingMemory ? '- `<working_memory>` - Persisted compacted memory snapshot' : null,
+        parts.thinkingOs ? '- `<thinking_os>` - Stable reasoning framework' : null,
+        parts.evolutionPrinciples ? '- `<evolution_principles>` - Learned principles (active + probation)' : null,
+        parts.corePrinciples ? '- `<core_principles>` - Core rules (NON-NEGOTIABLE, highest priority)' : null,
+    ].filter((line) => line !== null);
+    result += `
+
+---
+
+**【EXECUTION RULES】** (Priority: Low → High):
+${executionRules.join('\n')}
+`;
+    return result;
+}

package/dist/hooks/prompt-types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Type definitions for prompt assembly.
+ *
+ * Extracted from hooks/prompt.ts per PRI-444 to enable independent testing
+ * of pure-logic helpers without importing the full hook module.
+ *
+ * ERR checklist:
+ * EP-01: All unknown inputs use typeof/Object.hasOwn guards, never `as`
+ * EP-03: Pure functions never swallow errors silently
+ * EP-09: Pure functions are independently unit-testable without mocks
+ */
+import type { PluginLogger, OpenClawPluginApi } from '../openclaw-sdk.js';
+/** Cached file entry for TTL-based file reading. */
+export interface CachedFile {
+    content: string;
+    mtime: number;
+    loadedAt: number;
+}
+/** Per-workspace empathy session state. */
+export interface EmpathySessionState {
+    turnCounter: number;
+    keywordCache: {
+        store: unknown;
+        lang: string;
+    } | null;
+}
+/** API surface exposed to the prompt hook by the plugin runtime. */
+export interface PromptHookApi {
+    config?: {
+        empathy_engine?: {
+            enabled?: boolean;
+        };
+    };
+    runtime: OpenClawPluginApi['runtime'];
+    logger: PluginLogger;
+}
+/** Result of extracting the user message from the raw prompt text. */
+export interface ExtractedUserMessage {
+    /** Cleaned user message (empty string for boot checks). */
+    message: string;
+    /** True if the message appears to be from another agent (skip empathy). */
+    isAgentToAgent: boolean;
+    /** True if the message looks like empathy observer output (prevent recursion). */
+    isEmpathyPrompt: boolean;
+}
+/** Input for formatting core principles into prompt text. */
+export interface CorePrincipleEntry {
+    id: string;
+    text: string;
+}
+/** Input for formatting evolution principles (active + probation). */
+export interface EvolutionPrincipleEntry extends CorePrincipleEntry {
+}
+/** Parts assembled into appendSystemContext. Order = priority (low → high). */
+export interface AppendSystemContextParts {
+    behavioralConstraints?: string;
+    projectContext?: string;
+    workingMemory?: string;
+    thinkingOs?: string;
+    evolutionPrinciples?: string;
+    corePrinciples?: string;
+}
+/** Input for the heartbeat checklist wrapper. */
+export interface HeartbeatChecklistInput {
+    content: string;
+}

package/dist/hooks/prompt-types.js

@@ -0,0 +1,12 @@
+/**
+ * Type definitions for prompt assembly.
+ *
+ * Extracted from hooks/prompt.ts per PRI-444 to enable independent testing
+ * of pure-logic helpers without importing the full hook module.
+ *
+ * ERR checklist:
+ * EP-01: All unknown inputs use typeof/Object.hasOwn guards, never `as`
+ * EP-03: Pure functions never swallow errors silently
+ * EP-09: Pure functions are independently unit-testable without mocks
+ */
+export {};

package/dist/hooks/prompt.d.ts

@@ -1,52 +1,21 @@
-import type { PluginHookBeforePromptBuildEvent, PluginHookAgentContext, PluginHookBeforePromptBuildResult, PluginLogger, OpenClawPluginApi } from '../openclaw-sdk.js';
+import type { PluginHookBeforePromptBuildEvent, PluginHookAgentContext, PluginHookBeforePromptBuildResult } from '../openclaw-sdk.js';
 import type { ContextInjectionConfig } from '../types.js';
+import type { PromptHookApi } from './prompt-types.js';
 /**
- * Default model configuration for OpenClaw agents
+ * Reset all module-level prompt state for a workspace.
+ * Intended for test isolation — call in beforeEach().
  */
-interface AgentsDefaultsConfig {
-    model?: unknown;
-    subagents?: {
-        model?: unknown;
-    };
-}
-interface PromptHookApi {
-    config?: {
-        agents?: {
-            defaults?: AgentsDefaultsConfig;
-        };
-        empathy_engine?: {
-            enabled?: boolean;
-        };
-    };
-    runtime: OpenClawPluginApi['runtime'];
-    logger: PluginLogger;
-}
+export declare function resetPromptStateForTest(workspaceDir?: string): void;
 /**
- * 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
+ * OpenClaw API Prompt Hook
+ * Constructs the system prompt injected into LLM context for Principles Disciple
  */
-export declare function resolveModelFromConfig(modelConfig: unknown, logger?: PluginLogger): string | null;
 /**
  * Loads context injection config from .principles/PROFILE.json
  * Parses contextInjection configuration from PROFILE.json for context injection
  * @internal Used by evolution engine for context settings
  */
 export declare function loadContextInjectionConfig(workspaceDir: string): ContextInjectionConfig;
-/**
- * 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 declare function getDiagnosticianModel(api: PromptHookApi | null, logger?: PluginLogger): string;
-/**
- * Extract recent user messages for keyword optimization context.
- */
-/**
- * Build prompt for keyword optimization subagent.
- */
 export declare function handleBeforePromptBuild(event: PluginHookBeforePromptBuildEvent, ctx: PluginHookAgentContext & {
     api?: PromptHookApi;
 }): Promise<PluginHookBeforePromptBuildResult | void>;
-export {};

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/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.139.0",
+  "version": "1.140.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.139.0",
+  "version": "1.140.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",

package/dist/hooks/subagent.d.ts

@@ -1,9 +0,0 @@
-import type { PluginHookSubagentEndedEvent, PluginHookSubagentContext, OpenClawPluginApi } from '../openclaw-sdk.js';
-type SubagentEndedHookContext = PluginHookSubagentContext & {
-    api?: OpenClawPluginApi;
-    workspaceDir?: string;
-    sessionId?: string;
-    agentId?: string;
-};
-export declare function handleSubagentEnded(event: PluginHookSubagentEndedEvent, ctx: SubagentEndedHookContext): Promise<void>;
-export {};

package/dist/hooks/subagent.js

@@ -1,122 +0,0 @@
-import { WorkspaceContext } from '../core/workspace-context.js';
-import { extractAgentIdFromSessionKey } from '../utils/session-key.js';
-import { recordEvolutionSuccess } from '../core/evolution-engine.js';
-import { WorkflowStore } from '../service/subagent-workflow/workflow-store.js';
-/**
- * Factory to create the appropriate WorkflowManager by workflow_type string.
- * Used by the subagent_ended hook to dispatch lifecycle recovery to the right manager.
- */
-function createWorkflowManagerForType(workflowType) {
-    switch (workflowType) {
-        default:
-            return null;
-    }
-}
-const HELPER_WORKFLOW_SESSION_PREFIX = 'agent:main:subagent:workflow-';
-// Cleanup expired retry entries periodically
-function emitSubagentPainEvent(wctx, payload, logger) {
-    try {
-        wctx.evolutionReducer.emitSync({
-            ts: new Date().toISOString(),
-            type: 'pain_detected',
-            data: {
-                painId: `pain_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
-                painType: 'subagent_error',
-                source: payload.source,
-                reason: payload.reason,
-                score: payload.score,
-                sessionId: payload.sessionId,
-                agentId: payload.agentId,
-            },
-        });
-    }
-    catch (e) {
-        logger.warn(`[PD:Subagent] failed to emit evolution event: ${String(e)}`);
-    }
-}
-export async function handleSubagentEnded(event, ctx) {
-    const { outcome, targetSessionKey } = event;
-    const { workspaceDir } = ctx;
-    if (!workspaceDir)
-        return;
-    const wctx = WorkspaceContext.fromHookContext(ctx);
-    const logger = ctx.api?.logger ?? console;
-    // ── Helper Workflow Lifecycle Notification ──
-    // When a helper workflow's subagent ends, notify the workflow manager
-    // so that it can trigger fallback recovery (notifyWaitResult → finalizeOnce)
-    if (targetSessionKey?.startsWith(HELPER_WORKFLOW_SESSION_PREFIX)) {
-        try {
-            const store = new WorkflowStore({ workspaceDir });
-            const workflow = store.getWorkflowByChildSession(targetSessionKey);
-            if (workflow && workflow.state !== 'completed' && workflow.state !== 'terminal_error' && workflow.state !== 'expired') {
-                logger.info(`[PD:Subagent] Helper workflow lifecycle event: workflowId=${workflow.workflow_id}, workflowType=${workflow.workflow_type}, outcome=${outcome}`);
-                const mappedOutcome = outcome === 'deleted' ? 'deleted' :
-                    outcome === 'killed' ? 'killed' :
-                        outcome === 'reset' ? 'reset' :
-                            outcome === 'error' ? 'error' :
-                                outcome === 'timeout' ? 'timeout' : 'ok';
-                // Call notifyLifecycleEvent on the appropriate manager so it
-                // triggers notifyWaitResult → finalizeOnce / terminal transition.
-                const subagentRuntime = ctx.api?.runtime?.subagent;
-                if (subagentRuntime) {
-                    const mgr = createWorkflowManagerForType(workflow.workflow_type);
-                    if (mgr) {
-                        await mgr.notifyLifecycleEvent(workflow.workflow_id, 'subagent_ended', { outcome: mappedOutcome });
-                        mgr.dispose();
-                    }
-                    else {
-                        logger.warn(`[PD:Subagent] Unknown workflow type ${workflow.workflow_type} — falling back to store-only event`);
-                        store.recordEvent(workflow.workflow_id, 'subagent_ended', workflow.state, workflow.state, `subagent ended with outcome: ${outcome}`, { outcome: mappedOutcome });
-                    }
-                }
-                else {
-                    logger.warn(`[PD:Subagent] Subagent runtime not available — cannot notify manager, falling back to store event`);
-                    store.recordEvent(workflow.workflow_id, 'subagent_ended', workflow.state, workflow.state, `subagent ended with outcome: ${outcome}`, { outcome: mappedOutcome });
-                }
-                store.dispose();
-                return;
-            }
-            store.dispose();
-        }
-        catch (e) {
-            logger.warn(`[PD:Subagent] Failed to notify helper workflow lifecycle: ${String(e)}`);
-        }
-    }
-    const { config } = wctx;
-    // ── Outcome-based EP and Pain Signal handling ──
-    // OpenClaw v2026.3.23 fixes: timeout may be false positive (fast-finishing workers)
-    // Only penalize actual errors, not timeout/killed/reset
-    if (outcome === 'error') {
-        // Only actual errors trigger penalty
-        const scoreSettings = config.get('scores');
-        const score = scoreSettings.subagent_error_penalty;
-        const reason = `Subagent session ${targetSessionKey} ended with error`;
-        // Emit pain via Runtime v2 chain (M8: no .pain_flag file)
-        emitSubagentPainEvent(wctx, {
-            source: `subagent_error`,
-            reason,
-            score,
-            sessionId: ctx.sessionId,
-            agentId: ctx.agentId || extractAgentIdFromSessionKey(targetSessionKey),
-        }, logger);
-    }
-    if (outcome === 'timeout') {
-        // OpenClaw v2026.3.23 fix: timeout may be false positive
-        // Fast-finishing workers are no longer incorrectly reported as timed out
-        // Do not penalize - the task may have actually succeeded
-        logger.warn(`[PD:Subagent] Session ${targetSessionKey} timed out - not penalizing (OpenClaw fix applied)`);
-    }
-    if (outcome === 'killed' || outcome === 'reset') {
-        // User-initiated termination or system reset - not an agent failure
-        logger.info(`[PD:Subagent] Session ${targetSessionKey} ended with ${outcome} - no penalty (user/system action)`);
-    }
-    if (outcome === 'ok' || outcome === 'deleted') {
-        recordEvolutionSuccess(workspaceDir, 'subagent', {
-            sessionId: ctx.sessionId,
-            reason: 'subagent_success',
-        });
-    }
-    // ── End of subagent_ended handling ──
-    // Note: Diagnostician runs via HEARTBEAT (main session LLM), not as a subagent.
-    // Principle creation happens in evolution-worker.ts marker detection path.
-}