principles-disciple 1.145.3 → 1.147.0

package/dist/core/pain-diagnostic-gate.d.ts

@@ -1,6 +1,17 @@
 /**
  * Pain Diagnostic Gate — PRI-446 thin adapter
  *
+ * @deprecated PRI-454 — Gate A (PainDiagnosticGate) is superseded by Gate B
+ * (TriggerController + EvidenceTriage). This module remains as the rollback
+ * path when `painEvidenceAdmission` or `painEvidenceAdmissionDefault` flags
+ * are OFF. Do not add new callers. New admission logic must use
+ * `evaluateTriggerController` from runtime-v2/evidence-triage.
+ *
+ * Disposition: Archive (do not delete) per PRI-454 plan step 6.
+ * Removal conditions: Both flags confirmed ON in production for 30 days,
+ * and all 5 MVP paths verified on Gate B. See
+ * docs/plans/2026-06-pain-evidence-admission-track.md.
+ *
  * The pure decision logic (threshold tree, cooldown comparison, episode-key
  * construction) now lives in principles-core
  * (runtime-v2/pain-gate/pain-diagnostic-gate-policy.ts). This file is the

package/dist/core/pain-diagnostic-gate.js

@@ -1,6 +1,17 @@
 /**
  * Pain Diagnostic Gate — PRI-446 thin adapter
  *
+ * @deprecated PRI-454 — Gate A (PainDiagnosticGate) is superseded by Gate B
+ * (TriggerController + EvidenceTriage). This module remains as the rollback
+ * path when `painEvidenceAdmission` or `painEvidenceAdmissionDefault` flags
+ * are OFF. Do not add new callers. New admission logic must use
+ * `evaluateTriggerController` from runtime-v2/evidence-triage.
+ *
+ * Disposition: Archive (do not delete) per PRI-454 plan step 6.
+ * Removal conditions: Both flags confirmed ON in production for 30 days,
+ * and all 5 MVP paths verified on Gate B. See
+ * docs/plans/2026-06-pain-evidence-admission-track.md.
+ *
  * The pure decision logic (threshold tree, cooldown comparison, episode-key
  * construction) now lives in principles-core
  * (runtime-v2/pain-gate/pain-diagnostic-gate-policy.ts). This file is the

package/dist/hooks/after-tool-call-helpers.d.ts

@@ -92,5 +92,6 @@ export declare function emitPainIfAdmitted(wctx: WorkspaceContext, event: Plugin
 export { buildTrajectoryEvidence } from './trajectory-evidence.js';
 /**
  * Reset trigger cooldown state (for tests).
+ * PRI-454: Delegates to shared cooldown Map reset.
  */
 export declare function resetTriggerCooldownForTest(): void;

package/dist/hooks/after-tool-call-helpers.js

@@ -19,7 +19,7 @@ import { denoiseError, computeHash } from '../utils/hashing.js';
 import { SystemLogger } from '../core/system-logger.js';
 import { getEvolutionLogger, createTraceId } from '../core/evolution-logger.js';
 import { recordEvolutionSuccess, recordEvolutionFailure } from '../core/evolution-engine.js';
-import { isCooldownActive as isTriggerCooldownActive, markEpisodeAsDiagnosed, clearCooldownState } from './trigger-cooldown-tracker.js';
+import { isSharedCooldownActive, markSharedEpisodeAsDiagnosed, resetSharedCooldownForTest } from './trigger-cooldown-tracker.js';
 import { sanitizeForEvidence, sanitizeToolParamsForEvidence } from './message-sanitize.js';
 import { resolveSourceKind, buildToolFailureObservation } from './raw-observation-adapter.js';
 import { evaluateEvidenceTriage } from './triage-adapter.js';
@@ -313,15 +313,6 @@ export function handleProbationFeedback(sessionId, toolName, workspaceDir, wctx,
 }
 // ── Stage 6: Pain Admission ─────────────────────────────────────────────────
 const WRITE_TOOLS = ['write', 'edit', 'apply_patch', 'write_file', 'edit_file', 'replace'];
-/**
- * Cooldown map for trigger controller decisions.
- *
- * PRI-363: This replaces the hidden map in PainDiagnosticGate.
- * Core trigger-controller is stateless; plugin layer owns cooldown state.
- *
- * EP-05: Loop state freshness — each check reads fresh state from this map.
- */
-const TRIGGER_COOLDOWN_MAP = new Map();
 /**
  * Evaluate whether a tool failure should trigger pain diagnosis.
  *
@@ -346,8 +337,8 @@ export function evaluatePainAdmissionForToolCall(event, observation, outcome, la
         };
     }
     const failureSource = outcome.failureSource ?? 'tool_failure';
-    // Check cooldown before calling trigger controller
-    const cooldownActive = isTriggerCooldownActive(failureSource, sessionId, latestFailureState?.lastErrorHash, TRIGGER_COOLDOWN_MAP);
+    // Check cooldown before calling trigger controller (PRI-454: shared Map)
+    const cooldownActive = isSharedCooldownActive(failureSource, sessionId, latestFailureState?.lastErrorHash);
     // PRI-360 S1: Build RawObservation for unified source mapping
     const rawObs = {
         observedAt: new Date().toISOString(),
@@ -386,9 +377,9 @@ export function evaluatePainAdmissionForToolCall(event, observation, outcome, la
         tool: event.toolName,
         path: observation.relPath,
     }));
-    // If trigger controller says yes, mark cooldown and admit
+    // If trigger controller says yes, mark cooldown and admit (PRI-454: shared Map)
     if (triggerDecision.shouldCreateDiagnosticTask) {
-        markEpisodeAsDiagnosed(failureSource, sessionId, latestFailureState?.lastErrorHash, TRIGGER_COOLDOWN_MAP);
+        markSharedEpisodeAsDiagnosed(failureSource, sessionId, latestFailureState?.lastErrorHash);
         return {
             admitted: true,
             stage: 'trigger_admitted',
@@ -507,9 +498,10 @@ export function emitPainIfAdmitted(wctx, event, observation, outcome, admission,
 export { buildTrajectoryEvidence } from './trajectory-evidence.js';
 /**
  * Reset trigger cooldown state (for tests).
+ * PRI-454: Delegates to shared cooldown Map reset.
  */
 export function resetTriggerCooldownForTest() {
-    clearCooldownState(TRIGGER_COOLDOWN_MAP);
+    resetSharedCooldownForTest();
 }
 // ── Source Classification ────────────────────────────────────────────────────
 // classifyToolFailureSource logic is now in resolveSourceKind (PRI-360 S1)

package/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';
@@ -83,10 +85,14 @@ export function recordGateBlockAndReturn(wctx, blockCtx, logger) {
         // 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)}`;
-        // PEAT-B1: Evidence triage (feature-flagged)
-        let triageAdmitted = true;
-        const gateBlockTriageFlag = loadFeatureFlagFromConfig(wctx.workspaceDir, 'painEvidenceAdmission');
-        if (gateBlockTriageFlag.enabled) {
+        // 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({});
@@ -111,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,

package/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));
 }
@@ -241,25 +243,11 @@ 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
-            const rawObs = {
-                observedAt: new Date().toISOString(),
-                workspaceId: ctx.workspaceDir,
-                sessionId: ctx.sessionId,
-                detectionSource: source,
-                isGfiTriggered,
-            };
-            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}`);
-            }
-        }
+        // 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,
@@ -278,7 +266,56 @@ export function handleLlmOutput(event, ctx) {
             origin: 'system_infer',
             canonicalPainId: painId,
         });
-        if (triageAdmitted) {
+        if (useGateB) {
+            // PRI-454: Gate B path — TriggerController owns admission
+            const rawObs = {
+                observedAt: new Date().toISOString(),
+                workspaceId: ctx.workspaceDir,
+                sessionId: ctx.sessionId,
+                detectionSource: source,
+                isGfiTriggered,
+            };
+            const sourceKind = resolveSourceKind(rawObs);
+            const triage = evaluateEvidenceTriage(sourceKind, painScore);
+            if (triage.decision !== 'admit') {
+                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}`);
+                }
+            }
+        }
+        else {
+            // PRI-454: Gate A path (rollback when either flag is OFF)
             const gate = evaluatePainDiagnosticGate({
                 source: source === 'llm_paralysis' ? 'llm_paralysis' : 'semantic',
                 score: painScore,
@@ -314,9 +351,6 @@ export function handleLlmOutput(event, ctx) {
                 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/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 };
@@ -241,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,
-            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),
-        },
-    }, { recordObservability: false });
+        });
+        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/dist/hooks/prompt.js

@@ -15,6 +15,11 @@ import { matchEmpathyKeywords, loadKeywordStore, saveKeywordStore, getKeywordSto
 import { severityToPenalty, DEFAULT_EMPATHY_KEYWORD_CONFIG } from '../core/empathy-types.js';
 import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
 import { emitPainDetectedEvent, buildTrajectoryEvidence } from './pain.js';
+import { evaluateTriggerController } from '@principles/core/runtime-v2';
+import { isSharedCooldownActive, markSharedEpisodeAsDiagnosed } from './trigger-cooldown-tracker.js';
+import { buildEmpathyObservation, resolveSourceKind } from './raw-observation-adapter.js';
+import { evaluateEvidenceTriage } from './triage-adapter.js';
+import { loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
 import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
 import { detectCorrectionCue as coreDetectCorrectionCue, escapeXml, extractMessageContent, isMinimalTrigger, } from '@principles/core/prompt-builder';
 import { sanitizeForEvidence } from './message-sanitize.js';
@@ -310,19 +315,11 @@ export async function handleBeforePromptBuild(event, ctx) {
                     if (currentGfi >= highGfiThreshold) {
                         const gfiPainScore = Math.min(Math.round(currentGfi), 60);
                         logger?.info?.(`[PD:Empathy] GFI-TRIGGERED: currentGfi=${currentGfi.toFixed(1)} >= highGfi=${highGfiThreshold}, emitting pain signal (score=${gfiPainScore})`);
-                        const gate = evaluatePainDiagnosticGate({
-                            source: 'user_empathy',
-                            score: gfiPainScore,
-                            currentGfi,
-                            consecutiveErrors: currentSession?.consecutiveErrors ?? 0,
-                            sessionId,
-                            errorHash: 'empathy_gfi_threshold',
-                            thresholds: {
-                                painTrigger,
-                                highSeverity: wctx.config.get('severity_thresholds.high') || 70,
-                                semanticPain: Math.max(painTrigger, 60),
-                            },
-                        });
+                        // 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;
                         wctx.eventLog.recordPainSignal(sessionId, {
                             score: gfiPainScore,
                             source: 'user_empathy',
@@ -350,34 +347,104 @@ export async function handleBeforePromptBuild(event, ctx) {
                             origin: 'system_infer',
                             canonicalPainId: gfiPainId,
                         });
-                        if (gate.shouldDiagnose) {
-                            logger?.info?.(`[PD:Empathy] Gate approved, calling emitPainDetectedEvent...`);
-                            try {
-                                const evidence = buildTrajectoryEvidence(wctx, sessionId);
-                                await emitPainDetectedEvent(wctx, {
-                                    ts: new Date().toISOString(),
-                                    type: 'pain_detected',
-                                    data: {
-                                        painId: gfiPainId,
-                                        painType: 'user_frustration',
-                                        source: 'user_empathy',
-                                        reason: `Accumulated GFI (${currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Matched: ${matchResult.matchedTerms.join(', ')}`,
-                                        score: gfiPainScore,
-                                        sessionId,
-                                        agentId: 'main',
-                                        provenance: 'openclaw_context_bound',
-                                        evidence,
-                                    },
-                                }, { recordObservability: false });
-                                logger?.info?.(`[PD:Empathy] emitPainDetectedEvent completed (GFI-triggered)`);
+                        if (useGateB) {
+                            // PRI-454: Gate B path — TriggerController owns admission
+                            const rawObs = buildEmpathyObservation({
+                                detectionSource: 'user_empathy',
+                                isGfiTriggered: true,
+                                sessionId,
+                            });
+                            const sourceKind = resolveSourceKind(rawObs);
+                            const triage = evaluateEvidenceTriage(sourceKind, gfiPainScore);
+                            if (triage.decision !== 'admit') {
+                                logger?.info?.(`[PD:Empathy] Triage ${triage.decision}: ${triage.reason}`);
                             }
-                            catch (emitErr) {
-                                console.error(`[PD:Empathy] FAILED to emit GFI-triggered pain event: ${String(emitErr)}`);
-                                logger?.warn?.(`[PD:Empathy] Failed to emit GFI-triggered pain event: ${String(emitErr)}`);
+                            else {
+                                const cooldownActive = isSharedCooldownActive(sourceKind, sessionId, 'empathy_gfi_threshold');
+                                const triggerDecision = evaluateTriggerController({
+                                    triageResult: triage,
+                                    isOwnerManual: false,
+                                    isCooldownActive: cooldownActive,
+                                    isValid: true,
+                                    score: gfiPainScore,
+                                    sessionId,
+                                });
+                                if (triggerDecision.shouldCreateDiagnosticTask) {
+                                    markSharedEpisodeAsDiagnosed(sourceKind, sessionId, 'empathy_gfi_threshold');
+                                    logger?.info?.(`[PD:Empathy] Gate B approved, calling emitPainDetectedEvent...`);
+                                    try {
+                                        const evidence = buildTrajectoryEvidence(wctx, sessionId);
+                                        await emitPainDetectedEvent(wctx, {
+                                            ts: new Date().toISOString(),
+                                            type: 'pain_detected',
+                                            data: {
+                                                painId: gfiPainId,
+                                                painType: 'user_frustration',
+                                                source: 'user_empathy',
+                                                reason: `Accumulated GFI (${currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Matched: ${matchResult.matchedTerms.join(', ')}`,
+                                                score: gfiPainScore,
+                                                sessionId,
+                                                agentId: 'main',
+                                                provenance: 'openclaw_context_bound',
+                                                evidence,
+                                            },
+                                        }, { recordObservability: false });
+                                        logger?.info?.(`[PD:Empathy] emitPainDetectedEvent completed (GFI-triggered)`);
+                                    }
+                                    catch (emitErr) {
+                                        console.error(`[PD:Empathy] FAILED to emit GFI-triggered pain event: ${String(emitErr)}`);
+                                        logger?.warn?.(`[PD:Empathy] Failed to emit GFI-triggered pain event: ${String(emitErr)}`);
+                                    }
+                                }
+                                else {
+                                    logger?.info?.(`[PD:Empathy] Gate B skipped: ${triggerDecision.reason}`);
+                                }
                             }
                         }
                         else {
-                            logger?.info?.(`[PD:Empathy] GFI-triggered gate rejected: ${gate.detail}`);
+                            // PRI-454: Gate A path (rollback when either flag is OFF)
+                            const gate = evaluatePainDiagnosticGate({
+                                source: 'user_empathy',
+                                score: gfiPainScore,
+                                currentGfi,
+                                consecutiveErrors: currentSession?.consecutiveErrors ?? 0,
+                                sessionId,
+                                errorHash: 'empathy_gfi_threshold',
+                                thresholds: {
+                                    painTrigger,
+                                    highSeverity: wctx.config.get('severity_thresholds.high') || 70,
+                                    semanticPain: Math.max(painTrigger, 60),
+                                },
+                            });
+                            if (gate.shouldDiagnose) {
+                                logger?.info?.(`[PD:Empathy] Gate approved, calling emitPainDetectedEvent...`);
+                                try {
+                                    const evidence = buildTrajectoryEvidence(wctx, sessionId);
+                                    await emitPainDetectedEvent(wctx, {
+                                        ts: new Date().toISOString(),
+                                        type: 'pain_detected',
+                                        data: {
+                                            painId: gfiPainId,
+                                            painType: 'user_frustration',
+                                            source: 'user_empathy',
+                                            reason: `Accumulated GFI (${currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Matched: ${matchResult.matchedTerms.join(', ')}`,
+                                            score: gfiPainScore,
+                                            sessionId,
+                                            agentId: 'main',
+                                            provenance: 'openclaw_context_bound',
+                                            evidence,
+                                        },
+                                    }, { recordObservability: false });
+                                    logger?.info?.(`[PD:Empathy] emitPainDetectedEvent completed (GFI-triggered)`);
+                                }
+                                catch (emitErr) {
+                                    console.error(`[PD:Empathy] FAILED to emit GFI-triggered pain event: ${String(emitErr)}`);
+                                    logger?.warn?.(`[PD:Empathy] Failed to emit GFI-triggered pain event: ${String(emitErr)}`);
+                                }
+                            }
+                            else {
+                                logger?.info?.(`[PD:Empathy] GFI-triggered gate rejected: ${gate.detail}`);
+                            }
                         }
                     }
                     // Trigger asynchronous background Empathy Observer deep analysis (Zero Latency)
@@ -438,45 +505,109 @@ export async function handleBeforePromptBuild(event, ctx) {
                                 const freshGfi = freshSession?.currentGfi ?? 0;
                                 if (freshGfi >= highGfiThreshold) {
                                     const freshGfiPainScore = Math.min(Math.round(freshGfi), 60);
-                                    const gate = evaluatePainDiagnosticGate({
-                                        source: 'user_empathy',
-                                        score: freshGfiPainScore,
-                                        currentGfi: freshGfi,
-                                        consecutiveErrors: freshSession?.consecutiveErrors ?? 0,
-                                        sessionId,
-                                        errorHash: 'empathy_gfi_threshold',
-                                        thresholds: {
-                                            painTrigger,
-                                            highSeverity: wctx.config.get('severity_thresholds.high') || 70,
-                                            semanticPain: Math.max(painTrigger, 60),
-                                        },
-                                    });
-                                    if (gate.shouldDiagnose) {
-                                        logger?.info?.(`[PD:Empathy] GFI threshold crossed after background observer. Emitting pain signal...`);
-                                        try {
-                                            const evidence = buildTrajectoryEvidence(wctx, sessionId);
-                                            // PRI-453: Reuse observerPainId for lineage consistency —
-                                            // the same id is used as canonicalPainId in recordPainEvent
-                                            // and as painId in the emitted event, so EvidenceChainConsoleModel
-                                            // can JOIN pain_events.canonical_pain_id = tasks.input_ref.
-                                            await emitPainDetectedEvent(wctx, {
-                                                ts: new Date().toISOString(),
-                                                type: 'pain_detected',
-                                                data: {
-                                                    painId: observerPainId,
-                                                    painType: 'user_frustration',
-                                                    source: 'user_empathy',
-                                                    reason: `Accumulated GFI (${freshGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Verified by Empathy Observer.`,
-                                                    score: freshGfiPainScore,
-                                                    sessionId,
-                                                    agentId: 'main',
-                                                    provenance: 'openclaw_context_bound',
-                                                    evidence,
-                                                },
-                                            }, { recordObservability: false });
+                                    // 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 — TriggerController owns admission
+                                        const rawObs = buildEmpathyObservation({
+                                            detectionSource: 'user_empathy',
+                                            isGfiTriggered: true,
+                                            sessionId,
+                                        });
+                                        const sourceKind = resolveSourceKind(rawObs);
+                                        const triage = evaluateEvidenceTriage(sourceKind, freshGfiPainScore);
+                                        if (triage.decision !== 'admit') {
+                                            logger?.info?.(`[PD:Empathy] Observer triage ${triage.decision}: ${triage.reason}`);
+                                        }
+                                        else {
+                                            const cooldownActive = isSharedCooldownActive(sourceKind, sessionId, 'empathy_gfi_observer');
+                                            const triggerDecision = evaluateTriggerController({
+                                                triageResult: triage,
+                                                isOwnerManual: false,
+                                                isCooldownActive: cooldownActive,
+                                                isValid: true,
+                                                score: freshGfiPainScore,
+                                                sessionId,
+                                            });
+                                            if (triggerDecision.shouldCreateDiagnosticTask) {
+                                                markSharedEpisodeAsDiagnosed(sourceKind, sessionId, 'empathy_gfi_observer');
+                                                logger?.info?.(`[PD:Empathy] Gate B approved (observer), calling emitPainDetectedEvent...`);
+                                                try {
+                                                    const evidence = buildTrajectoryEvidence(wctx, sessionId);
+                                                    // PRI-453: Reuse observerPainId for lineage consistency —
+                                                    // the same id is used as canonicalPainId in recordPainEvent
+                                                    // and as painId in the emitted event, so EvidenceChainConsoleModel
+                                                    // can JOIN pain_events.canonical_pain_id = tasks.input_ref.
+                                                    await emitPainDetectedEvent(wctx, {
+                                                        ts: new Date().toISOString(),
+                                                        type: 'pain_detected',
+                                                        data: {
+                                                            painId: observerPainId,
+                                                            painType: 'user_frustration',
+                                                            source: 'user_empathy',
+                                                            reason: `Accumulated GFI (${freshGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Verified by Empathy Observer.`,
+                                                            score: freshGfiPainScore,
+                                                            sessionId,
+                                                            agentId: 'main',
+                                                            provenance: 'openclaw_context_bound',
+                                                            evidence,
+                                                        },
+                                                    }, { recordObservability: false });
+                                                }
+                                                catch (emitErr) {
+                                                    logger?.error?.(`[PD:Empathy] FAILED to emit observer-triggered pain event: ${String(emitErr)}`);
+                                                }
+                                            }
+                                            else {
+                                                logger?.info?.(`[PD:Empathy] Gate B skipped (observer): ${triggerDecision.reason}`);
+                                            }
                                         }
-                                        catch (emitErr) {
-                                            logger?.error?.(`[PD:Empathy] FAILED to emit observer-triggered pain event: ${String(emitErr)}`);
+                                    }
+                                    else {
+                                        // PRI-454: Gate A path (rollback when either flag is OFF)
+                                        const gate = evaluatePainDiagnosticGate({
+                                            source: 'user_empathy',
+                                            score: freshGfiPainScore,
+                                            currentGfi: freshGfi,
+                                            consecutiveErrors: freshSession?.consecutiveErrors ?? 0,
+                                            sessionId,
+                                            errorHash: 'empathy_gfi_threshold',
+                                            thresholds: {
+                                                painTrigger,
+                                                highSeverity: wctx.config.get('severity_thresholds.high') || 70,
+                                                semanticPain: Math.max(painTrigger, 60),
+                                            },
+                                        });
+                                        if (gate.shouldDiagnose) {
+                                            logger?.info?.(`[PD:Empathy] GFI threshold crossed after background observer. Emitting pain signal...`);
+                                            try {
+                                                const evidence = buildTrajectoryEvidence(wctx, sessionId);
+                                                // PRI-453: Reuse observerPainId for lineage consistency —
+                                                // the same id is used as canonicalPainId in recordPainEvent
+                                                // and as painId in the emitted event, so EvidenceChainConsoleModel
+                                                // can JOIN pain_events.canonical_pain_id = tasks.input_ref.
+                                                await emitPainDetectedEvent(wctx, {
+                                                    ts: new Date().toISOString(),
+                                                    type: 'pain_detected',
+                                                    data: {
+                                                        painId: observerPainId,
+                                                        painType: 'user_frustration',
+                                                        source: 'user_empathy',
+                                                        reason: `Accumulated GFI (${freshGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Verified by Empathy Observer.`,
+                                                        score: freshGfiPainScore,
+                                                        sessionId,
+                                                        agentId: 'main',
+                                                        provenance: 'openclaw_context_bound',
+                                                        evidence,
+                                                    },
+                                                }, { recordObservability: false });
+                                            }
+                                            catch (emitErr) {
+                                                logger?.error?.(`[PD:Empathy] FAILED to emit observer-triggered pain event: ${String(emitErr)}`);
+                                            }
                                         }
                                     }
                                 }

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

@@ -12,5 +12,5 @@
  * ERR checklist:
  * - ERR-011: re-export adapter, not a local re-definition of migrated logic.
  */
-export { resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation, } from '@principles/core/runtime-v2';
+export { resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation, buildEmpathyObservation, buildManualPainObservation, } from '@principles/core/runtime-v2';
 export type { RawObservation } from './raw-observation-types.js';

package/dist/hooks/raw-observation-adapter.js

@@ -12,4 +12,4 @@
  * ERR checklist:
  * - ERR-011: re-export adapter, not a local re-definition of migrated logic.
  */
-export { resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation, } from '@principles/core/runtime-v2';
+export { resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation, buildEmpathyObservation, buildManualPainObservation, } from '@principles/core/runtime-v2';

package/dist/hooks/trigger-cooldown-tracker.d.ts

@@ -28,3 +28,15 @@ export declare function clearCooldownState(cooldownMap: Map<string, number>): vo
  * Get the cooldown timestamp for a given episode (for tests).
  */
 export declare function getCooldownTimestamp(source: string, sessionId: string | undefined, errorHash: string | undefined, cooldownMap: ReadonlyMap<string, number>): number | undefined;
+/**
+ * Check whether cooldown is currently active using the shared Map.
+ */
+export declare function isSharedCooldownActive(source: string, sessionId: string | undefined, errorHash: string | undefined): boolean;
+/**
+ * Mark an episode as diagnosed using the shared Map.
+ */
+export declare function markSharedEpisodeAsDiagnosed(source: string, sessionId: string | undefined, errorHash: string | undefined): void;
+/**
+ * Clear all shared cooldown state (for tests).
+ */
+export declare function resetSharedCooldownForTest(): void;

package/dist/hooks/trigger-cooldown-tracker.js

@@ -53,3 +53,28 @@ export function getCooldownTimestamp(source, sessionId, errorHash, cooldownMap)
     const episodeKey = buildEpisodeKey(source, sessionId, errorHash);
     return cooldownMap.get(episodeKey);
 }
+// ── Shared Cooldown Map (PRI-454) ───────────────────────────────────────────
+//
+// Module-level singleton Map shared across all Gate B paths.
+// Replaces the per-file TRIGGER_COOLDOWN_MAP in after-tool-call-helpers.ts.
+// All paths (gate-block, llm, empathy, manual pain) use this single Map
+// to ensure unified cooldown state.
+const SHARED_COOLDOWN_MAP = new Map();
+/**
+ * Check whether cooldown is currently active using the shared Map.
+ */
+export function isSharedCooldownActive(source, sessionId, errorHash) {
+    return isCooldownActive(source, sessionId, errorHash, SHARED_COOLDOWN_MAP);
+}
+/**
+ * Mark an episode as diagnosed using the shared Map.
+ */
+export function markSharedEpisodeAsDiagnosed(source, sessionId, errorHash) {
+    markEpisodeAsDiagnosed(source, sessionId, errorHash, SHARED_COOLDOWN_MAP);
+}
+/**
+ * Clear all shared cooldown state (for tests).
+ */
+export function resetSharedCooldownForTest() {
+    SHARED_COOLDOWN_MAP.clear();
+}

package/openclaw.plugin.json

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

package/package.json

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