create-principles-disciple 1.85.0 → 1.87.0

package/plugin/dist/core/trajectory.js

@@ -134,12 +134,41 @@ export class TrajectoryDatabase {
         this.recordSession({ sessionId: input.sessionId, startedAt: input.createdAt });
         let insertedId = -1;
         this.withWrite(() => {
-            const runResult = this.db.prepare(`
+            // Try INSERT; on UNIQUE constraint violation for canonical_pain_id, do UPDATE instead.
+            // SQLite UPSERT (ON CONFLICT) does not support partial unique indexes, so we
+            // handle the conflict manually.
+            try {
+                const runResult = this.db.prepare(`
         INSERT INTO pain_events (
-          session_id, source, score, reason, severity, origin, confidence, text, created_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(input.sessionId, input.source, input.score, input.reason ?? null, input.severity ?? null, input.origin ?? null, input.confidence ?? null, input.text ?? null, input.createdAt ?? nowIso());
-            insertedId = runResult.lastInsertRowid;
+          session_id, source, score, reason, severity, origin, confidence, text, created_at,
+          canonical_pain_id, runtime_task_id
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(input.sessionId, input.source, input.score, input.reason ?? null, input.severity ?? null, input.origin ?? null, input.confidence ?? null, input.text ?? null, input.createdAt ?? nowIso(), input.canonicalPainId ?? null, input.runtimeTaskId ?? null);
+                insertedId = Number(runResult.lastInsertRowid);
+            }
+            catch (insertErr) {
+                if (input.canonicalPainId &&
+                    insertErr instanceof Error &&
+                    insertErr.message.includes('UNIQUE constraint failed') &&
+                    insertErr.message.includes('canonical_pain_id')) {
+                    this.db.prepare(`
+          UPDATE pain_events
+          SET runtime_task_id = COALESCE(?, runtime_task_id)
+          WHERE canonical_pain_id = ?
+        `).run(input.runtimeTaskId ?? null, input.canonicalPainId);
+                    const rawRow = this.db.prepare('SELECT id FROM pain_events WHERE canonical_pain_id = ?').get(input.canonicalPainId);
+                    // Runtime Contract #1/#2: validate DB row instead of `as` cast
+                    if (rawRow && typeof rawRow === 'object' && Object.hasOwn(rawRow, 'id') && typeof rawRow.id === 'number') {
+                        insertedId = rawRow.id;
+                    }
+                    else {
+                        insertedId = -1;
+                    }
+                }
+                else {
+                    throw insertErr;
+                }
+            }
         });
         // FTS indexing is best-effort — run outside the transaction so it cannot
         // roll back the committed pain event row (MEM-03, MEM-04).
@@ -1041,6 +1070,27 @@ export class TrajectoryDatabase {
                 throw err;
             }
         }
+        // PRI-406: Add canonical_pain_id and runtime_task_id columns to pain_events
+        for (const col of [
+            { name: 'canonical_pain_id', type: 'TEXT' },
+            { name: 'runtime_task_id', type: 'TEXT' },
+        ]) {
+            try {
+                this.db.exec(`ALTER TABLE pain_events ADD COLUMN ${col.name} ${col.type}`);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (!message.includes('duplicate column name') && !message.includes('no column named')) {
+                    throw err;
+                }
+            }
+        }
+        // PRI-406: Partial unique index on canonical_pain_id (non-null only) for dedup
+        this.db.exec(`
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_pain_events_canonical_pain_id
+      ON pain_events(canonical_pain_id)
+      WHERE canonical_pain_id IS NOT NULL
+    `);
         // Create FTS5 virtual table for pain_events text search (MEM-04)
         this.db.exec(`
       CREATE VIRTUAL TABLE IF NOT EXISTS pain_events_fts USING fts5(

package/plugin/dist/core/workspace-dir-validation.d.ts

@@ -1,8 +1,8 @@
 /**
  * WorkspaceDir Validation Utilities
  *
- * This module only validates candidate workspace directories and delegates
- * actual resolution policy to workspace-dir-service.ts.
+ * This module only validates candidate workspace directories. Runtime hook
+ * resolution policy lives at the I/O boundary in utils/workspace-resolver.ts.
  */
 export interface WorkspaceResolutionContext {
     workspaceDir?: string;

package/plugin/dist/core/workspace-dir-validation.js

@@ -1,8 +1,8 @@
 /**
  * WorkspaceDir Validation Utilities
  *
- * This module only validates candidate workspace directories and delegates
- * actual resolution policy to workspace-dir-service.ts.
+ * This module only validates candidate workspace directories. Runtime hook
+ * resolution policy lives at the I/O boundary in utils/workspace-resolver.ts.
  */
 import * as os from 'os';
 import * as path from 'path';

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

@@ -60,14 +60,17 @@ export declare function handleProbationFeedback(sessionId: string, toolName: str
 /**
  * Evaluate whether a tool failure should trigger pain diagnosis.
  *
+ * PRI-363: Single-gate architecture — only TriggerController decides.
+ *
  * Combines:
  * 1. Write-tool check — only write tools on failures enter this path
- * 2. PEAT-B1 triage — if feature flag is on, check evidence triage
- * 3. PainDiagnosticGate — cooldown + threshold check
+ * 2. PEAT-B1 triage — evidence triage (always enabled now)
+ * 3. PEAT-B2 trigger controller — single source of truth for task creation
+ * 4. Cooldown tracking — plugin layer owns this state
  *
  * Returns a structured decision with reason and stage.
  */
-export declare function evaluatePainAdmissionForToolCall(event: PluginHookAfterToolCallEvent, observation: ToolCallObservation, outcome: ToolCallOutcome, latestFailureState: SessionState | undefined, sessionState: SessionState | undefined, sessionId: string, workspaceDir: string, config: {
+export declare function evaluatePainAdmissionForToolCall(event: PluginHookAfterToolCallEvent, observation: ToolCallObservation, outcome: ToolCallOutcome, latestFailureState: SessionState | undefined, sessionState: SessionState | undefined, sessionId: string, workspaceDir: string, _config: {
     get: (key: string) => unknown;
 }): PainAdmissionDecision;
 /**
@@ -81,10 +84,6 @@ export declare function evaluatePainAdmissionForToolCall(event: PluginHookAfterT
 export declare function emitPainIfAdmitted(wctx: WorkspaceContext, event: PluginHookAfterToolCallEvent, observation: ToolCallObservation, outcome: ToolCallOutcome, admission: PainAdmissionDecision, sessionId: string, agentId: string | undefined, workspaceDir: string, emitPainDetectedEvent: (wctx: WorkspaceContext, event: import('../core/evolution-types.js').EvolutionLoopEvent) => Promise<void>): void;
 export { buildTrajectoryEvidence } from './trajectory-evidence.js';
 /**
- * Classify tool failure source.
- *
- * Pure function — no I/O, no side effects.
- * Determines whether a tool failure is a dispatch error (tool not found)
- * or a regular tool execution failure.
+ * Reset trigger cooldown state (for tests).
  */
-export declare function classifyToolFailureSource(toolName: string | undefined, error: unknown): 'dispatch_error' | 'tool_failure';
+export declare function resetTriggerCooldownForTest(): void;

package/plugin/dist/hooks/after-tool-call-helpers.js

@@ -19,10 +19,10 @@ import { denoiseError, computeHash } from '../utils/hashing.js';
 import { SystemLogger } from '../core/system-logger.js';
 import { getEvolutionLogger, createTraceId } from '../core/evolution-logger.js';
 import { recordEvolutionSuccess, recordEvolutionFailure } from '../core/evolution-engine.js';
-import { evaluatePainDiagnosticGate, isCooldownActiveForEpisode } from '../core/pain-diagnostic-gate.js';
+import { isCooldownActive as isTriggerCooldownActive, markEpisodeAsDiagnosed, clearCooldownState } from './trigger-cooldown-tracker.js';
 import { sanitizeForEvidence, sanitizeToolParamsForEvidence } from './message-sanitize.js';
-import { loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
-import { resolveSourceKindFromToolFailure, evaluateEvidenceTriage } from './triage-adapter.js';
+import { resolveSourceKind, buildToolFailureObservation } from './raw-observation-adapter.js';
+import { evaluateEvidenceTriage } from './triage-adapter.js';
 import { evaluateTriggerController } from '@principles/core/runtime-v2';
 import { buildTrajectoryEvidence } from './trajectory-evidence.js';
 // ── Stage 1: Classify ───────────────────────────────────────────────────────
@@ -33,8 +33,13 @@ import { buildTrajectoryEvidence } from './trajectory-evidence.js';
  * Extracts exitCode logic, determines failure/success, classifies failure source.
  */
 export function classifyToolCallOutcome(event) {
-    const resultObj = (event.result && typeof event.result === 'object') ? event.result : null;
-    const details = resultObj?.details && typeof resultObj.details === 'object' ? resultObj.details : null;
+    // EP-01: Validate event.result at runtime instead of `as` cast
+    const resultObj = (event.result && typeof event.result === 'object' && !Array.isArray(event.result))
+        ? event.result // safe: guarded by typeof + Array.isArray checks above
+        : null;
+    const details = (resultObj && resultObj.details && typeof resultObj.details === 'object' && !Array.isArray(resultObj.details))
+        ? resultObj.details // safe: guarded by typeof + Array.isArray checks above
+        : null;
     const topExitCode = resultObj?.exitCode;
     const detailExitCode = details?.exitCode;
     // Prefer the first *numeric* exit code
@@ -42,10 +47,18 @@ export function classifyToolCallOutcome(event) {
         : typeof detailExitCode === 'number' ? detailExitCode
             : 0;
     const isFailure = !!event.error || exitCode !== 0;
+    // PRI-360 S1: Use centralized builder for tool failure classification
+    // All dispatch/tool_failure rules live in raw-observation-adapter.ts
+    const obs = buildToolFailureObservation({
+        toolName: event.toolName,
+        error: event.error,
+        exitCode,
+    });
+    const failureSource = isFailure ? obs.failureSource : undefined;
     return {
         isFailure,
         exitCode,
-        failureSource: isFailure ? classifyToolFailureSource(event.toolName, event.error) : undefined,
+        failureSource,
     };
 }
 /**
@@ -236,17 +249,29 @@ export function handleProbationFeedback(sessionId, toolName, workspaceDir, wctx,
 }
 // ── Stage 6: Pain Admission ─────────────────────────────────────────────────
 const WRITE_TOOLS = ['write', 'edit', 'apply_patch', 'write_file', 'edit_file', 'replace'];
+/**
+ * Cooldown map for trigger controller decisions.
+ *
+ * PRI-363: This replaces the hidden map in PainDiagnosticGate.
+ * Core trigger-controller is stateless; plugin layer owns cooldown state.
+ *
+ * EP-05: Loop state freshness — each check reads fresh state from this map.
+ */
+const TRIGGER_COOLDOWN_MAP = new Map();
 /**
  * Evaluate whether a tool failure should trigger pain diagnosis.
  *
+ * PRI-363: Single-gate architecture — only TriggerController decides.
+ *
  * Combines:
  * 1. Write-tool check — only write tools on failures enter this path
- * 2. PEAT-B1 triage — if feature flag is on, check evidence triage
- * 3. PainDiagnosticGate — cooldown + threshold check
+ * 2. PEAT-B1 triage — evidence triage (always enabled now)
+ * 3. PEAT-B2 trigger controller — single source of truth for task creation
+ * 4. Cooldown tracking — plugin layer owns this state
  *
  * Returns a structured decision with reason and stage.
  */
-export function evaluatePainAdmissionForToolCall(event, observation, outcome, latestFailureState, sessionState, sessionId, workspaceDir, config) {
+export function evaluatePainAdmissionForToolCall(event, observation, outcome, latestFailureState, sessionState, sessionId, workspaceDir, _config) {
     // Only write-tool failures enter the pain path
     if (!WRITE_TOOLS.includes(event.toolName) || !outcome.isFailure) {
         return {
@@ -257,89 +282,62 @@ export function evaluatePainAdmissionForToolCall(event, observation, outcome, la
         };
     }
     const failureSource = outcome.failureSource ?? 'tool_failure';
-    // PEAT-B1: Evidence triage (feature-flagged)
-    // PEAT-B2: Trigger controller adds structured outcome + cooldown awareness
-    const painTriageFlag = loadFeatureFlagFromConfig(workspaceDir, 'painEvidenceAdmission');
-    if (painTriageFlag.enabled) {
-        const sourceKind = resolveSourceKindFromToolFailure(event.toolName, failureSource);
-        const triage = evaluateEvidenceTriage(sourceKind, observation.painScore);
-        // PEAT-B2: Evaluate trigger controller for structured decision
-        // Compute real cooldown state from PainDiagnosticGate's episode map
-        // so trigger decision aligns with the gate's cooldown logic (EP-07).
-        const cooldownActive = isCooldownActiveForEpisode(failureSource, sessionId, latestFailureState?.lastErrorHash);
-        const triggerDecision = evaluateTriggerController({
-            triageResult: triage,
-            isOwnerManual: false, // tool failures are never owner manual
-            isCooldownActive: cooldownActive,
-            isValid: true,
-            score: observation.painScore,
-            sessionId,
-        });
-        if (!triggerDecision.shouldCreateDiagnosticTask) {
-            SystemLogger.log(workspaceDir, 'TRIGGER_DECISION', JSON.stringify({
-                outcome: triggerDecision.outcome,
-                sourceKind: triggerDecision.sourceKind,
-                reason: triggerDecision.reason,
-                nextAction: triggerDecision.nextAction,
-                triageDecision: triggerDecision.triageDecision,
-                tool: event.toolName,
-                path: observation.relPath,
-            }));
-            return {
-                admitted: false,
-                stage: 'triage_evidence_only',
-                reason: triggerDecision.reason,
-                detail: `outcome=${triggerDecision.outcome}, sourceKind=${triggerDecision.sourceKind}, nextAction=${triggerDecision.nextAction}`,
-            };
-        }
-    }
-    // PainDiagnosticGate evaluation
-    const diagnosticGate = evaluatePainDiagnosticGate({
-        source: failureSource,
-        score: observation.painScore,
-        currentGfi: (latestFailureState ?? sessionState)?.currentGfi ?? 0,
-        consecutiveErrors: (latestFailureState ?? sessionState)?.consecutiveErrors ?? 0,
+    // Check cooldown before calling trigger controller
+    const cooldownActive = isTriggerCooldownActive(failureSource, sessionId, latestFailureState?.lastErrorHash, TRIGGER_COOLDOWN_MAP);
+    // PRI-360 S1: Build RawObservation for unified source mapping
+    const rawObs = {
+        observedAt: new Date().toISOString(),
+        workspaceId: workspaceDir,
+        sessionId,
+        toolName: event.toolName,
+        failureSource: outcome.failureSource,
+        // Infer toolNotFound from failureSource for resolveSourceKind compatibility
+        toolNotFound: outcome.failureSource === 'dispatch_error',
+        // Extract exit code from outcome for triage (nonZeroExit)
+        nonZeroExit: outcome.exitCode !== 0,
+    };
+    // PRI-360 S1: Use unified resolveSourceKind instead of resolveSourceKindFromToolFailure
+    const sourceKind = resolveSourceKind(rawObs);
+    // PEAT-B1: Evidence triage (with consecutiveErrors and isRisky for upgrade logic)
+    const triage = evaluateEvidenceTriage(sourceKind, observation.painScore, {
+        consecutiveErrors: (latestFailureState ?? sessionState)?.consecutiveErrors,
         isRisky: observation.isRisk,
-        errorHash: latestFailureState?.lastErrorHash,
+    });
+    // PEAT-B2: Trigger controller — single source of truth for task creation
+    const triggerDecision = evaluateTriggerController({
+        triageResult: triage,
+        isOwnerManual: false, // tool failures are never owner manual
+        isCooldownActive: cooldownActive,
+        isValid: true,
+        score: observation.painScore,
         sessionId,
-        thresholds: {
-            painTrigger: config.get('thresholds.pain_trigger') || 40,
-            highSeverity: config.get('severity_thresholds.high') || 70,
-            repeatedFailure: config.get('thresholds.stuck_loops_trigger') || 4,
-        },
     });
-    if (!diagnosticGate.shouldDiagnose) {
-        SystemLogger.log(workspaceDir, 'PAIN_DIAGNOSE_SKIPPED', `Tool failure recorded as friction only: ${diagnosticGate.detail}; tool=${event.toolName}; path=${observation.relPath}`);
-        let rejectPayload;
-        try {
-            rejectPayload = JSON.stringify({
-                reason: diagnosticGate.reason,
-                detail: diagnosticGate.detail,
-                source: failureSource,
-                sessionId,
-                gfi: (latestFailureState ?? sessionState)?.currentGfi ?? 0,
-                score: observation.painScore,
-            });
-        }
-        catch (e) {
-            SystemLogger.log(workspaceDir, 'PAYLOAD_SERIALIZE_FAILED', String(e));
-            rejectPayload = JSON.stringify({ reason: diagnosticGate.reason, detail: '(log serialization failed)' });
-        }
-        SystemLogger.log(workspaceDir, 'PAIN_GATE_REJECTED', rejectPayload);
+    // Log the decision
+    SystemLogger.log(workspaceDir, 'TRIGGER_DECISION', JSON.stringify({
+        outcome: triggerDecision.outcome,
+        sourceKind: triggerDecision.sourceKind,
+        reason: triggerDecision.reason,
+        nextAction: triggerDecision.nextAction,
+        triageDecision: triggerDecision.triageDecision,
+        tool: event.toolName,
+        path: observation.relPath,
+    }));
+    // If trigger controller says yes, mark cooldown and admit
+    if (triggerDecision.shouldCreateDiagnosticTask) {
+        markEpisodeAsDiagnosed(failureSource, sessionId, latestFailureState?.lastErrorHash, TRIGGER_COOLDOWN_MAP);
         return {
-            admitted: false,
-            stage: 'gate_rejected',
-            reason: diagnosticGate.reason,
-            detail: diagnosticGate.detail,
-            gateResult: { shouldDiagnose: false, reason: diagnosticGate.reason, detail: diagnosticGate.detail },
+            admitted: true,
+            stage: 'trigger_admitted',
+            reason: triggerDecision.reason,
+            detail: `outcome=${triggerDecision.outcome}, sourceKind=${triggerDecision.sourceKind}, nextAction=${triggerDecision.nextAction}`,
         };
     }
+    // Otherwise, reject with trigger controller's reason
     return {
-        admitted: true,
-        stage: 'gate_admitted',
-        reason: diagnosticGate.reason,
-        detail: diagnosticGate.detail,
-        gateResult: { shouldDiagnose: true, reason: diagnosticGate.reason, detail: diagnosticGate.detail },
+        admitted: false,
+        stage: 'trigger_rejected',
+        reason: triggerDecision.reason,
+        detail: `outcome=${triggerDecision.outcome}, sourceKind=${triggerDecision.sourceKind}, nextAction=${triggerDecision.nextAction}`,
     };
 }
 // ── Stage 7: Emit Pain ─────────────────────────────────────────────────────
@@ -439,24 +437,15 @@ export function emitPainIfAdmitted(wctx, event, observation, outcome, admission,
 }
 // ── Shared Helpers ──────────────────────────────────────────────────────────
 export { buildTrajectoryEvidence } from './trajectory-evidence.js';
-// ── Source Classification ────────────────────────────────────────────────────
 /**
- * Classify tool failure source.
- *
- * Pure function — no I/O, no side effects.
- * Determines whether a tool failure is a dispatch error (tool not found)
- * or a regular tool execution failure.
+ * Reset trigger cooldown state (for tests).
  */
-export function classifyToolFailureSource(toolName, error) {
-    if (!toolName || toolName.trim() === '')
-        return 'dispatch_error';
-    const msg = String(error ?? '');
-    if (/\btool\s+(?:\S+\s+)?not\s+found\b/i.test(msg))
-        return 'dispatch_error';
-    if (/\bunknown\s+tool\b/i.test(msg))
-        return 'dispatch_error';
-    return 'tool_failure';
+export function resetTriggerCooldownForTest() {
+    clearCooldownState(TRIGGER_COOLDOWN_MAP);
 }
+// ── Source Classification ────────────────────────────────────────────────────
+// classifyToolFailureSource logic is now in resolveSourceKind (PRI-360 S1)
+// This function is removed to avoid duplication.
 /**
  * Extract error type classification from error value.
  */

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

@@ -59,23 +59,17 @@ export interface ToolCallObservation {
 /**
  * Result of evaluating whether a tool failure should trigger pain diagnosis.
  *
- * Encapsulates the combined triage + PainDiagnosticGate decision.
+ * Encapsulates the single-gate trigger controller decision.
  */
 export interface PainAdmissionDecision {
     /** Whether the tool failure should proceed to pain emission */
     readonly admitted: boolean;
     /** The admission stage that made the decision */
-    readonly stage: 'triage_evidence_only' | 'gate_rejected' | 'gate_admitted' | 'not_applicable';
+    readonly stage: 'not_applicable' | 'trigger_admitted' | 'trigger_rejected';
     /** Human-readable reason for the decision */
     readonly reason: string;
     /** Detail about the decision */
     readonly detail: string;
-    /** The diagnostic gate result (if gate was evaluated) */
-    readonly gateResult?: {
-        readonly shouldDiagnose: boolean;
-        readonly reason: string;
-        readonly detail: string;
-    };
 }
 /**
  * Result of friction tracking for a tool call.

package/plugin/dist/hooks/gate.js

@@ -52,7 +52,7 @@ export function handleBeforeToolCall(event, ctx) {
     const relPath = normalizePath(filePath, ctx.workspaceDir);
     // 3. Rule Host Evaluation — sole gate
     try {
-        const ruleHost = new RuleHost(wctx.stateDir, logger);
+        const ruleHost = new RuleHost(wctx.stateDir, logger, { workspaceDir: ctx.workspaceDir });
         const hostInput = {
             action: {
                 toolName: event.toolName,

package/plugin/dist/hooks/llm.js

@@ -11,7 +11,8 @@ import { atomicWriteFileSync } from '../utils/io.js';
 import { emitPainDetectedEvent, buildTrajectoryEvidence } from './pain.js';
 import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
 import { loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
-import { resolveSourceKindFromLlmDetection, evaluateEvidenceTriage } from './triage-adapter.js';
+import { resolveSourceKind } from './raw-observation-adapter.js';
+import { evaluateEvidenceTriage } from './triage-adapter.js';
 function clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
 }
@@ -220,7 +221,15 @@ export function handleLlmOutput(event, ctx) {
         let triageAdmitted = true;
         const llmTriageFlag = loadFeatureFlagFromConfig(ctx.workspaceDir, 'painEvidenceAdmission');
         if (llmTriageFlag.enabled) {
-            const sourceKind = resolveSourceKindFromLlmDetection(source, isGfiTriggered);
+            // PRI-360 S1: Build RawObservation for unified source mapping
+            const rawObs = {
+                observedAt: new Date().toISOString(),
+                workspaceId: ctx.workspaceDir,
+                sessionId: ctx.sessionId,
+                detectionSource: source,
+                isGfiTriggered,
+            };
+            const sourceKind = resolveSourceKind(rawObs);
             const triage = evaluateEvidenceTriage(sourceKind, painScore);
             if (triage.decision !== 'admit') {
                 triageAdmitted = false;

package/plugin/dist/hooks/pain.d.ts

@@ -20,7 +20,6 @@ import type { PluginHookAfterToolCallEvent, PluginHookToolContext, OpenClawPlugi
 import { buildTrajectoryEvidence } from './trajectory-evidence.js';
 export { buildTrajectoryEvidence };
 export declare function emitPainDetectedEvent(wctx: WorkspaceContext, event: EvolutionLoopEvent): Promise<void>;
-export { classifyToolFailureSource } from './after-tool-call-helpers.js';
 /**
  * Handle after_tool_call hook — decomposed into pipeline stages.
  *

package/plugin/dist/hooks/pain.js

@@ -108,8 +108,9 @@ export async function emitPainDetectedEvent(wctx, event) {
 function createPainId(sessionId) {
     return `pain_${Date.now()}_${computeHash(sessionId).slice(0, 8)}`;
 }
-// ── Source Classification (re-exported from helpers) ────────────────────────
-export { classifyToolFailureSource } from './after-tool-call-helpers.js';
+// ── Source Classification ────────────────────────────────────────────────────
+// PRI-360 S1: classifyToolFailureSource is removed; source mapping is now unified
+// through resolveSourceKind in raw-observation-adapter.ts
 // ── Main Hook ───────────────────────────────────────────────────────────────
 /**
  * Handle after_tool_call hook — decomposed into pipeline stages.

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

@@ -0,0 +1,57 @@
+/**
+ * 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.
+ */
+import type { SourceKind } from '@principles/core/runtime-v2';
+import type { RawObservation } from './raw-observation-types.js';
+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;