principles-disciple 1.140.0 → 1.141.0

package/dist/core/detection-funnel.d.ts

@@ -1,24 +1,38 @@
+/**
+ * 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.
+ */
 import { type PainDictionary } from './dictionary.js';
-export interface DetectionResult {
-    detected: boolean;
-    severity?: number;
-    ruleId?: string;
-    source: 'l1_exact' | 'l2_cache' | 'l3_async_queued' | 'l3_semantic_hit';
-}
+import { type DetectionResult } from '@principles/core/runtime-v2';
+export type { DetectionResult };
 /**
  * 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 declare class DetectionFunnel {
-    private readonly cache;
-    private asyncQueue;
-    private readonly dictionary;
+    private readonly core;
     constructor(dictionary: PainDictionary);
     /**
      * Detects pain in the given text using L1 (Exact), L2 (Cache), and L3 (Async).
      */
     detect(text: string): DetectionResult;
-    private static computeHash;
-    private enqueueAsync;
     /**
      * Internal method for the worker to update the cache after a semantic hit.
      */

package/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/dist/core/pain-diagnostic-gate.d.ts

@@ -1,30 +1,24 @@
-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
+ *
+ * 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 +26,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/dist/core/pain-diagnostic-gate.js

@@ -1,42 +1,26 @@
+/**
+ * Pain Diagnostic Gate — PRI-446 thin adapter
+ *
+ * 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 +30,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;
 }

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

@@ -1,57 +1,16 @@
 /**
- * Raw Observation Adapter — PRI-362
+ * Raw Observation Adapter — PRI-362 / PRI-446
  *
- * Unified source-kind resolution from RawObservation.
+ * The source-kind resolution logic and RawObservation builders have been
+ * migrated to principles-core (runtime-v2/evidence-triage/observation-resolver.ts).
  *
- * Replaces scattered resolveSourceKindFrom* functions with a single
- * field-driven adapter that maps observation fields to SourceKind.
- *
- * Field precedence (highest to lowest):
- * 1. isManualEntry → owner_reported
- * 2. isGateBlock → rulehost_block
- * 3. isSubagentError → subagent_error
- * 4. isRateLimit → rate_limit (if true)
- * 5. toolName === 'pain' / 'skill:pain' → agent_on_owner_request (with openclaw_context_bound) / owner_reported
- * 6. failureSource → tool_failure / dispatch_error
- * 7. isGfiTriggered → gfi_threshold
- * 8. detectionSource → llm_paralysis / semantic / empathy_inferred / unknown
- * 9. Fallback → unknown
+ * This file is now a thin re-export adapter. It preserves the original export
+ * names (resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation,
+ * RawObservation) so all existing import sites and the source-string
+ * characterization tests keep working without changes.
  *
  * ERR checklist:
- * - ERR-001: Source kind resolved from runtime values, no `as` casts.
- * - ERR-002: Every path returns a valid SourceKind (fallback to 'unknown').
- * - EP-01: Runtime values validated before use.
+ * - ERR-011: re-export adapter, not a local re-definition of migrated logic.
  */
-import type { SourceKind } from '@principles/core/runtime-v2';
-import type { RawObservation } from './raw-observation-types.js';
+export { resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation, } from '@principles/core/runtime-v2';
 export type { RawObservation } from './raw-observation-types.js';
-/**
- * Resolve SourceKind from a unified RawObservation.
- *
- * This function replaces the scattered resolveSourceKindFrom* functions
- * and provides a single entry point for source-kind classification.
- *
- * Field precedence is explicitly defined in the function body to ensure
- * deterministic behavior and make the logic easy to understand and test.
- */
-export declare function resolveSourceKind(observation: RawObservation): SourceKind;
-/**
- * Build a RawObservation for a tool failure context.
- *
- * This replaces classifyToolFailureSource and the inline classification
- * in after-tool-call-helpers. All tool error → dispatch/tool_failure
- * classification is centralized here.
- */
-export declare function buildToolFailureObservation(options: {
-    toolName: string | undefined;
-    error: unknown;
-    exitCode?: number;
-    provenance?: RawObservation['provenance'];
-}): RawObservation;
-/**
- * Build a RawObservation for an LLM detection context.
- */
-export declare function buildLlmDetectionObservation(options: {
-    detectionSource: string;
-    isGfiTriggered: boolean;
-}): RawObservation;

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

@@ -1,170 +1,15 @@
 /**
- * Raw Observation Adapter — PRI-362
+ * Raw Observation Adapter — PRI-362 / PRI-446
  *
- * Unified source-kind resolution from RawObservation.
+ * The source-kind resolution logic and RawObservation builders have been
+ * migrated to principles-core (runtime-v2/evidence-triage/observation-resolver.ts).
  *
- * Replaces scattered resolveSourceKindFrom* functions with a single
- * field-driven adapter that maps observation fields to SourceKind.
- *
- * Field precedence (highest to lowest):
- * 1. isManualEntry → owner_reported
- * 2. isGateBlock → rulehost_block
- * 3. isSubagentError → subagent_error
- * 4. isRateLimit → rate_limit (if true)
- * 5. toolName === 'pain' / 'skill:pain' → agent_on_owner_request (with openclaw_context_bound) / owner_reported
- * 6. failureSource → tool_failure / dispatch_error
- * 7. isGfiTriggered → gfi_threshold
- * 8. detectionSource → llm_paralysis / semantic / empathy_inferred / unknown
- * 9. Fallback → unknown
+ * This file is now a thin re-export adapter. It preserves the original export
+ * names (resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation,
+ * RawObservation) so all existing import sites and the source-string
+ * characterization tests keep working without changes.
  *
  * ERR checklist:
- * - ERR-001: Source kind resolved from runtime values, no `as` casts.
- * - ERR-002: Every path returns a valid SourceKind (fallback to 'unknown').
- * - EP-01: Runtime values validated before use.
- */
-/**
- * Resolve SourceKind from a unified RawObservation.
- *
- * This function replaces the scattered resolveSourceKindFrom* functions
- * and provides a single entry point for source-kind classification.
- *
- * Field precedence is explicitly defined in the function body to ensure
- * deterministic behavior and make the logic easy to understand and test.
- */
-export function resolveSourceKind(observation) {
-    const { isManualEntry, isGateBlock, isSubagentError, isRateLimit, toolName, failureSource, isGfiTriggered, detectionSource, nonZeroExit, timedOut, toolNotFound, } = observation;
-    // Priority 1: Manual entry (CLI, owner-reported)
-    if (isManualEntry) {
-        return 'owner_reported';
-    }
-    // Priority 2: Gate block
-    if (isGateBlock) {
-        return 'rulehost_block';
-    }
-    // Priority 3: Subagent error
-    if (isSubagentError) {
-        return 'subagent_error';
-    }
-    // Priority 4: Provider rate limit (explicit true/false)
-    if (isRateLimit === true) {
-        return 'rate_limit';
-    }
-    if (isRateLimit === false) {
-        return 'provider_failure';
-    }
-    // Priority 5: Manual pain tool
-    if (toolName === 'pain' || toolName === 'skill:pain') {
-        // Match resolveSourceKindFromToolFailure behavior:
-        // openclaw_context_bound → agent_on_owner_request
-        // other provenance or undefined → owner_reported
-        if (observation.provenance === 'openclaw_context_bound') {
-            return 'agent_on_owner_request';
-        }
-        return 'owner_reported';
-    }
-    // Priority 6: GFI threshold (must check before failure source for LLM detection path)
-    if (isGfiTriggered) {
-        return 'gfi_threshold';
-    }
-    // Priority 7: Tool failure / dispatch error
-    if (failureSource) {
-        // Match resolveSourceKindFromToolFailure behavior:
-        // dispatch_error → dispatch_error, anything else → tool_failure
-        if (failureSource === 'dispatch_error') {
-            return 'dispatch_error';
-        }
-        return 'tool_failure';
-    }
-    // Infer failureSource from tool failure indicators if not explicitly set
-    if (toolNotFound) {
-        return 'dispatch_error';
-    }
-    // Match classifyToolFailureSource behavior: unknown tool name → dispatch_error
-    // BUT only if this looks like a tool failure context (has other tool fields)
-    // Otherwise, this is likely a non-tool observation (e.g., LLM detection)
-    const hasToolContext = toolName !== undefined || nonZeroExit || timedOut || toolNotFound;
-    if (hasToolContext && (!toolName || toolName.trim() === '')) {
-        return 'dispatch_error';
-    }
-    // Exit code-based detection: non-zero exit or timeout → tool_failure
-    if (nonZeroExit || timedOut) {
-        return 'tool_failure';
-    }
-    // Priority 8: LLM detection source
-    if (detectionSource) {
-        // Match resolveSourceKindFromLlmDetection behavior:
-        if (detectionSource === 'llm_paralysis') {
-            return 'llm_paralysis';
-        }
-        if (detectionSource.startsWith('llm_')) {
-            return 'semantic';
-        }
-        if (detectionSource === 'user_empathy') {
-            return 'empathy_inferred';
-        }
-    }
-    // Fallback: unknown
-    return 'unknown';
-}
-// ── Builder Functions ──────────────────────────────────────────────────────
-//
-// PRI-360 S1: These builders construct RawObservation from specific contexts,
-// centralizing source classification rules in the adapter layer.
-// Hooks should NOT hold source classification logic — use these builders.
-/**
- * Classify error message as dispatch_error vs tool_failure.
- *
- * This centralizes the regex-based classification that was previously
- * scattered in classifyToolFailureSource and after-tool-call-helpers.
- * Now hooks call this builder + resolveSourceKind instead of holding rules.
- */
-function classifyErrorForDispatch(error) {
-    if (!error)
-        return 'tool_failure';
-    const msg = String(error);
-    if (/\btool\s+(?:\S+\s+)?not\s+found\b/i.test(msg) || /\bunknown\s+tool\b/i.test(msg)) {
-        return 'dispatch_error';
-    }
-    return 'tool_failure';
-}
-/**
- * Build a RawObservation for a tool failure context.
- *
- * This replaces classifyToolFailureSource and the inline classification
- * in after-tool-call-helpers. All tool error → dispatch/tool_failure
- * classification is centralized here.
- */
-export function buildToolFailureObservation(options) {
-    const { toolName, error, provenance } = options;
-    const nonZeroExit = typeof options.exitCode === 'number' && options.exitCode !== 0;
-    // Classify dispatch vs tool_failure centrally
-    let failureSource;
-    if (!toolName || toolName.trim() === '') {
-        // Empty/whitespace tool name → dispatch error
-        failureSource = 'dispatch_error';
-    }
-    else {
-        failureSource = classifyErrorForDispatch(error);
-    }
-    // If neither error nor non-zero exit, this is not a failure context
-    if (!error && !nonZeroExit) {
-        failureSource = undefined;
-    }
-    return {
-        observedAt: new Date().toISOString(),
-        toolName,
-        failureSource,
-        nonZeroExit,
-        provenance,
-    };
-}
-/**
- * Build a RawObservation for an LLM detection context.
+ * - ERR-011: re-export adapter, not a local re-definition of migrated logic.
  */
-export function buildLlmDetectionObservation(options) {
-    return {
-        observedAt: new Date().toISOString(),
-        detectionSource: options.detectionSource,
-        isGfiTriggered: options.isGfiTriggered,
-    };
-}
+export { resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation, } from '@principles/core/runtime-v2';

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

@@ -1,62 +1,11 @@
 /**
- * Raw Observation Types — PRI-362
+ * Raw Observation Types — PRI-362 / PRI-446
  *
- * Source adapter layer that normalizes diverse hook contexts into a unified
- * observation model before mapping to SourceKind.
- *
- * This replaces scattered resolveSourceKindFrom* functions with a single
- * field-driven adapter.
+ * The RawObservation type has been migrated to principles-core
+ * (runtime-v2/evidence-triage/observation-resolver.ts). This file re-exports it
+ * so existing plugin import sites keep working unchanged.
  *
  * ERR checklist:
- * - ERR-001: No `as` casts; validate unknown payload field-by-field.
- * - ERR-002: Every decision carries reason + nextAction.
- * - EP-01: Source adapter validates before use.
- */
-/**
- * Raw observation from a source adapter.
- *
- * This is the input to resolveSourceKind. It contains all possible
- * context fields that different sources may provide. The adapter
- * reads only the fields it needs based on the observation source.
+ * - ERR-011: this is a re-export adapter, not a local re-definition.
  */
-export interface RawObservation {
-    /** When the observation was made (ISO timestamp) */
-    readonly observedAt: string;
-    /** Workspace identifier */
-    readonly workspaceId?: string;
-    /** Session identifier */
-    readonly sessionId?: string;
-    /** Trace identifier for correlation */
-    readonly traceId?: string;
-    /** Tool name (for after_tool_call hook) */
-    readonly toolName?: string;
-    /** Failure source classification */
-    readonly failureSource?: 'tool_failure' | 'dispatch_error';
-    /** Whether the tool call exited with non-zero code */
-    readonly nonZeroExit?: boolean;
-    /** Whether the tool call timed out */
-    readonly timedOut?: boolean;
-    /** Whether the tool does not exist */
-    readonly toolNotFound?: boolean;
-    /** Detection source identifier */
-    readonly detectionSource?: string;
-    /** Whether GFI threshold was crossed */
-    readonly isGfiTriggered?: boolean;
-    /** Whether the failure was a rate limit (429) */
-    readonly isRateLimit?: boolean;
-    /** Whether this observation came from a gate block */
-    readonly isGateBlock?: boolean;
-    /** Whether this was a manual CLI entry */
-    readonly isManualEntry?: boolean;
-    /** Provenance: how trustworthy and context-bound is the observation */
-    readonly provenance?: 'openclaw_context_bound' | 'owner_reported_no_host_trace' | 'automatic_hook';
-    /** Whether this observation came from a subagent error */
-    readonly isSubagentError?: boolean;
-    /**
-     * Raw payload from the source.
-     *
-     * This is always `unknown` (ERR-005). Source adapters validate only
-     * enough to identify the source and capture bounded context.
-     */
-    readonly payload?: unknown;
-}
+export type { RawObservation } from '@principles/core/runtime-v2';

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

@@ -1,15 +1,11 @@
 /**
- * Raw Observation Types — PRI-362
+ * Raw Observation Types — PRI-362 / PRI-446
  *
- * Source adapter layer that normalizes diverse hook contexts into a unified
- * observation model before mapping to SourceKind.
- *
- * This replaces scattered resolveSourceKindFrom* functions with a single
- * field-driven adapter.
+ * The RawObservation type has been migrated to principles-core
+ * (runtime-v2/evidence-triage/observation-resolver.ts). This file re-exports it
+ * so existing plugin import sites keep working unchanged.
  *
  * ERR checklist:
- * - ERR-001: No `as` casts; validate unknown payload field-by-field.
- * - ERR-002: Every decision carries reason + nextAction.
- * - EP-01: Source adapter validates before use.
+ * - ERR-011: this is a re-export adapter, not a local re-definition.
  */
 export {};

package/dist/hooks/triage-adapter.js

@@ -42,38 +42,18 @@ export { resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObserv
  * - Falling back to existing behavior when the flag is off
  */
 export function evaluateEvidenceTriage(sourceKind, score, options) {
+    // PRI-446: the risky high-score and repeated-failure upgrade rules now live
+    // in core triage-policy.ts (single source of truth). The adapter passes the
+    // context flags straight through; core decides whether to upgrade.
     const input = {
         sourceKind,
         score,
         isUnsafeHighConfidence: options?.isUnsafeHighConfidence,
         provenance: options?.provenance,
+        isRisky: options?.isRisky,
+        consecutiveErrors: options?.consecutiveErrors,
     };
-    let result = evaluateTriage(input);
-    // PEAT-B1 upgrade logic: risky high-score overrides evidence_only
-    // Matches PainDiagnosticGate.risky_high_score: isRisky && score >= 70 → admit
-    if (result.decision === 'evidence_only' &&
-        options?.isRisky === true &&
-        score >= 70) {
-        result = {
-            ...result,
-            decision: 'admit',
-            reason: 'Risky high-score operation overrides evidence-only decision. Immediate diagnosis required.',
-            nextAction: 'create_diagnostic_task',
-        };
-    }
-    // PEAT-B1 upgrade logic: repeated failures override evidence_only
-    // Threshold: 4 consecutive failures (matches PainDiagnosticGate.repeatedFailure)
-    if (result.decision === 'evidence_only' &&
-        options?.consecutiveErrors !== undefined &&
-        options.consecutiveErrors >= 4) {
-        result = {
-            ...result,
-            decision: 'admit',
-            reason: 'Repeated failures override evidence-only decision. Pattern suggests systemic issue requiring diagnosis.',
-            nextAction: 'create_diagnostic_task',
-        };
-    }
-    return result;
+    return evaluateTriage(input);
 }
 // ── High-Confidence Unsafe Action Detection ──────────────────────────────────
 /**

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.140.0",
+  "version": "1.141.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

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