principles-disciple 1.7.6 → 1.7.8

package/dist/commands/pain.js

@@ -88,11 +88,6 @@ export function handlePainCommand(ctx) {
         }
         return { text: isZh ? `❌ 无法识别当前会话。` : `❌ Session ID not found. Use /pd-status reset in a chat session.` };
     }
-    if (args === 'trust-reset') {
-        wctx.trust.resetTrust();
-        const newScore = wctx.trust.getScore();
-        return { text: isZh ? `✅ 智能体信任分已重置为初始值 (${newScore})。` : `✅ Agent trust score has been reset to initial value (${newScore}).` };
-    }
     if (args === 'data') {
         const stats = wctx.trajectory.getDataStats();
         return {
@@ -106,11 +101,7 @@ export function handlePainCommand(ctx) {
     const gfi = session ? session.currentGfi : 0;
     const dictionary = wctx.dictionary;
     const stats = dictionary.getStats();
-    const trust = wctx.trust;
-    const trustScore = trust.getScore();
-    const trustStage = trust.getStage();
     const gfiBar = createProgressBar(gfi, 100, 15);
-    const trustBar = createProgressBar(trustScore, 100, 15);
     // Determine Mental Mode (aligned with prompt.ts logic)
     let mentalMode = '';
     if (isZh) {
@@ -133,14 +124,13 @@ export function handlePainCommand(ctx) {
     let healthLabel = 'Healthy';
     let suggestionText = '';
     if (isZh) {
-        if (gfi > 80 || trustStage === 1) {
-            healthLabel = gfi > 80 ? '极度疲劳 🔴' : '信任破产 🔴';
+        if (gfi > 80) {
+            healthLabel = '极度疲劳 🔴';
             suggestionText = `
 💡 **建议 (系统检测到您当前遇到较大阻力)**:
    1. 执行 \`/pd-status reset\` 清零疲劳值。
-   2. 执行 \`/pd-status trust-reset\` 重置信任分。
-   3. 让 AI 调用 \`deep_reflect\` 工具进行深度反思。
-   4. 如果当前上下文太乱，考虑使用 \`/clear\` 开启新会话。`;
+   2. 让 AI 调用 \`deep_reflect\` 工具进行深度反思。
+   3. 如果当前上下文太乱，考虑使用 \`/clear\` 开启新会话。`;
         }
         else if (gfi > 50)
             healthLabel = '遇到阻力 🟡';
@@ -150,13 +140,12 @@ export function handlePainCommand(ctx) {
             healthLabel = '运转良好 🟢';
     }
     else {
-        if (gfi > 80 || trustStage === 1) {
-            healthLabel = gfi > 80 ? 'Critical 🔴' : 'Trust Bankruptcy 🔴';
+        if (gfi > 80) {
+            healthLabel = 'Critical 🔴';
             suggestionText = `
-💡 **Suggestion (High friction or low trust detected)**:
+💡 **Suggestion (High friction detected)**:
    1. Run \`/pd-status reset\` to clear friction.
-   2. Run \`/pd-status trust-reset\` to reset trust score.
-   3. Ask the AI to use the \`deep_reflect\` tool.
+   2. Ask the AI to use the \`deep_reflect\` tool.
    4. Consider starting a new session with \`/clear\`.`;
         }
         else if (gfi > 50)
@@ -178,7 +167,6 @@ export function handlePainCommand(ctx) {
         let text = `📊 **Principles Disciple - 系统健康度监控**\n`;
         text += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
         text += `💊 **当前疲劳指数 (GFI)**: ${gfiBar} ${gfi}/100\n`;
-        text += `💰 **当前信任积分 (Trust)**: ${trustBar} ${trustScore}/100 (Stage ${trustStage})\n`;
         text += `🧠 **当前心智模式**: ${mentalMode}\n`;
         text += `   ↳ 状态诊断: ${healthLabel}\n`;
         text += empathyInline;
@@ -197,7 +185,6 @@ export function handlePainCommand(ctx) {
         let text = `📊 **Principles Disciple - System Health Monitor**\n`;
         text += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
         text += `💊 **Current Friction (GFI)**: ${gfiBar} ${gfi}/100\n`;
-        text += `💰 **Current Trust Score**: ${trustBar} ${trustScore}/100 (Stage ${trustStage})\n`;
         text += `🧠 **Current Mental Mode**: ${mentalMode}\n`;
         text += `   ↳ Diagnosis: ${healthLabel}\n`;
         text += empathyInline;

package/dist/constants/tools.d.ts

@@ -1,11 +1,11 @@
-export declare const READ_ONLY_TOOL_NAMES: readonly ["read", "read_file", "read_many_files", "image_read", "search_file_content", "grep", "grep_search", "list_directory", "ls", "glob", "lsp_hover", "lsp_goto_definition", "lsp_find_references", "web_fetch", "web_search", "ref_search_documentation", "ref_read_url", "resolve-library-id", "get-library-docs", "memory_recall", "save_memory", "todo_read", "todo_write", "ask_user", "ask_user_question", "deep_reflect", "pd-status", "trust", "report"];
+export declare const READ_ONLY_TOOL_NAMES: readonly ["read", "read_file", "read_many_files", "image_read", "search_file_content", "grep", "grep_search", "list_directory", "ls", "glob", "lsp_hover", "lsp_goto_definition", "lsp_find_references", "web_fetch", "web_search", "ref_search_documentation", "ref_read_url", "resolve-library-id", "get-library-docs", "memory_recall", "save_memory", "todo_read", "todo_write", "ask_user", "ask_user_question", "deep_reflect", "pd-status", "report"];
 export declare const LOW_RISK_WRITE_TOOL_NAMES: readonly ["write", "write_file", "edit", "edit_file", "replace", "apply_patch", "insert", "patch"];
 export declare const BASH_TOOL_NAMES: readonly ["bash", "run_shell_command", "exec", "execute", "shell", "cmd"];
 export declare const HIGH_RISK_TOOL_NAMES: readonly ["delete_file", "move_file", "bash", "run_shell_command", "exec", "execute", "shell", "cmd"];
 export declare const AGENT_TOOL_NAMES: readonly ["sessions_spawn"];
 export declare const CONTENT_LIMITED_TOOL_NAMES: readonly ["write", "write_file", "edit", "edit_file", "replace", "apply_patch", "insert", "patch"];
 export declare const CONSTRUCTIVE_TOOL_NAMES: readonly ["write", "write_file", "edit", "edit_file", "replace", "apply_patch", "insert", "patch", "delete_file", "move_file", "bash", "run_shell_command", "exec", "execute", "shell", "cmd", "sessions_spawn", "evolve-task", "init-strategy"];
-export declare const EXPLORATORY_TOOL_NAMES: readonly ["read", "read_file", "read_many_files", "image_read", "search_file_content", "grep", "grep_search", "list_directory", "ls", "glob", "lsp_hover", "lsp_goto_definition", "lsp_find_references", "web_fetch", "web_search", "ref_search_documentation", "ref_read_url", "resolve-library-id", "get-library-docs", "memory_recall", "save_memory", "todo_read", "todo_write", "ask_user", "ask_user_question", "deep_reflect", "pd-status", "trust", "report"];
+export declare const EXPLORATORY_TOOL_NAMES: readonly ["read", "read_file", "read_many_files", "image_read", "search_file_content", "grep", "grep_search", "list_directory", "ls", "glob", "lsp_hover", "lsp_goto_definition", "lsp_find_references", "web_fetch", "web_search", "ref_search_documentation", "ref_read_url", "resolve-library-id", "get-library-docs", "memory_recall", "save_memory", "todo_read", "todo_write", "ask_user", "ask_user_question", "deep_reflect", "pd-status", "report"];
 export declare const READ_ONLY_TOOLS: Set<string>;
 export declare const LOW_RISK_WRITE_TOOLS: Set<string>;
 export declare const HIGH_RISK_TOOLS: Set<string>;

package/dist/constants/tools.js

@@ -7,7 +7,7 @@ export const READ_ONLY_TOOL_NAMES = [
     'memory_recall', 'save_memory', 'todo_read', 'todo_write',
     'ask_user', 'ask_user_question',
     'deep_reflect',
-    'pd-status', 'trust', 'report',
+    'pd-status', 'report',
 ];
 export const LOW_RISK_WRITE_TOOL_NAMES = [
     'write', 'write_file',

package/dist/core/adaptive-thresholds.d.ts

@@ -0,0 +1,186 @@
+/**
+ * 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
+ */
+/** File name for threshold state */
+export declare const THRESHOLD_STATE_FILE = "nocturnal-threshold-state.json";
+/** Default threshold values */
+export declare const DEFAULT_THRESHOLDS: {
+    /** Minimum score to pass arbiter validation */
+    readonly schemaCompletenessMin: 0.6;
+    /** Minimum principle alignment score */
+    readonly principleAlignmentMin: 0.7;
+    /** Minimum executability score */
+    readonly executabilityMin: 0.65;
+    /** Minimum boundedness score */
+    readonly boundednessMin: 0.5;
+    /** Minimum confidence/consistency score */
+    readonly confidenceMin: 0.6;
+    /** Minimum aggregate score to be tournament-eligible */
+    readonly aggregateMin: 0.65;
+};
+/** Minimum threshold value (safety bound) */
+export declare const THRESHOLD_MIN = 0;
+/** Maximum threshold value (safety bound) */
+export declare const THRESHOLD_MAX = 1;
+/** Maximum adjustment per update (bounded step size) */
+export declare const MAX_ADJUSTMENT_PER_STEP = 0.05;
+/** Minimum adjustment to trigger a change */
+export declare const MIN_ADJUSTMENT_TO_RECORD = 0.01;
+/**
+ * All threshold names that can be adaptively adjusted.
+ */
+export type ThresholdName = keyof typeof DEFAULT_THRESHOLDS;
+/**
+ * Current threshold values.
+ */
+export interface ThresholdValues {
+    schemaCompletenessMin: number;
+    principleAlignmentMin: number;
+    executabilityMin: number;
+    boundednessMin: number;
+    confidenceMin: number;
+    aggregateMin: number;
+}
+/**
+ * Threshold state for one threshold.
+ */
+export interface ThresholdState {
+    /** Current value */
+    currentValue: number;
+    /** Minimum bound */
+    minValue: number;
+    /** Maximum bound */
+    maxValue: number;
+    /** Last updated timestamp (ISO string) */
+    lastUpdatedAt: string;
+    /** Reason for last adjustment */
+    adjustmentReason?: string;
+    /** Number of adjustments made */
+    adjustmentCount: number;
+}
+/**
+ * Complete threshold state persisted to disk.
+ */
+export interface ThresholdPersistenceState {
+    /** Individual threshold states */
+    thresholds: Record<ThresholdName, ThresholdState>;
+    /** When the state was last updated (any threshold) */
+    lastUpdatedAt: string;
+    /** Version for migration support */
+    version: number;
+}
+/**
+ * Observable signals used to adjust thresholds.
+ */
+export interface ThresholdSignals {
+    /** Rate of malformed outputs (0-1) */
+    malformedRate: number;
+    /** Rate of arbiter rejections (0-1) */
+    arbiterRejectRate: number;
+    /** Rate of executability rejections (0-1) */
+    executabilityRejectRate: number;
+    /** Quality delta from reviewed subset comparison (positive = improvement) */
+    qualityDelta: number;
+}
+/**
+ * Result of loading threshold state.
+ */
+export interface LoadThresholdResult {
+    /** Whether loading succeeded */
+    success: boolean;
+    /** Current threshold values */
+    thresholds: ThresholdValues;
+    /** Whether fallback to defaults was used */
+    usedDefaults: boolean;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Result of updating a threshold.
+ */
+export interface UpdateThresholdResult {
+    /** Whether update succeeded */
+    success: boolean;
+    /** The updated threshold values */
+    thresholds: ThresholdValues;
+    /** Whether a change actually occurred */
+    changed: boolean;
+    /** The name of the changed threshold */
+    changedThreshold?: ThresholdName;
+    /** The old value */
+    oldValue?: number;
+    /** The new value */
+    newValue?: number;
+    /** Reason for the change */
+    reason?: string;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Load threshold values with fallback to defaults on corruption.
+ *
+ * @param stateDir - State directory
+ * @returns LoadThresholdResult with current values and status
+ */
+export declare function loadThresholdState(stateDir: string): LoadThresholdResult;
+/**
+ * Get effective threshold values (alias for loadThresholdState).
+ *
+ * @param stateDir - State directory
+ * @returns Current threshold values
+ */
+export declare function getEffectiveThresholds(stateDir: string): ThresholdValues;
+/**
+ * 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 declare function updateThresholdState(stateDir: string, thresholdName: ThresholdName, newValue: number, reason: string): UpdateThresholdResult;
+/**
+ * Reset all thresholds to defaults.
+ *
+ * @param stateDir - State directory
+ */
+export declare function resetThresholdState(stateDir: string): void;
+/**
+ * Get detailed threshold state for debugging/inspection.
+ *
+ * @param stateDir - State directory
+ * @returns Detailed threshold state or null if corrupted
+ */
+export declare function getDetailedThresholdState(stateDir: string): ThresholdPersistenceState | null;
+/**
+ * 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 declare function adjustThresholdsFromSignals(stateDir: string, signals: ThresholdSignals): UpdateThresholdResult;

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;