principles-disciple 1.138.0 → 1.140.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/service/evolution-worker.js

@@ -93,7 +93,8 @@ export function purgeStaleFailedTasks(queue, logger) {
     // Remove purged items from the queue (mutates in place)
     const purgedIds = new Set(purged.map((t) => t.id));
     for (let i = queue.length - 1; i >= 0; i--) {
-        if (purgedIds.has(queue[i].id))
+        const task = queue[i];
+        if (task && purgedIds.has(task.id))
             queue.splice(i, 1);
     }
     const summary = Object.entries(byReason)
@@ -377,17 +378,20 @@ async function processDetectionQueue(wctx, api, eventLog) {
                 if (wctx.trajectory) {
                     const searchResults = wctx.trajectory.searchPainEvents(text, 5);
                     if (searchResults.length > 0) {
+                        const topResult = searchResults[0];
+                        if (!topResult)
+                            continue;
                         // Found similar pain events - record as L3 semantic hit
                         if (eventLog) {
                             eventLog.recordRuleMatch(undefined, {
                                 ruleId: 'l3_semantic',
                                 layer: 'L3',
-                                severity: searchResults[0].score,
+                                severity: topResult.score,
                                 textPreview: text.substring(0, 100)
                             });
                         }
                         // Update detection funnel cache with L3 hit result
-                        funnel.updateCache(text, { detected: true, severity: searchResults[0].score });
+                        funnel.updateCache(text, { detected: true, severity: topResult.score });
                         // Don't track as candidate - this is a confirmed L3 hit
                         if (logger)
                             logger.info(`[PD:EvolutionWorker] L3 semantic hit: found ${searchResults.length} similar pain events for "${text.substring(0, 50)}..."`);

package/dist/service/runtime-summary-service.js

@@ -290,7 +290,10 @@ export class RuntimeSummaryService {
         if (sessions.length === 0) {
             return { session: null, reason: 'none' };
         }
-        return { session: sessions[0], reason: 'latest_active' };
+        const session = sessions[0];
+        if (!session)
+            return { session: null, reason: 'none' };
+        return { session, reason: 'latest_active' };
     }
     static mergeSessionSnapshots(persistedSessions, workspaceDir) {
         const merged = new Map();
@@ -392,6 +395,8 @@ export class RuntimeSummaryService {
                         if (!m)
                             continue;
                         const fileDate = m[1];
+                        if (!fileDate)
+                            continue;
                         if (fileDate > newestDate) {
                             newestDate = fileDate;
                             bestFile = path.join(dir, file);
@@ -463,6 +468,8 @@ export class RuntimeSummaryService {
     static findLastPainSignal(events, sessionId) {
         for (let i = events.length - 1; i >= 0; i--) {
             const entry = events[i];
+            if (!entry)
+                continue;
             if (entry.type !== 'pain_signal')
                 continue;
             if (sessionId && entry.sessionId !== sessionId)

package/dist/service/workflow-watchdog.js

@@ -32,7 +32,8 @@ export async function runWorkflowWatchdog(wctx, api, logger) {
                     const ageMin = Math.round((now - wf.created_at) / 60000);
                     details.push(`stale_active: ${wf.workflow_id} (${wf.workflow_type}, ${ageMin}min old)`);
                     const events = store.getEvents(wf.workflow_id);
-                    const lastEventReason = events.length > 0 ? events[events.length - 1].reason : 'unknown';
+                    const lastEvent = events[events.length - 1];
+                    const lastEventReason = lastEvent ? lastEvent.reason : 'unknown';
                     if (isExpectedSubagentError(lastEventReason)) {
                         logger?.debug?.(`[PD:Watchdog] Skipping stale active workflow ${wf.workflow_id}: expected subagent error (${lastEventReason})`);
                         continue;

package/dist/utils/retry.js

@@ -245,11 +245,13 @@ export function percentile(values, p) {
     const n = sorted.length;
     // For small samples, use median to avoid overfitting
     if (n < 10) {
-        return sorted[Math.floor(n / 2)];
+        const median = sorted[Math.floor(n / 2)];
+        return median ?? 0;
     }
     // Standard percentile calculation (nearest-rank method)
     const rank = Math.ceil((p / 100) * n);
-    return sorted[Math.min(rank, n) - 1];
+    const result = sorted[Math.min(rank, n) - 1];
+    return result ?? 0;
 }
 /**
  * Clamp timeout to safe bounds.
@@ -317,6 +319,9 @@ export function computeAdaptiveTimeout(history, fallbackMs, options = {}) {
     const sorted = [...history].sort((a, b) => a - b);
     const rank = Math.ceil((p / 100) * sorted.length);
     const pValue = sorted[Math.min(rank, sorted.length) - 1];
+    if (pValue === undefined) {
+        return Math.max(minTimeoutMs, Math.min(maxTimeoutMs, fallbackMs));
+    }
     const adaptive = pValue * safetyMultiplier;
     return Math.max(minTimeoutMs, Math.min(maxTimeoutMs, Math.round(adaptive)));
 }

package/dist/utils/session-key.js

@@ -13,6 +13,9 @@ export function extractAgentIdFromSessionKey(sessionKey) {
     const match = /^agent:([^:]+):/.exec(sessionKey);
     if (!match)
         return undefined;
-    const agentId = match[1].trim();
+    const raw = match[1];
+    if (!raw)
+        return undefined;
+    const agentId = raw.trim();
     return agentId || undefined;
 }