principles-disciple 1.7.5 → 1.7.8

package/dist/core/adaptive-thresholds.js

@@ -0,0 +1,300 @@
+/**
+ * Adaptive Thresholds — Bounded Threshold State Management
+ * ========================================================
+ *
+ * PURPOSE: Manage adaptive thresholds for Trinity candidate scoring with
+ * bounded, observable, and reproducible threshold changes.
+ *
+ * DESIGN CONSTRAINTS:
+ * - Thresholds only move within bounded ranges (min/max)
+ * - Changes depend on explicit observable signals only
+ * - No hidden learning loops
+ * - Threshold state is persisted and can be rolled back
+ * - Corruption or missing state falls back to safe defaults
+ *
+ * OBSERVABLE SIGNALS:
+ * - recent malformed rate (arbiter/executability failures)
+ * - recent arbiter reject rate
+ * - recent executability reject rate
+ * - reviewed subset quality delta
+ *
+ * PHASE 6 ONLY — No real training, no automatic deployment
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { withLock } from '../utils/file-lock.js';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** File name for threshold state */
+export const THRESHOLD_STATE_FILE = 'nocturnal-threshold-state.json';
+/** Default threshold values */
+export const DEFAULT_THRESHOLDS = {
+    /** Minimum score to pass arbiter validation */
+    schemaCompletenessMin: 0.6,
+    /** Minimum principle alignment score */
+    principleAlignmentMin: 0.7,
+    /** Minimum executability score */
+    executabilityMin: 0.65,
+    /** Minimum boundedness score */
+    boundednessMin: 0.5,
+    /** Minimum confidence/consistency score */
+    confidenceMin: 0.6,
+    /** Minimum aggregate score to be tournament-eligible */
+    aggregateMin: 0.65,
+};
+/** Minimum threshold value (safety bound) */
+export const THRESHOLD_MIN = 0.0;
+/** Maximum threshold value (safety bound) */
+export const THRESHOLD_MAX = 1.0;
+/** Maximum adjustment per update (bounded step size) */
+export const MAX_ADJUSTMENT_PER_STEP = 0.05;
+/** Minimum adjustment to trigger a change */
+export const MIN_ADJUSTMENT_TO_RECORD = 0.01;
+// ---------------------------------------------------------------------------
+// State Persistence
+// ---------------------------------------------------------------------------
+/**
+ * Get the threshold state file path.
+ */
+function getStatePath(stateDir) {
+    return path.join(stateDir, THRESHOLD_STATE_FILE);
+}
+/**
+ * Create default threshold persistence state.
+ */
+function createDefaultState() {
+    const now = new Date().toISOString();
+    const thresholds = {};
+    for (const [name, defaultValue] of Object.entries(DEFAULT_THRESHOLDS)) {
+        thresholds[name] = {
+            currentValue: defaultValue,
+            minValue: THRESHOLD_MIN,
+            maxValue: THRESHOLD_MAX,
+            lastUpdatedAt: now,
+            adjustmentCount: 0,
+        };
+    }
+    return {
+        thresholds,
+        lastUpdatedAt: now,
+        version: 1,
+    };
+}
+/**
+ * Read threshold state from disk (with locking).
+ */
+function readState(stateDir) {
+    const statePath = getStatePath(stateDir);
+    if (!fs.existsSync(statePath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(statePath, 'utf-8');
+        const parsed = JSON.parse(content);
+        return parsed;
+    }
+    catch {
+        // Corrupted — return null to trigger default fallback
+        return null;
+    }
+}
+/**
+ * Write threshold state to disk (with locking).
+ */
+function writeState(stateDir, state) {
+    const statePath = getStatePath(stateDir);
+    const stateDirPath = path.dirname(statePath);
+    if (!fs.existsSync(stateDirPath)) {
+        fs.mkdirSync(stateDirPath, { recursive: true });
+    }
+    withLock(statePath, () => {
+        const tmpPath = `${statePath}.tmp`;
+        fs.writeFileSync(tmpPath, JSON.stringify(state, null, 2), 'utf-8');
+        fs.renameSync(tmpPath, statePath);
+    });
+}
+// ---------------------------------------------------------------------------
+// Core Threshold Operations
+// ---------------------------------------------------------------------------
+/**
+ * Load threshold values with fallback to defaults on corruption.
+ *
+ * @param stateDir - State directory
+ * @returns LoadThresholdResult with current values and status
+ */
+export function loadThresholdState(stateDir) {
+    const rawState = readState(stateDir);
+    if (!rawState) {
+        return {
+            success: true,
+            thresholds: { ...DEFAULT_THRESHOLDS },
+            usedDefaults: true,
+        };
+    }
+    // Validate and reconstruct threshold values
+    const thresholds = { ...DEFAULT_THRESHOLDS };
+    let usedDefaults = false;
+    for (const [name, defaultValue] of Object.entries(DEFAULT_THRESHOLDS)) {
+        const key = name;
+        const state = rawState.thresholds[key];
+        if (state && typeof state.currentValue === 'number') {
+            // Clamp to bounds (defensive)
+            thresholds[key] = Math.max(state.minValue, Math.min(state.maxValue, state.currentValue));
+        }
+        else {
+            thresholds[key] = defaultValue;
+            usedDefaults = true;
+        }
+    }
+    return {
+        success: true,
+        thresholds: thresholds,
+        usedDefaults,
+    };
+}
+/**
+ * Get effective threshold values (alias for loadThresholdState).
+ *
+ * @param stateDir - State directory
+ * @returns Current threshold values
+ */
+export function getEffectiveThresholds(stateDir) {
+    const result = loadThresholdState(stateDir);
+    return result.thresholds;
+}
+/**
+ * Update a single threshold with bounded step size.
+ *
+ * @param stateDir - State directory
+ * @param thresholdName - Name of threshold to update
+ * @param newValue - New value (will be clamped to bounds)
+ * @param reason - Reason for the adjustment (required for tracking)
+ * @returns UpdateThresholdResult
+ */
+export function updateThresholdState(stateDir, thresholdName, newValue, reason) {
+    // Read current state
+    let rawState = readState(stateDir);
+    if (!rawState) {
+        rawState = createDefaultState();
+    }
+    const currentState = rawState.thresholds[thresholdName];
+    if (!currentState) {
+        return {
+            success: false,
+            thresholds: { ...DEFAULT_THRESHOLDS },
+            changed: false,
+            error: `Unknown threshold: ${thresholdName}`,
+        };
+    }
+    // Calculate bounded new value
+    const clampedValue = Math.max(currentState.minValue, Math.min(currentState.maxValue, newValue));
+    // Check if change is meaningful
+    const delta = Math.abs(clampedValue - currentState.currentValue);
+    if (delta < MIN_ADJUSTMENT_TO_RECORD) {
+        return {
+            success: true,
+            thresholds: getEffectiveThresholds(stateDir),
+            changed: false,
+        };
+    }
+    // Enforce maximum step size for bounded, safe threshold adjustments
+    let finalValue = clampedValue;
+    if (delta > MAX_ADJUSTMENT_PER_STEP) {
+        const direction = clampedValue > currentState.currentValue ? 1 : -1;
+        finalValue = currentState.currentValue + direction * MAX_ADJUSTMENT_PER_STEP;
+    }
+    // Update state
+    const now = new Date().toISOString();
+    rawState.thresholds[thresholdName] = {
+        ...currentState,
+        currentValue: finalValue,
+        lastUpdatedAt: now,
+        adjustmentReason: reason,
+        adjustmentCount: currentState.adjustmentCount + 1,
+    };
+    rawState.lastUpdatedAt = now;
+    writeState(stateDir, rawState);
+    return {
+        success: true,
+        thresholds: getEffectiveThresholds(stateDir),
+        changed: true,
+        changedThreshold: thresholdName,
+        oldValue: currentState.currentValue,
+        newValue: finalValue,
+        reason,
+    };
+}
+/**
+ * Reset all thresholds to defaults.
+ *
+ * @param stateDir - State directory
+ */
+export function resetThresholdState(stateDir) {
+    const defaultState = createDefaultState();
+    writeState(stateDir, defaultState);
+}
+/**
+ * Get detailed threshold state for debugging/inspection.
+ *
+ * @param stateDir - State directory
+ * @returns Detailed threshold state or null if corrupted
+ */
+export function getDetailedThresholdState(stateDir) {
+    return readState(stateDir);
+}
+// ---------------------------------------------------------------------------
+// Signal-Based Threshold Adjustment
+// ---------------------------------------------------------------------------
+/**
+ * Adjust thresholds based on observable signals.
+ *
+ * This is a simple proportional controller that adjusts thresholds
+ * based on observed rejection rates. The adjustment is bounded
+ * and requires a minimum signal magnitude to trigger.
+ *
+ * @param stateDir - State directory
+ * @param signals - Observable signals
+ * @returns UpdateThresholdResult describing the most significant change
+ */
+export function adjustThresholdsFromSignals(stateDir, signals) {
+    const currentThresholds = getEffectiveThresholds(stateDir);
+    let bestResult = {
+        success: true,
+        thresholds: currentThresholds,
+        changed: false,
+    };
+    // High malformed rate → tighten schema completeness threshold
+    if (signals.malformedRate > 0.3) {
+        const adjustment = signals.malformedRate * 0.1;
+        const newValue = currentThresholds.schemaCompletenessMin + adjustment;
+        const result = updateThresholdState(stateDir, 'schemaCompletenessMin', newValue, `High malformed rate (${signals.malformedRate.toFixed(2)}) → tightening schema threshold`);
+        if (result.changed)
+            bestResult = result;
+    }
+    // High arbiter reject rate → tighten principle alignment threshold
+    if (signals.arbiterRejectRate > 0.25) {
+        const adjustment = signals.arbiterRejectRate * 0.08;
+        const result = updateThresholdState(stateDir, 'principleAlignmentMin', currentThresholds.principleAlignmentMin + adjustment, `High arbiter reject rate (${signals.arbiterRejectRate.toFixed(2)}) → tightening alignment threshold`);
+        if (result.changed && (!bestResult.changed || (result.newValue - result.oldValue) > 0)) {
+            bestResult = result;
+        }
+    }
+    // High executability reject rate → tighten executability threshold
+    if (signals.executabilityRejectRate > 0.3) {
+        const adjustment = signals.executabilityRejectRate * 0.1;
+        const result = updateThresholdState(stateDir, 'executabilityMin', currentThresholds.executabilityMin + adjustment, `High executability reject rate (${signals.executabilityRejectRate.toFixed(2)}) → tightening executability threshold`);
+        if (result.changed && (!bestResult.changed || (result.newValue - result.oldValue) > 0)) {
+            bestResult = result;
+        }
+    }
+    // Good quality delta → slightly loosen thresholds (reward good performance)
+    if (signals.qualityDelta > 0.1) {
+        const reward = Math.min(signals.qualityDelta * 0.05, MAX_ADJUSTMENT_PER_STEP);
+        const result = updateThresholdState(stateDir, 'aggregateMin', Math.max(currentThresholds.aggregateMin - reward, THRESHOLD_MIN), `Positive quality delta (${signals.qualityDelta.toFixed(2)}) → rewarding with slightly lower aggregate threshold`);
+        if (result.changed && (!bestResult.changed || (result.oldValue - result.newValue) > 0)) {
+            bestResult = result;
+        }
+    }
+    return bestResult;
+}

package/dist/core/config.d.ts

@@ -21,51 +21,16 @@ export interface GfiGateSettings {
         large_change_block: number;
     };
     large_change_lines: number;
-    trust_stage_multipliers: {
+    ep_tier_multipliers: {
         '1': number;
         '2': number;
         '3': number;
         '4': number;
+        '5': number;
     };
     bash_safe_patterns: string[];
     bash_dangerous_patterns: string[];
 }
-export interface TrustSettings {
-    stages: {
-        stage_1_observer: number;
-        stage_2_editor: number;
-        stage_3_developer: number;
-    };
-    cold_start: {
-        initial_trust: number;
-        grace_failures: number;
-        cold_start_period_ms: number;
-    };
-    penalties: {
-        tool_failure_base: number;
-        risky_failure_base: number;
-        gate_bypass_attempt: number;
-        failure_streak_multiplier: number;
-        max_penalty: number;
-    };
-    rewards: {
-        success_base: number;
-        subagent_success: number;
-        tool_success_reward: number;
-        streak_bonus_threshold: number;
-        streak_bonus: number;
-        recovery_boost: number;
-        max_reward: number;
-    };
-    limits: {
-        stage_2_max_lines: number;
-        stage_3_max_lines: number;
-        stage_2_max_percentage: number;
-        stage_3_max_percentage: number;
-        min_lines_fallback: number;
-    };
-    history_limit?: number;
-}
 export interface DiagnosticianSettings {
     context: {
         time_window_minutes: number;
@@ -110,7 +75,6 @@ export interface PainSettings {
         initial_delay_ms: number;
         task_timeout_ms: number;
     };
-    trust: TrustSettings;
     deep_reflection?: DeepReflectionSettings;
     empathy_engine?: {
         enabled?: boolean;

package/dist/core/config.js

@@ -46,46 +46,6 @@ export const DEFAULT_SETTINGS = {
         initial_delay_ms: 5000,
         task_timeout_ms: 60 * 60 * 1000 // 1 hour, matching evolution-worker.ts default
     },
-    trust: {
-        stages: {
-            stage_1_observer: 30,
-            stage_2_editor: 60,
-            stage_3_developer: 80,
-        },
-        cold_start: {
-            // 🚀 The most important change: Start at 85 (Developer level)
-            // This allows the AI to perform medium-sized edits right out of the box
-            // without needing to beg for a PLAN.md on every single change.
-            initial_trust: 85,
-            grace_failures: 5, // Give the AI 5 free mistakes before deducting any trust points
-            cold_start_period_ms: 24 * 60 * 60 * 1000,
-        },
-        penalties: {
-            // 🛡️ Forgiving penalties for exploration
-            tool_failure_base: -2, // Was -8. A simple 'ls' typo shouldn't cost 8 points.
-            risky_failure_base: -10, // Was -15.
-            gate_bypass_attempt: -5,
-            failure_streak_multiplier: -2,
-            max_penalty: -20,
-        },
-        rewards: {
-            success_base: 2, // Was 1. Faster recovery
-            subagent_success: 5, // Was 3.
-            tool_success_reward: 0.2, // 👈 Minor reward for tool success, but resets streak!
-            streak_bonus_threshold: 3, // Was 5. Easier to get bonuses
-            streak_bonus: 5,
-            recovery_boost: 5, // Was 3. If trust drops low, it's easier to climb back up
-            max_reward: 15,
-        },
-        limits: {
-            stage_2_max_lines: 50, // Was 10. 10 lines is barely enough to fix a function signature.
-            stage_3_max_lines: 300, // Was 100. Allow substantial feature implementation.
-            stage_2_max_percentage: 10, // Percentage-based threshold for Stage 2
-            stage_3_max_percentage: 15, // Percentage-based threshold for Stage 3
-            min_lines_fallback: 20, // Minimum threshold even for small files
-        },
-        history_limit: 50
-    },
     deep_reflection: {
         enabled: true,
         mode: 'auto',
@@ -122,11 +82,12 @@ export const DEFAULT_SETTINGS = {
             large_change_block: 50, // 大规模修改警告阈值
         },
         large_change_lines: 50,
-        trust_stage_multipliers: {
-            '1': 0.5, // Observer: 更严格，阈值减半
-            '2': 0.75, // Editor: 阈值降低 25%
-            '3': 1.0, // Developer: 标准阈值
-            '4': 1.5, // Architect: 更宽松，阈值提高 50%
+        ep_tier_multipliers: {
+            '1': 0.5, // Seed: 更严格，阈值减半
+            '2': 0.75, // Sprout: 阈值降低 25%
+            '3': 1.0, // Sapling: 标准阈值
+            '4': 1.5, // Tree: 更宽松
+            '5': 2.0, // Forest: 最宽松
         },
         bash_safe_patterns: [
             '^(ls|dir|pwd|which|where|echo|env|cat|type|head|tail|less|more)\\b',
@@ -216,25 +177,9 @@ export class PainConfig {
      * Basic validation for critical settings
      */
     validate(settings) {
-        // Ensure trust scores stay within 0-100 logical range
-        const s = settings.trust.stages;
-        if (s.stage_1_observer < 0 || s.stage_1_observer > 100)
-            s.stage_1_observer = 30;
-        if (s.stage_2_editor < 0 || s.stage_2_editor > 100)
-            s.stage_2_editor = 60;
-        if (s.stage_3_developer < 0 || s.stage_3_developer > 100)
-            s.stage_3_developer = 80;
         // Ensure intervals are positive
         if (settings.intervals.worker_poll_ms < 1000)
             settings.intervals.worker_poll_ms = 15 * 60 * 1000;
-        // Ensure percentage limits are in valid range [0, 100]
-        const l = settings.trust.limits;
-        if (l.stage_2_max_percentage < 0 || l.stage_2_max_percentage > 100)
-            l.stage_2_max_percentage = 10;
-        if (l.stage_3_max_percentage < 0 || l.stage_3_max_percentage > 100)
-            l.stage_3_max_percentage = 15;
-        if (l.min_lines_fallback < 1)
-            l.min_lines_fallback = 20;
     }
     /**
      * Gets a value using dot notation (e.g. 'thresholds.pain_trigger')

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

@@ -1,3 +1,12 @@
+/**
+ * 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;
@@ -59,8 +68,26 @@ export declare class ControlUiDatabase {
     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;
     restoreRawText(inlineText?: string | null, blobRef?: string | null): string;
     private initSchema;

package/dist/core/control-ui-db.js

@@ -39,6 +39,12 @@ export class ControlUiDatabase {
             return Number(result.lastInsertRowid);
         });
     }
+    /**
+     * 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, beforeCreatedAt, limit = 5) {
         return {
             toolCalls: this.all(`
@@ -107,9 +113,21 @@ export class ControlUiDatabase {
             })),
         };
     }
+    /**
+     * 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(sql, ...params) {
         return this.db.prepare(sql).all(...params);
     }
+    /**
+     * 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(sql, ...params) {
         return this.db.prepare(sql).get(...params);
     }

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

@@ -1,4 +1,4 @@
-import type { EventLogEntry, DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, DeepReflectionEventData, TrustChangeEventData, EmpathyRollbackEventData } from '../types/event-types.js';
+import type { EventLogEntry, DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, DeepReflectionEventData, EmpathyRollbackEventData } from '../types/event-types.js';
 import type { PluginLogger } from '../openclaw-sdk.js';
 /**
  * EventLog - Structured event logging with daily statistics aggregation.
@@ -23,7 +23,6 @@ export declare class EventLog {
     recordPlanApproval(sessionId: string | undefined, data: PlanApprovalEventData): void;
     recordEvolutionTask(data: EvolutionTaskEventData): void;
     recordDeepReflection(sessionId: string | undefined, data: DeepReflectionEventData): void;
-    recordTrustChange(sessionId: string | undefined, data: TrustChangeEventData): 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;

package/dist/core/event-log.js

@@ -57,9 +57,6 @@ export class EventLog {
         const category = data.passed ? 'passed' : data.timeout ? 'failure' : 'completed';
         this.record('deep_reflection', category, sessionId, data);
     }
-    recordTrustChange(sessionId, data) {
-        this.record('trust_change', 'changed', sessionId, data);
-    }
     recordEmpathyRollback(sessionId, data) {
         this.record('empathy_rollback', 'rolled_back', sessionId, data);
     }

package/dist/core/evolution-engine.js

@@ -14,7 +14,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { resolvePdPath } from './paths.js';
 import { withLock } from '../utils/file-lock.js';
-import { CONSTRUCTIVE_TOOLS, CONTENT_LIMITED_TOOLS, EXPLORATORY_TOOLS, HIGH_RISK_TOOLS, } from '../constants/tools.js';
+import { CONSTRUCTIVE_TOOLS, EXPLORATORY_TOOLS, HIGH_RISK_TOOLS, } from '../constants/tools.js';
 import { EvolutionTier, DEFAULT_EVOLUTION_CONFIG, TIER_DEFINITIONS, TASK_DIFFICULTY_CONFIG, getTierDefinition, getTierByPoints, } from './evolution-types.js';
 // ===== 主引擎 =====
 export class EvolutionEngine {
@@ -137,26 +137,6 @@ export class EvolutionEngine {
     beforeToolCall(context) {
         const tierDef = this.getTierDefinition();
         const perms = tierDef.permissions;
-        // 行数检查（仅针对写操作工具）
-        if (CONTENT_LIMITED_TOOLS.has(context.toolName)) {
-            if (context.content) {
-                const lineCount = context.content.split('\n').length;
-                if (lineCount > perms.maxLinesPerWrite) {
-                    return {
-                        allowed: false,
-                        reason: `Tier ${this.scorecard.currentTier} (${tierDef.name}) 限制: 最多 ${perms.maxLinesPerWrite} 行，当前 ${lineCount} 行`,
-                        currentTier: this.scorecard.currentTier,
-                    };
-                }
-            }
-            if (context.lineCount && context.lineCount > perms.maxLinesPerWrite) {
-                return {
-                    allowed: false,
-                    reason: `Tier ${this.scorecard.currentTier} (${tierDef.name}) 限制: 最多 ${perms.maxLinesPerWrite} 行`,
-                    currentTier: this.scorecard.currentTier,
-                };
-            }
-        }
         // 风险路径检查
         if (context.isRiskPath && !perms.allowRiskPath) {
             return {

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

@@ -1,4 +1,4 @@
-import type { EvolutionLoopEvent, Principle } from './evolution-types.js';
+import type { EvolutionLoopEvent, Principle, PrincipleDetectorSpec, PrincipleEvaluatorLevel } from './evolution-types.js';
 export interface EvolutionReducer {
     emit(event: EvolutionLoopEvent): void;
     emitSync(event: EvolutionLoopEvent): void;
@@ -21,6 +21,10 @@ export interface EvolutionReducer {
         triggerPattern: string;
         action: string;
         source: string;
+        /** Evaluability level — defaults to 'manual_only' if omitted */
+        evaluability?: PrincipleEvaluatorLevel;
+        /** Detector metadata — absent or malformed = 'manual_only' evaluability */
+        detectorMetadata?: PrincipleDetectorSpec;
     }): string | null;
     getStats(): {
         candidateCount: number;
@@ -65,6 +69,8 @@ export declare class EvolutionReducerImpl implements EvolutionReducer {
         triggerPattern: string;
         action: string;
         source: string;
+        evaluability?: PrincipleEvaluatorLevel;
+        detectorMetadata?: PrincipleDetectorSpec;
     }): string | null;
     getStats(): {
         candidateCount: number;