@vorionsys/atsf-core 0.2.4 → 0.3.0

package/dist/trust-engine/index.d.ts

@@ -2,14 +2,17 @@
  * Trust Engine - Behavioral Trust Scoring
  *
  * Calculates and maintains trust scores for entities based on behavioral signals.
- * Features 8-tier trust system (T0-T7) with event emission for observability.
+ * Features 6-tier trust system with event emission for observability.
  *
  * @packageDocumentation
  */
 import { EventEmitter } from 'events';
 import type { TrustScore, TrustLevel, TrustSignal, TrustComponents, ID } from '../common/types.js';
 import type { PersistenceProvider } from '../persistence/types.js';
-import { initialFactorScores, type FactorCodeString } from '@vorionsys/basis';
+import type { TrustVerifier } from './trust-verifier.js';
+import type { ParameSphereEngine } from '../paramesphere/paramesphere-engine.js';
+import type { CognitiveEnvelope } from '../paramesphere/cognitive-envelope.js';
+import type { ActivationStats } from '../paramesphere/types.js';
 /**
  * Trust level thresholds (8 tiers T0-T7) - per BASIS specification
  */
@@ -21,20 +24,58 @@ export declare const TRUST_THRESHOLDS: Record<TrustLevel, {
  * Trust level names (8 tiers T0-T7) - per BASIS specification
  */
 export declare const TRUST_LEVEL_NAMES: Record<TrustLevel, string>;
-export declare const FACTOR_CODES: readonly ["CT-COMP", "CT-REL", "CT-OBS", "CT-TRANS", "CT-ACCT", "CT-SAFE", "CT-SEC", "CT-PRIV", "CT-ID", "OP-HUMAN", "OP-ALIGN", "OP-CONTEXT", "OP-STEW", "SF-HUM", "SF-ADAPT", "SF-LEARN"];
-export type FactorCode = FactorCodeString;
-export declare const FACTOR_WEIGHTS: Record<"CT-COMP" | "CT-REL" | "CT-OBS" | "CT-TRANS" | "CT-ACCT" | "CT-SAFE" | "CT-SEC" | "CT-PRIV" | "CT-ID" | "OP-HUMAN" | "OP-ALIGN" | "OP-CONTEXT" | "OP-STEW" | "SF-HUM" | "SF-ADAPT" | "SF-LEARN", number>;
-export declare const SIGNAL_PREFIX_TO_FACTORS: Record<string, ("CT-COMP" | "CT-REL" | "CT-OBS" | "CT-TRANS" | "CT-ACCT" | "CT-SAFE" | "CT-SEC" | "CT-PRIV" | "CT-ID" | "OP-HUMAN" | "OP-ALIGN" | "OP-CONTEXT" | "OP-STEW" | "SF-HUM" | "SF-ADAPT" | "SF-LEARN")[]>;
-export { initialFactorScores };
 /**
- * @deprecated Use FACTOR_WEIGHTS for 16-factor scoring. Kept for backwards compatibility.
  * Signal weights for score calculation
  */
 export declare const SIGNAL_WEIGHTS: Record<keyof TrustComponents, number>;
+/**
+ * Penalty ratio per BASIS specification: P(T) = 3 + T
+ *
+ * Negative signals have their EWA weight multiplied by (3 + currentTier),
+ * so higher-tier agents are punished MORE severely for failures.
+ *   T0 = 3×, T1 = 4×, T2 = 5×, T3 = 6×, T4 = 7×, T5 = 8×, T6 = 9×, T7 = 10×
+ *
+ * Only applies to negative signals (value < neutral 0.5). Positive signals
+ * are NOT amplified.
+ */
+export declare const PENALTY_RATIO_BASE = 3;
+/**
+ * Calculate the penalty weight multiplier for a given tier.
+ * P(T) = 3 + T
+ */
+export declare function penaltyMultiplier(tier: TrustLevel): number;
+/**
+ * 16-factor trust model — granular decomposition of the 4-dimension model.
+ * Each factor maps to one of the 4 TrustComponents dimensions.
+ */
+export declare const FACTOR_CODES: readonly ["CT-COMP", "CT-REL", "CT-OBS", "CT-TRANS", "CT-ACCT", "CT-SAFE", "CT-SEC", "CT-PRIV", "CT-ID", "OP-HUMAN", "OP-ALIGN", "OP-CONTEXT", "OP-STEW", "SF-HUM", "SF-ADAPT", "SF-LEARN"];
+export declare const FACTOR_WEIGHTS: Record<string, number>;
+/**
+ * Cached running-total state for a single component bucket (behavioral/compliance/identity/context).
+ * Used by the incremental scoring path to avoid O(n) recalculation on every signal.
+ */
+export interface CachedComponentState {
+    weightedSum: number;
+    totalWeight: number;
+    count: number;
+}
+/**
+ * Per-entity cached score state for incremental updates.
+ * Stores running weighted averages per component so that new signals
+ * can update the score in O(1) instead of recalculating from all signals.
+ */
+export interface CachedScoreState {
+    behavioral: CachedComponentState;
+    compliance: CachedComponentState;
+    identity: CachedComponentState;
+    context: CachedComponentState;
+    /** Total signal count at last full recalculation */
+    lastFullRecalcAt: number;
+}
 /**
  * Trust event types
  */
-export type TrustEventType = 'trust:initialized' | 'trust:signal_recorded' | 'trust:score_changed' | 'trust:tier_changed' | 'trust:decay_applied' | 'trust:recovery_applied' | 'trust:recovery_milestone';
+export type TrustEventType = 'trust:initialized' | 'trust:signal_recorded' | 'trust:signal_deduplicated' | 'trust:score_changed' | 'trust:tier_changed' | 'trust:readiness_adjusted' | 'trust:freshness_adjusted' | 'trust:decay_applied' | 'trust:failure_detected' | 'trust:recovery_applied' | 'trust:recovery_milestone' | 'trust:fingerprint_drift' | 'trust:envelope_breach' | 'trust:fingerprint_baseline_set';
 /**
  * Base trust event
  */
@@ -90,6 +131,38 @@ export interface TrustDecayAppliedEvent extends TrustEvent {
     newScore: TrustScore;
     decayAmount: number;
     stalenessMs: number;
+    accelerated: boolean;
+}
+/**
+ * Readiness Degree adjusted event (primary neutral terminology)
+ */
+export interface TrustReadinessAdjustedEvent extends TrustEvent {
+    type: 'trust:readiness_adjusted';
+    previousScore: TrustScore;
+    newScore: TrustScore;
+    adjustmentAmount: number;
+    stalenessMs: number;
+    accelerated: boolean;
+}
+/**
+ * Freshness adjustment event (neutral terminology alias for trust:decay_applied)
+ */
+export interface TrustFreshnessAdjustedEvent extends TrustEvent {
+    type: 'trust:freshness_adjusted';
+    previousScore: TrustScore;
+    newScore: TrustScore;
+    adjustmentAmount: number;
+    stalenessMs: number;
+    accelerated: boolean;
+}
+/**
+ * Failure detected event
+ */
+export interface TrustFailureDetectedEvent extends TrustEvent {
+    type: 'trust:failure_detected';
+    signal: TrustSignal;
+    failureCount: number;
+    acceleratedDecayActive: boolean;
 }
 /**
  * Recovery applied event
@@ -113,10 +186,68 @@ export interface TrustRecoveryMilestoneEvent extends TrustEvent {
     newScore: TrustScore;
     details: string;
 }
+/**
+ * Signal deduplication event — emitted when diminishing returns are applied
+ */
+export interface TrustSignalDeduplicatedEvent extends TrustEvent {
+    type: 'trust:signal_deduplicated';
+    signal: TrustSignal;
+    originalValue: number;
+    adjustedValue: number;
+    diminishingFactor: number;
+    repeatCount: number;
+}
+/**
+ * Fingerprint drift detected event
+ */
+export interface TrustFingerprintDriftEvent extends TrustEvent {
+    type: 'trust:fingerprint_drift';
+    similarity: number;
+    magnitude: number;
+    driftThreshold: number;
+}
+/**
+ * Cognitive envelope breach detected event
+ */
+export interface TrustEnvelopeBreachEvent extends TrustEvent {
+    type: 'trust:envelope_breach';
+    distance: number;
+    trustMultiplier: number;
+    breachCounter: number;
+}
+/**
+ * Fingerprint baseline set event
+ */
+export interface TrustFingerprintBaselineSetEvent extends TrustEvent {
+    type: 'trust:fingerprint_baseline_set';
+    fingerprintSha256: string;
+}
 /**
  * Union of all trust events
  */
-export type AnyTrustEvent = TrustInitializedEvent | TrustSignalRecordedEvent | TrustScoreChangedEvent | TrustTierChangedEvent | TrustDecayAppliedEvent | TrustRecoveryAppliedEvent | TrustRecoveryMilestoneEvent;
+export type AnyTrustEvent = TrustInitializedEvent | TrustSignalRecordedEvent | TrustSignalDeduplicatedEvent | TrustScoreChangedEvent | TrustTierChangedEvent | TrustReadinessAdjustedEvent | TrustFreshnessAdjustedEvent | TrustDecayAppliedEvent | TrustFailureDetectedEvent | TrustRecoveryAppliedEvent | TrustRecoveryMilestoneEvent | TrustFingerprintDriftEvent | TrustEnvelopeBreachEvent | TrustFingerprintBaselineSetEvent;
+/**
+ * Time-bound exception for Readiness Degree adjustments.
+ */
+export interface ReadinessException {
+    /** Human-readable reason for exception */
+    reason: string;
+    /** Exception issue timestamp */
+    issuedAt: string;
+    /** Exception expiration timestamp */
+    expiresAt: string;
+    /** 0..1 scale applied to scheduled reductions while exception is active (default: 1) */
+    reductionScale: number;
+}
+/**
+ * Canonical reason codes for time-bound readiness exceptions.
+ */
+export declare const READINESS_EXCEPTION_REASON_CODES: readonly ["approved_leave", "planned_maintenance", "telemetry_outage", "legal_hold", "incident_response", "dependency_outage"];
+export type ReadinessExceptionReasonCode = typeof READINESS_EXCEPTION_REASON_CODES[number];
+/**
+ * @deprecated Use ReadinessException.
+ */
+export type FreshnessException = ReadinessException;
 /**
  * Entity trust record
  */
@@ -124,19 +255,34 @@ export interface TrustRecord {
     entityId: ID;
     score: TrustScore;
     level: TrustLevel;
-    /** @deprecated Use factorScores instead */
     components: TrustComponents;
-    /** Per-factor scores (0.0 to 1.0) for each of the 16 trust factors */
-    factorScores: Record<string, number>;
     signals: TrustSignal[];
     lastCalculatedAt: string;
     history: TrustHistoryEntry[];
+    /** Recent failure timestamps for accelerated decay */
+    recentFailures: string[];
     /** Recent success timestamps for recovery */
     recentSuccesses: string[];
     /** Peak score achieved (for recovery milestone tracking) */
     peakScore: TrustScore;
     /** Consecutive successful signals count */
     consecutiveSuccesses: number;
+    /** Scheduled readiness checkpoint index */
+    readinessCheckpointIndex?: number;
+    /** Deferred multiplier accumulated during active exception windows */
+    deferredReadinessMultiplier?: number;
+    /** Optional active readiness exception */
+    readinessException?: ReadinessException;
+    /** Baseline score captured when readiness schedule starts */
+    readinessBaselineScore?: TrustScore;
+    /** @deprecated Use readinessCheckpointIndex */
+    freshnessCheckpointIndex?: number;
+    /** @deprecated Use deferredReadinessMultiplier */
+    deferredFreshnessMultiplier?: number;
+    /** @deprecated Use readinessException */
+    freshnessException?: FreshnessException;
+    /** @deprecated Use readinessBaselineScore */
+    freshnessBaselineScore?: TrustScore;
 }
 /**
  * Trust history entry
@@ -153,62 +299,55 @@ export interface TrustHistoryEntry {
 export interface TrustCalculation {
     score: TrustScore;
     level: TrustLevel;
-    /** @deprecated Use factorScores */
     components: TrustComponents;
-    /** Per-factor scores for all 16 trust factors */
-    factorScores: Record<string, number>;
     factors: string[];
 }
 /**
- * Human-readable explanation of a trust score.
- *
- * Returned by `TrustEngine.explainScore()` to provide full transparency
- * into how a score was computed. Every field is designed for audit logs,
- * dashboards, or end-user display.
+ * Factor breakdown entry in a trust explanation
+ */
+export interface TrustFactorBreakdown {
+    code: string;
+    weight: number;
+    rawScore: number;
+    contribution: number;
+}
+/**
+ * Trust score explanation returned by explainScore
  */
 export interface TrustExplanation {
-    /** Entity ID */
     entityId: ID;
-    /** Final trust score (0-1000) */
     score: TrustScore;
-    /** Trust level index (0-7) */
     level: TrustLevel;
-    /** Human-readable level name (e.g. "Trusted") */
     levelName: string;
-    /** Score range for the current level */
     levelRange: {
         min: number;
         max: number;
     };
-    /** Score needed to reach the next level (null if at T7) */
-    pointsToNextLevel: number | null;
-    /** Total number of signals ingested */
     signalCount: number;
-    /** Breakdown of each factor: code, weight, raw score, weighted contribution */
-    factorBreakdown: {
-        code: string;
-        weight: number;
-        rawScore: number;
-        /** Contribution = rawScore * weight * 1000 (portion of final score) */
-        contribution: number;
-    }[];
-    /** Top factors contributing positively (sorted by contribution desc) */
-    topPositiveFactors: string[];
-    /** Top factors dragging score down (sorted by contribution asc) */
-    topNegativeFactors: string[];
-    /** Decay multiplier currently applied (1.0 = no decay) */
-    decayMultiplier: number;
-    /** Days since last signal */
+    factorBreakdown: TrustFactorBreakdown[];
     daysSinceLastSignal: number | null;
-    /** ISO timestamp of explanation generation */
+    decayMultiplier: number;
+    pointsToNextLevel: number | null;
     generatedAt: string;
 }
 /**
  * Trust Engine configuration
  */
 export interface TrustEngineConfig {
-    /** How often to check for and apply decay, in milliseconds (default: 60000 = 1 minute) */
+    /** Base decay rate per interval (default: 0.01 = 1%) */
+    decayRate?: number;
+    /** Decay interval in milliseconds (default: 60000 = 1 minute) */
+    decayIntervalMs?: number;
+    /** Alias for decayIntervalMs — decay check interval in milliseconds */
     decayCheckIntervalMs?: number;
+    /** Signal value threshold below which a signal is considered a failure (default: 0.3) */
+    failureThreshold?: number;
+    /** Multiplier applied to decay rate when entity has recent failures (default: 1.0) */
+    acceleratedDecayMultiplier?: number;
+    /** Time window in ms to consider failures as "recent" (default: 3600000 = 1 hour) */
+    failureWindowMs?: number;
+    /** Minimum failures within window to trigger accelerated decay (default: 2) */
+    minFailuresForAcceleration?: number;
     /** Persistence provider for storing trust records */
     persistence?: PersistenceProvider;
     /** Auto-persist changes (default: true when persistence is provided) */
@@ -231,13 +370,54 @@ export interface TrustEngineConfig {
     maxTotalListeners?: number;
     /** Warn when listener count exceeds this percentage of max (default: 0.8 = 80%) */
     listenerWarningThreshold?: number;
+    /** Freshness adjustment mode (default: checkpoint_schedule) */
+    freshnessMode?: 'legacy_interval' | 'checkpoint_schedule';
+    /** Absolute day checkpoints since last trust-relevant action */
+    freshnessCheckpointDays?: number[];
+    /** Reduction percentages per checkpoint (0..1) */
+    freshnessCheckpointReductions?: number[];
+    /** Readiness Degree adjustment mode (preferred name) */
+    readinessMode?: 'legacy_interval' | 'checkpoint_schedule';
+    /** Readiness Degree checkpoint days (preferred name) */
+    readinessCheckpointDays?: number[];
+    /** Readiness Degree checkpoint reductions (preferred name) */
+    readinessCheckpointReductions?: number[];
+    /** Allowed readiness exception reason codes (default: READINESS_EXCEPTION_REASON_CODES) */
+    readinessExceptionAllowedReasons?: ReadinessExceptionReasonCode[];
+    /** Maximum readiness exception duration in ms (default: 30 days) */
+    readinessExceptionMaxDurationMs?: number;
+    /** @deprecated Use readinessExceptionAllowedReasons */
+    freshnessExceptionAllowedReasons?: ReadinessExceptionReasonCode[];
+    /** @deprecated Use readinessExceptionMaxDurationMs */
+    freshnessExceptionMaxDurationMs?: number;
+    /** Enable signal deduplication / diminishing returns (default: true) */
+    signalDedupEnabled?: boolean;
+    /** Diminishing factor applied per consecutive repeat of the same signal type (default: 0.5 — halving) */
+    signalDedupDecayFactor?: number;
+    /** Sliding window size: max recent signals to track per entity for dedup (default: 10) */
+    signalDedupWindowSize?: number;
+    /** Time window in ms after which dedup counters reset for a signal type (default: 3600000 = 1 hour) */
+    signalDedupWindowMs?: number;
+    /** Minimum diminishing factor floor — repeated signals never go below this (default: 0.0625 = 1/16) */
+    signalDedupMinFactor?: number;
+    /** Optional ParameSphere SVD fingerprinting engine for internal-state monitoring */
+    paramesphere?: ParameSphereEngine;
+    /** Optional Cognitive Envelope for breach detection */
+    cognitiveEnvelope?: CognitiveEnvelope;
+    /** Optional TrustVerifier for cryptographic state commitment after every score change */
+    verifier?: TrustVerifier;
 }
 /**
  * Trust Engine service with event emission and subscription limits
  */
 export declare class TrustEngine extends EventEmitter {
     private records;
-    private _decayCheckIntervalMs;
+    private _decayRate;
+    private _decayIntervalMs;
+    private _failureThreshold;
+    private _acceleratedDecayMultiplier;
+    private _failureWindowMs;
+    private _minFailuresForAcceleration;
     private _persistence?;
     private _autoPersist;
     private _successThreshold;
@@ -251,7 +431,39 @@ export declare class TrustEngine extends EventEmitter {
     private _listenerWarningThreshold;
     private _listenerCounts;
     private _totalListeners;
+    private _readinessMode;
+    private _readinessCheckpointDays;
+    private _readinessCheckpointReductions;
+    private _allowedReadinessExceptionReasons;
+    private _readinessExceptionMaxDurationMs;
+    private _signalDedupEnabled;
+    private _signalDedupDecayFactor;
+    private _signalDedupWindowSize;
+    private _signalDedupWindowMs;
+    private _signalDedupMinFactor;
+    /**
+     * Per-entity dedup tracker. Each entry holds recent signal type records
+     * used to compute diminishing returns for repeated identical signal types.
+     */
+    private _dedupState;
+    private _scoreCache;
+    /** Number of signals between forced full recalculations for drift correction */
+    private static readonly INCREMENTAL_RECALC_INTERVAL;
+    private _paramesphere?;
+    private _cognitiveEnvelope?;
+    private _fingerprintBaselines;
+    private _verifier?;
     constructor(config?: TrustEngineConfig);
+    /** Decay check interval in milliseconds */
+    get decayCheckIntervalMs(): number;
+    private validateReadinessExceptionOptions;
+    private getCheckpointIntervalMs;
+    private ensureReadinessState;
+    private isUsingDefaultReadinessSchedule;
+    private isReadinessExceptionActive;
+    private applyDeferredReadinessCatchupIfExpired;
+    private applyScheduledReadinessAdjustment;
+    private emitReadinessAdjustmentEvents;
     /**
      * Add event listener with subscription limits
      * @throws Error if listener limits are exceeded
@@ -295,9 +507,21 @@ export declare class TrustEngine extends EventEmitter {
         maxListenersPerEvent: number;
     };
     /**
-     * Get the decay check interval in milliseconds
+     * Get the current decay rate
      */
-    get decayCheckIntervalMs(): number;
+    get decayRate(): number;
+    /**
+     * Get the decay interval in milliseconds
+     */
+    get decayIntervalMs(): number;
+    /**
+     * Get the failure threshold
+     */
+    get failureThreshold(): number;
+    /**
+     * Get the accelerated decay multiplier
+     */
+    get acceleratedDecayMultiplier(): number;
     /**
      * Get the persistence provider
      */
@@ -326,6 +550,29 @@ export declare class TrustEngine extends EventEmitter {
      * Persist a single record if auto-persist is enabled
      */
     private autoPersistRecord;
+    /**
+     * Check an entity's model fingerprint for drift.
+     * If drift exceeds threshold, automatically records a negative trust signal.
+     * Returns the drift result.
+     */
+    checkFingerprint(entityId: string, weights: Float32Array[], activations?: ActivationStats[]): Promise<{
+        drifted: boolean;
+        similarity: number;
+        magnitude: number;
+    } | null>;
+    /**
+     * Set or update the fingerprint baseline for an entity.
+     * Call after initial model load or after a verified safe update.
+     */
+    setFingerprintBaseline(entityId: string, weights: Float32Array[], activations?: ActivationStats[]): Promise<void>;
+    /**
+     * Check if entity behavioral signals are within cognitive envelope bounds.
+     * If breach detected, records a negative trust signal with multiplier.
+     */
+    checkCognitiveEnvelope(entityId: string, observation: number[]): Promise<{
+        breached: boolean;
+        distance?: number;
+    } | null>;
     /**
      * Close the trust engine and persistence provider
      */
@@ -338,6 +585,14 @@ export declare class TrustEngine extends EventEmitter {
      * Calculate trust score for an entity
      */
     calculate(entityId: ID): Promise<TrustCalculation>;
+    /**
+     * Check if an entity has accelerated decay active
+     */
+    private hasAcceleratedDecay;
+    /**
+     * Clean up old failure timestamps outside the window
+     */
+    private cleanupFailures;
     /**
      * Clean up old success timestamps outside the window
      */
@@ -358,22 +613,18 @@ export declare class TrustEngine extends EventEmitter {
      * Get trust score for an entity (with automatic decay)
      */
     getScore(entityId: ID): Promise<TrustRecord | undefined>;
-    /**
-     * Validate a trust signal before ingestion.
-     * Rejects NaN, Infinity, out-of-range values, and missing required fields.
-     *
-     * @throws Error on invalid signal
-     */
-    private validateSignal;
     /**
      * Record a trust signal
-     * @throws Error if signal is invalid (NaN, out of range, missing fields)
      */
     recordSignal(signal: TrustSignal): Promise<void>;
     /**
      * Initialize trust for a new entity
      */
     initializeEntity(entityId: ID, initialLevel?: TrustLevel): Promise<TrustRecord>;
+    /**
+     * Explain a trust score with full factor breakdown
+     */
+    explainScore(entityId: ID): Promise<TrustExplanation>;
     /**
      * Get all entity IDs
      */
@@ -382,53 +633,130 @@ export declare class TrustEngine extends EventEmitter {
      * Get trust level name
      */
     getLevelName(level: TrustLevel): string;
-    /**
-     * Generate a human-readable explanation of an entity's current trust score.
-     *
-     * Provides full transparency into how the score was computed, including
-     * per-factor contributions, decay status, and what's needed to advance.
-     *
-     * @example
-     * ```ts
-     * const explanation = await engine.explainScore('agent-123');
-     * console.log(`Score: ${explanation.score} (${explanation.levelName})`);
-     * console.log(`Top factor: ${explanation.topPositiveFactors[0]}`);
-     * console.log(`Points to next tier: ${explanation.pointsToNextLevel}`);
-     * ```
-     */
-    explainScore(entityId: ID): Promise<TrustExplanation>;
     /**
      * Convert score to trust level
      */
     private scoreToLevel;
     /**
-     * @deprecated Use calculateFactorScores for 16-factor model. Kept for backwards compatibility.
      * Calculate component scores from signals
      */
     private calculateComponents;
     /**
-     * Calculate per-factor scores from signals.
-     * Signals can use either:
-     *   - Factor code prefix (e.g. 'CT-COMP.success')
-     *   - Legacy bucket prefix (e.g. 'behavioral.success') — mapped to factors via SIGNAL_PREFIX_TO_FACTORS
+     * Calculate average signal value with default.
+     *
+     * Applies the BASIS penalty ratio P(T) = 3 + T to negative signals:
+     * negative signal weights are multiplied by (3 + currentTier) so that
+     * higher-tier agents suffer proportionally larger score drops from failures.
+     */
+    private averageSignalValue;
+    /**
+     * Human/manual positive approvals carry less upward impact at higher tiers.
      */
-    private calculateFactorScores;
+    private adjustSignalValueForTier;
+    private isHumanApprovalSignal;
+    private getHumanApprovalAssistFactor;
     /**
-     * Calculate average signal value with default
+     * Resolve which component bucket a signal type belongs to.
+     * Returns the component key or undefined if the signal type is unrecognized.
      */
-    private averageSignalValue;
+    private resolveSignalComponent;
+    /**
+     * Create a fresh empty CachedScoreState.
+     */
+    private createEmptyCacheState;
+    /**
+     * Build the score cache from a full recalculation of all stored signals.
+     * This mirrors the logic in averageSignalValue but captures the running totals.
+     */
+    private buildCacheFromSignals;
+    /**
+     * Incrementally update the cached score state with a single new signal.
+     * Returns the updated TrustCalculation. This is O(1) per signal.
+     */
+    private incrementalUpdate;
+    /**
+     * Invalidate the incremental score cache for an entity,
+     * forcing the next recordSignal to do a full recalculation.
+     */
+    invalidateScoreCache(entityId?: ID): void;
     /**
      * Get significant factors affecting the score
      */
     private getSignificantFactors;
+    /**
+     * Apply signal deduplication with diminishing returns.
+     *
+     * Tracks recent signal types per entity within a sliding window. When the same
+     * signal type appears consecutively (within the window), its effective value is
+     * pulled toward 0.5 (neutral) by an exponentially decaying factor. This prevents
+     * replay attacks from inflating or deflating trust scores while still allowing
+     * legitimate repeated signals to have some (diminished) impact.
+     *
+     * The adjustment formula moves the value toward 0.5 (the neutral baseline):
+     *   adjustedValue = 0.5 + (originalValue - 0.5) * factor
+     *
+     * This means:
+     * - Positive signals (value > 0.5) have their positive impact reduced
+     * - Negative signals (value < 0.5) have their negative impact reduced
+     * - A value of exactly 0.5 is never adjusted
+     */
+    private applySignalDedup;
+    /**
+     * Check whether signal deduplication is enabled
+     */
+    get signalDedupEnabled(): boolean;
+    /**
+     * Clear dedup state for an entity (useful for testing or resets)
+     */
+    clearDedupState(entityId?: ID): void;
     /**
      * Create initial trust record
      */
     private createInitialRecord;
+    /**
+     * Configure a time-bound Readiness Degree exception for an entity.
+     */
+    setReadinessException(entityId: ID, options: {
+        reason: ReadinessExceptionReasonCode;
+        expiresAt: string;
+        reductionScale?: number;
+    }): void;
+    /**
+     * @deprecated Use setReadinessException.
+     */
+    setFreshnessException(entityId: ID, options: {
+        reason: ReadinessExceptionReasonCode;
+        expiresAt: string;
+        reductionScale?: number;
+    }): void;
+    /**
+     * Clear Readiness Degree exception for an entity.
+     */
+    clearReadinessException(entityId: ID): void;
+    /**
+     * @deprecated Use clearReadinessException.
+     */
+    clearFreshnessException(entityId: ID): void;
+    /**
+     * Get active Readiness Degree exception for an entity.
+     */
+    getReadinessException(entityId: ID): ReadinessException | undefined;
+    /**
+     * @deprecated Use getReadinessException.
+     */
+    getFreshnessException(entityId: ID): FreshnessException | undefined;
+    /**
+     * Check if accelerated decay is currently active for an entity
+     */
+    isAcceleratedDecayActive(entityId: ID): boolean;
     /**
      * Check if accelerated recovery is currently active for an entity
      */
     isAcceleratedRecoveryActive(entityId: ID): boolean;
+    /**
+     * Get current failure count for an entity
+     */
+    getFailureCount(entityId: ID): number;
     /**
      * Get consecutive success count for an entity
      */
@@ -437,6 +765,16 @@ export declare class TrustEngine extends EventEmitter {
      * Get peak score for an entity
      */
     getPeakScore(entityId: ID): TrustScore;
+    /**
+     * Verify an entity's trust score against its verifier commitment chain.
+     * Requires a TrustVerifier to be configured; throws if none is set.
+     */
+    verifyEntity(entityId: ID): import("./trust-verifier.js").TrustVerificationResult;
+    /**
+     * Verify all tracked entities against the verifier commitment chain.
+     * Requires a TrustVerifier to be configured; throws if none is set.
+     */
+    verifyAll(): Map<string, import("./trust-verifier.js").TrustVerificationResult>;
 }
 /**
  * Create a new Trust Engine instance