create-principles-disciple 1.92.0 → 1.94.0

package/plugin/dist/hooks/gate-block-helper.js

@@ -15,6 +15,8 @@ import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
 import { emitPainDetectedEvent } from './pain.js';
 import { loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
 import { evaluateEvidenceTriage } from './triage-adapter.js';
+import { evaluateTriggerController } from '@principles/core/runtime-v2';
+import { isSharedCooldownActive, markSharedEpisodeAsDiagnosed } from './trigger-cooldown-tracker.js';
 import { isRisky } from '../utils/io.js';
 import { normalizeProfile } from '../core/profile.js';
 import { SystemLogger } from '../core/system-logger.js';
@@ -78,19 +80,19 @@ export function recordGateBlockAndReturn(wctx, blockCtx, logger) {
     // so one mild block does not start a long diagnostician run.
     if (sessionId) {
         const GATE_BLOCK_PAIN_SCORE = 45; // Must be >= pain_trigger (40) so single gate block can trigger diagnosis (PRI-274)
-        // Record to trajectory (fire-and-forget, no .pain_flag file needed)
-        wctx.trajectory?.recordPainEvent?.({
-            sessionId,
-            source: 'gate_blocked',
-            score: GATE_BLOCK_PAIN_SCORE,
-            reason: `Gate blocked ${toolName} on ${filePath}: ${reason}`,
-            severity: 'mild',
-            origin: 'system_infer',
-        });
-        // PEAT-B1: Evidence triage (feature-flagged)
-        let triageAdmitted = true;
-        const gateBlockTriageFlag = loadFeatureFlagFromConfig(wctx.workspaceDir, 'painEvidenceAdmission');
-        if (gateBlockTriageFlag.enabled) {
+        // PRI-453: Generate painId early. SDK observability path (emitPainDetectedEvent
+        // with default recordObservability: true) handles all writes: events_*.jsonl +
+        // evolution.jsonl + trajectory.db (with canonicalPainId for dedup). No separate
+        // legacy recordPainEvent call needed — avoids double-write to trajectory.db.
+        const gatePainId = `gate_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+        // PRI-454: Dual-gate migration. When both flags ON → Gate B (TriggerController).
+        // When either OFF → Gate A (PainDiagnosticGate, rollback).
+        const triageFlag = loadFeatureFlagFromConfig(wctx.workspaceDir, 'painEvidenceAdmission');
+        const defaultFlag = loadFeatureFlagFromConfig(wctx.workspaceDir, 'painEvidenceAdmissionDefault');
+        const useGateB = triageFlag.enabled && defaultFlag.enabled;
+        // PEAT-B1: Evidence triage (runs when Gate B is active)
+        const session = getSession(sessionId);
+        if (useGateB) {
             // Load profile with 1MB size guard, matching pain.ts pattern
             const profilePath = wctx.resolve('PROFILE');
             let profile = normalizeProfile({});
@@ -115,16 +117,54 @@ export function recordGateBlockAndReturn(wctx, blockCtx, logger) {
             // weight, NOT the action risk severity. The rulehost principle already determined
             // this action was important enough to block — that is the real signal.
             const isUnsafe = isRisky(filePath, profile.risk_paths);
+            // PRI-454 P2-1: Pass consecutiveErrors and isRisky to match Gate A's
+            // upgrade logic. Rule 3 (consecutiveErrors >= 4 → admit) was being
+            // dropped, so non-risky repeated gate blocks never triggered diagnosis.
             const triage = evaluateEvidenceTriage('rulehost_block', GATE_BLOCK_PAIN_SCORE, {
                 isUnsafeHighConfidence: isUnsafe,
+                isRisky: isUnsafe,
+                consecutiveErrors: session?.consecutiveErrors,
             });
             if (triage.decision !== 'admit') {
-                triageAdmitted = false;
                 logger.info?.(`[PD_GATE] Triage ${triage.decision}: ${triage.reason}`);
             }
+            else {
+                // PRI-454: Gate B path — TriggerController owns admission
+                const errorHash = `${toolName}:${filePath}:${reason}`;
+                const cooldownActive = isSharedCooldownActive('rulehost_block', sessionId, errorHash);
+                const triggerDecision = evaluateTriggerController({
+                    triageResult: triage,
+                    isOwnerManual: false,
+                    isCooldownActive: cooldownActive,
+                    isValid: true,
+                    score: GATE_BLOCK_PAIN_SCORE,
+                    sessionId,
+                });
+                if (triggerDecision.shouldCreateDiagnosticTask) {
+                    markSharedEpisodeAsDiagnosed('rulehost_block', sessionId, errorHash);
+                    void emitPainDetectedEvent(wctx, {
+                        ts: new Date().toISOString(),
+                        type: 'pain_detected',
+                        data: {
+                            painId: gatePainId,
+                            painType: 'user_frustration',
+                            source: 'gate_blocked',
+                            reason: `Gate blocked ${toolName} on ${filePath}: ${reason}`,
+                            score: GATE_BLOCK_PAIN_SCORE,
+                            sessionId,
+                            agentId: 'main',
+                        },
+                    }).catch((emitErr) => {
+                        logWarn(`[PD_GATE] Failed to emit gate block pain event: ${String(emitErr)}`);
+                    });
+                }
+                else {
+                    logger.info?.(`[PD_GATE] Gate B skipped: ${triggerDecision.reason}`);
+                }
+            }
         }
-        const session = getSession(sessionId);
-        if (triageAdmitted) {
+        else {
+            // PRI-454: Gate A path (rollback when either flag is OFF)
             const gate = evaluatePainDiagnosticGate({
                 source: 'gate_blocked',
                 score: GATE_BLOCK_PAIN_SCORE,
@@ -142,7 +182,7 @@ export function recordGateBlockAndReturn(wctx, blockCtx, logger) {
                     ts: new Date().toISOString(),
                     type: 'pain_detected',
                     data: {
-                        painId: `gate_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+                        painId: gatePainId,
                         painType: 'user_frustration',
                         source: 'gate_blocked',
                         reason: `Gate blocked ${toolName} on ${filePath}: ${reason}`,

package/plugin/dist/hooks/lifecycle.js

@@ -120,12 +120,9 @@ export async function extractPainFromSessionFile(sessionFile, ctx) {
             if (!fs.existsSync(dir))
                 fs.mkdirSync(dir, { recursive: true });
             fs.appendFileSync(dailyLogPath, entry, 'utf8');
-            const semanticPath = wctx.resolve('SEMANTIC_PAIN');
-            const semanticDir = path.dirname(semanticPath);
-            if (!fs.existsSync(semanticDir))
-                fs.mkdirSync(semanticDir, { recursive: true });
-            let semanticEntry = `\n### Sample ${timestamp}\n- Source: compaction\n\n\`\`\`\n${painPoints.join('\n---\n')}\n\`\`\`\n`;
-            fs.appendFileSync(semanticPath, semanticEntry, 'utf8');
+            // SEMANTIC_PAIN (confusion_samples.md) write removed (PRI-451 Wave 1):
+            // the file had zero readers. The MEMORY.md write above and the fatal-intercept
+            // emitPainDetectedEvent below are both LIVE and remain.
             const hasFatal = painPoints.some(p => p.includes('[FATAL INTERCEPT]'));
             if (hasFatal) {
                 // Emit via the Runtime v2 pain chain — no .pain_flag file written

package/plugin/dist/hooks/llm.js

@@ -13,6 +13,8 @@ import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
 import { loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
 import { resolveSourceKind } from './raw-observation-adapter.js';
 import { evaluateEvidenceTriage } from './triage-adapter.js';
+import { evaluateTriggerController } from '@principles/core/runtime-v2';
+import { isSharedCooldownActive, markSharedEpisodeAsDiagnosed } from './trigger-cooldown-tracker.js';
 function clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
 }
@@ -194,14 +196,8 @@ export function handleLlmOutput(event, ctx) {
     const detectionText = isEmpathyAuditPayload(text) ? '' : text;
     const detectionService = DetectionService.get(wctx.stateDir);
     const detection = detectionService.detect(detectionText);
-    if (detection.detected) {
-        eventLog.recordRuleMatch(ctx.sessionId, {
-            ruleId: detection.ruleId || detection.source,
-            layer: detection.source === 'l1_exact' ? 'L1' : (detection.source === 'l2_cache' ? 'L2' : 'L3'),
-            severity: detection.severity || 0,
-            textPreview: detectionText.substring(0, 100)
-        });
-    }
+    // recordRuleMatch call removed (PRI-451 Wave 1): dead code — its only
+    // consumer was stats.pain.rulesMatched (dead counter, removed in Wave 1.5).
     let painScore = detection.detected ? (detection.severity || 0) : 0;
     let source = detection.detected
         ? (detection.ruleId ? `llm_${detection.ruleId.toLowerCase()}` : `llm_${detection.source}`)
@@ -247,11 +243,31 @@ export function handleLlmOutput(event, ctx) {
         matchedReason = `Accumulated GFI (${state.currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Source: empathy keyword friction.`;
     }
     if (painScore >= painTriggerThreshold) {
-        // PEAT-B1: Evidence triage (feature-flagged)
-        let triageAdmitted = true;
-        const llmTriageFlag = loadFeatureFlagFromConfig(ctx.workspaceDir, 'painEvidenceAdmission');
-        if (llmTriageFlag.enabled) {
-            // PRI-360 S1: Build RawObservation for unified source mapping
+        // PRI-454: Dual-gate migration. When both flags ON → Gate B (TriggerController).
+        // When either OFF → Gate A (PainDiagnosticGate, rollback).
+        const triageFlag = loadFeatureFlagFromConfig(ctx.workspaceDir, 'painEvidenceAdmission');
+        const defaultFlag = loadFeatureFlagFromConfig(ctx.workspaceDir, 'painEvidenceAdmissionDefault');
+        const useGateB = triageFlag.enabled && defaultFlag.enabled;
+        eventLog.recordPainSignal(ctx.sessionId, {
+            score: painScore,
+            source: source,
+            reason: matchedReason,
+            isRisky: false
+        });
+        // PRI-453: Generate painId early and write to trajectory.db via legacy
+        // recordPainEvent so that disabling SDK observability path does not lose
+        // trajectory coverage. canonicalPainId enables dedup.
+        const painId = `llm_${Date.now()}`;
+        wctx.trajectory?.recordPainEvent?.({
+            sessionId: ctx.sessionId || 'unknown',
+            source,
+            score: painScore,
+            reason: matchedReason,
+            origin: 'system_infer',
+            canonicalPainId: painId,
+        });
+        if (useGateB) {
+            // PRI-454: Gate B path — TriggerController owns admission
             const rawObs = {
                 observedAt: new Date().toISOString(),
                 workspaceId: ctx.workspaceDir,
@@ -262,17 +278,44 @@ export function handleLlmOutput(event, ctx) {
             const sourceKind = resolveSourceKind(rawObs);
             const triage = evaluateEvidenceTriage(sourceKind, painScore);
             if (triage.decision !== 'admit') {
-                triageAdmitted = false;
                 ctx.logger?.info?.(`[PD:LLM] Triage ${triage.decision}: ${triage.reason}`);
             }
+            else {
+                const cooldownActive = isSharedCooldownActive(sourceKind, ctx.sessionId, source);
+                const triggerDecision = evaluateTriggerController({
+                    triageResult: triage,
+                    isOwnerManual: false,
+                    isCooldownActive: cooldownActive,
+                    isValid: true,
+                    score: painScore,
+                    sessionId: ctx.sessionId,
+                });
+                if (triggerDecision.shouldCreateDiagnosticTask) {
+                    markSharedEpisodeAsDiagnosed(sourceKind, ctx.sessionId, source);
+                    const evidence = buildTrajectoryEvidence(wctx, ctx.sessionId || 'unknown');
+                    emitPainDetectedEvent(wctx, {
+                        ts: new Date().toISOString(),
+                        type: 'pain_detected',
+                        data: {
+                            painId,
+                            painType: 'user_frustration',
+                            source,
+                            reason: `${matchedReason}; trigger=${triggerDecision.outcome}`,
+                            score: painScore,
+                            sessionId: ctx.sessionId || 'unknown',
+                            agentId: ctx.agentId,
+                            provenance: 'openclaw_context_bound',
+                            evidence,
+                        },
+                    }, { recordObservability: false });
+                }
+                else {
+                    ctx.logger?.info?.(`[PD:LLM] Gate B skipped: ${triggerDecision.reason}`);
+                }
+            }
         }
-        eventLog.recordPainSignal(ctx.sessionId, {
-            score: painScore,
-            source: source,
-            reason: matchedReason,
-            isRisky: false
-        });
-        if (triageAdmitted) {
+        else {
+            // PRI-454: Gate A path (rollback when either flag is OFF)
             const gate = evaluatePainDiagnosticGate({
                 source: source === 'llm_paralysis' ? 'llm_paralysis' : 'semantic',
                 score: painScore,
@@ -292,7 +335,7 @@ export function handleLlmOutput(event, ctx) {
                     ts: new Date().toISOString(),
                     type: 'pain_detected',
                     data: {
-                        painId: `llm_${Date.now()}`,
+                        painId,
                         painType: 'user_frustration',
                         source,
                         reason: `${matchedReason}; diagnosticGate=${gate.reason}`,
@@ -302,15 +345,12 @@ export function handleLlmOutput(event, ctx) {
                         provenance: 'openclaw_context_bound',
                         evidence,
                     },
-                });
+                }, { recordObservability: false });
             }
             else {
                 ctx.logger?.info?.(`[PD:LLM] Pain signal recorded without Runtime V2 diagnosis: ${gate.detail}`);
             }
         }
-        else {
-            ctx.logger?.info?.(`[PD:LLM] Triage evidence-only: pain signal recorded without diagnosis or gate evaluation`);
-        }
     }
     // ═══ Thinking OS: Mental Model Usage Tracking ═══
     trackThinkingModelUsage({

package/plugin/dist/hooks/pain.d.ts

@@ -19,7 +19,9 @@ import type { EvolutionLoopEvent } from '../core/evolution-types.js';
 import type { PluginHookAfterToolCallEvent, PluginHookToolContext, OpenClawPluginApi } from '../openclaw-sdk.js';
 import { buildTrajectoryEvidence } from './trajectory-evidence.js';
 export { buildTrajectoryEvidence };
-export declare function emitPainDetectedEvent(wctx: WorkspaceContext, event: EvolutionLoopEvent): Promise<void>;
+export declare function emitPainDetectedEvent(wctx: WorkspaceContext, event: EvolutionLoopEvent, options?: {
+    recordObservability?: boolean;
+}): Promise<void>;
 /**
  * Handle after_tool_call hook — decomposed into pipeline stages.
  *

package/plugin/dist/hooks/pain.js

@@ -24,7 +24,11 @@ import { getEvolutionLogger, createTraceId } from '../core/evolution-logger.js';
 import { resolveWorkspaceDirForRuntimeV2 } from '../utils/workspace-resolver.js';
 import { PainToPrincipleService, PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
 import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
-import { loadPdConfigForPlugin } from '../core/pd-config-loader.js';
+import { loadPdConfigForPlugin, loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
+import { evaluateTriggerController } from '@principles/core/runtime-v2';
+import { isSharedCooldownActive, markSharedEpisodeAsDiagnosed } from './trigger-cooldown-tracker.js';
+import { buildManualPainObservation, resolveSourceKind } from './raw-observation-adapter.js';
+import { evaluateEvidenceTriage } from './triage-adapter.js';
 import { classifyToolCallOutcome, buildToolCallObservation, handleFrictionTrackingForFailure, handleFrictionTrackingForSuccess, recordHygieneTracking, handleProbationFeedback, evaluatePainAdmissionForToolCall, emitPainIfAdmitted, } from './after-tool-call-helpers.js';
 import { buildTrajectoryEvidence } from './trajectory-evidence.js';
 export { buildTrajectoryEvidence };
@@ -44,7 +48,7 @@ function createPainToPrincipleService(wctx) {
 }
 // buildTrajectoryEvidence is in ./trajectory-evidence.ts (re-exported above)
 // ── Pain Event Emission ─────────────────────────────────────────────────────
-export async function emitPainDetectedEvent(wctx, event) {
+export async function emitPainDetectedEvent(wctx, event, options) {
     try {
         wctx.evolutionReducer.emitSync(event);
     }
@@ -68,6 +72,10 @@ export async function emitPainDetectedEvent(wctx, event) {
                     score: painData.score,
                 }));
             }
+            // PRI-453: Hook paths that already write events_*.jsonl + trajectory.db
+            // via legacy writers pass recordObservability: false to avoid triple-write.
+            // CLI pd pain record and paths without legacy writers keep the default true.
+            const recordObs = options?.recordObservability ?? true;
             const result = await service.recordPain({
                 painId: painData.painId,
                 painType: painData.painType,
@@ -80,7 +88,7 @@ export async function emitPainDetectedEvent(wctx, event) {
                 traceId: painData.traceId,
                 provenance: painData.provenance,
                 evidence: painData.evidence,
-                recordObservability: true,
+                recordObservability: recordObs,
             });
             if (result.status === 'failed' && result.failureCategory) {
                 SystemLogger.log(wctx.workspaceDir, 'PAIN_SERVICE_FAILED', JSON.stringify({
@@ -216,6 +224,8 @@ function handleManualPain(event, ctx, wctx, workspaceDir, sessionId) {
         reason: `User intervention: ${reason}`,
         isRisky: true
     });
+    // PRI-453: Generate painId early to pass as canonicalPainId for dedup.
+    const painId = createPainId(sessionId);
     wctx.trajectory?.recordPainEvent?.({
         sessionId,
         source: 'manual',
@@ -223,6 +233,7 @@ function handleManualPain(event, ctx, wctx, workspaceDir, sessionId) {
         reason: `User intervention: ${reason}`,
         origin: 'user_manual',
         text: reason,
+        canonicalPainId: painId,
     });
     // Log to EvolutionLogger
     const evoLogger = getEvolutionLogger(workspaceDir, wctx.trajectory);
@@ -234,61 +245,120 @@ function handleManualPain(event, ctx, wctx, workspaceDir, sessionId) {
         toolName: event.toolName,
         sessionId,
     });
-    // Apply PainDiagnosticGate with cooldown
-    const session = getSession(sessionId);
-    const gate = evaluatePainDiagnosticGate({
-        source: 'manual',
-        score: 100,
-        currentGfi: session?.currentGfi ?? 0,
-        sessionId,
-    });
-    if (!gate.shouldDiagnose) {
-        SystemLogger.log(workspaceDir, 'MANUAL_PAIN_SKIPPED', `Manual pain within cooldown: ${gate.detail}`);
-        let payload;
-        try {
-            payload = JSON.stringify({
-                reason: gate.reason,
-                detail: gate.detail,
-                source: 'manual',
-                sessionId,
-                gfi: 0,
-                score: 100,
-            });
-        }
-        catch (e) {
-            SystemLogger.log(workspaceDir, 'PAYLOAD_SERIALIZE_FAILED', String(e));
-            payload = JSON.stringify({ reason: gate.reason, detail: '(log serialization failed)' });
-        }
-        SystemLogger.log(workspaceDir, 'PAIN_GATE_REJECTED', payload);
-        // PEAT-B2: Record trigger decision even when cooldown blocks manual pain
+    // PRI-454: Dual-gate migration. When both flags ON → Gate B (TriggerController).
+    // When either OFF → Gate A (PainDiagnosticGate, rollback).
+    const triageFlag = loadFeatureFlagFromConfig(workspaceDir, 'painEvidenceAdmission');
+    const defaultFlag = loadFeatureFlagFromConfig(workspaceDir, 'painEvidenceAdmissionDefault');
+    const useGateB = triageFlag.enabled && defaultFlag.enabled;
+    if (useGateB) {
+        // PRI-454: Gate B path — manual pain is owner-reported.
+        // isOwnerManual: true → evaluateTriggerController returns manual_owner_admitted
+        // (bypasses triage and cooldown per PRODUCT_IDENTITY: owner-governed).
+        const rawObs = buildManualPainObservation({ sessionId });
+        const sourceKind = resolveSourceKind(rawObs); // → 'owner_reported'
+        const triage = evaluateEvidenceTriage(sourceKind, 100); // → 'admit'
+        const cooldownActive = isSharedCooldownActive(sourceKind, sessionId, 'manual_pain');
+        const triggerDecision = evaluateTriggerController({
+            triageResult: triage,
+            isOwnerManual: true,
+            isCooldownActive: cooldownActive,
+            isValid: true,
+            score: 100,
+            sessionId,
+        });
+        // PEAT-B2: Record trigger decision
         const painTriageFlag = loadPdConfigForPlugin(workspaceDir);
         if (painTriageFlag.effective) {
             SystemLogger.log(workspaceDir, 'TRIGGER_DECISION', JSON.stringify({
-                outcome: 'cooldown_skipped',
-                sourceKind: 'owner_reported',
-                reason: `Manual pain within cooldown: ${gate.detail}`,
-                nextAction: 'wait_for_cooldown_or_manual_retrigger',
+                outcome: triggerDecision.outcome,
+                sourceKind: triggerDecision.sourceKind,
+                reason: triggerDecision.reason,
+                nextAction: triggerDecision.nextAction,
                 isOwnerManual: true,
                 sessionId,
                 score: 100,
             }));
         }
-        return;
+        if (triggerDecision.shouldCreateDiagnosticTask) {
+            markSharedEpisodeAsDiagnosed(sourceKind, sessionId, 'manual_pain');
+            emitPainDetectedEvent(wctx, {
+                ts: new Date().toISOString(),
+                type: 'pain_detected',
+                data: {
+                    painId,
+                    painType: 'user_frustration',
+                    source: event.toolName,
+                    reason: `User intervention: ${reason}`,
+                    score: 100,
+                    sessionId,
+                    traceId,
+                    agentId: ctx.agentId,
+                    provenance: (sessionId && sessionId !== 'unknown') ? 'openclaw_context_bound' : 'owner_reported_no_host_trace',
+                    evidence: buildTrajectoryEvidence(wctx, sessionId),
+                },
+            }, { recordObservability: false });
+        }
+        else {
+            SystemLogger.log(workspaceDir, 'MANUAL_PAIN_SKIPPED', triggerDecision.reason);
+        }
     }
-    emitPainDetectedEvent(wctx, {
-        ts: new Date().toISOString(),
-        type: 'pain_detected',
-        data: {
-            painId: createPainId(sessionId),
-            painType: 'user_frustration',
-            source: event.toolName,
-            reason: `User intervention: ${reason}`,
+    else {
+        // PRI-454: Gate A path (rollback when either flag is OFF)
+        const session = getSession(sessionId);
+        const gate = evaluatePainDiagnosticGate({
+            source: 'manual',
             score: 100,
+            currentGfi: session?.currentGfi ?? 0,
             sessionId,
-            traceId,
-            agentId: ctx.agentId,
-            provenance: (sessionId && sessionId !== 'unknown') ? 'openclaw_context_bound' : 'owner_reported_no_host_trace',
-            evidence: buildTrajectoryEvidence(wctx, sessionId),
-        },
-    });
+        });
+        if (!gate.shouldDiagnose) {
+            SystemLogger.log(workspaceDir, 'MANUAL_PAIN_SKIPPED', `Manual pain within cooldown: ${gate.detail}`);
+            let payload;
+            try {
+                payload = JSON.stringify({
+                    reason: gate.reason,
+                    detail: gate.detail,
+                    source: 'manual',
+                    sessionId,
+                    gfi: 0,
+                    score: 100,
+                });
+            }
+            catch (e) {
+                SystemLogger.log(workspaceDir, 'PAYLOAD_SERIALIZE_FAILED', String(e));
+                payload = JSON.stringify({ reason: gate.reason, detail: '(log serialization failed)' });
+            }
+            SystemLogger.log(workspaceDir, 'PAIN_GATE_REJECTED', payload);
+            // PEAT-B2: Record trigger decision even when cooldown blocks manual pain
+            const painTriageFlag = loadPdConfigForPlugin(workspaceDir);
+            if (painTriageFlag.effective) {
+                SystemLogger.log(workspaceDir, 'TRIGGER_DECISION', JSON.stringify({
+                    outcome: 'cooldown_skipped',
+                    sourceKind: 'owner_reported',
+                    reason: `Manual pain within cooldown: ${gate.detail}`,
+                    nextAction: 'wait_for_cooldown_or_manual_retrigger',
+                    isOwnerManual: true,
+                    sessionId,
+                    score: 100,
+                }));
+            }
+            return;
+        }
+        emitPainDetectedEvent(wctx, {
+            ts: new Date().toISOString(),
+            type: 'pain_detected',
+            data: {
+                painId,
+                painType: 'user_frustration',
+                source: event.toolName,
+                reason: `User intervention: ${reason}`,
+                score: 100,
+                sessionId,
+                traceId,
+                agentId: ctx.agentId,
+                provenance: (sessionId && sessionId !== 'unknown') ? 'openclaw_context_bound' : 'owner_reported_no_host_trace',
+                evidence: buildTrajectoryEvidence(wctx, sessionId),
+            },
+        }, { recordObservability: false });
+    }
 }

package/plugin/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;