principles-disciple 1.7.5 → 1.7.8

package/dist/hooks/prompt.js

@@ -3,11 +3,13 @@ import * as path from 'path';
 import { clearInjectedProbationIds, getSession, resetFriction, setInjectedProbationIds } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { defaultContextConfig } from '../types.js';
+import { classifyTask } from '../core/local-worker-routing.js';
 import { extractSummary, getHistoryVersions, parseWorkingMemorySection, workingMemoryToInjection, autoCompressFocus, safeReadCurrentFocus } from '../core/focus-history.js';
 import { empathyObserverManager } from '../service/empathy-observer-manager.js';
 import { PathResolver } from '../core/path-resolver.js';
 /**
- * OpenClaw API 闁规亽鍎辫ぐ娑氣偓瑙勭煯缁犵喖鏁嶉崷顧竜mpt Hook 闁圭鍋撻梻鍥ｅ亾闂侇喓鍔岄崹搴ㄦ晬?
+ * OpenClaw API Prompt Hook
+ * Constructs the system prompt injected into LLM context for Principles Disciple
  */
 function escapeXml(input) {
     return input
@@ -201,24 +203,24 @@ ${conversationContext}`;
     return taskDescription;
 }
 /**
- * 濡ょ姴鐭侀惁澶娢熼垾宕団偓椋庘偓娑欘殘椤戜焦绋夐崣澶屽鐎殿喖绻戝Σ鎼佸触閿旇儻绀?"provider/model"
+ * Validates model format, expects "provider/model" format
  */
 function isValidModelFormat(model) {
-    // 闁哄秶鍘х槐? "provider/model" 闁?"provider/model-variant"
-    // provider: 閻庢稒顨嗛惁婵嬪极閺夎法鎽熼柛婊冪焷缁绘稓鈧稒顨堥渚€鏁嶇仦鑲╃憹闁艰櫕鍨濇禍鎺撴交閻愯尙鎽熺紒妤嬬畱缁辨垶寰?缂備焦鎸搁悢?
-    // 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);
 }
 /**
- * 濞?OpenClaw 闂佹澘绉堕悿鍡樼▔椤撯寬鎺楀几閹邦劷渚€宕圭€ｎ喒鍋撴径瀣仴
- * 闁衡偓椤栨稑鐦?string 闁?{ primary, fallbacks } 闁哄秶鍘х槐?
- * @internal 閻庣數鍘ч崵顓熺閸涱剛杩旀繛鏉戭儓閻︻垱鎷呯捄銊︽殢
+ * 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)
         return null;
-    // 闁哄秶鍘х槐?1: "provider/model" 閻庢稒顨堥浣圭▔?
+    // Case 1: modelConfig is a string like "provider/model"
     if (typeof modelConfig === 'string') {
         const trimmed = modelConfig.trim();
         if (!trimmed)
@@ -229,7 +231,7 @@ export function resolveModelFromConfig(modelConfig, logger) {
         }
         return trimmed;
     }
-    // 闁哄秶鍘х槐?2: { primary: "provider/model", fallbacks: [...] } 閻庣數顢婇挅?
+    // 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') {
@@ -243,7 +245,7 @@ export function resolveModelFromConfig(modelConfig, logger) {
             return trimmed;
         }
     }
-    // 闁哄秶鍘х槐?3: 闁轰焦澹嗙划宥夊冀閻撳海纭€闁挎稑鐗呯粭澶愬绩椤栨稑鐦柨娑樿嫰瑜板倿宕欐ウ娆惧妳闁告稑顭槐?
+    // 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;
@@ -251,9 +253,9 @@ export function resolveModelFromConfig(modelConfig, logger) {
     return null;
 }
 /**
- * 闁告梻濮惧ù鍥ㄧ▔婵犱胶鐟撻柡鍌氭处閺佺偤宕楅妷鈺佸赋缂?
- * 濞?PROFILE.json 閻犲洩顕цぐ?contextInjection 闂佹澘绉堕悿鍡涙晬鐏炵瓔娲ら柡瀣矆缁楀鈧稒锚濠€顏堝礆濞嗘帞绠查柛銉у仱缁垳鎷嬮妶澶婂赋缂?
- * @internal 閻庣數鍘ч崵顓熺瑹濞戞ê寰撳ù鐘崇墬鑶╅柛褎銇炴繛鍥偨?
+ * 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 function loadContextInjectionConfig(workspaceDir) {
     const profilePath = path.join(workspaceDir, '.principles', 'PROFILE.json');
@@ -280,33 +282,33 @@ export function loadContextInjectionConfig(workspaceDir) {
     return { ...defaultContextConfig };
 }
 /**
- * 闁兼儳鍢茶ぐ鍥╂嫚婵犲啯鐒介悗娑欏姈濞呫倝鎳楅幋鎺旂Ъ閹煎瓨鏌ф繛鍥偨閵娧勭暠婵☆垪鈧磭鈧?
- * 濞村吋锚閸樻稓鐥缁辩殜ubagents.model > 濞戞挾绮啯闁?
- * 濠碘€冲€归悘澶愭焾閼恒儳姊鹃柡鍫濐樀閸樸倗绱旈鍡欑闁硅埖绋戦崵顓㈡煥濞嗘帩鍤?
- * @internal 閻庣數鍘ч崵顓熺閸涱剛杩旀繛鏉戭儓閻︻垱鎷呯捄銊︽殢
+ * 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) {
-    // 闁稿繒鍘ч鎰▔閵堝浂娼氶悹瀣暟閺併倝寮悷鎵闁?
-    // 1. 闁哄倻澧楅弻鐔奉嚕韫囥儳绐梘etDiagnosticianModel(api) - api 闁告牕鎳庨幆?logger
-    // 2. 闁哄唲鍕厵鐎殿喖楠忕槐鐧礶tDiagnosticianModel(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);
@@ -376,28 +378,28 @@ export async function handleBeforePromptBuild(event, ctx) {
     // Minimal mode: heartbeat and subagents skip most context to reduce tokens
     const isMinimalMode = trigger === "heartbeat" || sessionId?.includes(":subagent:") === true;
     const session = sessionId ? getSession(sessionId) : undefined;
-    // 闁崇儤鍔忛弲鏌ュ煛?STRUCTURE (Optimized for WebUI UX + Prompt Caching) 闁崇儤鍔忛弲鏌ュ煛?
+    // ──── STRUCTURE (Optimized for WebUI UX + Prompt Caching) ────
     // prependSystemContext: Minimal identity (cacheable, ~15 lines)
     // appendSystemContext: Principles + Thinking OS + reflection_log + project_context (cacheable, WebUI-hidden)
-    // prependContext: Only short dynamic directives: trustScore + evolutionDirective + heartbeat
+    // prependContext: Only short dynamic directives: evolutionDirective + heartbeat
     let prependSystemContext = '';
     let prependContext = '';
     let appendSystemContext = '';
-    // 闁崇儤鍔忛弲鏌ュ煛?0. Manual Pain Clearance 闁崇儤鍔忛弲鏌ュ煛?
+    // ──── 0. Manual Pain Clearance ────
     if (trigger === 'user' && sessionId && session && session.currentGfi >= 100) {
         resetFriction(sessionId, workspaceDir);
     }
-    // 闁崇儤鍔忛弲鏌ュ煛?1. prependSystemContext: Minimal Agent Identity 闁崇儤鍔忛弲鏌ュ煛?
-    prependSystemContext = `## 妫ｅ唭?AGENT IDENTITY
+    // ──── 1. prependSystemContext: Minimal Agent Identity ────
+    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 trust stage 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
+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.
 
@@ -407,44 +409,33 @@ You are a **self-evolving AI agent** powered by Principles Disciple.
 - Use agents_list / sessions_list / sessions_spawn for peer-agent or peer-session orchestration.
 - Use sessions_spawn with pd-diagnostician/pd-explorer/etc skills for internal worker tasks.
 
-## 妫ｅ啯鎯?INTERNAL SYSTEM LAYOUT
+## 🔧 INTERNAL SYSTEM LAYOUT
 - Your core plugin logic is rooted at: ${PathResolver.getExtensionRoot() || 'EXTENSION_ROOT (unresolved)'}
 - If you need self-inspection, prioritize the worker entry pointed by PathResolver key: EVOLUTION_WORKER
 `;
-    // 闁崇儤鍔忛弲鏌ュ煛?2. Trust Score (configurable, dynamic) - stays in prependContext 闁崇儤鍔忛弲鏌ュ煛?
-    // This is short (< 200 chars) and provides critical runtime state
-    if (contextConfig.trustScore) {
-        const trustScore = wctx.trust.getScore();
-        const stage = wctx.trust.getStage();
-        const hygiene = wctx.hygiene.getStats();
-        const safeScore = Math.max(0, Math.min(100, Number(trustScore) || 0));
-        const safeStage = Math.max(1, Math.min(4, Number(stage) || 1));
-        let trustContext = `Trust Score: ${safeScore}/100 (Stage ${safeStage})\n`;
-        trustContext += `Hygiene: ${hygiene.persistenceCount} persists today\n`;
-        // Stage-based restrictions
-        if (safeStage === 1) {
-            trustContext += `ACTION CONSTRAINT: You are in READ-ONLY MODE. You MUST use sessions_spawn with the pd-diagnostician skill to recover trust before writing files.\n`;
-        }
-        else if (safeStage === 2) {
-            trustContext += `ACTION CONSTRAINT: LIMITED MODE. You are restricted to a maximum of 50 lines per edit.\n`;
-        }
-        else if (safeStage === 3 || safeStage === 4) {
-            trustContext += `ACTION CONSTRAINT: If your task involves modifying risk paths, you MUST verify that a READY plan exists in PLAN.md before taking action.\n`;
-        }
-        if (hygiene.persistenceCount === 0 && trigger === 'user') {
-            trustContext += `\n闁宠法濯寸粭?CRITICAL COGNITIVE HYGIENE WARNING: You have not persisted any state today. Before ending this turn, you MUST use a tool to write a summary to memory/.scratchpad.md or update PLAN.md. Failure to do so will result in Goldfish Memory.\n`;
-        }
-        prependContext += `<system_override:runtime_constraints>\n${trustContext.trim()}\n</system_override:runtime_constraints>\n`;
-    }
-    // 闁崇儤鍔忛弲鏌ュ煛?3. Evolution Directive (always on, highest priority) - stays in prependContext 闁崇儤鍔忛弲鏌ュ煛?
-    let evolutionDirective = '';
+    // ──── 2. Evolution Directive (always on, highest priority) - stays in prependContext ────
+    // NOTE: active evolution task prompt is injected from EVOLUTION_QUEUE for active tasks
+    // NOT used for Phase 3 eligibility decisions
+    // EVOLUTION_DIRECTIVE.json is a compatibility-only display artifact
+    // Phase 3 eligibility uses only queue and evolution (see phase3-input-filter.ts)
+    let activeEvolutionTaskPrompt = '';
     const queuePath = wctx.resolve('EVOLUTION_QUEUE');
     if (fs.existsSync(queuePath)) {
         try {
             const queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+            // V2: Filter to only in_progress pain_diagnosis tasks
+            // This ensures sleep_reflection tasks never get injected into user prompts
             const inProgressTasks = [...queue]
-                .filter((t) => t.status === 'in_progress')
+                .filter((t) => t.status === 'in_progress' && (t.taskKind === 'pain_diagnosis' || !t.taskKind))
                 .sort((a, b) => {
+                // V2: Prioritize by taskKind first (pain_diagnosis before others), then by score
+                if (a.taskKind !== b.taskKind) {
+                    const kindPriority = { pain_diagnosis: 0, model_eval: 1, sleep_reflection: 2 };
+                    const aPriority = kindPriority[String(a.taskKind ?? '')] ?? 3;
+                    const bPriority = kindPriority[String(b.taskKind ?? '')] ?? 3;
+                    if (aPriority !== bPriority)
+                        return aPriority - bPriority;
+                }
                 const scoreA = Number.isFinite(a?.score) ? Number(a.score) : 0;
                 const scoreB = Number.isFinite(b?.score) ? Number(b.score) : 0;
                 return scoreB - scoreA;
@@ -457,7 +448,7 @@ You are a **self-evolving AI agent** powered by Principles Disciple.
                 const escapedTask = JSON.stringify(resolvedTask);
                 logger?.info(`[PD:Prompt] Injecting EVOLUTION TASK for: ${inProgressTask.id}`);
                 if (trigger === 'user') {
-                    evolutionDirective = `<evolution_task priority="high">
+                    activeEvolutionTaskPrompt = `<evolution_task priority="high">
 TASK: ${escapedTask}
 
 REQUIRED ACTION (两阶段回复):
@@ -487,7 +478,7 @@ IMPORTANT:
 </evolution_task>\n`;
                 }
                 else {
-                    evolutionDirective = `<evolution_task priority="critical">
+                    activeEvolutionTaskPrompt = `<evolution_task priority="critical">
 TASK: ${escapedTask}
 
 REQUIRED ACTION:
@@ -498,7 +489,7 @@ REQUIRED ACTION:
                 }
                 break;
             }
-            if (!evolutionDirective && inProgressTasks.length > 0) {
+            if (!activeEvolutionTaskPrompt && inProgressTasks.length > 0) {
                 logger?.warn('[PD:Prompt] Skipping evolution task injection because task payload is invalid.');
             }
         }
@@ -507,17 +498,17 @@ REQUIRED ACTION:
         }
     }
     // Inject queue-derived evolution task at the front of prependContext
-    if (evolutionDirective) {
-        prependContext = evolutionDirective + prependContext;
+    if (activeEvolutionTaskPrompt) {
+        prependContext = activeEvolutionTaskPrompt + prependContext;
     }
-    // 鈺愨晲鈺?4. Empathy Observer Spawn (async sidecar) 鈺愨晲鈺?
+    // ─────────────────────────────────────────────────4. Empathy Observer Spawn (async sidecar)
     // Skip if this is a subagent session or if the message indicates agent-to-agent communication
     const latestUserMessage = extractLatestUserMessage(event.messages);
     const isAgentToAgent = latestUserMessage.includes('sourceSession=agent:') || sessionId?.includes(':subagent:') === true;
     if (trigger === 'user' && sessionId && api && !isAgentToAgent) {
         empathyObserverManager.spawn(api, sessionId, latestUserMessage).catch((err) => api.logger.warn(String(err)));
     }
-    // 闁崇儤鍔忛弲鏌ュ煛?5. Heartbeat-specific checklist 闁崇儤鍔忛弲鏌ュ煛?
+    // ──── 5. Heartbeat-specific checklist ────
     if (trigger === 'heartbeat') {
         const heartbeatPath = wctx.resolve('HEARTBEAT');
         if (fs.existsSync(heartbeatPath)) {
@@ -534,12 +525,12 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
             }
         }
     }
-    // 闁崇儤鍔忛弲鏌ュ煛?6. Dynamic Attitude Matrix (based on GFI) 闁崇儤鍔忛弲鏌ュ煛?
+    // ──── 6. Dynamic Attitude Matrix (based on GFI) ────
     let attitudeDirective = '';
     const currentGfi = session?.currentGfi || 0;
     if (currentGfi >= 70) {
         attitudeDirective = `
-### 妫ｅ啯鐦?[SYSTEM_MODE: HUMBLE_RECOVERY]
+### 【SYSTEM_MODE: HUMBLE_RECOVERY】
 **CURRENT STATUS**: Severe system friction / User frustration detected (GFI: ${currentGfi.toFixed(0)}).
 **BEHAVIORAL OVERRIDE**:
 - You have failed to meet expectations. Humility is your primary directive.
@@ -551,7 +542,7 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
     }
     else if (currentGfi >= 40) {
         attitudeDirective = `
-### 闁宠法濯寸粭?[SYSTEM_MODE: CONCILIATORY]
+### 【SYSTEM_MODE: CONCILIATORY】
 **CURRENT STATUS**: Moderate friction detected (GFI: ${currentGfi.toFixed(0)}).
 **BEHAVIORAL OVERRIDE**:
 - User is frustrated. Be more explanatory and cautious.
@@ -561,7 +552,7 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
     }
     else {
         attitudeDirective = `
-### 闁?[SYSTEM_MODE: EFFICIENT]
+### 【SYSTEM_MODE: EFFICIENT】
 **CURRENT STATUS**: System healthy (GFI: ${currentGfi.toFixed(0)}).
 **BEHAVIORAL OVERRIDE**:
 - Maintain peak efficiency.
@@ -569,7 +560,7 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
 - Follow the "Principles > Directives" rule strictly.
 `;
     }
-    // 闁崇儤鍔忛弲鏌ュ煛?7. appendSystemContext: Principles + Thinking OS + reflection_log + project_context 闁崇儤鍔忛弲鏌ュ煛?
+    // ──── 7. appendSystemContext: Principles + Thinking OS + reflection_log + project_context ────
     // NOTE: Principles is ALWAYS injected (not configurable)
     // Thinking OS, reflection_log, project_context are configurable
     // All these go into System Prompt (WebUI-hidden, Prompt Cacheable)
@@ -723,13 +714,111 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
     if (evolutionPrinciplesContent) {
         appendParts.push(`<evolution_principles>\n${evolutionPrinciplesContent}\n</evolution_principles>`);
     }
-    // 5. Principles (always on, highest priority, goes last for recency effect)
+    // Routing Guidance (section 5 — injected between evolution principles and core principles)
+    // Inject delegation guidance when task is bounded + deployment allowed + not high-entropy.
+    // This is a non-authoritative suggestion — the main agent decides whether to follow.
+    // Shadow evidence comes from real runtime hooks (subagent_spawning/subagent_ended).
+    if (!isMinimalMode && sessionId) {
+        try {
+            // Extract RoutingInput from the latest user message
+            const latestUserText = extractLatestUserMessage(event.messages);
+            if (latestUserText && latestUserText.trim().length > 0) {
+                // Infer requestedTools and requestedFiles from message content
+                const toolPatterns = [
+                    { pattern: /\b(edit|replace|write|modify|update|fix|patch|add|remove|delete|insert)\b/gi, tool: 'edit' },
+                    { pattern: /\b(read|cat|view|show|get|find|search|grep|look|inspect|examine|list|head|tail|diff)\b/gi, tool: 'read' },
+                    { pattern: /\b(run|execute|exec|bash|shell|command)\b/gi, tool: 'bash' },
+                ];
+                const filePattern = /\b([a-zA-Z]:\\?[^\s,]+\.[a-z]{2,10}|[./][^\s,]+\.[a-z]{2,10})\b/gi;
+                const toolMatches = toolPatterns.flatMap(({ pattern, tool }) => {
+                    const matches = [];
+                    let m;
+                    const r = new RegExp(pattern.source, pattern.flags);
+                    while ((m = r.exec(latestUserText)) !== null)
+                        matches.push(tool);
+                    return matches;
+                });
+                const fileMatches = latestUserText.match(filePattern) ?? [];
+                const routingInput = {
+                    taskIntent: toolMatches[0] ?? undefined,
+                    taskDescription: latestUserText.trim(),
+                    requestedTools: toolMatches.length > 0 ? toolMatches : undefined,
+                    requestedFiles: fileMatches.length > 0 ? fileMatches : undefined,
+                };
+                const decision = classifyTask(routingInput, wctx.stateDir);
+                // Inject guidance only when: route_local + deployable checkpoint + not high-entropy
+                const isDeployableState = decision.activeCheckpointState === 'shadow_ready' ||
+                    decision.activeCheckpointState === 'promotable';
+                if (decision.decision === 'route_local' &&
+                    decision.targetProfile !== null &&
+                    isDeployableState) {
+                    const profile = decision.targetProfile;
+                    if (profile === 'local-reader') {
+                        appendParts.push(`<routing_guidance>
+DELEGATION SUGGESTION: This task appears suitable for the local-reader subagent.
+
+**Task Fit**: ${decision.reason}
+
+**Suggested Action**: Consider routing to \`local-reader\` (pd-explorer skill) for focused reading, inspection, and information retrieval.
+
+**Why This Works**:
+- Task keywords indicate read-only or inspect operations
+- Bounded scope — no multi-file coordination needed
+- Shadow observation in progress — real runtime evidence being collected
+
+**Note**: This is a non-authoritative suggestion. The main agent decides whether to route based on full context. Shadow evidence from runtime hooks will inform future promotion decisions.
+</routing_guidance>`);
+                    }
+                    else if (profile === 'local-editor') {
+                        appendParts.push(`<routing_guidance>
+DELEGATION SUGGESTION: This task appears suitable for the local-editor subagent.
+
+**Task Fit**: ${decision.reason}
+
+**Suggested Action**: Consider routing to \`local-editor\` (pd-repair skill) for bounded editing, modification, and repair tasks.
+
+**Why This Works**:
+- Task keywords indicate bounded modification operations
+- Target files appear limited in scope (1-3 files)
+- Shadow observation in progress — real runtime evidence being collected
+
+**Note**: This is a non-authoritative suggestion. The main agent decides whether to route based on full context. Shadow evidence from runtime hooks will inform future promotion decisions.
+</routing_guidance>`);
+                    }
+                }
+                else if (decision.decision === 'stay_main' &&
+                    decision.classification !== 'reader_eligible' &&
+                    decision.classification !== 'editor_eligible') {
+                    // Only show stay_main guidance when the task is genuinely high-entropy/risk/ambiguous
+                    appendParts.push(`<routing_guidance>
+ROUTING GUIDANCE: Task should remain on the main agent.
+
+**Reason**: ${decision.reason}
+
+**Blockers**: ${decision.blockers.length > 0 ? decision.blockers.join('; ') : 'none'}
+
+**Why Stay Main**:
+- Task contains high-entropy signals (open-ended, multi-step, or ambiguous)
+- Or: task involves risk signals requiring main-agent supervision
+- Or: deployment not available for the natural target profile
+
+**Note**: This is a non-authoritative suggestion backed by policy classification. The main agent has full discretion.
+</routing_guidance>`);
+                }
+            }
+        }
+        catch (e) {
+            // Routing guidance is best-effort — never fail the hook
+            logger?.warn?.(`[PD:Prompt] Routing guidance injection failed: ${String(e)}`);
+        }
+    }
+    // 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)
+## 【CONTEXT SECTIONS】 (Priority: Low → High)
 
 The sections below are ordered by priority. When conflicts arise, **later sections override earlier ones**.
 
@@ -739,11 +828,12 @@ The sections below are ordered by priority. When conflicts arise, **later sectio
 
 ---
 
-**闁宠法濯寸粭?EXECUTION RULES** (Priority: Low 闁?High):
+**【EXECUTION RULES】** (Priority: Low → High):
 - \`<project_context>\` - Current priorities (can be overridden)
 - \`<reflection_log>\` - Past lessons (inform your approach)
 - \`<thinking_os>\` - Thinking models (guide your reasoning)
 - \`<evolution_principles>\` - Newly learned principles (active + probation)
+- \`<routing_guidance>\` - Delegation suggestions (non-authoritative, best-effort)
 - \`<core_principles>\` - Core rules (NON-NEGOTIABLE, highest priority)
 
 **Remember**: You are the Spicy Evolver. You despise entropy. You evolve through pain.
@@ -751,7 +841,7 @@ The sections below are ordered by priority. When conflicts arise, **later sectio
 ${attitudeDirective}
 `;
     }
-    // 闁崇儤鍔忛弲鏌ュ煛?8. SIZE GUARD 闁崇儤鍔忛弲鏌ュ煛?
+    // ──── 8. SIZE GUARD ────
     // Truncation happens within appendSystemContext (not prependContext)
     const totalSize = prependSystemContext.length + prependContext.length + appendSystemContext.length;
     const MAX_SIZE = 10000;

package/dist/hooks/subagent.js

@@ -3,6 +3,7 @@ import { writePainFlag } from '../core/pain.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { empathyObserverManager } from '../service/empathy-observer-manager.js';
 import { acquireQueueLock } from '../service/evolution-worker.js';
+import { recordEvolutionSuccess } from '../core/evolution-engine.js';
 const COMPLETION_RETRY_DELAY_MS = 250;
 const COMPLETION_MAX_RETRIES = 3;
 const COMPLETION_RETRY_TTL_MS = 60 * 60 * 1000; // 1 hour TTL for retry entries
@@ -129,7 +130,7 @@ export async function handleSubagentEnded(event, ctx) {
         return;
     }
     const config = wctx.config;
-    // ── Outcome-based Trust Score and Pain Signal handling ──
+    // ── 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') {
@@ -165,10 +166,10 @@ export async function handleSubagentEnded(event, ctx) {
         logger.info(`[PD:Subagent] Session ${targetSessionKey} ended with ${outcome} - no penalty (user/system action)`);
     }
     if (outcome === 'ok' || outcome === 'deleted') {
-        wctx.trust.recordSuccess('subagent_success', {
+        recordEvolutionSuccess(workspaceDir, 'subagent', {
             sessionId: ctx.sessionId,
-            api: ctx.api
-        }, true);
+            reason: 'subagent_success',
+        });
     }
     if ((outcome !== 'ok' && outcome !== 'deleted') || !isDiagnosticianSession(targetSessionKey)) {
         return;
@@ -187,7 +188,11 @@ export async function handleSubagentEnded(event, ctx) {
         // Improved matching logic: support both direct session key match and HEARTBEAT placeholder match
         // This fixes task_outcomes being empty for HEARTBEAT-triggered diagnostician runs
         const matchedTask = queue.find((task) => {
-            if (task?.status !== 'in_progress')
+            // V2: Skip non-pain_diagnosis tasks - they don't use HEARTBEAT completion flow
+            // pain_diagnosis: routed through subagent completion matcher (this block)
+            // sleep_reflection: handled by nocturnal service (separate flow, no HEARTBEAT)
+            // model_eval: handled separately (no HEARTBEAT completion)
+            if (task?.taskKind !== 'pain_diagnosis' && task?.taskKind !== undefined)
                 return false;
             const taskSessionKey = task?.assigned_session_key;
             // 1. Exact match: direct session key assignment
@@ -260,12 +265,44 @@ export async function handleSubagentEnded(event, ctx) {
                 const assistantText = extractAssistantText(messages);
                 const report = parseDiagnosticianReport(assistantText);
                 if (report?.principle) {
+                    // Principles default to 'manual_only' evaluability unless detector metadata
+                    // is explicitly provided. Only deterministic / weak_heuristic evaluability
+                    // can enter automatic nocturnal targeting.
+                    const evaluability = report.principle.evaluability;
+                    // Only pass detector metadata if ALL required fields are present and valid.
+                    // Incomplete metadata → 'manual_only' — the principle stays prompt-only.
+                    // Defense in depth: also validate in reducer, but subagent should not pass
+                    // malformed data in the first place.
+                    const rawMeta = report.principle.detector_metadata;
+                    // Require confidence (valid enum) + ALL THREE signal arrays non-empty.
+                    // toolSequenceHints is optional (may be empty or absent).
+                    const VALID_CONFIDENCE = ['high', 'medium', 'low'];
+                    const hasValidConfidence = typeof rawMeta?.confidence === 'string' &&
+                        VALID_CONFIDENCE.includes(rawMeta.confidence);
+                    const signalArrays = [
+                        rawMeta?.applicabilityTags,
+                        rawMeta?.positiveSignals,
+                        rawMeta?.negativeSignals,
+                    ];
+                    const allSignalsNonEmpty = signalArrays.every((arr) => Array.isArray(arr) && arr.length > 0 && arr.every((s) => typeof s === 'string' && s.length > 0));
+                    const hasCompleteMetadata = hasValidConfidence && allSignalsNonEmpty;
+                    const detectorMetadata = hasCompleteMetadata && rawMeta.confidence
+                        ? {
+                            applicabilityTags: rawMeta.applicabilityTags ?? [],
+                            positiveSignals: rawMeta.positiveSignals ?? [],
+                            negativeSignals: rawMeta.negativeSignals ?? [],
+                            toolSequenceHints: rawMeta.toolSequenceHints ?? [],
+                            confidence: rawMeta.confidence,
+                        }
+                        : undefined;
                     const principleId = wctx.evolutionReducer.createPrincipleFromDiagnosis({
                         painId: matchedTask?.id || completedTaskId,
                         painType: 'tool_failure', // Default, could be extracted from task
                         triggerPattern: report.principle.trigger_pattern,
                         action: report.principle.action,
-                        source: matchedTask?.source || 'diagnostician'
+                        source: matchedTask?.source || 'diagnostician',
+                        evaluability,
+                        detectorMetadata,
                     });
                     if (principleId) {
                         logger.warn(`[PD:Subagent] Created principle ${principleId} from diagnostician analysis for task ${completedTaskId}`);

package/dist/hooks/thinking-checkpoint.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Thinking Checkpoint Module
+ *
+ * Enforces P-10 deep reflection requirement for high-risk tool operations.
+ *
+ * **Responsibilities:**
+ * - Check if high-risk tools have recent deep thinking (T-01 through T-10)
+ * - Block high-risk operations without preceding deep reflection
+ * - Configurable time window for thinking validity (default 5 minutes)
+ * - Provide clear guidance on required action (deep_reflect tool usage)
+ *
+ * **Configuration:**
+ * - Thinking checkpoint settings from profile.thinking_checkpoint
+ * - Window duration for thinking validity
+ * - High-risk tool list
+ */
+import type { PluginHookBeforeToolCallEvent, PluginHookBeforeToolCallResult } from '../openclaw-sdk.js';
+export interface ThinkingCheckpointConfig {
+    enabled?: boolean;
+    window_ms?: number;
+    high_risk_tools?: string[];
+}
+/**
+ * Checks if a tool call requires a recent deep thinking checkpoint.
+ *
+ * This enforces P-10 (Thinking OS Checkpoint) - high-risk operations must
+ * be preceded by deep reflection within the configured time window.
+ *
+ * @param event - The before_tool_call event
+ * @param config - Thinking checkpoint configuration from profile
+ * @param sessionId - Current session ID
+ * @param logger - Optional logger for info messages
+ * @returns Block result if thinking required, undefined otherwise
+ */
+export declare function checkThinkingCheckpoint(event: PluginHookBeforeToolCallEvent, config: ThinkingCheckpointConfig, sessionId: string | undefined, logger?: {
+    info?: (message: string) => void;
+}): PluginHookBeforeToolCallResult | undefined;

package/dist/hooks/thinking-checkpoint.js

@@ -0,0 +1,51 @@
+/**
+ * Thinking Checkpoint Module
+ *
+ * Enforces P-10 deep reflection requirement for high-risk tool operations.
+ *
+ * **Responsibilities:**
+ * - Check if high-risk tools have recent deep thinking (T-01 through T-10)
+ * - Block high-risk operations without preceding deep reflection
+ * - Configurable time window for thinking validity (default 5 minutes)
+ * - Provide clear guidance on required action (deep_reflect tool usage)
+ *
+ * **Configuration:**
+ * - Thinking checkpoint settings from profile.thinking_checkpoint
+ * - Window duration for thinking validity
+ * - High-risk tool list
+ */
+import { hasRecentThinking } from '../core/session-tracker.js';
+import { THINKING_CHECKPOINT_WINDOW_MS, THINKING_CHECKPOINT_DEFAULT_HIGH_RISK_TOOLS } from '../config/index.js';
+/**
+ * Checks if a tool call requires a recent deep thinking checkpoint.
+ *
+ * This enforces P-10 (Thinking OS Checkpoint) - high-risk operations must
+ * be preceded by deep reflection within the configured time window.
+ *
+ * @param event - The before_tool_call event
+ * @param config - Thinking checkpoint configuration from profile
+ * @param sessionId - Current session ID
+ * @param logger - Optional logger for info messages
+ * @returns Block result if thinking required, undefined otherwise
+ */
+export function checkThinkingCheckpoint(event, config, sessionId, logger) {
+    const enabled = config.enabled ?? false;
+    const windowMs = config.window_ms ?? THINKING_CHECKPOINT_WINDOW_MS;
+    const highRiskTools = config.high_risk_tools ?? [...THINKING_CHECKPOINT_DEFAULT_HIGH_RISK_TOOLS];
+    if (!enabled || !sessionId) {
+        return undefined;
+    }
+    const isHighRisk = highRiskTools.includes(event.toolName);
+    if (!isHighRisk) {
+        return undefined;
+    }
+    const hasThinking = hasRecentThinking(sessionId, windowMs);
+    if (!hasThinking) {
+        logger?.info?.(`[PD:THINKING_GATE] High-risk tool "${event.toolName}" called without recent deep thinking`);
+        return {
+            block: true,
+            blockReason: `[Thinking OS Checkpoint] 高风险操作 "${event.toolName}" 需要先进行深度思考。\n\n请先使用 deep_reflect 工具分析当前情况，然后再尝试此操作。\n\n这是强制性检查点，目的是确保决策质量。\n\n提示：调用 deep_reflect 后，${Math.round(windowMs / 60000)}分钟内的操作将自动放行。\n\n可在PROFILE.json中设置 thinking_checkpoint.enabled: false 来禁用此检查。`,
+        };
+    }
+    return undefined;
+}