/**
 * Trust Score Accumulation System
 *
 * Builds trust gradients from gate outcomes over time. Sits alongside the
 * CoherenceScheduler (coherence.ts) but tracks a separate dimension:
 * accumulated trust from successful/failed gate evaluations.
 *
 * TrustAccumulator:
 * - Maintains a running trust score per agent (0.0 to 1.0)
 * - Accumulates trust from gate outcomes (allow, deny, warn)
 * - Applies exponential decay toward the initial value when idle
 * - Maps trust scores to privilege tiers (trusted, standard, probation, untrusted)
 *
 * TrustLedger:
 * - Records every trust score change with full context
 * - Supports export/import for persistence
 * - Querying by agent or threshold
 *
 * Trust-based rate limiting:
 * - Adjusts rate limits proportionally to accumulated trust
 *
 * @module @claude-flow/guidance/trust
 */
// ============================================================================
// Default Configuration
// ============================================================================
const DEFAULT_TRUST_CONFIG = {
    initialTrust: 0.5,
    allowDelta: 0.01,
    denyDelta: -0.05,
    warnDelta: -0.02,
    decayRate: 0.01,
    decayIntervalMs: 60_000, // 1 minute
};
// ============================================================================
// Trust Tier Thresholds
// ============================================================================
const TIER_THRESHOLDS = {
    trusted: 0.8,
    standard: 0.5,
    probation: 0.3,
};
// ============================================================================
// Rate Limit Multipliers
// ============================================================================
const RATE_LIMIT_MULTIPLIERS = {
    trusted: 2.0,
    standard: 1.0,
    probation: 0.5,
    untrusted: 0.1,
};
// ============================================================================
// Trust Accumulator
// ============================================================================
/**
 * Maintains running trust scores per agent, accumulates trust from gate
 * outcomes, applies time-based exponential decay, and maps scores to
 * privilege tiers.
 */
export class TrustAccumulator {
    config;
    agents = new Map();
    constructor(config = {}) {
        this.config = { ...DEFAULT_TRUST_CONFIG, ...config };
    }
    /**
     * Record a gate outcome for an agent, adjusting their trust score.
     *
     * - 'allow' increases trust by `allowDelta`
     * - 'deny' decreases trust by `denyDelta` (negative value)
     * - 'warn' decreases trust by `warnDelta` (negative value)
     *
     * Before applying the delta, exponential decay is applied if enough
     * time has elapsed since the last update.
     *
     * Returns the trust record describing the change.
     */
    recordOutcome(agentId, outcome, reason) {
        const state = this.getOrCreateState(agentId);
        const now = Date.now();
        // Apply decay before the outcome delta
        this.applyDecay(state, now);
        const previousScore = state.score;
        // Determine delta from outcome
        let delta;
        switch (outcome) {
            case 'allow':
                delta = this.config.allowDelta;
                break;
            case 'deny':
                delta = this.config.denyDelta;
                break;
            case 'warn':
                delta = this.config.warnDelta;
                break;
        }
        // Apply delta and clamp to [0, 1]
        state.score = clamp(state.score + delta, 0, 1);
        state.totalEvents++;
        state.lastUpdated = now;
        return {
            agentId,
            previousScore,
            newScore: state.score,
            delta,
            reason,
            timestamp: now,
            gateDecision: outcome,
        };
    }
    /**
     * Get the current trust score for an agent.
     * Returns the configured initial trust if the agent is unknown.
     */
    getScore(agentId) {
        const state = this.agents.get(agentId);
        if (!state)
            return this.config.initialTrust;
        // Apply decay before reading (non-mutating copy for read)
        const now = Date.now();
        const elapsed = now - state.lastUpdated;
        if (elapsed >= this.config.decayIntervalMs) {
            this.applyDecay(state, now);
        }
        return state.score;
    }
    /**
     * Determine the privilege tier for an agent based on their trust score.
     *
     * - >= 0.8: 'trusted' (expanded privileges, higher rate limits)
     * - >= 0.5: 'standard' (normal operation)
     * - >= 0.3: 'probation' (restricted tools, lower rate limits)
     * - < 0.3: 'untrusted' (read-only, must earn trust back)
     */
    getTier(agentId) {
        const score = this.getScore(agentId);
        return scoreToTier(score);
    }
    /**
     * Get a full snapshot of an agent's trust state.
     */
    getSnapshot(agentId) {
        const score = this.getScore(agentId);
        const state = this.agents.get(agentId);
        return {
            agentId,
            score,
            tier: scoreToTier(score),
            totalEvents: state?.totalEvents ?? 0,
            lastUpdated: state?.lastUpdated ?? 0,
        };
    }
    /**
     * Get snapshots for all tracked agents.
     */
    getAllSnapshots() {
        const snapshots = [];
        for (const agentId of this.agents.keys()) {
            snapshots.push(this.getSnapshot(agentId));
        }
        return snapshots;
    }
    /**
     * Get a trust-adjusted rate limit for an agent.
     *
     * Multipliers by tier:
     * - trusted: 2x base limit
     * - standard: 1x base limit
     * - probation: 0.5x base limit
     * - untrusted: 0.1x base limit
     */
    getTrustBasedRateLimit(agentId, baseLimit) {
        const tier = this.getTier(agentId);
        return Math.floor(baseLimit * RATE_LIMIT_MULTIPLIERS[tier]);
    }
    /**
     * Manually set an agent's trust score (e.g., from persistence restore).
     * Clamps to [0, 1].
     */
    setScore(agentId, score) {
        const state = this.getOrCreateState(agentId);
        state.score = clamp(score, 0, 1);
        state.lastUpdated = Date.now();
    }
    /**
     * Remove an agent from tracking entirely.
     */
    removeAgent(agentId) {
        return this.agents.delete(agentId);
    }
    /**
     * Get the number of tracked agents.
     */
    get agentCount() {
        return this.agents.size;
    }
    /**
     * Get all tracked agent IDs.
     */
    getAgentIds() {
        return [...this.agents.keys()];
    }
    /**
     * Get the current configuration.
     */
    getConfig() {
        return { ...this.config };
    }
    /**
     * Reset all tracked agents.
     */
    clear() {
        this.agents.clear();
    }
    // ===== Private =====
    getOrCreateState(agentId) {
        let state = this.agents.get(agentId);
        if (!state) {
            state = {
                score: this.config.initialTrust,
                totalEvents: 0,
                lastUpdated: Date.now(),
            };
            this.agents.set(agentId, state);
        }
        return state;
    }
    /**
     * Apply exponential decay toward the initial trust value.
     *
     * The decay formula moves the score toward `initialTrust` by a fraction
     * proportional to the number of decay intervals elapsed:
     *
     *   score = score + (initialTrust - score) * (1 - (1 - decayRate)^intervals)
     *
     * This ensures idle agents gradually return to the baseline.
     */
    applyDecay(state, now) {
        const elapsed = now - state.lastUpdated;
        if (elapsed < this.config.decayIntervalMs)
            return;
        const intervals = Math.floor(elapsed / this.config.decayIntervalMs);
        if (intervals <= 0)
            return;
        const retainFactor = Math.pow(1 - this.config.decayRate, intervals);
        const target = this.config.initialTrust;
        // Exponential interpolation toward target
        state.score = target + (state.score - target) * retainFactor;
        state.lastUpdated = now;
    }
}
// ============================================================================
// Trust Ledger
// ============================================================================
/**
 * Records all trust score changes with full context. Supports persistence
 * via export/import and querying by agent or threshold.
 */
export class TrustLedger {
    records = [];
    static MAX_RECORDS = 10_000;
    /**
     * Append a trust record to the ledger.
     */
    record(entry) {
        this.records.push(entry);
        // Evict oldest records when the ledger exceeds capacity
        if (this.records.length > TrustLedger.MAX_RECORDS) {
            this.records = this.records.slice(-TrustLedger.MAX_RECORDS);
        }
    }
    /**
     * Get the full trust history for a specific agent, ordered chronologically.
     */
    getHistoryForAgent(agentId) {
        return this.records.filter(r => r.agentId === agentId);
    }
    /**
     * Get all agents whose most recent score is below the given threshold.
     * Returns one record per agent (the most recent).
     */
    getAgentsBelowThreshold(threshold) {
        const latestByAgent = new Map();
        for (const record of this.records) {
            const existing = latestByAgent.get(record.agentId);
            if (!existing || record.timestamp > existing.timestamp) {
                latestByAgent.set(record.agentId, record);
            }
        }
        const result = [];
        for (const record of latestByAgent.values()) {
            if (record.newScore < threshold) {
                result.push(record);
            }
        }
        return result;
    }
    /**
     * Get all agents whose most recent score is at or above the given threshold.
     * Returns one record per agent (the most recent).
     */
    getAgentsAboveThreshold(threshold) {
        const latestByAgent = new Map();
        for (const record of this.records) {
            const existing = latestByAgent.get(record.agentId);
            if (!existing || record.timestamp > existing.timestamp) {
                latestByAgent.set(record.agentId, record);
            }
        }
        const result = [];
        for (const record of latestByAgent.values()) {
            if (record.newScore >= threshold) {
                result.push(record);
            }
        }
        return result;
    }
    /**
     * Get records within a time range.
     */
    getRecordsInRange(startMs, endMs) {
        return this.records.filter(r => r.timestamp >= startMs && r.timestamp <= endMs);
    }
    /**
     * Get the most recent N records.
     */
    getRecentRecords(count) {
        return this.records.slice(-count);
    }
    /**
     * Get the total number of records.
     */
    get recordCount() {
        return this.records.length;
    }
    /**
     * Export all records for persistence.
     */
    exportRecords() {
        return [...this.records];
    }
    /**
     * Import records from persistence. Appends to existing records.
     */
    importRecords(records) {
        this.records.push(...records);
        // Re-enforce capacity limit after import
        if (this.records.length > TrustLedger.MAX_RECORDS) {
            this.records = this.records.slice(-TrustLedger.MAX_RECORDS);
        }
    }
    /**
     * Clear all records.
     */
    clear() {
        this.records = [];
    }
}
// ============================================================================
// Integrated Trust System
// ============================================================================
/**
 * Combines TrustAccumulator and TrustLedger into a single coordinated
 * system. Gate outcomes are accumulated and automatically logged.
 */
export class TrustSystem {
    accumulator;
    ledger;
    constructor(config = {}) {
        this.accumulator = new TrustAccumulator(config);
        this.ledger = new TrustLedger();
    }
    /**
     * Record a gate outcome, update the accumulator, and log to the ledger.
     */
    recordOutcome(agentId, outcome, reason) {
        const record = this.accumulator.recordOutcome(agentId, outcome, reason);
        this.ledger.record(record);
        return record;
    }
    /**
     * Get the current trust score for an agent.
     */
    getScore(agentId) {
        return this.accumulator.getScore(agentId);
    }
    /**
     * Get the current privilege tier for an agent.
     */
    getTier(agentId) {
        return this.accumulator.getTier(agentId);
    }
    /**
     * Get a trust-adjusted rate limit for an agent.
     */
    getTrustBasedRateLimit(agentId, baseLimit) {
        return this.accumulator.getTrustBasedRateLimit(agentId, baseLimit);
    }
    /**
     * Get a full snapshot of an agent's trust state.
     */
    getSnapshot(agentId) {
        return this.accumulator.getSnapshot(agentId);
    }
    /**
     * Get snapshots for all tracked agents.
     */
    getAllSnapshots() {
        return this.accumulator.getAllSnapshots();
    }
}
// ============================================================================
// Standalone Rate Limit Helper
// ============================================================================
/**
 * Compute a trust-adjusted rate limit from a score and base limit.
 *
 * This is a stateless utility for cases where you have a trust score
 * but no TrustAccumulator instance.
 *
 * Multipliers by tier:
 * - trusted (>= 0.8): 2x
 * - standard (>= 0.5): 1x
 * - probation (>= 0.3): 0.5x
 * - untrusted (< 0.3): 0.1x
 */
export function getTrustBasedRateLimit(score, baseLimit) {
    const tier = scoreToTier(score);
    return Math.floor(baseLimit * RATE_LIMIT_MULTIPLIERS[tier]);
}
// ============================================================================
// Factory Functions
// ============================================================================
/**
 * Create a TrustAccumulator with optional configuration.
 */
export function createTrustAccumulator(config) {
    return new TrustAccumulator(config);
}
/**
 * Create an empty TrustLedger.
 */
export function createTrustLedger() {
    return new TrustLedger();
}
/**
 * Create a coordinated TrustSystem (accumulator + ledger).
 */
export function createTrustSystem(config) {
    return new TrustSystem(config);
}
// ============================================================================
// Helpers
// ============================================================================
/**
 * Map a trust score to a privilege tier.
 */
function scoreToTier(score) {
    if (score >= TIER_THRESHOLDS.trusted)
        return 'trusted';
    if (score >= TIER_THRESHOLDS.standard)
        return 'standard';
    if (score >= TIER_THRESHOLDS.probation)
        return 'probation';
    return 'untrusted';
}
/**
 * Clamp a number to the range [min, max].
 */
function clamp(value, min, max) {
    return Math.min(max, Math.max(min, value));
}
//# sourceMappingURL=trust.js.map