create-principles-disciple 1.92.0 → 1.94.0

package/core/dist/runtime-v2/evidence-triage/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI1C,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAElF,gBAAgB;AAChB,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAQpD,OAAO,EACL,yBAAyB,EACzB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,yBAAyB,CAAC;AAUjC,OAAO,EACL,4BAA4B,EAC5B,+BAA+B,EAC/B,+BAA+B,EAC/B,yBAAyB,EACzB,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI1C,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAElF,gBAAgB;AAChB,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,6EAA6E;AAC7E,OAAO,EAAE,0BAA0B,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAI5F,OAAO,EACL,iBAAiB,EACjB,2BAA2B,EAC3B,4BAA4B,EAC5B,uBAAuB,EACvB,0BAA0B,GAC3B,MAAM,2BAA2B,CAAC;AAQnC,OAAO,EACL,yBAAyB,EACzB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,yBAAyB,CAAC;AAUjC,OAAO,EACL,4BAA4B,EAC5B,+BAA+B,EAC/B,+BAA+B,EAC/B,yBAAyB,EACzB,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,uBAAuB,CAAC"}

package/core/dist/runtime-v2/evidence-triage/observation-resolver.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Observation Resolver — PRI-446 (migrated from the plugin adapter)
+ *
+ * Unified source-kind resolution from RawObservation.
+ *
+ * Pure data mapping — no I/O, no plugin imports, no side effects. This module
+ * replaces the scattered resolveSourceKindFrom* helpers that previously lived in
+ * the plugin-side raw-observation-adapter.ts. The plugin file now re-exports
+ * these symbols so existing callers and source-string characterization tests
+ * keep working unchanged.
+ *
+ * Field precedence (highest to lowest):
+ * 1. isManualEntry → owner_reported
+ * 2. isGateBlock → rulehost_block
+ * 3. isSubagentError → subagent_error
+ * 4. isRateLimit → rate_limit / provider_failure
+ * 5. toolName === 'pain' / 'skill:pain' → agent_on_owner_request / owner_reported
+ * 6. isGfiTriggered → gfi_threshold
+ * 7. failureSource → tool_failure / dispatch_error
+ * 8. detectionSource → llm_paralysis / semantic / empathy_inferred / unknown
+ * 9. Fallback → unknown
+ *
+ * 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.
+ */
+import type { SourceKind } from './types.js';
+/**
+ * Raw observation from a source adapter.
+ *
+ * This is the input to resolveSourceKind. It contains all possible
+ * context fields that different sources may provide. The resolver
+ * reads only the fields it needs based on the observation source.
+ */
+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;
+}
+/**
+ * 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;
+/**
+ * Build a RawObservation for an empathy/GFI-triggered context (PRI-454).
+ *
+ * Used by prompt.ts paths 2 and 3 (GFI threshold crossing + empathy keyword match).
+ * When isGfiTriggered=true, resolveSourceKind returns 'gfi_threshold' (evidence_only).
+ * When isGfiTriggered=false, resolveSourceKind returns 'empathy_inferred' (owner_confirm).
+ */
+export declare function buildEmpathyObservation(options: {
+    detectionSource: string;
+    isGfiTriggered: boolean;
+    sessionId?: string;
+}): RawObservation;
+/**
+ * Build a RawObservation for a manual pain entry (PRI-454).
+ *
+ * Used by pain.ts path 5 (manual /pd-pain command).
+ * resolveSourceKind returns 'owner_reported' (triage: admit).
+ */
+export declare function buildManualPainObservation(options: {
+    sessionId?: string;
+}): RawObservation;
+//# sourceMappingURL=observation-resolver.d.ts.map

package/core/dist/runtime-v2/evidence-triage/observation-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observation-resolver.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/observation-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAI7C;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,oDAAoD;IACpD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,2BAA2B;IAC3B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,yBAAyB;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,uCAAuC;IACvC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAG1B,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,oCAAoC;IACpC,QAAQ,CAAC,aAAa,CAAC,EAAE,cAAc,GAAG,gBAAgB,CAAC;IAC3D,sDAAsD;IACtD,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,sCAAsC;IACtC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,sCAAsC;IACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAGhC,kCAAkC;IAClC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,wCAAwC;IACxC,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAGlC,iDAAiD;IACjD,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAG/B,sDAAsD;IACtD,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAG/B,0CAA0C;IAC1C,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,uEAAuE;IACvE,QAAQ,CAAC,UAAU,CAAC,EAAE,wBAAwB,GAAG,8BAA8B,GAAG,gBAAgB,CAAC;IAGnG,0DAA0D;IAC1D,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IAGnC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAID;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,cAAc,GAAG,UAAU,CAkGzE;AAwBD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE;IACnD,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,cAAc,CAAC,YAAY,CAAC,CAAC;CAC3C,GAAG,cAAc,CA0BjB;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE;IACpD,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;CACzB,GAAG,cAAc,CAMjB;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE;IAC/C,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,cAAc,CAOjB;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,cAAc,CAMjB"}

package/core/dist/runtime-v2/evidence-triage/observation-resolver.js

@@ -0,0 +1,203 @@
+/**
+ * Observation Resolver — PRI-446 (migrated from the plugin adapter)
+ *
+ * Unified source-kind resolution from RawObservation.
+ *
+ * Pure data mapping — no I/O, no plugin imports, no side effects. This module
+ * replaces the scattered resolveSourceKindFrom* helpers that previously lived in
+ * the plugin-side raw-observation-adapter.ts. The plugin file now re-exports
+ * these symbols so existing callers and source-string characterization tests
+ * keep working unchanged.
+ *
+ * Field precedence (highest to lowest):
+ * 1. isManualEntry → owner_reported
+ * 2. isGateBlock → rulehost_block
+ * 3. isSubagentError → subagent_error
+ * 4. isRateLimit → rate_limit / provider_failure
+ * 5. toolName === 'pain' / 'skill:pain' → agent_on_owner_request / owner_reported
+ * 6. isGfiTriggered → gfi_threshold
+ * 7. failureSource → tool_failure / dispatch_error
+ * 8. detectionSource → llm_paralysis / semantic / empathy_inferred / unknown
+ * 9. Fallback → unknown
+ *
+ * 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.
+ */
+// ── Source Kind Resolution ──────────────────────────────────────────────────
+/**
+ * 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.
+ */
+export function buildLlmDetectionObservation(options) {
+    return {
+        observedAt: new Date().toISOString(),
+        detectionSource: options.detectionSource,
+        isGfiTriggered: options.isGfiTriggered,
+    };
+}
+/**
+ * Build a RawObservation for an empathy/GFI-triggered context (PRI-454).
+ *
+ * Used by prompt.ts paths 2 and 3 (GFI threshold crossing + empathy keyword match).
+ * When isGfiTriggered=true, resolveSourceKind returns 'gfi_threshold' (evidence_only).
+ * When isGfiTriggered=false, resolveSourceKind returns 'empathy_inferred' (owner_confirm).
+ */
+export function buildEmpathyObservation(options) {
+    return {
+        observedAt: new Date().toISOString(),
+        detectionSource: options.detectionSource,
+        isGfiTriggered: options.isGfiTriggered,
+        sessionId: options.sessionId,
+    };
+}
+/**
+ * Build a RawObservation for a manual pain entry (PRI-454).
+ *
+ * Used by pain.ts path 5 (manual /pd-pain command).
+ * resolveSourceKind returns 'owner_reported' (triage: admit).
+ */
+export function buildManualPainObservation(options) {
+    return {
+        observedAt: new Date().toISOString(),
+        isManualEntry: true,
+        sessionId: options.sessionId,
+    };
+}
+//# sourceMappingURL=observation-resolver.js.map

package/core/dist/runtime-v2/evidence-triage/observation-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observation-resolver.js","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/observation-resolver.ts"],"names":[],"mappings":"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"}

package/core/dist/runtime-v2/evidence-triage/triage-policy.d.ts

@@ -14,6 +14,10 @@
  * - ERR-005: Input is unknown, validated field-by-field.
  */
 import type { TriageInput, TriageResult } from './types.js';
+/** Pain score at or above which a risky action upgrades to admit. */
+export declare const RISKY_HIGH_SCORE_THRESHOLD = 70;
+/** Consecutive failures at or above which a tool failure upgrades to admit. */
+export declare const REPEATED_FAILURE_THRESHOLD = 4;
 /**
  * Evaluate triage policy for incoming evidence.
  *

package/core/dist/runtime-v2/evidence-triage/triage-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triage-policy.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/triage-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAA8B,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAuCxF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,CAmC/D"}
+{"version":3,"file":"triage-policy.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/triage-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAA8B,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAWxF,qEAAqE;AACrE,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAC7C,+EAA+E;AAC/E,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAyF5C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,CA4C/D"}

package/core/dist/runtime-v2/evidence-triage/triage-policy.js

@@ -15,33 +15,82 @@
  */
 import { isSourceKind } from './types.js';
 import { getSourceDescriptor } from './source-descriptors.js';
+// ── Upgrade Thresholds (PRI-446 — migrated verbatim from the plugin adapter) ──
+//
+// These constants previously lived inline in the plugin-side triage-adapter
+// as magic numbers `70` and `4`. They are moved here byte-for-byte so the
+// upgrade decision has a single source of truth. The adapter now passes
+// isRisky / consecutiveErrors through to core instead of overriding the result.
+/** Pain score at or above which a risky action upgrades to admit. */
+export const RISKY_HIGH_SCORE_THRESHOLD = 70;
+/** Consecutive failures at or above which a tool failure upgrades to admit. */
+export const REPEATED_FAILURE_THRESHOLD = 4;
 // ── Upgrade Rules ───────────────────────────────────────────────────────────
 /**
  * Apply upgrade rules for upgradable source kinds.
  *
- * Currently only 'rulehost_block' can be upgraded:
- * - If isUnsafeHighConfidence is true, upgrade from 'evidence_only' to 'admit'
+ * Three rules (PRI-446 consolidated all of them into core):
+ * 1. rulehost_block + isUnsafeHighConfidence → admit
+ * 2. tool_failure (or any evidence_only upgradeable kind) + isRisky + score >= 70 → admit
+ * 3. tool_failure (or any evidence_only upgradeable kind) + consecutiveErrors >= 4 → admit
  *
  * This is the ONLY place where context-dependent upgrades happen in core.
- * The plugin adapter sets isUnsafeHighConfidence based on hook context.
+ * The plugin adapter sets the context flags based on hook context.
+ *
+ * Rule precedence matches the prior plugin implementation: risky high-score is
+ * checked before repeated failure, but since both produce the same upgraded
+ * decision with the same nextAction, the order is only observable via the
+ * reason string. We preserve the plugin's prior order (risky first).
  */
 function applyUpgradeRules(input, defaultDecision) {
+    if (defaultDecision !== 'evidence_only') {
+        return defaultDecision;
+    }
+    // Rule 1: rulehost_block unsafe action (pre-existing).
     if (input.sourceKind === 'rulehost_block' && input.isUnsafeHighConfidence === true) {
         return 'admit';
     }
+    // Rule 2: risky high-score (migrated from plugin, PRI-446).
+    if (input.isRisky === true && input.score >= RISKY_HIGH_SCORE_THRESHOLD) {
+        return 'admit';
+    }
+    // Rule 3: repeated failure (migrated from plugin, PRI-446).
+    if (input.consecutiveErrors !== undefined && input.consecutiveErrors >= REPEATED_FAILURE_THRESHOLD) {
+        return 'admit';
+    }
     return defaultDecision;
 }
 function getUpgradeReason(sourceKind, decision, input) {
-    if (sourceKind === 'rulehost_block' && decision === 'admit') {
+    if (decision !== 'admit') {
+        return `Upgraded decision for ${sourceKind}: ${decision}`;
+    }
+    if (sourceKind === 'rulehost_block' && input.isUnsafeHighConfidence === true) {
         return `RuleHost blocked a high-confidence unsafe action (score=${input.score}). Upgrading to direct diagnosis.`;
     }
+    // PRI-446: verbatim string from the plugin triage-adapter
+    if (input.isRisky === true && input.score >= RISKY_HIGH_SCORE_THRESHOLD) {
+        return 'Risky high-score operation overrides evidence-only decision. Immediate diagnosis required.';
+    }
+    // PRI-446: verbatim string from the plugin triage-adapter
+    if (input.consecutiveErrors !== undefined && input.consecutiveErrors >= REPEATED_FAILURE_THRESHOLD) {
+        return 'Repeated failures override evidence-only decision. Pattern suggests systemic issue requiring diagnosis.';
+    }
     // Should not reach here — fallback
     return `Upgraded decision for ${sourceKind}: ${decision}`;
 }
-function getUpgradeNextAction(sourceKind, decision) {
-    if (sourceKind === 'rulehost_block' && decision === 'admit') {
+function getUpgradeNextAction(sourceKind, decision, input) {
+    if (decision !== 'admit') {
         return 'none';
     }
+    if (sourceKind === 'rulehost_block' && input.isUnsafeHighConfidence === true) {
+        return 'none';
+    }
+    // PRI-446: verbatim nextAction from the plugin triage-adapter
+    // (both risky-high-score and repeated-failure used 'create_diagnostic_task').
+    if ((input.isRisky === true && input.score >= RISKY_HIGH_SCORE_THRESHOLD) ||
+        (input.consecutiveErrors !== undefined && input.consecutiveErrors >= REPEATED_FAILURE_THRESHOLD)) {
+        return 'create_diagnostic_task';
+    }
     return 'none';
 }
 // ── Evaluation ──────────────────────────────────────────────────────────────
@@ -73,15 +122,23 @@ export function evaluateTriage(input) {
             nextAction: 'classify_source_kind_and_store_as_evidence',
         };
     }
-    // Apply upgrade rules for upgradable kinds
-    if (descriptor.canUpgrade) {
+    // Apply upgrade rules. PRI-446: rule 1 (rulehost_block) is gated by
+    // descriptor.canUpgrade; rules 2/3 (risky high-score / repeated failure) are
+    // context-driven and apply to any evidence_only kind when the relevant flag is
+    // present, matching the prior plugin behavior. applyUpgradeRules internally
+    // guards on defaultDecision === 'evidence_only', so non-upgradeable kinds
+    // (admit/health_only/owner_confirm) are never affected.
+    const upgradeable = descriptor.canUpgrade ||
+        input.isRisky !== undefined ||
+        input.consecutiveErrors !== undefined;
+    if (upgradeable) {
         const upgraded = applyUpgradeRules(input, descriptor.defaultDecision);
         if (upgraded !== descriptor.defaultDecision) {
             return {
                 decision: upgraded,
                 sourceKind,
                 reason: getUpgradeReason(sourceKind, upgraded, input),
-                nextAction: getUpgradeNextAction(sourceKind, upgraded),
+                nextAction: getUpgradeNextAction(sourceKind, upgraded, input),
             };
         }
     }

package/core/dist/runtime-v2/evidence-triage/triage-policy.js.map

@@ -1 +1 @@
-{"version":3,"file":"triage-policy.js","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/triage-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,+EAA+E;AAE/E;;;;;;;;GAQG;AACH,SAAS,iBAAiB,CAAC,KAAkB,EAAE,eAA+B;IAC5E,IAAI,KAAK,CAAC,UAAU,KAAK,gBAAgB,IAAI,KAAK,CAAC,sBAAsB,KAAK,IAAI,EAAE,CAAC;QACnF,OAAO,OAAO,CAAC;IACjB,CAAC;IACD,OAAO,eAAe,CAAC;AACzB,CAAC;AAED,SAAS,gBAAgB,CAAC,UAAsB,EAAE,QAAwB,EAAE,KAAkB;IAC5F,IAAI,UAAU,KAAK,gBAAgB,IAAI,QAAQ,KAAK,OAAO,EAAE,CAAC;QAC5D,OAAO,2DAA2D,KAAK,CAAC,KAAK,mCAAmC,CAAC;IACnH,CAAC;IACD,mCAAmC;IACnC,OAAO,yBAAyB,UAAU,KAAK,QAAQ,EAAE,CAAC;AAC5D,CAAC;AAED,SAAS,oBAAoB,CAAC,UAAsB,EAAE,QAAwB;IAC5E,IAAI,UAAU,KAAK,gBAAgB,IAAI,QAAQ,KAAK,OAAO,EAAE,CAAC;QAC5D,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,+EAA+E;AAE/E;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,cAAc,CAAC,KAAkB;IAC/C,kDAAkD;IAClD,MAAM,UAAU,GAAe,YAAY,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC;IAE7F,qBAAqB;IACrB,MAAM,UAAU,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAC;IACnD,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,iFAAiF;QACjF,OAAO;YACL,QAAQ,EAAE,eAAe;YACzB,UAAU,EAAE,SAAS;YACrB,MAAM,EAAE,gBAAgB,UAAU,2DAA2D;YAC7F,UAAU,EAAE,4CAA4C;SACzD,CAAC;IACJ,CAAC;IAED,2CAA2C;IAC3C,IAAI,UAAU,CAAC,UAAU,EAAE,CAAC;QAC1B,MAAM,QAAQ,GAAG,iBAAiB,CAAC,KAAK,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC;QACtE,IAAI,QAAQ,KAAK,UAAU,CAAC,eAAe,EAAE,CAAC;YAC5C,OAAO;gBACL,QAAQ,EAAE,QAAQ;gBAClB,UAAU;gBACV,MAAM,EAAE,gBAAgB,CAAC,UAAU,EAAE,QAAQ,EAAE,KAAK,CAAC;gBACrD,UAAU,EAAE,oBAAoB,CAAC,UAAU,EAAE,QAAQ,CAAC;aACvD,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO;QACL,QAAQ,EAAE,UAAU,CAAC,eAAe;QACpC,UAAU;QACV,MAAM,EAAE,UAAU,CAAC,MAAM;QACzB,UAAU,EAAE,UAAU,CAAC,UAAU;KAClC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"triage-policy.js","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/triage-policy.ts"],"names":[],"mappings":"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"}

package/core/dist/runtime-v2/evidence-triage/types.d.ts

@@ -56,6 +56,20 @@ export interface TriageInput {
     readonly isUnsafeHighConfidence?: boolean;
     /** Provenance: how was this pain observed? */
     readonly provenance?: 'openclaw_context_bound' | 'owner_reported_no_host_trace' | 'automatic_hook';
+    /**
+     * Whether the failed action was risky/irreversible.
+     *
+     * Migrated from the plugin triage-adapter (PRI-446): a risky action with
+     * a high pain score upgrades an evidence_only decision to admit.
+     */
+    readonly isRisky?: boolean;
+    /**
+     * Number of consecutive failures observed for the current session/tool.
+     *
+     * Migrated from the plugin triage-adapter (PRI-446): repeated failures
+     * (>= RISKY_HIGH_SCORE_THRESHOLD) upgrade an evidence_only decision to admit.
+     */
+    readonly consecutiveErrors?: number;
 }
 /**
  * Runtime guard for SourceKind.

package/core/dist/runtime-v2/evidence-triage/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAClB,gBAAgB,GAChB,wBAAwB,GACxB,cAAc,GACd,gBAAgB,GAChB,kBAAkB,GAClB,YAAY,GACZ,gBAAgB,GAChB,kBAAkB,GAClB,UAAU,GACV,eAAe,GACf,gBAAgB,GAChB,eAAe,GACf,SAAS,CAAC;AAId;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,eAAe,GACf,eAAe,GACf,aAAa,GACb,QAAQ,CAAC;AAIb;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,yCAAyC;IACzC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,8BAA8B;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAID;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,6BAA6B;IAC7B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,yBAAyB;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAC1C,8CAA8C;IAC9C,QAAQ,CAAC,UAAU,CAAC,EAAE,wBAAwB,GAAG,8BAA8B,GAAG,gBAAgB,CAAC;CACpG;AAoBD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAClB,gBAAgB,GAChB,wBAAwB,GACxB,cAAc,GACd,gBAAgB,GAChB,kBAAkB,GAClB,YAAY,GACZ,gBAAgB,GAChB,kBAAkB,GAClB,UAAU,GACV,eAAe,GACf,gBAAgB,GAChB,eAAe,GACf,SAAS,CAAC;AAId;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,eAAe,GACf,eAAe,GACf,aAAa,GACb,QAAQ,CAAC;AAIb;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,yCAAyC;IACzC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,8BAA8B;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAID;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,6BAA6B;IAC7B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,yBAAyB;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAC1C,8CAA8C;IAC9C,QAAQ,CAAC,UAAU,CAAC,EAAE,wBAAwB,GAAG,8BAA8B,GAAG,gBAAgB,CAAC;IACnG;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CACrC;AAoBD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE"}

package/core/dist/runtime-v2/evidence-triage/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA6EH,gFAAgF;AAEhF,MAAM,kBAAkB,GAAwB,IAAI,GAAG,CAAa;IAClE,gBAAgB;IAChB,wBAAwB;IACxB,cAAc;IACd,gBAAgB;IAChB,kBAAkB;IAClB,YAAY;IACZ,gBAAgB;IAChB,kBAAkB;IAClB,UAAU;IACV,eAAe;IACf,gBAAgB;IAChB,eAAe;IACf,SAAS;CACV,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,kBAAkB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACpE,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA2FH,gFAAgF;AAEhF,MAAM,kBAAkB,GAAwB,IAAI,GAAG,CAAa;IAClE,gBAAgB;IAChB,wBAAwB;IACxB,cAAc;IACd,gBAAgB;IAChB,kBAAkB;IAClB,YAAY;IACZ,gBAAgB;IAChB,kBAAkB;IAClB,UAAU;IACV,eAAe;IACf,gBAAgB;IAChB,eAAe;IACf,SAAS;CACV,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,kBAAkB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACpE,CAAC"}

package/core/dist/runtime-v2/feature-flags/__tests__/feature-flag-contract.test.js

@@ -206,6 +206,15 @@ describe('computeEffectiveFlags', () => {
                 continue;
             if (flag.id === 'story_a_approval_completion')
                 continue;
+            // PRI-454: painEvidenceAdmission + painEvidenceAdmissionDefault flipped to default-on
+            if (flag.id === 'painEvidenceAdmission')
+                continue;
+            if (flag.id === 'pain_evidence_admission')
+                continue;
+            if (flag.id === 'painEvidenceAdmissionDefault')
+                continue;
+            if (flag.id === 'pain_evidence_admission_default')
+                continue;
             expect(flag.enabled, `quiet flag ${flag.id} should default off`).toBe(false);
         }
     });
@@ -323,26 +332,46 @@ describe('DEFAULT_FEATURE_FLAGS', () => {
             }
         }
     });
-    it('PEAT-B1: painEvidenceAdmission is registered as quiet, default-off', () => {
+    it('PEAT-B1: painEvidenceAdmission is registered as quiet, default-on (PRI-454 flip)', () => {
         const flag = DEFAULT_FEATURE_FLAGS.find(f => f.id === 'painEvidenceAdmission');
         expect(flag).toBeDefined();
         if (!flag)
             throw new Error('painEvidenceAdmission flag not found');
         expect(flag.category).toBe('quiet');
-        expect(flag.enabled).toBe(false);
+        expect(flag.enabled).toBe(true);
         expect(flag.since).toBe('2026-06-06');
         expect(flag.description).toContain('PEAT-B1');
     });
-    it('PRI-404: pain_evidence_admission snake_case alias is registered as quiet, default-off', () => {
+    it('PRI-404: pain_evidence_admission snake_case alias is registered as quiet, default-on (PRI-454 flip)', () => {
         const flag = DEFAULT_FEATURE_FLAGS.find(f => f.id === 'pain_evidence_admission');
         expect(flag).toBeDefined();
         if (!flag)
             throw new Error('pain_evidence_admission flag not found');
         expect(flag.category).toBe('quiet');
-        expect(flag.enabled).toBe(false);
+        expect(flag.enabled).toBe(true);
         expect(flag.since).toBe('2026-06-15');
         expect(flag.description).toContain('Snake-case');
     });
+    it('PRI-454: painEvidenceAdmissionDefault is registered as quiet, default-on', () => {
+        const flag = DEFAULT_FEATURE_FLAGS.find(f => f.id === 'painEvidenceAdmissionDefault');
+        expect(flag).toBeDefined();
+        if (!flag)
+            throw new Error('painEvidenceAdmissionDefault flag not found');
+        expect(flag.category).toBe('quiet');
+        expect(flag.enabled).toBe(true);
+        expect(flag.since).toBe('2026-06-24');
+        expect(flag.description).toContain('PRI-454');
+    });
+    it('PRI-454: pain_evidence_admission_default snake_case alias is registered as quiet, default-on', () => {
+        const flag = DEFAULT_FEATURE_FLAGS.find(f => f.id === 'pain_evidence_admission_default');
+        expect(flag).toBeDefined();
+        if (!flag)
+            throw new Error('pain_evidence_admission_default flag not found');
+        expect(flag.category).toBe('quiet');
+        expect(flag.enabled).toBe(true);
+        expect(flag.since).toBe('2026-06-24');
+        expect(flag.description).toContain('PRI-454');
+    });
     it('PRI-404: pain_evidence_admission is recognized by computeEffectiveFlags (no unknown warning)', () => {
         const userFlags = {
             pain_evidence_admission: { enabled: true },