create-principles-disciple 1.92.0 → 1.94.0

package/plugin/dist/core/detection-funnel.js

@@ -1,104 +1,56 @@
-import { createHash } from 'crypto';
-import { shouldIgnorePainProtocolText } from './dictionary.js';
 /**
- * A simple LRU Cache implementation using Map.
+ * Detection Funnel — PRI-446 thin adapter
+ *
+ * The pure three-layer funnel logic (LRU cache, async queue, layer dispatch)
+ * now lives in principles-core
+ * (runtime-v2/detection/detection-funnel-policy.ts). This file is a thin shell
+ * that wires DetectionFunnelCore with the two environment-coupled dependencies
+ * the plugin owns:
+ *   - crypto.createHash (the L2 cache key hasher)
+ *   - PainDictionary.match (the L1 exact matcher)
+ *   - shouldIgnorePainProtocolText (the protocol-token gate)
+ *
+ * It re-exports DetectionFunnel (same class name + constructor signature) and
+ * DetectionResult so DetectionService, llm.ts, and evolution-worker keep working
+ * unchanged.
+ *
+ * ERR checklist:
+ * - ERR-011: this is a thin adapter delegating to core pure logic.
  */
-class SimpleLRU {
-    cache;
-    maxSize;
-    constructor(maxSize = 100) {
-        this.cache = new Map();
-        this.maxSize = maxSize;
-    }
-    get(key) {
-        const item = this.cache.get(key);
-        if (item !== undefined) {
-            // Refresh: delete and re-insert
-            this.cache.delete(key);
-            this.cache.set(key, item);
-        }
-        return item;
-    }
-    set(key, value) {
-        if (this.cache.has(key)) {
-            this.cache.delete(key);
-        }
-        else if (this.cache.size >= this.maxSize) {
-            // Remove the oldest (first) item
-            const firstKey = this.cache.keys().next().value;
-            if (firstKey !== undefined) {
-                this.cache.delete(firstKey);
-            }
-        }
-        this.cache.set(key, value);
-    }
-}
+import { createHash } from 'crypto';
+import { shouldIgnorePainProtocolText } from './dictionary.js';
+import { DetectionFunnelCore, } from '@principles/core/runtime-v2';
 /**
  * Orchestrates the three-layer detection funnel for pain signals.
+ *
+ * Delegates to the core DetectionFunnelCore, injecting the crypto hasher,
+ * the dictionary matcher, and the protocol-token gate.
  */
 export class DetectionFunnel {
-    cache = new SimpleLRU(100);
-    asyncQueue = [];
-    dictionary;
+    core;
     constructor(dictionary) {
-        this.dictionary = dictionary;
+        this.core = new DetectionFunnelCore({
+            match: (text) => dictionary.match(text),
+            hash: (text) => createHash('sha256').update(text).digest('hex'),
+            shouldIgnoreProtocol: shouldIgnorePainProtocolText,
+        });
     }
     /**
      * Detects pain in the given text using L1 (Exact), L2 (Cache), and L3 (Async).
      */
     detect(text) {
-        if (shouldIgnorePainProtocolText(text)) {
-            return { detected: false, source: 'l1_exact' };
-        }
-        // --- Layer 1: Exact Match (Sync) ---
-        const exactMatch = this.dictionary.match(text);
-        if (exactMatch) {
-            return {
-                detected: true,
-                severity: exactMatch.severity,
-                ruleId: exactMatch.ruleId,
-                source: 'l1_exact'
-            };
-        }
-        // --- Layer 2: LRU Cache (Sync) ---
-        const hash = DetectionFunnel.computeHash(text);
-        const cached = this.cache.get(hash);
-        if (cached) {
-            return {
-                detected: cached.detected,
-                severity: cached.severity,
-                source: 'l2_cache'
-            };
-        }
-        // --- Layer 3: Async Semantic Queue ---
-        this.enqueueAsync(text);
-        return {
-            detected: false,
-            source: 'l3_async_queued'
-        };
-    }
-    static computeHash(text) {
-        return createHash('sha256').update(text).digest('hex');
-    }
-    enqueueAsync(text) {
-        if (this.asyncQueue.length < 1000) {
-            this.asyncQueue.push(text);
-        }
-        // Worker will pick this up and perform semantic search via createMemorySearchTool
+        return this.core.detect(text);
     }
     /**
      * Internal method for the worker to update the cache after a semantic hit.
      */
     updateCache(text, result) {
-        const hash = DetectionFunnel.computeHash(text);
-        this.cache.set(hash, result);
+        this.core.updateCache(text, result);
     }
     /**
      * Retrieves and clears the current asynchronous queue.
      */
     flushQueue() {
-        const queue = [...this.asyncQueue];
-        this.asyncQueue = [];
-        return queue;
+        return this.core.flushQueue();
     }
 }

package/plugin/dist/core/event-log.d.ts

@@ -1,4 +1,4 @@
-import type { EventLogEntry, DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, DiagnosisTaskEventData, HeartbeatDiagnosisEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData } from '../types/event-types.js';
+import type { EventLogEntry, DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, DiagnosisTaskEventData, HeartbeatDiagnosisEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData } from '../types/event-types.js';
 import type { PluginLogger } from '../openclaw-sdk.js';
 export declare class EventLog {
     private readonly logsDir;
@@ -11,7 +11,6 @@ export declare class EventLog {
     private flushTimer?;
     private currentEventsFile;
     private currentDate;
-    private readonly painScoreSums;
     constructor(stateDir: string, logger?: PluginLogger);
     private getEventsFile;
     private getTodayStr;
@@ -19,7 +18,6 @@ export declare class EventLog {
     private cleanupOldEventFiles;
     recordToolCall(sessionId: string | undefined, data: ToolCallEventData): void;
     recordPainSignal(sessionId: string | undefined, data: PainSignalEventData): void;
-    recordRuleMatch(sessionId: string | undefined, data: RuleMatchEventData): void;
     recordRulePromotion(data: RulePromotionEventData): void;
     recordHookExecution(data: HookExecutionEventData, opts?: {
         flushImmediately?: boolean;

package/plugin/dist/core/event-log.js

@@ -15,7 +15,8 @@ export class EventLog {
     flushTimer;
     currentEventsFile;
     currentDate;
-    painScoreSums = new Map();
+    // painScoreSums map removed (PRI-451 Wave 1.5): it only fed the dead
+    // stats.pain.avgScore counter, which is also removed.
     constructor(stateDir, logger) {
         this.logsDir = path.join(stateDir, 'logs');
         if (!fs.existsSync(this.logsDir)) {
@@ -30,7 +31,7 @@ export class EventLog {
         return path.join(this.logsDir, `events_${date}.jsonl`);
     }
     getTodayStr() {
-        return new Date().toISOString().split('T')[0];
+        return new Date().toISOString().split('T')[0] ?? '';
     }
     ensureEventsFile() {
         const today = this.getTodayStr();
@@ -68,9 +69,8 @@ export class EventLog {
     recordPainSignal(sessionId, data) {
         this.record('pain_signal', 'detected', sessionId, data);
     }
-    recordRuleMatch(sessionId, data) {
-        this.record('rule_match', 'detected', sessionId, data);
-    }
+    // recordRuleMatch removed (PRI-451 Wave 1): dead code. Its only effect was
+    // incrementing stats.pain.rulesMatched (also dead, removed in Wave 1.5).
     recordRulePromotion(data) {
         this.record('rule_promotion', 'promoted', undefined, data);
     }
@@ -255,7 +255,7 @@ export class EventLog {
         }
     }
     formatDate(date) {
-        return date.toISOString().split('T')[0];
+        return date.toISOString().split('T')[0] ?? '';
     }
     loadStats() {
         if (fs.existsSync(this.statsFile)) {
@@ -293,16 +293,8 @@ export class EventLog {
         }
         else if (entry.type === 'pain_signal') {
             const data = entry.data;
-            stats.pain.signalsDetected++;
-            stats.pain.maxScore = Math.max(stats.pain.maxScore, data.score);
-            if (data.source) {
-                stats.pain.signalsBySource[data.source] = (stats.pain.signalsBySource[data.source] || 0) + 1;
-            }
-            const currentSum = this.painScoreSums.get(entry.date) ?? 0;
-            this.painScoreSums.set(entry.date, currentSum + (data.score || 0));
-            stats.pain.avgScore = stats.pain.signalsDetected > 0
-                ? Math.round((currentSum + (data.score || 0)) / stats.pain.signalsDetected)
-                : 0;
+            // stats.pain.* counters removed (PRI-451 Wave 1.5): no live reader.
+            // The user_empathy aggregation below (stats.empathy.*) is LIVE and stays.
             if (data.source === 'user_empathy') {
                 if (data.deduped) {
                     stats.empathy.dedupedCount++;
@@ -343,11 +335,14 @@ export class EventLog {
                 if (!stats.hooks.byType[data.hook]) {
                     stats.hooks.byType[data.hook] = { total: 0, success: 0, failure: 0 };
                 }
-                stats.hooks.byType[data.hook].total++;
-                if (entry.category === 'success')
-                    stats.hooks.byType[data.hook].success++;
-                else
-                    stats.hooks.byType[data.hook].failure++;
+                const hookStats = stats.hooks.byType[data.hook];
+                if (hookStats) {
+                    hookStats.total++;
+                    if (entry.category === 'success')
+                        hookStats.success++;
+                    else
+                        hookStats.failure++;
+                }
             }
         }
         else if (entry.type === 'empathy_rollback') {
@@ -355,14 +350,11 @@ export class EventLog {
             stats.empathy.rollbackCount++;
             stats.empathy.rolledBackScore += data.originalScore || 0;
         }
-        else if (entry.type === 'rule_match') {
-            const data = entry.data;
-            if (data.ruleId) {
-                stats.pain.rulesMatched[data.ruleId] = (stats.pain.rulesMatched[data.ruleId] || 0) + 1;
-            }
-        }
+        // rule_match handler removed (PRI-451 Wave 1.5): recordRuleMatch is gone
+        // (Wave 1.1), so no rule_match events are emitted; stats.pain.rulesMatched
+        // was its only consumer and is also removed.
         else if (entry.type === 'rule_promotion') {
-            stats.pain.candidatesPromoted++;
+            // stats.pain.candidatesPromoted removed (PRI-451 Wave 1.5): dead counter.
             stats.evolution.rulesPromoted++;
         }
         else if (entry.type === 'evolution_task') {
@@ -383,13 +375,13 @@ export class EventLog {
             const raw = entry.data;
             if (Object.prototype.hasOwnProperty.call(raw, 'category')) {
                 const cat = raw['category'];
-                if (cat === 'success' || cat === 'missing_json' || cat === 'incomplete_fields') {
+                if (typeof cat === 'string' && (cat === 'success' || cat === 'missing_json' || cat === 'incomplete_fields')) {
                     stats.evolution.diagnosticianReportsWritten++;
                 }
-                if (cat === 'missing_json') {
+                if (typeof cat === 'string' && cat === 'missing_json') {
                     stats.evolution.reportsMissingJson++;
                 }
-                if (cat === 'incomplete_fields') {
+                if (typeof cat === 'string' && cat === 'incomplete_fields') {
                     stats.evolution.reportsIncompleteFields++;
                 }
             }
@@ -651,6 +643,8 @@ export class EventLog {
         const allEvents = this.getMergedEvents();
         for (let i = allEvents.length - 1; i >= 0; i--) {
             const entry = allEvents[i];
+            if (!entry)
+                continue;
             if (entry.sessionId === sessionId && entry.type === 'pain_signal') {
                 const data = entry.data;
                 if (data.source === 'user_empathy' && !data.deduped) {
@@ -664,6 +658,8 @@ export class EventLog {
         const allEvents = this.getMergedEvents();
         for (let i = allEvents.length - 1; i >= 0; i--) {
             const entry = allEvents[i];
+            if (!entry)
+                continue;
             if (entry.sessionId === sessionId && entry.type === "pain_signal") {
                 return entry.data;
             }

package/plugin/dist/core/evolution-reducer.d.ts

@@ -52,20 +52,12 @@ export declare class EvolutionReducerImpl implements EvolutionReducer {
     private readonly failureStreak;
     private lastPromotedAt;
     private isReplaying;
-    /** Registered pain_detected callbacks (e.g., PainSignalBridge). */
-    private readonly _painCallbacks;
     constructor(opts: {
         workspaceDir: string;
         stateDir?: string;
     });
     emit(event: EvolutionLoopEvent): void;
     emitSync(event: EvolutionLoopEvent): void;
-    /**
-     * Register a callback for 'pain_detected' events.
-     * The callback is invoked synchronously within emitSync() after applyEvent completes.
-     * HG-4: Callbacks are fire-and-forget from the emitSync perspective.
-     */
-    on(callback: (event: EvolutionLoopEvent) => void): void;
     getEventLog(): EvolutionLoopEvent[];
     getCandidatePrinciples(): Principle[];
     getProbationPrinciples(): Principle[];

package/plugin/dist/core/evolution-reducer.js

@@ -38,8 +38,9 @@ export class EvolutionReducerImpl {
     failureStreak = new Map();
     lastPromotedAt = null;
     isReplaying = false;
-    /** Registered pain_detected callbacks (e.g., PainSignalBridge). */
-    _painCallbacks = [];
+    // _painCallbacks pub/sub removed (PRI-451 Wave 1): no code ever registered a
+    // callback via .on(). The pain_detected → PainSignalBridge bridge happens via
+    // emitPainDetectedEvent (hooks/pain.ts), not this pub/sub layer.
     constructor(opts) {
         this.workspaceDir = opts.workspaceDir;
         this.stateDir = opts.stateDir;
@@ -77,14 +78,9 @@ export class EvolutionReducerImpl {
         }
         // Performance: sweepExpiredProbation() moved to getProbationPrinciples() for lazy cleanup
     }
-    /**
-     * Register a callback for 'pain_detected' events.
-     * The callback is invoked synchronously within emitSync() after applyEvent completes.
-     * HG-4: Callbacks are fire-and-forget from the emitSync perspective.
-     */
-    on(callback) {
-        this._painCallbacks.push(callback);
-    }
+    // on(callback) pub/sub registration removed (PRI-451 Wave 1): dead code —
+    // no caller ever registered a callback. pain_detected events still flow via
+    // emitPainDetectedEvent → PainSignalBridge, unaffected.
     getEventLog() {
         return [...this.memoryEvents];
     }
@@ -522,15 +518,9 @@ export class EvolutionReducerImpl {
                 if (!this.isReplaying) {
                     this.onPainDetected(event.data, event.ts);
                 }
-                // PainSignalBridge subscriptions: invoke registered callbacks (fire-and-forget)
-                for (const cb of this._painCallbacks) {
-                    try {
-                        cb(event);
-                    }
-                    catch {
-                        // Keep the evolution loop resilient — callback errors must not propagate
-                    }
-                }
+                // _painCallbacks dispatch removed (PRI-451 Wave 1): no callback was ever
+                // registered via .on() (also removed). The pain_detected → PainSignalBridge
+                // bridge flows through emitPainDetectedEvent (hooks/pain.ts), not here.
                 return;
             case 'candidate_created':
                 this.onCandidateCreated(event.data, event.ts);

package/plugin/dist/core/focus-history.js

@@ -503,7 +503,7 @@ export function recoverFromTemplate(focusPath, extensionRoot) {
             };
         }
         let template = fs.readFileSync(templatePath, 'utf-8');
-        const [today] = new Date().toISOString().split('T');
+        const today = new Date().toISOString().split('T')[0] ?? '';
         template = template.replace(/{YYYY-MM-DD}/g, today);
         if (fs.existsSync(focusPath)) {
             const backupPath = `${focusPath}.corrupted.${Date.now()}.md`;

package/plugin/dist/core/hygiene/tracker.js

@@ -24,7 +24,7 @@ export class HygieneTracker {
         this.currentStats = this.loadStats();
     }
     loadStats() {
-        const [today] = new Date().toISOString().split('T');
+        const today = new Date().toISOString().split('T')[0] ?? '';
         if (fs.existsSync(this.statsFile)) {
             try {
                 const content = fs.readFileSync(this.statsFile, 'utf-8');
@@ -54,7 +54,7 @@ export class HygieneTracker {
     saveStats() {
         let allStats = {};
         // Check if we need to rotate date (reset currentStats if date changed)
-        const [today] = new Date().toISOString().split('T');
+        const today = new Date().toISOString().split('T')[0] ?? '';
         if (this.currentStats.date !== today) {
             this.currentStats = createEmptyHygieneStats(today);
         }
@@ -101,7 +101,7 @@ export class HygieneTracker {
     }
     getStats() {
         // Check for date change on every get
-        const [today] = new Date().toISOString().split('T');
+        const today = new Date().toISOString().split('T')[0] ?? '';
         if (this.currentStats.date !== today) {
             this.currentStats = createEmptyHygieneStats(today);
         }

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

@@ -1,30 +1,35 @@
-declare const PAIN_DIAGNOSTIC_SOURCES: readonly ["manual", "tool_failure", "dispatch_error", "gate_blocked", "user_empathy", "llm_paralysis", "semantic", "subagent_error"];
-export type PainDiagnosticSource = typeof PAIN_DIAGNOSTIC_SOURCES[number];
-export type PainDiagnosticGateReason = 'manual' | 'high_gfi' | 'repeated_failure' | 'semantic_pain' | 'llm_paralysis' | 'risky_high_score' | 'subagent_error' | 'gate_blocked' | 'cooldown' | 'below_gate';
-export interface PainDiagnosticGateInput {
-    source: PainDiagnosticSource | string;
-    score: number;
-    currentGfi: number;
-    consecutiveErrors?: number;
-    isRisky?: boolean;
-    errorHash?: string;
-    sessionId?: string;
-    nowMs?: number;
-    cooldownMs?: number;
-    thresholds?: {
-        painTrigger?: number;
-        highSeverity?: number;
-        highGfi?: number;
-        repeatedFailure?: number;
-        semanticPain?: number;
-    };
-}
-export interface PainDiagnosticGateDecision {
-    shouldDiagnose: boolean;
-    reason: PainDiagnosticGateReason;
-    episodeKey: string;
-    detail: string;
-}
+/**
+ * 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
+ * stateful adapter that owns:
+ *   - the cooldown Map (lastDiagnosedAtByEpisode)
+ *   - Date.now() injection
+ *   - SystemLogger for unknown-source telemetry
+ *
+ * It preserves the original export names (evaluatePainDiagnosticGate,
+ * isCooldownActiveForEpisode, resetPainDiagnosticGateForTest) so all 5 callers
+ * (gate-block-helper, llm, pain, prompt x2) and the characterization test keep
+ * working unchanged.
+ *
+ * ERR checklist:
+ * - ERR-011: this is a stateful adapter delegating to core pure logic.
+ */
+import { type PainDiagnosticSource, type PainDiagnosticGateReason, type PainDiagnosticGateInput, type PainDiagnosticGateDecision } from '@principles/core/runtime-v2';
+export type { PainDiagnosticSource, PainDiagnosticGateReason, PainDiagnosticGateInput, PainDiagnosticGateDecision, };
 export declare function resetPainDiagnosticGateForTest(): void;
 /**
  * Check whether cooldown is currently active for a given episode.
@@ -32,5 +37,9 @@ export declare function resetPainDiagnosticGateForTest(): void;
  * with the PainDiagnosticGate's cooldown state.
  */
 export declare function isCooldownActiveForEpisode(source: string, sessionId: string | undefined, errorHash: string | undefined, cooldownMs?: number): boolean;
+/**
+ * Evaluate the pain diagnostic gate. Delegates the pure decision to core and,
+ * when the decision is to diagnose, records the current time against the
+ * episode so subsequent calls within the cooldown window are suppressed.
+ */
 export declare function evaluatePainDiagnosticGate(input: PainDiagnosticGateInput): PainDiagnosticGateDecision;
-export {};

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

@@ -1,42 +1,37 @@
+/**
+ * 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
+ * stateful adapter that owns:
+ *   - the cooldown Map (lastDiagnosedAtByEpisode)
+ *   - Date.now() injection
+ *   - SystemLogger for unknown-source telemetry
+ *
+ * It preserves the original export names (evaluatePainDiagnosticGate,
+ * isCooldownActiveForEpisode, resetPainDiagnosticGateForTest) so all 5 callers
+ * (gate-block-helper, llm, pain, prompt x2) and the characterization test keep
+ * working unchanged.
+ *
+ * ERR checklist:
+ * - ERR-011: this is a stateful adapter delegating to core pure logic.
+ */
 import { SystemLogger } from './system-logger.js';
-const PAIN_DIAGNOSTIC_SOURCES = [
-    'manual',
-    'tool_failure',
-    'dispatch_error',
-    'gate_blocked',
-    'user_empathy',
-    'llm_paralysis',
-    'semantic',
-    'subagent_error',
-];
-const DEFAULT_COOLDOWN_MS = 15 * 60 * 1000;
+import { evaluatePainDiagnosticGateDecision, normalizedSource, buildEpisodeKey, isCooldownActive as isCooldownActiveCore, } from '@principles/core/runtime-v2';
+// Module-level cooldown state — owned by this adapter (core is stateless).
 const lastDiagnosedAtByEpisode = new Map();
-function normalizedSource(source) {
-    if (source.startsWith('llm_') && source !== 'llm_paralysis') {
-        return 'semantic';
-    }
-    if (!PAIN_DIAGNOSTIC_SOURCES.includes(source)) {
-        SystemLogger.log('', 'GATE_UNKNOWN_SOURCE', `Unknown pain source: "${source}"`);
-    }
-    return source;
-}
-function buildEpisodeKey(input) {
-    const source = normalizedSource(input.source);
-    const sessionId = input.sessionId || 'unknown';
-    const hash = input.errorHash || 'no-hash';
-    return `${sessionId}:${source}:${hash}`;
-}
-function withinCooldown(input, episodeKey) {
-    const cooldownMs = input.cooldownMs ?? DEFAULT_COOLDOWN_MS;
-    if (cooldownMs <= 0)
-        return false;
-    const nowMs = input.nowMs ?? Date.now();
-    const last = lastDiagnosedAtByEpisode.get(episodeKey);
-    return last !== undefined && nowMs - last < cooldownMs;
-}
-function markDiagnosed(input, episodeKey) {
-    lastDiagnosedAtByEpisode.set(episodeKey, input.nowMs ?? Date.now());
-}
 export function resetPainDiagnosticGateForTest() {
     lastDiagnosedAtByEpisode.clear();
 }
@@ -46,60 +41,29 @@ export function resetPainDiagnosticGateForTest() {
  * with the PainDiagnosticGate's cooldown state.
  */
 export function isCooldownActiveForEpisode(source, sessionId, errorHash, cooldownMs) {
-    const episodeKey = buildEpisodeKey({ source, sessionId, errorHash });
-    return withinCooldown({ source, sessionId, errorHash, cooldownMs }, episodeKey);
+    const episodeKey = buildEpisodeKey({ source, sessionId, errorHash, score: 0, currentGfi: 0 });
+    const last = lastDiagnosedAtByEpisode.get(episodeKey);
+    const nowMs = Date.now();
+    return isCooldownActiveCore({ source, sessionId, errorHash, cooldownMs, nowMs, lastDiagnosedAtMs: last });
 }
+/**
+ * Evaluate the pain diagnostic gate. Delegates the pure decision to core and,
+ * when the decision is to diagnose, records the current time against the
+ * episode so subsequent calls within the cooldown window are suppressed.
+ */
 export function evaluatePainDiagnosticGate(input) {
-    const source = normalizedSource(input.source);
-    const episodeKey = buildEpisodeKey(input);
-    const painTrigger = input.thresholds?.painTrigger ?? 40;
-    const highSeverity = input.thresholds?.highSeverity ?? 70;
-    const highGfi = input.thresholds?.highGfi ?? Math.max(highSeverity, painTrigger + 30);
-    const repeatedFailure = input.thresholds?.repeatedFailure ?? 4;
-    const semanticPain = input.thresholds?.semanticPain ?? Math.max(painTrigger, 60);
-    const score = Number.isFinite(input.score) ? input.score : 0;
-    const currentGfi = Number.isFinite(input.currentGfi) ? input.currentGfi : 0;
-    const consecutiveErrors = Number.isFinite(input.consecutiveErrors) ? input.consecutiveErrors : 0;
-    const approve = (reason, detail) => {
-        if (withinCooldown(input, episodeKey)) {
-            return {
-                shouldDiagnose: false,
-                reason: 'cooldown',
-                episodeKey,
-                detail: `recently diagnosed; ${detail}`,
-            };
-        }
-        markDiagnosed(input, episodeKey);
-        return { shouldDiagnose: true, reason, episodeKey, detail };
-    };
-    if (source === 'manual') {
-        return approve('manual', 'manual pain signal bypasses automatic gate');
-    }
-    if (source === 'subagent_error' && score >= painTrigger) {
-        return approve('subagent_error', `subagent error score ${score} >= ${painTrigger}`);
-    }
-    if (source === 'llm_paralysis' && score >= painTrigger) {
-        return approve('llm_paralysis', `llm paralysis score ${score} >= ${painTrigger}`);
-    }
-    if (source === 'gate_blocked' && score >= painTrigger) {
-        return approve('gate_blocked', `gate blocked score ${score} >= ${painTrigger}`);
-    }
-    if ((source === 'user_empathy' || source === 'semantic') && score >= semanticPain) {
-        return approve('semantic_pain', `semantic pain score ${score} >= ${semanticPain}`);
+    // Surface unknown sources via telemetry (core cannot log).
+    const { unknown } = normalizedSource(input.source);
+    if (unknown) {
+        SystemLogger.log('', 'GATE_UNKNOWN_SOURCE', `Unknown pain source: "${input.source}"`);
     }
-    if (input.isRisky === true && score >= highSeverity) {
-        return approve('risky_high_score', `risky operation score ${score} >= ${highSeverity}`);
-    }
-    if (consecutiveErrors >= repeatedFailure) {
-        return approve('repeated_failure', `consecutive errors ${consecutiveErrors} >= ${repeatedFailure}`);
-    }
-    if (currentGfi >= highGfi) {
-        return approve('high_gfi', `GFI ${currentGfi.toFixed(1)} >= ${highGfi}`);
+    const episodeKey = buildEpisodeKey(input);
+    const last = lastDiagnosedAtByEpisode.get(episodeKey);
+    const nowMs = input.nowMs ?? Date.now();
+    const decision = evaluatePainDiagnosticGateDecision({ ...input, nowMs }, last);
+    // Record the diagnosis time when approved (matches prior markDiagnosed behavior).
+    if (decision.shouldDiagnose) {
+        lastDiagnosedAtByEpisode.set(episodeKey, nowMs);
     }
-    return {
-        shouldDiagnose: false,
-        reason: 'below_gate',
-        episodeKey,
-        detail: `score=${score}; gfi=${currentGfi.toFixed(1)}; consecutive=${consecutiveErrors}`,
-    };
+    return decision;
 }