create-principles-disciple 1.85.0 → 1.87.0

package/plugin/dist/core/merge-gate-audit.js

@@ -1,241 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { getImplementationAssetRoot } from './code-implementation-storage.js';
-import { resolvePdPath } from './paths.js';
-function computeOverallStatus(checks) {
-    if (checks.some((check) => check.status === 'block')) {
-        return 'block';
-    }
-    if (checks.some((check) => check.status === 'defer')) {
-        return 'defer';
-    }
-    return 'pass';
-}
-function countStatuses(checks) {
-    const counts = { pass: 0, block: 0, defer: 0 };
-    for (const check of checks) {
-        counts[check.status] += 1;
-    }
-    return counts;
-}
-function auditPainFlagPathContract(workspaceDir) {
-    const painFlagPath = resolvePdPath(workspaceDir, 'PAIN_FLAG');
-    const expectedPath = path.join(path.resolve(workspaceDir), '.state', '.pain_flag');
-    const normalizedPainFlagPath = path.normalize(painFlagPath);
-    const normalizedExpectedPath = path.normalize(expectedPath);
-    if (normalizedPainFlagPath !== normalizedExpectedPath) {
-        return {
-            id: 'pain_flag_path_contract',
-            status: 'block',
-            summary: 'Canonical pain flag path does not resolve under workspace/.state/.pain_flag.',
-            details: {
-                resolvedPath: normalizedPainFlagPath,
-                expectedPath: normalizedExpectedPath,
-            },
-        };
-    }
-    return {
-        id: 'pain_flag_path_contract',
-        status: 'pass',
-        summary: 'Canonical pain flag path resolves to workspace/.state/.pain_flag.',
-        details: {
-            resolvedPath: normalizedPainFlagPath,
-        },
-    };
-}
-function auditQueuePathContract(workspaceDir) {
-    const queuePath = resolvePdPath(workspaceDir, 'EVOLUTION_QUEUE');
-    const expectedPath = path.join(path.resolve(workspaceDir), '.state', 'evolution_queue.json');
-    const normalizedQueuePath = path.normalize(queuePath);
-    const normalizedExpectedPath = path.normalize(expectedPath);
-    if (normalizedQueuePath !== normalizedExpectedPath) {
-        return {
-            id: 'queue_path_contract',
-            status: 'block',
-            summary: 'Canonical evolution queue path does not resolve under workspace/.state/evolution_queue.json.',
-            details: {
-                resolvedPath: normalizedQueuePath,
-                expectedPath: normalizedExpectedPath,
-            },
-        };
-    }
-    return {
-        id: 'queue_path_contract',
-        status: 'pass',
-        summary: 'Canonical evolution queue path resolves to workspace/.state/evolution_queue.json.',
-        details: {
-            resolvedPath: normalizedQueuePath,
-        },
-    };
-}
-function isReplayReportShape(value) {
-    if (!value || typeof value !== 'object') {
-        return false;
-    }
-    const report = value;
-    return (typeof report.overallDecision === 'string' &&
-        typeof report.generatedAt === 'string' &&
-        typeof report.implementationId === 'string' &&
-        report.evidenceSummary !== undefined &&
-        Array.isArray(report.blockers));
-}
-function collectReplayReportPaths(stateDir) {
-    const implementationsRoot = path.join(stateDir, 'principles', 'implementations');
-    if (!fs.existsSync(implementationsRoot))
-        return [];
-    const implementationIds = fs
-        .readdirSync(implementationsRoot, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => entry.name);
-    const paths = [];
-    for (const id of implementationIds) {
-        const replaysDir = path.join(getImplementationAssetRoot(stateDir, id), 'replays');
-        if (!fs.existsSync(replaysDir))
-            continue;
-        const files = fs
-            .readdirSync(replaysDir, { withFileTypes: true })
-            .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
-            .map((entry) => path.join(replaysDir, entry.name));
-        paths.push(...files);
-    }
-    return paths;
-}
-function hasValidEvidenceSummary(parsed) {
-    if (!parsed || typeof parsed !== 'object')
-        return false;
-    const report = parsed;
-    const summary = report.evidenceSummary;
-    if (!summary)
-        return false;
-    if (typeof summary.evidenceStatus !== 'string') {
-        return false;
-    }
-    return typeof summary.totalSamples === 'number';
-}
-function validateSingleReplayReport(reportPath) {
-    let rawContent;
-    try {
-        rawContent = fs.readFileSync(reportPath, 'utf-8');
-    }
-    catch {
-        return 'io_error';
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(rawContent);
-    }
-    catch {
-        return 'malformed';
-    }
-    if (!isReplayReportShape(parsed)) {
-        return 'malformed';
-    }
-    if (!hasValidEvidenceSummary(parsed)) {
-        return 'missing_evidence_summary';
-    }
-    const evidenceSummary = parsed.evidenceSummary;
-    if (parsed.overallDecision === 'pass' && evidenceSummary.totalSamples === 0) {
-        return 'unsupported_pass';
-    }
-    if (parsed.overallDecision === 'needs-review' && evidenceSummary.totalSamples === 0) {
-        return 'empty_needs_review';
-    }
-    return 'valid';
-}
-function categorizeReplayReports(reportPaths) {
-    const results = {
-        ioErrorReports: [],
-        malformedReports: [],
-        missingEvidenceSummary: [],
-        unsupportedPassingReports: [],
-        emptyEvidenceNeedsReview: [],
-    };
-    for (const reportPath of reportPaths) {
-        const category = validateSingleReplayReport(reportPath);
-        switch (category) {
-            case 'io_error':
-                results.ioErrorReports.push(reportPath);
-                break;
-            case 'malformed':
-                results.malformedReports.push(reportPath);
-                break;
-            case 'missing_evidence_summary':
-                results.missingEvidenceSummary.push(reportPath);
-                break;
-            case 'unsupported_pass':
-                results.unsupportedPassingReports.push(reportPath);
-                break;
-            case 'empty_needs_review':
-                results.emptyEvidenceNeedsReview.push(reportPath);
-                break;
-        }
-    }
-    return results;
-}
-function hasValidationFailures(results) {
-    return (results.malformedReports.length > 0 ||
-        results.ioErrorReports.length > 0 ||
-        results.missingEvidenceSummary.length > 0 ||
-        results.unsupportedPassingReports.length > 0 ||
-        results.emptyEvidenceNeedsReview.length > 0);
-}
-function auditReplayEvidenceIntegrity(stateDir) {
-    const replayReportPaths = collectReplayReportPaths(stateDir);
-    if (replayReportPaths.length === 0) {
-        return {
-            id: 'replay_evidence_integrity',
-            status: 'defer',
-            summary: 'No replay reports found. Replay evidence integrity cannot be verified yet.',
-        };
-    }
-    const results = categorizeReplayReports(replayReportPaths);
-    if (hasValidationFailures(results)) {
-        return {
-            id: 'replay_evidence_integrity',
-            status: 'block',
-            summary: 'Replay reports contain malformed payloads, I/O errors, empty-evidence passes, or zero-evidence needs-review verdicts.',
-            details: {
-                reportCount: replayReportPaths.length,
-                ...results,
-            },
-        };
-    }
-    return {
-        id: 'replay_evidence_integrity',
-        status: 'pass',
-        summary: 'Replay reports include evidence summaries and no empty-evidence unsafe verdicts.',
-        details: {
-            reportCount: replayReportPaths.length,
-        },
-    };
-}
-export function runMergeGateAudit(workspaceDir, stateDir) {
-    const checks = [
-        auditPainFlagPathContract(workspaceDir),
-        auditQueuePathContract(workspaceDir),
-        auditReplayEvidenceIntegrity(stateDir),
-    ];
-    return {
-        overallStatus: computeOverallStatus(checks),
-        generatedAt: new Date().toISOString(),
-        workspaceDir: path.resolve(workspaceDir),
-        stateDir: path.resolve(stateDir),
-        checks,
-        counts: countStatuses(checks),
-    };
-}
-export function formatMergeGateAuditReport(report) {
-    const lines = [
-        '=== Merge Gate Audit ===',
-        `Overall Status: ${report.overallStatus.toUpperCase()}`,
-        `Generated At: ${report.generatedAt}`,
-        `Workspace: ${report.workspaceDir}`,
-        `State Dir: ${report.stateDir}`,
-        `Counts: pass=${report.counts.pass}, block=${report.counts.block}, defer=${report.counts.defer}`,
-        '',
-    ];
-    for (const check of report.checks) {
-        lines.push(`[${check.status.toUpperCase()}] ${check.id}: ${check.summary}`);
-    }
-    return `${lines.join('\n')}\n`;
-}

package/plugin/dist/core/pain-context-extractor.d.ts

@@ -1,31 +0,0 @@
-/**
- * Pain Context Extractor
- *
- * Extracts conversation context from OpenClaw session JSONL files
- * to provide diagnostic context beyond the pain reason.
- *
- * DESIGN PRINCIPLES (from real data analysis):
- * - JSONL files can be 6 lines (HEARTBEAT injection) to 632+ lines (full conversation)
- * - Large files: one line can be 11MB (system prompt) — MUST skip oversized lines
- * - Assistant text appears ONLY in final replies (~3% of assistant messages)
- * - Most assistant messages contain toolCall blocks (what operations were performed)
- * - toolResult contains tool output (success AND failure) — both are useful for diagnosis
- * - Always read from END of file to get most recent context
- *
- * SAFETY:
- * - Never load entire file (tail-only, max 512KB)
- * - Skip lines > 100KB (real files have 11MB single lines)
- * - Cap total output at 2000 chars
- * - All errors caught silently — return empty string on failure
- */
-/**
- * Extracts recent conversation context from a session's JSONL file.
- *
- * SAFETY: Tail-only read, skip oversized lines, cap output.
- * Returns empty string on any failure — caller should use pain reason as fallback.
- */
-export declare function extractRecentConversation(sessionId: string, agentId?: string, maxTurns?: number): Promise<string>;
-/**
- * Extracts failed tool call context with argument correlation.
- */
-export declare function extractFailedToolContext(sessionId: string, agentId: string, toolName: string, filePath?: string): Promise<string>;

package/plugin/dist/core/pain-context-extractor.js

@@ -1,278 +0,0 @@
-/**
- * Pain Context Extractor
- *
- * Extracts conversation context from OpenClaw session JSONL files
- * to provide diagnostic context beyond the pain reason.
- *
- * DESIGN PRINCIPLES (from real data analysis):
- * - JSONL files can be 6 lines (HEARTBEAT injection) to 632+ lines (full conversation)
- * - Large files: one line can be 11MB (system prompt) — MUST skip oversized lines
- * - Assistant text appears ONLY in final replies (~3% of assistant messages)
- * - Most assistant messages contain toolCall blocks (what operations were performed)
- * - toolResult contains tool output (success AND failure) — both are useful for diagnosis
- * - Always read from END of file to get most recent context
- *
- * SAFETY:
- * - Never load entire file (tail-only, max 512KB)
- * - Skip lines > 100KB (real files have 11MB single lines)
- * - Cap total output at 2000 chars
- * - All errors caught silently — return empty string on failure
- */
-import * as fsPromises from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-// =========================================================================
-// Safety Limits
-// =========================================================================
-/** Skip JSONL lines larger than this */
-const MAX_LINE_BYTES = 100_000; // 100KB
-/** Only read last portion of file */
-const TAIL_READ_SIZE = 512_000; // 512KB
-/** Max turns to extract */
-const MAX_TURNS = 8;
-/** Max chars per turn entry */
-const MAX_TURN_CHARS = 400;
-/** Max total output */
-const MAX_OUTPUT_CHARS = 2000;
-/** Valid characters for session IDs and agent IDs — prevents path traversal */
-const SAFE_ID_REGEX = /^[a-zA-Z0-9_-]+$/;
-function getAgentsDir() {
-    return process.env.PD_TEST_AGENTS_DIR || path.join(os.homedir(), '.openclaw', 'agents');
-}
-// =========================================================================
-// Safe File Reading (Async)
-// =========================================================================
-async function safeTail(filePath) {
-    try {
-        // Check existence and stats asynchronously
-        let stat;
-        try {
-            stat = await fsPromises.stat(filePath);
-        }
-        catch {
-            return []; // File doesn't exist or can't be accessed
-        }
-        if (stat.size === 0)
-            return [];
-        const isTruncated = stat.size > TAIL_READ_SIZE;
-        const readSize = Math.min(stat.size, TAIL_READ_SIZE);
-        const buffer = Buffer.alloc(readSize);
-        // Use async file read
-        const fileHandle = await fsPromises.open(filePath, 'r');
-        try {
-            await fileHandle.read(buffer, 0, readSize, stat.size - readSize);
-            await fileHandle.close();
-            const content = buffer.toString('utf8');
-            // Only strip first line if file was actually truncated (started mid-line)
-            const validContent = isTruncated ? content.slice(content.indexOf('\n') + 1) : content;
-            return validContent.split('\n').filter(l => l.trim().length > 0);
-        }
-        catch (err) {
-            // Ensure file handle is closed even on error
-            try {
-                await fileHandle.close();
-            }
-            catch { /* ignore close error */ }
-            throw err;
-        }
-    }
-    catch (err) {
-        console.debug(`[pain-context-extractor] safeTail failed: ${String(err)}`);
-        return [];
-    }
-}
-function parseSafeMessages(lines) {
-    const messages = [];
-    for (const line of lines) {
-        if (line.length > MAX_LINE_BYTES)
-            continue;
-        try {
-            const parsed = JSON.parse(line);
-            if (parsed.type !== 'message' || !parsed.message)
-                continue;
-            const msg = parsed.message;
-            const content = Array.isArray(msg.content) ? msg.content : [];
-            messages.push({
-                role: msg.role || '',
-                textParts: content.filter((c) => c.type === 'text').map((c) => c.text || ''),
-                toolCalls: content.filter((c) => c.type === 'toolCall').map((c) => ({ id: c.id, name: c.name, arguments: c.arguments })),
-                toolCallId: msg.toolCallId,
-                toolName: msg.toolName,
-                details: msg.details,
-            });
-        }
-        catch { /* malformed JSON line, skip silently — expected with corrupted files */ }
-    }
-    return messages;
-}
-// =========================================================================
-// Turn Extraction
-// =========================================================================
-/**
- * Extracts a concise turn representation from a message.
- * Returns null if nothing useful to extract.
- */
-function extractTurn(msg) {
-    if (msg.role === 'user' && msg.textParts.length > 0) {
-        // For user messages, skip system prompt injection patterns
-        const text = msg.textParts.join(' ').trim();
-        if (!text)
-            return null;
-        // Skip if it looks like a system injection
-        if (text.startsWith('<evolution_task') || text.startsWith('<system_override') ||
-            text.startsWith('You are an empathy observer') || text.startsWith('Analyze ONLY') ||
-            text.startsWith('{"damageDetected"'))
-            return null;
-        // Find the last meaningful user input line
-        const lines = text.split('\n');
-        let lastInput = '';
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (trimmed.length > 3 && trimmed.length < 500 &&
-                !trimmed.startsWith('<') && !trimmed.startsWith('{') &&
-                !trimmed.startsWith('Trust Score:') && !trimmed.startsWith('Hygiene:')) {
-                lastInput = trimmed;
-            }
-        }
-        const userInput = lastInput || text;
-        return `[User]: ${userInput.substring(0, MAX_TURN_CHARS)}`;
-    }
-    if (msg.role === 'assistant') {
-        const parts = [];
-        // Priority 1: final text reply (if present)
-        if (msg.textParts.length > 0) {
-            const text = msg.textParts.join(' ').trim();
-            if (text)
-                parts.push(`[Assistant]: ${text.substring(0, MAX_TURN_CHARS)}`);
-        }
-        // Priority 2: tool call summary (always include if present, for context)
-        if (msg.toolCalls.length > 0) {
-            const tools = msg.toolCalls.map(tc => tc.name).filter(Boolean);
-            const uniqueTools = [...new Set(tools)];
-            if (uniqueTools.length > 0) {
-                parts.push(`[Assistant → ${uniqueTools.join(', ')}]`);
-            }
-        }
-        return parts.length > 0 ? parts.join(' ') : null;
-    }
-    if (msg.role === 'toolResult') {
-        const exitCode = msg.details?.exitCode;
-        const isError = msg.details?.isError || (exitCode !== undefined && exitCode !== 0);
-        const text = msg.textParts.join(' ').trim();
-        const toolLabel = msg.toolName || 'tool';
-        if (isError) {
-            // Failed tool call — important for diagnosis
-            const errorPreview = text ? text.substring(0, MAX_TURN_CHARS) : `(exit ${exitCode ?? '?'})`;
-            return `[${toolLabel} FAILED]: ${errorPreview}`;
-        }
-        // Successful tool call — include brief result
-        if (text) {
-            // For successful results, show first meaningful line
-            const lines = text.split('\n').filter(l => l.trim());
-            const firstLine = lines[0]?.substring(0, MAX_TURN_CHARS) || '';
-            if (firstLine)
-                return `[${toolLabel}]: ${firstLine}`;
-        }
-    }
-    return null;
-}
-// =========================================================================
-// Public API
-// =========================================================================
-/**
- * Extracts recent conversation context from a session's JSONL file.
- *
- * SAFETY: Tail-only read, skip oversized lines, cap output.
- * Returns empty string on any failure — caller should use pain reason as fallback.
- */
-export async function extractRecentConversation(sessionId, agentId = 'main', maxTurns = MAX_TURNS) {
-    if (!sessionId || sessionId.length < 5 || !SAFE_ID_REGEX.test(sessionId))
-        return '';
-    if (agentId && !SAFE_ID_REGEX.test(agentId))
-        return '';
-    try {
-        const jsonlPath = path.join(getAgentsDir(), agentId, 'sessions', `${sessionId}.jsonl`);
-        const lines = await safeTail(jsonlPath);
-        const messages = parseSafeMessages(lines);
-        if (messages.length === 0)
-            return '';
-        const turns = [];
-        for (const msg of messages) {
-            const turn = extractTurn(msg);
-            if (turn)
-                turns.push(turn);
-        }
-        const recent = turns.slice(-maxTurns);
-        if (recent.length === 0)
-            return '';
-        const result = recent.join('\n');
-        return result.length > MAX_OUTPUT_CHARS ? result.substring(0, MAX_OUTPUT_CHARS - 3) + '...' : result;
-    }
-    catch (err) {
-        console.debug(`[pain-context-extractor] extractRecentConversation failed for session=${sessionId}, agent=${agentId}: ${String(err)}`);
-        return ''; // Fail silently
-    }
-}
-/**
- * Extracts failed tool call context with argument correlation.
- */
-export async function extractFailedToolContext(sessionId, agentId, toolName, filePath) {
-    if (!sessionId || sessionId.length < 5 || !SAFE_ID_REGEX.test(sessionId) || !toolName)
-        return '';
-    if (agentId && !SAFE_ID_REGEX.test(agentId))
-        return '';
-    try {
-        const jsonlPath = path.join(getAgentsDir(), agentId, 'sessions', `${sessionId}.jsonl`);
-        const lines = await safeTail(jsonlPath);
-        const messages = parseSafeMessages(lines);
-        if (messages.length === 0)
-            return '';
-        // Build toolCallId → arguments map
-        // Keep both full args (for matching) and truncated (for display)
-        const toolArgsById = new Map();
-        for (const msg of messages) {
-            for (const tc of msg.toolCalls) {
-                if (tc.id && tc.name) {
-                    const args = tc.arguments || {};
-                    const fullArgs = JSON.stringify(args);
-                    const truncated = {};
-                    for (const [k, v] of Object.entries(args)) {
-                        const s = typeof v === 'string' ? v : JSON.stringify(v);
-                        truncated[k] = s.length > 150 ? s.substring(0, 150) + '...' : s;
-                    }
-                    toolArgsById.set(tc.id, {
-                        name: tc.name,
-                        fullArgs,
-                        previewArgs: JSON.stringify(truncated, null, 2),
-                    });
-                }
-            }
-        }
-        const parts = [];
-        for (const msg of messages) {
-            if (msg.role === 'toolResult' && msg.toolName === toolName) {
-                const exitCode = msg.details?.exitCode;
-                const isError = msg.details?.isError || (exitCode !== undefined && exitCode !== 0);
-                if (!isError)
-                    continue;
-                const { toolCallId } = msg;
-                const correlated = toolCallId ? toolArgsById.get(toolCallId) : null;
-                if (filePath && correlated && !correlated.fullArgs.includes(filePath))
-                    continue;
-                parts.push(`[Tool Call: ${correlated?.name || toolName}]`);
-                if (correlated)
-                    parts.push(`Arguments: ${correlated.previewArgs.substring(0, 300)}`);
-                parts.push(`Exit Code: ${exitCode ?? 'N/A'}`);
-                const errorText = msg.textParts.join(' ').trim();
-                if (errorText)
-                    parts.push(`Error: ${errorText.substring(0, 500)}`);
-                break;
-            }
-        }
-        return parts.length > 0 ? parts.join('\n') : '';
-    }
-    catch (err) {
-        console.debug(`[pain-context-extractor] extractFailedToolContext failed for tool=${toolName}, session=${sessionId}: ${String(err)}`);
-        return '';
-    }
-}

package/plugin/dist/core/pain-lifecycle.d.ts

@@ -1,15 +0,0 @@
-export declare const PAIN_FLAG_FILENAME = ".pain_flag";
-/**
- * Removes the .pain_flag file from the workspace's .state directory.
- * Called when a pain signal task completes (success, timeout, duplicate, or invalid)
- * to prevent stale flags from triggering repeated processing.
- *
- * Optionally verifies the file content before deleting to prevent accidentally removing
- * a concurrent new signal that was written between checkPainFlag reading the file and
- * this deletion call (TOCTOU race).
- *
- * @param workspaceDir - Workspace directory
- * @param expectedPainEventId - If provided, only deletes the file if its pain_event_id matches.
- *                              This prevents deleting a newly written signal during a race window.
- */
-export declare function clearPainFlag(workspaceDir: string, expectedPainEventId?: number | string): void;

package/plugin/dist/core/pain-lifecycle.js

@@ -1,37 +0,0 @@
-import * as fs from 'fs';
-import { resolvePdPath } from './paths.js';
-export const PAIN_FLAG_FILENAME = '.pain_flag';
-/**
- * Removes the .pain_flag file from the workspace's .state directory.
- * Called when a pain signal task completes (success, timeout, duplicate, or invalid)
- * to prevent stale flags from triggering repeated processing.
- *
- * Optionally verifies the file content before deleting to prevent accidentally removing
- * a concurrent new signal that was written between checkPainFlag reading the file and
- * this deletion call (TOCTOU race).
- *
- * @param workspaceDir - Workspace directory
- * @param expectedPainEventId - If provided, only deletes the file if its pain_event_id matches.
- *                              This prevents deleting a newly written signal during a race window.
- */
-export function clearPainFlag(workspaceDir, expectedPainEventId) {
-    const painFlagPath = resolvePdPath(workspaceDir, 'PAIN_FLAG');
-    try {
-        // Guard against TOCTOU race: if expectedPainEventId is provided,
-        // re-read the file and verify the pain_event_id matches before deleting.
-        // This prevents accidentally removing a new signal written between
-        // checkPainFlag reading the flag and this deletion.
-        if (expectedPainEventId !== undefined) {
-            const content = fs.readFileSync(painFlagPath, 'utf8');
-            const idMatch = content.includes(`pain_event_id: ${expectedPainEventId}`);
-            if (!idMatch) {
-                // File was rewritten with a different signal — do not delete.
-                return;
-            }
-        }
-        fs.unlinkSync(painFlagPath);
-    }
-    catch {
-        // Best-effort cleanup — ENOENT means already gone, other errors are ignored.
-    }
-}

package/plugin/dist/core/pain-signal-adapter.d.ts

@@ -1,37 +0,0 @@
-/**
- * PainSignalAdapter interface for the Evolution SDK.
- *
- * This interface decouples the evolution engine from specific AI agent
- * frameworks (OpenClaw, Claude Code, etc.). All modules that need to
- * capture pain signals from tool failures should depend on this interface
- * rather than importing framework-specific event types directly.
- *
- * The interface uses a generic type parameter for the raw framework event,
- * so each framework implementation provides its own concrete type.
- */
-import type { PainSignal } from './pain-signal.js';
-/**
- * Framework-agnostic adapter for capturing pain signals.
- *
- * @typeParam TRawEvent - The framework-specific event type
- * (e.g., PluginHookAfterToolCallEvent for OpenClaw)
- */
-export interface PainSignalAdapter<TRawEvent> {
-    /**
-     * Translate a framework-specific event into a universal PainSignal.
-     *
-     * Returns null when the event does not produce a pain signal (e.g., the
-     * event type is not a failure, or the event lacks required fields).
-     *
-     * This method performs pure translation only. Trigger decision logic
-     * (e.g., GFI threshold checks, tool name filtering) stays in the
-     * framework-side hook logic. Per D-02, capture() only translates.
-     *
-     * Translation failures (malformed events, missing required fields)
-     * return null rather than throwing. This keeps the adapter resilient.
-     *
-     * @param rawEvent - The framework-specific event to translate
-     * @returns A valid PainSignal, or null if the event does not produce one
-     */
-    capture(rawEvent: TRawEvent): PainSignal | null;
-}

package/plugin/dist/core/pain-signal-adapter.js

@@ -1 +0,0 @@
-export {};

package/plugin/dist/core/pain-signal.d.ts

@@ -1,6 +0,0 @@
-import { type PainSeverity as CorePainSeverity, type PainSignal as CorePainSignal, type PainSignalValidationResult as CorePainSignalValidationResult, PainSignalSchema, deriveSeverity, validatePainSignal } from '@principles/core/runtime-v2';
-export type PainSeverity = CorePainSeverity;
-export declare const PainSeverity: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"low">, import("@sinclair/typebox").TLiteral<"medium">, import("@sinclair/typebox").TLiteral<"high">, import("@sinclair/typebox").TLiteral<"critical">]>;
-export type PainSignal = CorePainSignal;
-export type PainSignalValidationResult = CorePainSignalValidationResult;
-export { PainSignalSchema, deriveSeverity, validatePainSignal, };

package/plugin/dist/core/pain-signal.js

@@ -1,3 +0,0 @@
-import { PainSeveritySchema, PainSignalSchema, deriveSeverity, validatePainSignal, } from '@principles/core/runtime-v2';
-export const PainSeverity = PainSeveritySchema;
-export { PainSignalSchema, deriveSeverity, validatePainSignal, };