create-principles-disciple 1.93.0 → 1.95.0

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

@@ -86,9 +86,12 @@ export declare function evaluatePainAdmissionForToolCall(event: PluginHookAfterT
  *
  * Only called when the admission decision is 'admitted'.
  */
-export declare function emitPainIfAdmitted(wctx: WorkspaceContext, event: PluginHookAfterToolCallEvent, observation: ToolCallObservation, outcome: ToolCallOutcome, admission: PainAdmissionDecision, sessionId: string, agentId: string | undefined, workspaceDir: string, emitPainDetectedEvent: (wctx: WorkspaceContext, event: import('../core/evolution-types.js').EvolutionLoopEvent) => Promise<void>): void;
+export declare function emitPainIfAdmitted(wctx: WorkspaceContext, event: PluginHookAfterToolCallEvent, observation: ToolCallObservation, outcome: ToolCallOutcome, admission: PainAdmissionDecision, sessionId: string, agentId: string | undefined, workspaceDir: string, emitPainDetectedEvent: (wctx: WorkspaceContext, event: import('../core/evolution-types.js').EvolutionLoopEvent, options?: {
+    recordObservability?: boolean;
+}) => Promise<void>): void;
 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/plugin/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',
@@ -417,6 +408,9 @@ export function emitPainIfAdmitted(wctx, event, observation, outcome, admission,
     if (!admission.admitted)
         return;
     const failureSource = outcome.failureSource ?? 'tool_failure';
+    // PRI-453: Generate painId early so it can be passed as canonicalPainId to
+    // recordPainEvent, enabling dedup between legacy trajectory write and SDK path.
+    const painId = `pain_${Date.now()}_${observation.errorHash.slice(0, 8)}`;
     // Record to trajectory before Runtime V2 diagnosis
     wctx.trajectory?.recordPainEvent({
         sessionId,
@@ -426,6 +420,7 @@ export function emitPainIfAdmitted(wctx, event, observation, outcome, admission,
         severity: observation.painScore >= 70 ? 'severe' : observation.painScore >= 40 ? 'moderate' : 'mild',
         origin: 'system_infer',
         text: sanitizeForEvidence(observation.params.text ?? observation.params.content, workspaceDir) || undefined,
+        canonicalPainId: painId,
     });
     // Observe: track which principles would have prevented this pain (observation-only)
     try {
@@ -481,7 +476,7 @@ export function emitPainIfAdmitted(wctx, event, observation, outcome, admission,
         sessionId,
     });
     // Create painId inline (matches original createPainId)
-    const painId = `pain_${Date.now()}_${observation.errorHash.slice(0, 8)}`;
+    // PRI-453: painId is now generated early (above) to pass as canonicalPainId.
     emitPainDetectedEvent(wctx, {
         ts: new Date().toISOString(),
         type: 'pain_detected',
@@ -497,15 +492,16 @@ export function emitPainIfAdmitted(wctx, event, observation, outcome, admission,
             provenance: 'automatic_hook',
             evidence: buildTrajectoryEvidence(wctx, sessionId),
         },
-    });
+    }, { recordObservability: false });
 }
 // ── Shared Helpers ──────────────────────────────────────────────────────────
 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/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,12 @@ 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 { createIntentDocReader } from '../core/intent-doc-reader-adapter.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 };
@@ -40,11 +45,15 @@ function createPainToPrincipleService(wctx) {
         autoIntakeEnabled: true,
         effectiveConfig: configResult.effective,
         getEnvVar: (name) => process.env[name],
+        // PRI-468: wire INTENT.md reader so Stage A can produce intentTension
+        // when intent_engineering flag is on. Adapter performs no I/O beyond
+        // delegating to safeReadIntentDoc (which owns the flag-first check).
+        intentDocReader: createIntentDocReader(wctx.workspaceDir),
     });
 }
 // 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 +77,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 +93,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 +229,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 +238,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 +250,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 });
+    }
 }