create-principles-disciple 1.85.0 → 1.87.0

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

@@ -0,0 +1,170 @@
+/**
+ * Raw Observation Adapter — PRI-362
+ *
+ * Unified source-kind resolution from RawObservation.
+ *
+ * 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
+ *
+ * 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.
+ */
+export function buildLlmDetectionObservation(options) {
+    return {
+        observedAt: new Date().toISOString(),
+        detectionSource: options.detectionSource,
+        isGfiTriggered: options.isGfiTriggered,
+    };
+}

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

@@ -0,0 +1,62 @@
+/**
+ * Raw Observation Types — PRI-362
+ *
+ * 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.
+ *
+ * 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.
+ */
+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;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Raw Observation Types — PRI-362
+ *
+ * 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.
+ *
+ * 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.
+ */
+export {};

package/plugin/dist/hooks/trajectory-collector.d.ts

@@ -1,36 +1,25 @@
 /**
- * Trajectory Collector - 行为进化引擎 Phase 0 数据收集
+ * Trajectory Collector - message write trajectory recording
  *
- * 收集工具调用和 LLM 输出到 memory/trajectories/ 目录
- * 用于分析工具使用模式、识别原则应用案例、评估行为质量
+ * Records message data to memory/trajectories/ JSONL files.
+ * PRI-347 removed tool_call and llm_output JSONL writers (no consumers).
+ * PRI-346 will repurpose handleBeforeMessageWrite for SQLite collection.
  */
-import type { PluginHookAfterToolCallEvent, PluginHookToolContext, PluginHookLlmOutputEvent, PluginHookAgentContext, PluginHookBeforeMessageWriteEvent } from '../openclaw-sdk.js';
+import type { PluginHookAgentContext, PluginHookBeforeMessageWriteEvent } from '../openclaw-sdk.js';
 /**
- * 工具调用完成后的处理
- * 记录：工具名、参数、结果、错误、执行时间
- */
-export declare function handleAfterToolCall(event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext & {
-    workspaceDir?: string;
-}): void;
-/**
- * LLM 输出处理
- * 记录：provider、model、输出长度、token 使用量
- */
-export declare function handleLlmOutput(event: PluginHookLlmOutputEvent, ctx: PluginHookAgentContext & {
-    workspaceDir?: string;
-}): void;
-/**
- * 消息写入前的处理
- * 记录：用户/助手消息内容
+ * PRI-346: Message write hook with SQLite fallback trajectory recording.
+ *
+ * When allowConversationAccess is NOT set (unauthorized), llm_output is silently
+ * blocked by OpenClaw and trajectory.db has no data. This hook is NOT in
+ * CONVERSATION_HOOK_NAMES, so it always fires — making it the natural fallback.
+ *
+ * De-duplication: only writes to SQLite when llm_output is blocked (unauthorized).
+ * When llm_output is working (authorized), this hook degrades to JSONL-only.
+ *
+ * ERR-002: structured observability when fallback fires.
+ * ERR-001/005: content is sanitized before persisting.
  */
 export declare function handleBeforeMessageWrite(event: PluginHookBeforeMessageWriteEvent, ctx: PluginHookAgentContext & {
     workspaceDir?: string;
+    pluginConfig?: unknown;
 }): void;
-/**
- * 脱敏处理：移除敏感参数（保留旧函数签名以兼容）
- * @deprecated 使用 scrubSensitive 替代
- */
-/**
- * 轨迹汇总统计（供 cron 任务调用）
- */
-export declare function computeTrajectoryStats(workspaceDir: string): object;

package/plugin/dist/hooks/trajectory-collector.js

@@ -1,17 +1,20 @@
 /**
- * Trajectory Collector - 行为进化引擎 Phase 0 数据收集
+ * Trajectory Collector - message write trajectory recording
  *
- * 收集工具调用和 LLM 输出到 memory/trajectories/ 目录
- * 用于分析工具使用模式、识别原则应用案例、评估行为质量
+ * Records message data to memory/trajectories/ JSONL files.
+ * PRI-347 removed tool_call and llm_output JSONL writers (no consumers).
+ * PRI-346 will repurpose handleBeforeMessageWrite for SQLite collection.
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import { MAX_STRING_LENGTH } from '../config/defaults/runtime.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+import { SystemLogger } from '../core/system-logger.js';
+import { sanitizeForEvidence } from './message-sanitize.js';
+import { checkConversationAccessConfig } from '../core/config-health.js';
 const TRAJECTORY_DIR = 'memory/trajectories/';
 // 敏感字段匹配正则
 const SENSITIVE_KEY_PATTERN = /password|token|authorization|secret|api[_-]?key|credential|cookie|session/i;
-// 最大结果长度（不同于 MAX_STRING_LENGTH）
-const MAX_RESULT_LENGTH = 500;
 /**
  * 递归脱敏处理：遍历对象/数组，移除敏感字段值
  */
@@ -121,58 +124,17 @@ function writeTrajectoryRecord(workspaceDir, record) {
     });
 }
 /**
- * 工具调用完成后的处理
- * 记录：工具名、参数、结果、错误、执行时间
- */
-export function handleAfterToolCall(event, ctx) {
-    const { workspaceDir } = ctx;
-    if (!workspaceDir)
-        return;
-    // 递归脱敏处理所有字段
-    const sanitizedParams = scrubSensitive(event.params);
-    const sanitizedResult = event.result == null
-        ? null
-        : String(scrubSensitive(event.result)).slice(0, MAX_RESULT_LENGTH);
-    const sanitizedError = event.error == null
-        ? null
-        : String(scrubSensitive(event.error));
-    writeTrajectoryRecord(workspaceDir, {
-        type: 'tool_call',
-        timestamp: new Date().toISOString(),
-        sessionId: ctx.sessionId || 'unknown',
-        toolName: event.toolName,
-        params: sanitizedParams,
-        result: sanitizedResult,
-        error: sanitizedError,
-        durationMs: event.durationMs,
-        success: !event.error,
-        runId: event.runId || null,
-        toolCallId: event.toolCallId || null
-    });
-}
-/**
- * LLM 输出处理
- * 记录：provider、model、输出长度、token 使用量
- */
-export function handleLlmOutput(event, ctx) {
-    const { workspaceDir } = ctx;
-    if (!workspaceDir)
-        return;
-    const totalTextLength = event.assistantTexts?.reduce((sum, text) => sum + (text?.length || 0), 0) || 0;
-    writeTrajectoryRecord(workspaceDir, {
-        type: 'llm_output',
-        timestamp: new Date().toISOString(),
-        sessionId: ctx.sessionId || 'unknown',
-        provider: event.provider,
-        model: event.model,
-        textLength: totalTextLength,
-        outputCount: event.assistantTexts?.length || 0,
-        usage: event.usage ? scrubSensitive(event.usage) : null
-    });
-}
-/**
- * 消息写入前的处理
- * 记录：用户/助手消息内容
+ * PRI-346: Message write hook with SQLite fallback trajectory recording.
+ *
+ * When allowConversationAccess is NOT set (unauthorized), llm_output is silently
+ * blocked by OpenClaw and trajectory.db has no data. This hook is NOT in
+ * CONVERSATION_HOOK_NAMES, so it always fires — making it the natural fallback.
+ *
+ * De-duplication: only writes to SQLite when llm_output is blocked (unauthorized).
+ * When llm_output is working (authorized), this hook degrades to JSONL-only.
+ *
+ * ERR-002: structured observability when fallback fires.
+ * ERR-001/005: content is sanitized before persisting.
  */
 export function handleBeforeMessageWrite(event, ctx) {
     const { workspaceDir } = ctx;
@@ -181,13 +143,12 @@ export function handleBeforeMessageWrite(event, ctx) {
     const msg = event.message;
     if (!msg || !msg.role)
         return;
-    // 只记录 user 和 assistant 消息
+    // Only record user and assistant messages
     if (msg.role !== 'user' && msg.role !== 'assistant')
         return;
-    // 提取文本内容
+    // Extract text content (consistent with existing implementation)
     let content = '';
     if (typeof msg.content === 'string') {
-        // Reason: msg.content is string | ContentPart[]; destructuring would require renaming in the else branch
         content = msg.content;
     }
     else if (Array.isArray(msg.content)) {
@@ -196,63 +157,69 @@ export function handleBeforeMessageWrite(event, ctx) {
             .map((part) => part.text)
             .join('\n');
     }
-    // 脱敏处理内容预览
+    // Sanitize content preview for JSONL
     const sanitizedPreview = scrubSensitive(content.slice(0, 200));
+    // Existing JSONL write (always, for backward compatibility)
     writeTrajectoryRecord(workspaceDir, {
         type: 'message',
         timestamp: new Date().toISOString(),
-        sessionId: event.sessionKey || 'unknown',
+        sessionId: event.sessionKey || event.sessionId || 'unknown',
         role: msg.role,
         contentLength: content.length,
         contentPreview: typeof sanitizedPreview === 'string' ? sanitizedPreview : '[sanitized]',
-        agentId: event.agentId || null
+        agentId: event.agentId || null,
+        fallback: 'before_message_write',
     });
-}
-/**
- * 脱敏处理：移除敏感参数（保留旧函数签名以兼容）
- * @deprecated 使用 scrubSensitive 替代
- */
-/**
- * 轨迹汇总统计（供 cron 任务调用）
- */
-export function computeTrajectoryStats(workspaceDir) {
-    const dir = path.join(workspaceDir, TRAJECTORY_DIR);
-    const todayFile = path.join(dir, getTodayFilename());
-    if (!fs.existsSync(todayFile)) {
-        return { date: getTodayFilename(), totalRecords: 0, toolCalls: 0, llmOutputs: 0, messages: 0 };
+    // ── SQLite fallback (PRI-346): only when conversation hooks are blocked ──
+    const accessCheck = checkConversationAccessConfig(ctx.pluginConfig);
+    if (accessCheck.authorized) {
+        // llm_output is working — do NOT duplicate write to SQLite (de-dup, case D)
+        return;
     }
-    const content = fs.readFileSync(todayFile, 'utf8');
-    const lines = content.split('\n').filter(line => line.trim());
-    const toolCalls = lines.filter(line => {
+    // Conversation hooks blocked — this hook is the fallback trajectory writer
+    if (msg.role === 'assistant') {
         try {
-            return JSON.parse(line).type === 'tool_call';
+            const wctx = WorkspaceContext.fromHookContext({ workspaceDir, logger: ctx.logger });
+            const sanitized = sanitizeForEvidence(content.slice(0, MAX_STRING_LENGTH), workspaceDir);
+            const sessionId = event.sessionKey ?? ctx.sessionId ?? 'unknown';
+            wctx.trajectory?.recordAssistantTurn?.({
+                sessionId,
+                runId: 'before_message_write_fallback',
+                provider: 'unknown',
+                model: 'unknown',
+                rawText: content,
+                sanitizedText: sanitized,
+                usageJson: {},
+                empathySignalJson: { detected: false, severity: 'mild', confidence: 1 },
+                createdAt: new Date().toISOString(),
+            });
         }
-        catch {
-            return false;
-        }
-    }).length;
-    const llmOutputs = lines.filter(line => {
-        try {
-            return JSON.parse(line).type === 'llm_output';
-        }
-        catch {
-            return false;
+        catch (err) {
+            ctx.logger?.warn?.(`[PD:before_message_write] SQLite fallback write failed: ${String(err)}`);
         }
-    }).length;
-    const messages = lines.filter(line => {
+    }
+    else if (msg.role === 'user') {
         try {
-            return JSON.parse(line).type === 'message';
+            const wctx = WorkspaceContext.fromHookContext({ workspaceDir, logger: ctx.logger });
+            const sessionId = event.sessionKey ?? ctx.sessionId ?? 'unknown';
+            wctx.trajectory?.recordUserTurn?.({
+                sessionId,
+                turnIndex: 0,
+                rawText: content.slice(0, MAX_STRING_LENGTH),
+                correctionDetected: false,
+                createdAt: new Date().toISOString(),
+            });
         }
-        catch {
-            return false;
+        catch (err) {
+            ctx.logger?.warn?.(`[PD:before_message_write] SQLite user turn fallback failed: ${String(err)}`);
         }
-    }).length;
-    return {
-        date: getTodayFilename(),
-        totalRecords: lines.length,
-        toolCalls,
-        llmOutputs,
-        messages,
-        generatedAt: new Date().toISOString()
-    };
+    }
+    // ERR-002: Structured observability — no silent fallback
+    SystemLogger.log(workspaceDir, 'CONVERSATION_HOOK_BLOCKED', JSON.stringify({
+        reason: accessCheck.reason,
+        nextAction: accessCheck.nextAction,
+        hook: 'llm_output',
+        fallback: 'before_message_write',
+        role: msg.role,
+    }));
 }

package/plugin/dist/hooks/trajectory-evidence.js

@@ -55,6 +55,29 @@ export function buildTrajectoryEvidence(wctx, sessionId) {
             });
         }
     }
+    // PRI-358: Extract failed tool_calls as evidence
+    try {
+        const allToolCalls = wctx.trajectory.listToolCallsForSession(sessionId) ?? [];
+        const failedToolCalls = allToolCalls.filter(tc => tc.outcome === 'failure').slice(-3);
+        for (const tc of failedToolCalls) {
+            if (evidence.length >= MAX_EVIDENCE_ENTRIES)
+                break;
+            const note = `Tool ${tc.toolName} failed: ${tc.errorType ?? 'unknown'} (exitCode: ${tc.exitCode ?? 'N/A'})`;
+            evidence.push({
+                sourceRef: `tool_call_failure:${tc.createdAt}`,
+                note: sanitizeAssistantText(note.slice(0, MAX_EVIDENCE_NOTE_CHARS)),
+            });
+        }
+    }
+    catch (e) {
+        // Only add unavailable entry when no other evidence exists (avoid noise)
+        if (evidence.length === 0) {
+            evidence.push({
+                sourceRef: 'tool_call_failure:unavailable',
+                note: `trajectory_tool_calls_unavailable: ${String(e).slice(0, 100)}`,
+            });
+        }
+    }
     if (evidence.length === 0) {
         evidence.push({
             sourceRef: 'trajectory:empty',

package/plugin/dist/hooks/triage-adapter.d.ts

@@ -19,40 +19,14 @@
  */
 import { type TriageResult, type SourceKind } from '@principles/core/runtime-v2';
 /**
- * Map after_tool_call hook context to SourceKind.
+ * Map RawObservation to SourceKind.
  *
- * Classifies based on:
- * - toolName: 'pain' or 'skill:pain' → agent_on_owner_request
- * - failureSource: 'dispatch_error' vs 'tool_failure'
- * - isRisky + score: only used for rulehost_block upgrade, not for kind resolution
- */
-export declare function resolveSourceKindFromToolFailure(toolName: string | undefined, failureSource: 'tool_failure' | 'dispatch_error', provenance?: 'openclaw_context_bound' | 'owner_reported_no_host_trace' | 'automatic_hook'): SourceKind;
-/**
- * Map empathy/semantic detection context to SourceKind.
+ * This is the unified entry point for source-kind classification.
+ * It replaces the scattered resolveSourceKindFrom* functions.
  *
- * Classifies based on detection source prefix:
- * - 'llm_paralysis' → llm_paralysis
- * - 'llm_*' (detection rule) → semantic
- * - 'user_empathy' or empathy keyword match → empathy_inferred
- * - GFI threshold crossed → gfi_threshold
- */
-export declare function resolveSourceKindFromLlmDetection(detectionSource: string, isGfiTriggered: boolean): SourceKind;
-/**
- * Map gate-block context to SourceKind.
- */
-export declare function resolveSourceKindFromGateBlock(): SourceKind;
-/**
- * Map /pd-pain command to SourceKind.
- */
-export declare function resolveSourceKindFromCommand(): SourceKind;
-/**
- * Map provider/rate-limit failure to SourceKind.
- */
-export declare function resolveSourceKindFromProvider(isRateLimit: boolean): SourceKind;
-/**
- * Map subagent error to SourceKind.
+ * PRI-360 S1: All source-kind resolution now goes through this single entry point.
  */
-export declare function resolveSourceKindFromSubagent(): SourceKind;
+export { resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation, type RawObservation } from './raw-observation-adapter.js';
 /**
  * Evaluate evidence triage for a given source kind and context.
  *
@@ -67,6 +41,8 @@ export declare function resolveSourceKindFromSubagent(): SourceKind;
 export declare function evaluateEvidenceTriage(sourceKind: SourceKind, score: number, options?: {
     isUnsafeHighConfidence?: boolean;
     provenance?: 'openclaw_context_bound' | 'owner_reported_no_host_trace' | 'automatic_hook';
+    consecutiveErrors?: number;
+    isRisky?: boolean;
 }): TriageResult;
 /**
  * Determine if a gate-blocked action is a high-confidence unsafe action.