principles-disciple 1.107.0 → 1.109.0

package/src/core/merge-gate-audit.ts

@@ -1,314 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { getImplementationAssetRoot } from './code-implementation-storage.js';
-import { resolvePdPath } from './paths.js';
-import type { ReplayReport } from './replay-engine.js';
-
-export type MergeGateAuditStatus = 'pass' | 'block' | 'defer';
-
-export interface MergeGateAuditCheck {
-  id: string;
-  status: MergeGateAuditStatus;
-  summary: string;
-  details?: Record<string, unknown>;
-}
-
-export interface MergeGateAuditReport {
-  overallStatus: MergeGateAuditStatus;
-  generatedAt: string;
-  workspaceDir: string;
-  stateDir: string;
-  checks: MergeGateAuditCheck[];
-  counts: {
-    pass: number;
-    block: number;
-    defer: number;
-  };
-}
-
-function computeOverallStatus(checks: MergeGateAuditCheck[]): MergeGateAuditStatus {
-  if (checks.some((check) => check.status === 'block')) {
-    return 'block';
-  }
-  if (checks.some((check) => check.status === 'defer')) {
-    return 'defer';
-  }
-  return 'pass';
-}
-
-function countStatuses(checks: MergeGateAuditCheck[]): MergeGateAuditReport['counts'] {
-  const counts = { pass: 0, block: 0, defer: 0 };
-  for (const check of checks) {
-    counts[check.status] += 1;
-  }
-  return counts;
-}
-
-function auditPainFlagPathContract(workspaceDir: string): MergeGateAuditCheck {
-  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: string): MergeGateAuditCheck {
-  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: unknown): value is ReplayReport {
-  if (!value || typeof value !== 'object') {
-    return false;
-  }
-
-  const report = value as Partial<ReplayReport>;
-  return (
-    typeof report.overallDecision === 'string' &&
-    typeof report.generatedAt === 'string' &&
-    typeof report.implementationId === 'string' &&
-    report.evidenceSummary !== undefined &&
-    Array.isArray(report.blockers)
-  );
-}
-
-function collectReplayReportPaths(stateDir: string): string[] {
-  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: string[] = [];
-  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;
-}
-
-type ReplayValidationCategory =
-  | 'io_error'
-  | 'malformed'
-  | 'missing_evidence_summary'
-  | 'unsupported_pass'
-  | 'empty_needs_review'
-  | 'valid';
-
-function hasValidEvidenceSummary(parsed: unknown): boolean {
-  if (!parsed || typeof parsed !== 'object') return false;
-  const report = parsed as Partial<ReplayReport>;
-  const summary = report.evidenceSummary;
-  if (!summary) return false;
-  if (typeof (summary as Partial<ReplayReport['evidenceSummary']>).evidenceStatus !== 'string') {
-    return false;
-  }
-  return typeof (summary as Partial<ReplayReport['evidenceSummary']>).totalSamples === 'number';
-}
-
-function validateSingleReplayReport(reportPath: string): ReplayValidationCategory {
-  let rawContent: string;
-  try {
-    rawContent = fs.readFileSync(reportPath, 'utf-8');
-  } catch {
-    return 'io_error';
-  }
-
-  let parsed: unknown;
-  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';
-}
-
-interface ReplayValidationResults {
-  ioErrorReports: string[];
-  malformedReports: string[];
-  missingEvidenceSummary: string[];
-  unsupportedPassingReports: string[];
-  emptyEvidenceNeedsReview: string[];
-}
-
-function categorizeReplayReports(reportPaths: string[]): ReplayValidationResults {
-  const results: ReplayValidationResults = {
-    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: ReplayValidationResults): boolean {
-  return (
-    results.malformedReports.length > 0 ||
-    results.ioErrorReports.length > 0 ||
-    results.missingEvidenceSummary.length > 0 ||
-    results.unsupportedPassingReports.length > 0 ||
-    results.emptyEvidenceNeedsReview.length > 0
-  );
-}
-
-function auditReplayEvidenceIntegrity(stateDir: string): MergeGateAuditCheck {
-  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: string, stateDir: string): MergeGateAuditReport {
-  const checks: MergeGateAuditCheck[] = [
-    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: MergeGateAuditReport): string {
-  const lines: string[] = [
-    '=== 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/src/core/pain-context-extractor.ts

@@ -1,306 +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 type * as fs from 'fs';
-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(): string {
-  return process.env.PD_TEST_AGENTS_DIR || path.join(os.homedir(), '.openclaw', 'agents');
-}
-
-// =========================================================================
-// Safe File Reading (Async)
-// =========================================================================
-
-async function safeTail(filePath: string): Promise<string[]> {
-  try {
-    // Check existence and stats asynchronously
-     
-     
-    let stat: fs.Stats;
-    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 [];
-  }
-}
-
-// =========================================================================
-// Safe JSONL Parsing
-// =========================================================================
-
-interface ParsedMessage {
-  role: string;
-  textParts: string[];
-  toolCalls: { id?: string; name?: string; arguments?: Record<string, unknown> }[];
-  toolCallId?: string;
-  toolName?: string;
-  details?: { exitCode?: number; isError?: boolean; aggregated?: string };
-}
-
-function parseSafeMessages(lines: string[]): ParsedMessage[] {
-  const messages: ParsedMessage[] = [];
-  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: { type: string }) => c.type === 'text').map((c: { text?: string }) => c.text || ''),
-        toolCalls: content.filter((c: { type: string }) => c.type === 'toolCall').map((c: { id?: string; name?: string; arguments?: Record<string, unknown> }) => ({ 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: ParsedMessage): string | null {
-  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: string[] = [];
-    
-    // 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: string,
-  agentId = 'main',
-  maxTurns: number = MAX_TURNS,
-): Promise<string> {
-  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: string[] = [];
-    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: string,
-  agentId: string,
-  toolName: string,
-  filePath?: string,
-): Promise<string> {
-  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<string, { name: string; fullArgs: string; previewArgs: string }>();
-    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: Record<string, unknown> = {};
-          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: string[] = [];
-    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/src/core/pain-lifecycle.ts

@@ -1,38 +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: string, expectedPainEventId?: number | string): void {
-    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/src/core/pain-signal-adapter.ts

@@ -1,42 +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';
-
-// ---------------------------------------------------------------------------
-// PainSignalAdapter Interface
-// ---------------------------------------------------------------------------
-
-/**
- * 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;
-}