principles-disciple 1.201.0 → 1.202.0

package/dist/core/config.d.ts

@@ -0,0 +1,111 @@
+export interface GfiGateSettings {
+    enabled: boolean;
+    thresholds: {
+        low_risk_block: number;
+        high_risk_block: number;
+        large_change_block: number;
+    };
+    large_change_lines: number;
+    ep_tier_multipliers: {
+        '1': number;
+        '2': number;
+        '3': number;
+        '4': number;
+        '5': number;
+    };
+    bash_safe_patterns: string[];
+    bash_dangerous_patterns: string[];
+}
+export interface DiagnosticianSettings {
+    context: {
+        time_window_minutes: number;
+        max_message_length: number;
+        max_summary_length: number;
+    };
+}
+export interface PainSettings {
+    language: 'en' | 'zh';
+    trajectory?: {
+        blob_inline_threshold_bytes?: number;
+        busy_timeout_ms?: number;
+        orphan_blob_grace_days?: number;
+    };
+    diagnostician?: DiagnosticianSettings;
+    thresholds: {
+        pain_trigger: number;
+        cognitive_paralysis_input: number;
+        stuck_loops_trigger: number;
+        semantic_min_score: number;
+        promotion_count_threshold: number;
+        promotion_similarity_threshold: number;
+    };
+    scores: {
+        paralysis: number;
+        default_confusion: number;
+        default_loop: number;
+        tool_failure_friction: number;
+        exit_code_penalty: number;
+        spiral_penalty: number;
+        missing_test_command_penalty: number;
+        subagent_error_penalty: number;
+        subagent_timeout_penalty: number;
+    };
+    severity_thresholds: {
+        high: number;
+        medium: number;
+        low: number;
+    };
+    intervals: {
+        worker_poll_ms: number;
+        initial_delay_ms: number;
+        task_timeout_ms: number;
+    };
+    empathy_engine?: {
+        enabled?: boolean;
+        dedupe_window_ms?: number;
+        penalties?: {
+            mild?: number;
+            moderate?: number;
+            severe?: number;
+        };
+        rate_limit?: {
+            max_per_turn?: number;
+            max_per_hour?: number;
+        };
+        model_calibration?: Record<string, number>;
+    };
+    gfi_gate?: GfiGateSettings;
+    compression?: {
+        /** 触发自动压缩的行数阈值 */
+        line_threshold?: number;
+        /** 触发自动压缩的字节阈值 */
+        size_threshold_kb?: number;
+        /** 自动压缩间隔（小时） */
+        interval_hours?: number;
+        /** 保留的已完成任务数 */
+        keep_completed_tasks?: number;
+        /** Working Memory 最大条数 */
+        max_working_memory_artifacts?: number;
+    };
+}
+export declare const DEFAULT_SETTINGS: PainSettings;
+export declare class PainConfig {
+    private settings;
+    private readonly filePath;
+    constructor(stateDir: string);
+    load(): void;
+    save(): void;
+    private deepMerge;
+    /**
+     * Basic validation for critical settings
+     */
+    private validate;
+    /**
+     * Gets a value using dot notation (e.g. 'thresholds.pain_trigger')
+     */
+    get(keyPath: string): any;
+    /**
+     * Returns all settings as a plain object.
+     */
+    getAll(): PainSettings;
+}

package/dist/core/control-ui-db.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Control UI database stores ANALYTICS READ MODELS.
+ *
+ * PURPOSE: Aggregated data for dashboard visualization and historical insights.
+ * USAGE: Control UI queries and dashboard displays.
+ * NOT FOR: Control decisions, Phase 3 eligibility, or real-time operations.
+ *
+ * Runtime truth comes from: queue state, workspace trust scorecard, active sessions
+ */
+export interface ThinkingModelEventInput {
+    sessionId: string;
+    runId: string;
+    assistantTurnId: number;
+    modelId: string;
+    matchedPattern: string;
+    scenarioJson: unknown;
+    toolContextJson: unknown;
+    painContextJson: unknown;
+    principleContextJson: unknown;
+    triggerExcerpt: string;
+    createdAt: string;
+}
+export interface ControlUiDatabaseOptions {
+    workspaceDir: string;
+    busyTimeoutMs?: number;
+}
+export interface RecentThinkingContext {
+    toolCalls: {
+        id: number;
+        toolName: string;
+        outcome: 'success' | 'failure' | 'blocked';
+        errorType: string | null;
+        errorMessage: string | null;
+        createdAt: string;
+    }[];
+    painEvents: {
+        id: number;
+        source: string;
+        score: number;
+        reason: string | null;
+        createdAt: string;
+    }[];
+    gateBlocks: {
+        id: number;
+        toolName: string;
+        reason: string;
+        filePath: string | null;
+        createdAt: string;
+    }[];
+    userCorrections: {
+        id: number;
+        correctionCue: string | null;
+        rawExcerpt: string | null;
+        createdAt: string;
+    }[];
+    principleEvents: {
+        id: number;
+        principleId: string | null;
+        eventType: string;
+        createdAt: string;
+    }[];
+}
+export declare class ControlUiDatabase {
+    private readonly workspaceDir;
+    private readonly dbPath;
+    private readonly blobDir;
+    private readonly db;
+    constructor(opts: ControlUiDatabaseOptions);
+    dispose(): void;
+    recordThinkingModelEvent(input: ThinkingModelEventInput): number;
+    /**
+     * Get recent thinking context for a session.
+     *
+     * Returns: Analytics data (read model) aggregated from trajectory database.
+     * Not: Runtime truth or real-time queue state.
+     */
+    getRecentThinkingContext(sessionId: string, beforeCreatedAt: string, limit?: number): RecentThinkingContext;
+    /**
+     * Execute SQL query and return all rows.
+     *
+     * Returns: Analytics data (read model) aggregated from trajectory database.
+     * Not: Runtime truth or real-time queue state.
+     */
+    all<T>(sql: string, ...params: unknown[]): T[];
+    /**
+     * Execute SQL query and return first row.
+     *
+     * Returns: Analytics data (read model) aggregated from trajectory database.
+     * Not: Runtime truth or real-time queue state.
+     */
+    get<T>(sql: string, ...params: unknown[]): T | undefined;
+    /**
+     * Execute SQL statement that does not return rows (DDL, CREATE TABLE, etc.).
+     *
+     * Returns: void (executes directly)
+     * Not for: SELECT queries (use all() or get() instead)
+     */
+    execute(sql: string): void;
+    /**
+     * Execute a parameterized write statement (INSERT, UPDATE, DELETE).
+     */
+    run(sql: string, ...params: unknown[]): void;
+    restoreRawText(inlineText?: string | null, blobRef?: string | null): string;
+    private initSchema;
+    /**
+     * Create or replace a view, tolerating missing dependency tables.
+     *
+     * Views in ControlUiDatabase depend on tables created by TrajectoryDatabase
+     * (assistant_turns, tool_calls, pain_events, user_turns, correction_samples).
+     * If ControlUiDatabase is constructed before TrajectoryDatabase has created
+     * those tables, CREATE VIEW would throw. We DROP+CREATE with try/catch so
+     * missing-dependency views are skipped with a warning (rc-9: surfaced via
+     * console.info) rather than aborting schema initialization.
+     */
+    private createViewSafely;
+    private withWrite;
+}

package/dist/core/correction-cue-learner.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Correction Cue Learner
+ *
+ * Persistent, learnable keyword store for correction cue detection.
+ * Replaces the hardcoded cue list in detectCorrectionCue() with a
+ * crash-safe JSON store that can grow over time.
+ *
+ * Persistence contract:
+ *   - Atomic write: temp-file-then-rename (T-38-02)
+ *   - Cache invalidated after every write (D-05)
+ *   - 200-term hard cap enforced before any write (T-38-01)
+ */
+import type { CorrectionKeyword, CorrectionKeywordStore, CorrectionMatchResult } from './correction-types.js';
+export declare function _resetCorrectionCueCache(): void;
+export declare function loadCorrectionKeywordStore(stateDir: string): CorrectionKeywordStore;
+export declare function saveCorrectionKeywordStore(stateDir: string, store: CorrectionKeywordStore): void;
+export declare function _resetCorrectionCueLearnerInstance(): void;
+export declare class CorrectionCueLearner {
+    private readonly store;
+    private readonly stateDir;
+    constructor(stateDir: string);
+    match(text: string): CorrectionMatchResult;
+    recordHits(terms: string[]): void;
+    recordTruePositive(term: string): void;
+    recordFalsePositive(term: string): void;
+    add(keyword: Omit<CorrectionKeyword, 'addedAt'>): void;
+    updateWeight(term: string, weight: number): void;
+    remove(term: string): void;
+    getStore(): CorrectionKeywordStore;
+    getLastOptimizedAt(): string;
+    flush(): void;
+    static get(stateDir: string): CorrectionCueLearner;
+}

package/dist/core/correction-types.d.ts

@@ -0,0 +1,3 @@
+import type { CorrectionKeyword, CorrectionKeywordStore, CorrectionMatchResult } from '@principles/core/runtime-v2';
+export type { CorrectionKeyword, CorrectionKeywordStore, CorrectionMatchResult, };
+export { MAX_CORRECTION_KEYWORDS, CORRECTION_SEED_KEYWORDS, } from '@principles/core/runtime-v2';

package/dist/core/detection-funnel.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Detection Funnel — PRI-446 thin adapter
+ *
+ * The pure three-layer funnel logic (LRU cache, async queue, layer dispatch)
+ * now lives in principles-core
+ * (runtime-v2/detection/detection-funnel-policy.ts). This file is a thin shell
+ * that wires DetectionFunnelCore with the two environment-coupled dependencies
+ * the plugin owns:
+ *   - crypto.createHash (the L2 cache key hasher)
+ *   - PainDictionary.match (the L1 exact matcher)
+ *   - shouldIgnorePainProtocolText (the protocol-token gate)
+ *
+ * It re-exports DetectionFunnel (same class name + constructor signature) and
+ * DetectionResult so DetectionService, llm.ts, and evolution-worker keep working
+ * unchanged.
+ *
+ * ERR checklist:
+ * - ERR-011: this is a thin adapter delegating to core pure logic.
+ */
+import { type PainDictionary } from './dictionary.js';
+import { type DetectionResult } from '@principles/core/runtime-v2';
+export type { DetectionResult };
+/**
+ * Orchestrates the three-layer detection funnel for pain signals.
+ *
+ * Delegates to the core DetectionFunnelCore, injecting the crypto hasher,
+ * the dictionary matcher, and the protocol-token gate.
+ */
+export declare class DetectionFunnel {
+    private readonly core;
+    constructor(dictionary: PainDictionary);
+    /**
+     * Detects pain in the given text using L1 (Exact), L2 (Cache), and L3 (Async).
+     */
+    detect(text: string): DetectionResult;
+    /**
+     * Internal method for the worker to update the cache after a semantic hit.
+     */
+    updateCache(text: string, result: {
+        detected: boolean;
+        severity?: number;
+    }): void;
+    /**
+     * Retrieves and clears the current asynchronous queue.
+     */
+    flushQueue(): string[];
+}

package/dist/core/detection-service.d.ts

@@ -0,0 +1,15 @@
+import { DetectionFunnel } from './detection-funnel.js';
+/**
+ * Singleton service to manage the Semantic Detection Funnel.
+ */
+export declare const DetectionService: {
+    /**
+     * Gets or initializes the Detection Funnel instance.
+     * @param stateDir The directory used to initialize the dictionary.
+     */
+    get(stateDir: string): DetectionFunnel;
+    /**
+     * Resets the singleton instance (primarily for testing).
+     */
+    reset(): void;
+};

package/dist/core/dictionary-service.d.ts

@@ -0,0 +1,15 @@
+import { PainDictionary } from './dictionary.js';
+/**
+ * Singleton service to manage the Pain Dictionary.
+ */
+export declare const DictionaryService: {
+    /**
+     * Gets or initializes the Pain Dictionary instance.
+     * @param stateDir The directory where the dictionary JSON is stored.
+     */
+    get(stateDir: string): PainDictionary;
+    /**
+     * Resets the singleton instance (primarily for testing).
+     */
+    reset(): void;
+};

package/dist/core/dictionary.d.ts

@@ -0,0 +1,38 @@
+export type RuleType = 'regex' | 'exact_match';
+export interface PainRule {
+    type: RuleType;
+    pattern?: string;
+    phrases?: string[];
+    severity: number;
+    hits: number;
+    status: 'active' | 'dormant' | 'archived';
+}
+export interface PainDictionaryData {
+    rules: Record<string, PainRule>;
+}
+export declare const PAIN_PROTOCOL_TOKENS: readonly ['[EVOLUTION_ACK]', 'HEARTBEAT_OK', 'HEARTBEAT_CHECK'];
+export declare function shouldIgnorePainProtocolText(text: string): boolean;
+export declare class PainDictionary {
+    private readonly stateDir;
+    private data;
+    private readonly store;
+    private readonly compiledRegex;
+    constructor(stateDir: string);
+    load(): void;
+    private compile;
+    getRule(id: string): PainRule | undefined;
+    getAllRules(): Record<string, PainRule>;
+    /**
+     * Adds a new rule or updates an existing one.
+     */
+    addRule(id: string, rule: Omit<PainRule, 'hits'>): void;
+    match(text: string): {
+        ruleId: string;
+        severity: number;
+    } | undefined;
+    flush(): void;
+    getStats(): {
+        totalRules: number;
+        totalHits: number;
+    };
+}

package/dist/core/empathy-keyword-matcher.d.ts

@@ -0,0 +1,5 @@
+import type { EmpathyKeywordStore } from '@principles/core/prompt-builder';
+export { matchEmpathyKeywords, createDefaultKeywordStore, applyKeywordUpdates, shouldTriggerOptimization, getKeywordStoreSummary, } from '@principles/core/prompt-builder';
+export type { EmpathyKeywordStore, EmpathyKeywordEntry, EmpathyKeywordStats, EmpathyMatchResult, EmpathyKeywordConfig, } from '@principles/core/prompt-builder';
+export declare function loadKeywordStore(stateDir: string, language?: 'zh' | 'en'): EmpathyKeywordStore;
+export declare function saveKeywordStore(stateDir: string, store: EmpathyKeywordStore): void;

package/dist/core/empathy-types.d.ts

@@ -0,0 +1,2 @@
+export type { EmpathyKeywordStore, EmpathyKeywordEntry, EmpathyKeywordStats, EmpathyMatchResult, EmpathyKeywordUpdate, EmpathyOptimizationResult, SeedKeywordEntry, EmpathyKeywordConfig, } from '@principles/core/prompt-builder';
+export { EMPATHY_SEED_KEYWORDS, DEFAULT_EMPATHY_KEYWORD_CONFIG, scoreToSeverity, severityToPenalty, normalizeSeverity, } from '@principles/core/prompt-builder';

package/dist/core/event-log.d.ts

@@ -0,0 +1,98 @@
+import type { EventLogEntry, DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, DiagnosisTaskEventData, HeartbeatDiagnosisEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData, RuleHostSkippedEventData } from '../types/event-types.js';
+import type { PluginLogger } from '../openclaw-sdk.js';
+export declare class EventLog {
+    private readonly logsDir;
+    private readonly statsFile;
+    private readonly logger?;
+    private readonly statsCache;
+    private eventBuffer;
+    private readonly maxBufferSize;
+    private readonly flushIntervalMs;
+    private flushTimer?;
+    private currentEventsFile;
+    private currentDate;
+    constructor(stateDir: string, logger?: PluginLogger);
+    private getEventsFile;
+    private getTodayStr;
+    private ensureEventsFile;
+    private cleanupOldEventFiles;
+    recordToolCall(sessionId: string | undefined, data: ToolCallEventData): void;
+    recordPainSignal(sessionId: string | undefined, data: PainSignalEventData): void;
+    recordRulePromotion(data: RulePromotionEventData): void;
+    recordHookExecution(data: HookExecutionEventData, opts?: {
+        flushImmediately?: boolean;
+    }): void;
+    recordGateBlock(sessionId: string | undefined, data: GateBlockEventData): void;
+    recordGateBypass(sessionId: string | undefined, data: GateBypassEventData): void;
+    recordPlanApproval(sessionId: string | undefined, data: PlanApprovalEventData): void;
+    recordEvolutionTask(data: EvolutionTaskEventData): void;
+    recordEvolutionTaskCompleted(data: EvolutionTaskEventData): void;
+    recordEmpathyRollback(sessionId: string | undefined, data: EmpathyRollbackEventData): void;
+    recordError(sessionId: string | undefined, message: string, context?: Record<string, unknown>): void;
+    recordWarn(sessionId: string | undefined, message: string, context?: Record<string, unknown>): void;
+    recordDiagnosisTask(data: DiagnosisTaskEventData): void;
+    recordHeartbeatDiagnosis(data: HeartbeatDiagnosisEventData): void;
+    recordDiagnosticianReport(data: DiagnosticianReportEventData): void;
+    recordPrincipleCandidate(data: PrincipleCandidateEventData): void;
+    recordRuleEnforced(data: RuleEnforcedEventData): void;
+    recordRuleHostEvaluated(data: RuleHostEvaluatedEventData): void;
+    recordRuleHostBlocked(data: RuleHostBlockedEventData): void;
+    recordRuleHostRequireApproval(data: RuleHostRequireApprovalEventData): void;
+    recordRuleHostAutoCorrectProposed(data: RuleHostAutoCorrectProposedEventData): void;
+    recordRuleHostAutoCorrectApplied(data: RuleHostAutoCorrectAppliedEventData): void;
+    recordRuntimeV2ActivationsInjected(data: RuntimeV2PromptActivationsInjectedEventData): void;
+    /**
+     * PRI-437: Record that an approved rule failed to compile or load.
+     *
+     * This is NOT just a logger.warn — the unhealthy state is persisted to EventLog
+     * so it's visible to CLI (pd runtime health) and Console API.
+     *
+     * ERR-002: degradation includes a reason and nextAction (not silent).
+     */
+    recordRuleHostUnhealthy(data: RuleHostUnhealthyEventData): void;
+    /**
+     * PRI-491: Record that an active activation was skipped at load time for a
+     * structured reason (flag-off v2, unsupported action, unsupported context
+     * version, missing target_ref). Unlike rulehost_unhealthy (compile/load
+     * failures), these are configuration/flag issues — the RuleCode itself may
+     * be valid, but the runtime chose not to execute it.
+     *
+     * ERR-002: degradation/suspension includes reason + nextAction (rc-9).
+     */
+    recordRuleHostSkipped(data: RuleHostSkippedEventData): void;
+    /**
+     * Redact telemetry-sensitive string values in event data before persistence.
+     * Applies redactTelemetryString to known high-risk fields (filePath, command,
+     * reason, args, new_string, old_string, text, paramsSummary values) and to all
+     * string values in tool_call/rulehost_* data as a safety net.
+     *
+     * ERR-002: never throws; returns data unchanged on error.
+     * ERR-045/046: covers composite command strings, Authorization headers, env vars.
+     */
+    private redactEventData;
+    private record;
+    private formatDate;
+    private loadStats;
+    private updateStats;
+    private startFlushTimer;
+    flush(): void;
+    getBufferedEvents(): EventLogEntry[];
+    private getEventDedupKey;
+    private readPersistedEvents;
+    private getMergedEvents;
+    private flushEvents;
+    private flushStats;
+    getDailyStats(date: string): DailyStats;
+    getEmpathyStats(range: 'today' | 'week' | 'session', sessionId?: string): EmpathyEventStats;
+    private aggregateSessionEmpathy;
+    rollbackEmpathyEvent(eventId: string, sessionId: string | undefined, reason: string, triggeredBy: 'user_command' | 'natural_language' | 'system'): number;
+    getLastEmpathyEventId(sessionId: string): string | null;
+    findLatestPainSignal(sessionId: string | undefined): PainSignalEventData | null;
+    dispose(): void;
+}
+export declare class EventLogService {
+    private static readonly instances;
+    static get(stateDir: string, logger?: PluginLogger): EventLog;
+    static flushAll(): void;
+    static disposeAll(): void;
+}

package/dist/core/evolution-engine.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Evolution Engine V2.0 - MVP
+ *
+ * 成长驱动的进化积分系统，替代惩罚驱动的 Trust Engine。
+ *
+ * 核心原则：
+ * 1. 起点0分，只能增加，不扣分
+ * 2. 失败记录教训，不扣分
+ * 3. 同类任务失败后首次成功 = 双倍奖励（1小时冷却）
+ * 4. 高等级做低级任务积分衰减
+ * 5. 原子写入防止并发损坏
+ */
+import type { EvolutionScorecard, EvolutionStats, EvolutionConfig, TaskDifficulty, TierDefinition, GateDecision, ToolCallContext } from './evolution-types.js';
+import { EvolutionTier } from './evolution-types.js';
+export declare class EvolutionEngine {
+    private readonly scorecard;
+    private readonly workspaceDir;
+    private readonly stateDir;
+    private readonly config;
+    private readonly storagePath;
+    constructor(workspaceDir: string, config?: Partial<EvolutionConfig>);
+    /** 获取当前积分 */
+    getPoints(): number;
+    /** 获取可用积分 */
+    getAvailablePoints(): number;
+    /** 获取当前等级 */
+    getTier(): EvolutionTier;
+    /** 获取当前等级定义 */
+    getTierDefinition(): TierDefinition;
+    /** 获取完整积分卡 */
+    getScorecard(): EvolutionScorecard;
+    /** 获取统计信息 */
+    getStats(): EvolutionStats;
+    /** 获取状态摘要 */
+    getStatusSummary(): {
+        tier: EvolutionTier;
+        tierName: string;
+        totalPoints: number;
+        availablePoints: number;
+        permissions: import("@principles/core/runtime-v2").TierPermissions;
+        stats: EvolutionStats;
+        nextTier: {
+            tier: EvolutionTier;
+            name: string;
+            pointsNeeded: number;
+        } | null;
+    };
+    recordSuccess(toolName: string, options?: {
+        filePath?: string;
+        difficulty?: TaskDifficulty;
+        reason?: string;
+        sessionId?: string;
+    }): {
+        pointsAwarded: number;
+        isDoubleReward: boolean;
+        newTier?: EvolutionTier;
+    };
+    recordFailure(toolName: string, options?: {
+        filePath?: string;
+        difficulty?: TaskDifficulty;
+        reason?: string;
+        sessionId?: string;
+    }): {
+        pointsAwarded: number;
+        lessonRecorded: boolean;
+    };
+    /** 工具调用前检查 */
+    beforeToolCall(context: ToolCallContext): GateDecision;
+    private calculatePoints;
+    private getDifficultyPenalty;
+    private canReceiveDoubleReward;
+    private checkAndApplyPromotion;
+    private static inferDifficulty;
+    private static computeTaskHash;
+    private createEvent;
+    private addEvent;
+    private loadOrCreateScorecard;
+    private createNewScorecard;
+    /** 持久化评分卡（含锁保护） */
+    private saveScorecard;
+    /** Per-instance retry queue (P0 fix: was static, causing cross-instance race) */
+    private retryQueue;
+    private retryTimer;
+    /** 调度重试保存 */
+    private scheduleRetrySave;
+    /** 处理重试队列 */
+    private processRetryQueue;
+    /** 无锁快速保存（用于重试） */
+    private saveScorecardImmediate;
+    private generateId;
+    dispose(): void;
+}
+/** 获取指定 workspace 的引擎实例 */
+export declare function getEvolutionEngine(workspaceDir: string): EvolutionEngine;
+export declare function disposeEvolutionEngine(workspaceDir: string): void;
+export declare function disposeAllEvolutionEngines(): void;
+/** 记录成功（便捷函数） */
+export declare function recordEvolutionSuccess(workspaceDir: string, toolName: string, options?: {
+    filePath?: string;
+    difficulty?: TaskDifficulty;
+    reason?: string;
+    sessionId?: string;
+}): {
+    pointsAwarded: number;
+    isDoubleReward: boolean;
+    newTier?: EvolutionTier;
+};
+/** 记录失败（便捷函数） */
+export declare function recordEvolutionFailure(workspaceDir: string, toolName: string, options?: {
+    filePath?: string;
+    difficulty?: TaskDifficulty;
+    reason?: string;
+    sessionId?: string;
+}): {
+    pointsAwarded: number;
+    lessonRecorded: boolean;
+};
+/** Gate 检查（便捷函数） */
+export declare function checkEvolutionGate(workspaceDir: string, context: ToolCallContext): GateDecision;