principles-disciple 1.8.1 → 1.8.2

package/dist/core/nocturnal-trajectory-extractor.js

@@ -1,307 +0,0 @@
-/**
- * Nocturnal Trajectory Extractor — Structured Session Snapshot API
- * ==============================================================
- *
- * PURPOSE: Provide minimal necessary structured trajectory extraction
- * for the nocturnal reflection pipeline. NOT a general-purpose data mirror.
- *
- * DESIGN PRINCIPLES:
- * - Uses sanitized text ONLY — never raw_text or blob payloads
- * - Two distinct query paths:
- *     1. Analytics query (listRecentNocturnalCandidateSessions) — for target selection
- *     2. Runtime query (getNocturnalSessionSnapshot) — for sample generation
- * - All snapshots are self-contained and principle-relevant metadata-rich
- *
- * WHAT THIS MODULE DOES:
- * - List recent sessions with metadata relevant to nocturnal target selection
- * - Extract structured session snapshots for a selected violating session
- *
- * WHAT THIS MODULE DOES NOT DO:
- * - NO snapshot database cloning
- * - NO full trajectory export
- * - NO raw text exposure
- * - NO target selection logic
- * - NO sample generation
- *
- * ARTIFACT OUTPUTS go to:
- *   .state/nocturnal/samples/    ← structured JSON artifacts
- *
- * FILE: {stateDir}/nocturnal/snapshots/  (cached snapshots if needed, optional)
- */
-import { TrajectoryRegistry } from './trajectory.js';
-import { detectThinkingModelMatches, listThinkingModels } from './thinking-models.js';
-// ---------------------------------------------------------------------------
-// Core Extractor
-// ---------------------------------------------------------------------------
-/**
- * Nocturnal Trajectory Extractor.
- *
- * Provides sanitized, structured access to session data for the nocturnal
- * reflection pipeline. All queries return sanitized text only.
- *
- * This class is a thin, focused wrapper around TrajectoryDatabase.
- * It does NOT cache snapshots or maintain its own state.
- */
-export class NocturnalTrajectoryExtractor {
-    trajectory;
-    constructor(trajectory) {
-        this.trajectory = trajectory;
-    }
-    /**
-     * List recent sessions suitable for nocturnal target selection.
-     *
-     * ANALYTICS QUERY — used by nocturnal target selector to find candidate sessions.
-     *
-     * @param options - Query options
-     * @returns Lightweight session summaries ordered by most recently updated
-     */
-    listRecentNocturnalCandidateSessions(options = {}) {
-        const limit = options.limit ?? 20;
-        const minToolCalls = options.minToolCalls ?? 1;
-        // Get recent sessions from trajectory DB
-        const sessions = this.trajectory.listRecentSessions({
-            limit: limit * 3, // Over-fetch to allow filtering
-            dateFrom: options.dateFrom,
-            dateTo: options.dateTo,
-        });
-        if (sessions.length === 0) {
-            return [];
-        }
-        // For each session, get counts
-        // We batch these by fetching tool_calls count per session
-        const summaries = [];
-        for (const session of sessions) {
-            if (summaries.length >= limit)
-                break;
-            const toolCalls = this.trajectory.listToolCallsForSession(session.sessionId);
-            const painEvents = this.trajectory.listPainEventsForSession(session.sessionId);
-            const gateBlocks = this.trajectory.listGateBlocksForSession(session.sessionId);
-            // Filter by minimum tool calls threshold
-            if (toolCalls.length < minToolCalls) {
-                continue;
-            }
-            const failureCount = toolCalls.filter((tc) => tc.outcome === 'failure').length;
-            summaries.push({
-                sessionId: session.sessionId,
-                startedAt: session.startedAt,
-                updatedAt: session.updatedAt,
-                assistantTurnCount: 0, // Not readily available without extra query
-                toolCallCount: toolCalls.length,
-                painEventCount: painEvents.length,
-                gateBlockCount: gateBlocks.length,
-                failureCount,
-            });
-        }
-        return summaries;
-    }
-    /**
-     * Get a full structured snapshot for a specific session.
-     *
-     * RUNTIME QUERY — used by nocturnal service after target selection.
-     *
-     * SECURITY GUARANTEES:
-     * - Only sanitizedText from assistant turns (never raw_text)
-     * - Only correction cues from user turns (never raw user text)
-     * - Tool calls with outcome and error info (no raw parameters)
-     * - Pain events with score and reason (no raw event data)
-     * - Gate blocks with tool/reason info (no file content)
-     *
-     * @param sessionId - Session ID to snapshot
-     * @returns Full structured snapshot, or null if session not found
-     */
-    getNocturnalSessionSnapshot(sessionId) {
-        // Verify session exists — must use a large enough limit to cover all candidates,
-        // not just the single most-recent session (which would cause false negatives when
-        // the selector targets an older session).
-        const sessions = this.trajectory.listRecentSessions({ limit: 1000 });
-        const sessionExists = sessions.some((s) => s.sessionId === sessionId);
-        if (!sessionExists) {
-            // Session might not be in trajectory DB — try to get basic info
-            // If no data at all, return null for fail-safe
-            return null;
-        }
-        // Fetch all turn data
-        const assistantTurns = this.trajectory.listAssistantTurns(sessionId);
-        const userTurns = this.trajectory.listUserTurnsForSession(sessionId);
-        const toolCalls = this.trajectory.listToolCallsForSession(sessionId);
-        const painEvents = this.trajectory.listPainEventsForSession(sessionId);
-        const gateBlocks = this.trajectory.listGateBlocksForSession(sessionId);
-        // Map to sanitized structures
-        // SECURITY: Only sanitizedText from assistant turns
-        const sanitizedAssistantTurns = assistantTurns.map((turn, index) => ({
-            turnIndex: index,
-            sanitizedText: turn.sanitizedText,
-            model: turn.model,
-            createdAt: turn.createdAt,
-        }));
-        // SECURITY: Only derived cues from user turns
-        const sanitizedUserTurns = userTurns.map((turn) => ({
-            turnIndex: turn.turnIndex,
-            correctionDetected: turn.correctionDetected,
-            correctionCue: turn.correctionCue,
-            createdAt: turn.createdAt,
-        }));
-        // Tool calls — include outcome and error info but not raw params
-        const nocturnalToolCalls = toolCalls.map((tc) => ({
-            toolName: tc.toolName,
-            outcome: tc.outcome,
-            filePath: tc.filePath,
-            durationMs: tc.durationMs,
-            exitCode: tc.exitCode,
-            errorType: tc.errorType,
-            errorMessage: tc.errorMessage,
-            createdAt: tc.createdAt,
-        }));
-        // Pain events — score and reason only
-        const nocturnalPainEvents = painEvents.map((pe) => ({
-            source: pe.source,
-            score: pe.score,
-            severity: pe.severity,
-            reason: pe.reason,
-            createdAt: pe.createdAt,
-        }));
-        // Gate blocks — tool and reason only
-        const nocturnalGateBlocks = gateBlocks.map((gb) => ({
-            toolName: gb.toolName,
-            filePath: gb.filePath,
-            reason: gb.reason,
-            planStatus: gb.planStatus,
-            createdAt: gb.createdAt,
-        }));
-        // Compute summary stats
-        const failureCount = toolCalls.filter((tc) => tc.outcome === 'failure').length;
-        // Get session metadata (use trajectory data)
-        const sessionMeta = sessions.find((s) => s.sessionId === sessionId);
-        return {
-            sessionId,
-            startedAt: sessionMeta?.startedAt ?? new Date(0).toISOString(),
-            updatedAt: sessionMeta?.updatedAt ?? new Date(0).toISOString(),
-            assistantTurns: sanitizedAssistantTurns,
-            userTurns: sanitizedUserTurns,
-            toolCalls: nocturnalToolCalls,
-            painEvents: nocturnalPainEvents,
-            gateBlocks: nocturnalGateBlocks,
-            stats: {
-                totalAssistantTurns: sanitizedAssistantTurns.length,
-                totalToolCalls: nocturnalToolCalls.length,
-                totalPainEvents: nocturnalPainEvents.length,
-                totalGateBlocks: nocturnalGateBlocks.length,
-                failureCount,
-            },
-        };
-    }
-}
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-/**
- * Creates a NocturnalTrajectoryExtractor from a workspace directory.
- *
- * USAGE:
- *   const extractor = createNocturnalTrajectoryExtractor(workspaceDir);
- *   const sessions = extractor.listRecentNocturnalCandidateSessions({ limit: 10 });
- *   const snapshot = extractor.getNocturnalSessionSnapshot(sessionId);
- */
-export function createNocturnalTrajectoryExtractor(workspaceDir, _stateDir // Ignored; kept for API compatibility with existing call sites
-) {
-    // Use the registry to get or create the TrajectoryDatabase instance
-    const trajectory = TrajectoryRegistry.get(workspaceDir);
-    return new NocturnalTrajectoryExtractor(trajectory);
-}
-// ---------------------------------------------------------------------------
-// Direct module helpers (for cases where you already have TrajectoryDatabase)
-// ---------------------------------------------------------------------------
-/**
- * List recent sessions for nocturnal target selection.
- * Convenience wrapper around NocturnalTrajectoryExtractor.
- */
-export function listNocturnalCandidateSessions(trajectory, options = {}) {
-    return new NocturnalTrajectoryExtractor(trajectory).listRecentNocturnalCandidateSessions(options);
-}
-/**
- * Get a session snapshot for nocturnal reflection.
- * Convenience wrapper around NocturnalTrajectoryExtractor.
- */
-export function getNocturnalSessionSnapshot(trajectory, sessionId) {
-    return new NocturnalTrajectoryExtractor(trajectory).getNocturnalSessionSnapshot(sessionId);
-}
-// ---------------------------------------------------------------------------
-// Reflection Quality Metrics
-// ---------------------------------------------------------------------------
-/**
- * Compute thinking model activation for a text.
- * Returns 0-1 ratio of matched thinking models to total available models.
- *
- * @param text - Text to analyze
- * @returns Activation ratio (0-1)
- */
-export function computeThinkingModelActivation(text) {
-    if (!text || text.trim().length === 0)
-        return 0;
-    const matches = detectThinkingModelMatches(text);
-    const totalModels = listThinkingModels().length;
-    return Math.round((matches.length / totalModels) * 100) / 100;
-}
-/**
- * Compute planning ratio from a session snapshot.
- * Planning ratio = write operations preceded immediately by a read tool / total write operations.
- * A higher ratio indicates more careful planning behavior (reading before writing).
- *
- * Only the immediately preceding tool is checked — each write needs its own
- * preceding read to count as planned. This prevents a single read from satisfying
- * multiple writes in sequence.
- *
- * @param snapshot - Session snapshot to analyze
- * @returns Planning ratio (0-1), or 0 if no write operations
- */
-export function computePlanningRatio(snapshot) {
-    const toolCalls = snapshot.toolCalls;
-    let totalWrites = 0;
-    let writesWithPrecedingRead = 0;
-    for (let i = 0; i < toolCalls.length; i++) {
-        const tc = toolCalls[i];
-        const isWriteTool = /^(edit|write|create|delete|remove|move|rename)/i.test(tc.toolName);
-        if (isWriteTool) {
-            totalWrites++;
-            // Check only the immediately preceding tool
-            if (i > 0) {
-                const prevTc = toolCalls[i - 1];
-                const isReadTool = /^(read|grep|search|find|inspect|look)/i.test(prevTc.toolName);
-                if (isReadTool) {
-                    writesWithPrecedingRead++;
-                }
-            }
-        }
-    }
-    if (totalWrites === 0)
-        return 0;
-    return Math.round((writesWithPrecedingRead / totalWrites) * 100) / 100;
-}
-/**
- * Compute thinking model delta between original and improved decisions.
- * Positive delta means the improved decision uses more thinking models.
- *
- * @param originalText - Original (bad) decision text
- * @param improvedText - Improved (better) decision text
- * @returns Delta in thinking model activation (-1 to 1)
- */
-export function computeThinkingModelDelta(originalText, improvedText) {
-    const originalActivation = computeThinkingModelActivation(originalText);
-    const improvedActivation = computeThinkingModelActivation(improvedText);
-    const delta = improvedActivation - originalActivation;
-    return Math.round(delta * 100) / 100;
-}
-/**
- * Compute planning ratio gain between original and improved snapshots.
- * Positive gain means the improved behavior has better planning (more reads before writes).
- *
- * @param originalSnapshot - Original session snapshot
- * @param improvedSnapshot - Improved session snapshot
- * @returns Planning ratio gain (-1 to 1)
- */
-export function computePlanningRatioGain(originalSnapshot, improvedSnapshot) {
-    const originalRatio = computePlanningRatio(originalSnapshot);
-    const improvedRatio = computePlanningRatio(improvedSnapshot);
-    const gain = improvedRatio - originalRatio;
-    return Math.round(gain * 100) / 100;
-}

package/dist/core/nocturnal-trinity.d.ts

@@ -1,311 +0,0 @@
-/**
- * Nocturnal Trinity — Three-Stage Reflection Chain
- * ================================================
- *
- * PURPOSE: Upgrade single-reflector nocturnal sample generation to a
- * Dreamer -> Philosopher -> Scribe Trinity chain that produces higher quality
- * decision-point samples through structured multi-stage reflection.
- *
- * TRINITY STAGES:
- *  1. Dreamer   — Generates multiple candidate corrections/alternatives
- *  2. Philosopher — Provides principle-grounded critique and ranking
- *  3. Scribe    — Produces the final structured artifact draft using tournament selection
- *
- * DESIGN CONSTRAINTS:
- *  - All stage I/O is structured JSON contracts (not prose)
- *  - Any malformed stage output fails the entire chain closed
- *  - Single-reflector fallback is preserved via useTrinity flag
- *  - Trinity mode is configurable but defaults to enabled
- *  - Final artifact still passes arbiter + executability validation
- *  - Telemetry records chain mode, stage outcomes, candidate counts
- *  - Tournament selection is deterministic (same inputs → same winner)
- *
- * RUNTIME ADAPTER:
- *  - useStubs=true: uses synchronous stub implementations (no external calls)
- *  - useStubs=false: requires a TrinityRuntimeAdapter for real subagent execution
- *  - Adapter uses ONLY public plugin runtime APIs (api.runtime.subagent.*)
- */
-import type { NocturnalSessionSnapshot } from './nocturnal-trajectory-extractor.js';
-import { type ScoringWeights, type TournamentTraceEntry } from './nocturnal-candidate-scoring.js';
-import { type ThresholdValues } from './adaptive-thresholds.js';
-/**
- * Interface for Trinity stage invocation.
- * Implementations can use real subagent runtimes or stubs.
- */
-export interface TrinityRuntimeAdapter {
-    /**
-     * Invoke the Dreamer stage.
-     * @param snapshot Session trajectory snapshot
-     * @param principleId Target principle ID
-     * @param maxCandidates Maximum number of candidates to generate
-     * @returns Dreamer output JSON
-     */
-    invokeDreamer(snapshot: NocturnalSessionSnapshot, principleId: string, maxCandidates: number): Promise<DreamerOutput>;
-    /**
-     * Invoke the Philosopher stage.
-     * @param dreamerOutput Dreamer's output
-     * @param principleId Target principle ID
-     * @returns Philosopher output JSON
-     */
-    invokePhilosopher(dreamerOutput: DreamerOutput, principleId: string): Promise<PhilosopherOutput>;
-    /**
-     * Invoke the Scribe stage.
-     * @param dreamerOutput Dreamer's output
-     * @param philosopherOutput Philosopher's output
-     * @param snapshot Session snapshot
-     * @param principleId Target principle ID
-     * @param telemetry Running telemetry
-     * @param config Trinity config
-     * @returns Scribe draft artifact or null if failed
-     */
-    invokeScribe(dreamerOutput: DreamerOutput, philosopherOutput: PhilosopherOutput, snapshot: NocturnalSessionSnapshot, principleId: string, telemetry: TrinityTelemetry, config: TrinityConfig): Promise<TrinityDraftArtifact | null>;
-    /**
-     * Clean up any resources used by the adapter.
-     * Called after Trinity chain completes (success or failure).
-     */
-    close?(): Promise<void>;
-}
-/**
- * OpenClaw-backed Trinity runtime adapter.
- * Uses ONLY public plugin runtime APIs (api.runtime.subagent.*).
- * Does NOT depend on OpenClaw internals.
- */
-export declare class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
-    private readonly api;
-    private readonly stageTimeoutMs;
-    constructor(api: OpenClawTrinityRuntimeAdapter['api'], stageTimeoutMs?: number);
-    invokeDreamer(snapshot: NocturnalSessionSnapshot, principleId: string, maxCandidates: number): Promise<DreamerOutput>;
-    invokePhilosopher(dreamerOutput: DreamerOutput, principleId: string): Promise<PhilosopherOutput>;
-    invokeScribe(dreamerOutput: DreamerOutput, philosopherOutput: PhilosopherOutput, snapshot: NocturnalSessionSnapshot, principleId: string, telemetry: TrinityTelemetry, config: TrinityConfig): Promise<TrinityDraftArtifact | null>;
-    close(): Promise<void>;
-    private extractAssistantText;
-    private buildDreamerPrompt;
-    private buildPhilosopherPrompt;
-    private buildScribePrompt;
-    private parseDreamerOutput;
-    private parsePhilosopherOutput;
-    private parseScribeOutput;
-    /**
-     * Extract JSON object from text that may contain markdown code blocks.
-     */
-    private extractJson;
-}
-/**
- * Configuration for Trinity chain execution.
- */
-export interface TrinityConfig {
-    /**
-     * Whether to use Trinity chain (true) or single-reflector (false).
-     * Default: true
-     */
-    useTrinity: boolean;
-    /**
-     * Maximum candidates Dreamer should generate.
-     * Default: 3
-     */
-    maxCandidates: number;
-    /**
-     * Whether to use stub stage outputs (for testing without real model calls).
-     * Default: false (real subagent calls via runtimeAdapter)
-     */
-    useStubs: boolean;
-    /**
-     * Runtime adapter for real subagent execution.
-     * Required when useStubs is false. Ignored when useStubs is true.
-     * Default: undefined
-     */
-    runtimeAdapter?: TrinityRuntimeAdapter;
-    /**
-     * Scoring weights for tournament selection.
-     * Default: DEFAULT_SCORING_WEIGHTS
-     */
-    scoringWeights?: ScoringWeights;
-    /**
-     * Threshold values for tournament eligibility.
-     * Default: DEFAULT_THRESHOLDS
-     */
-    thresholds?: ThresholdValues;
-    /**
-     * State directory for threshold persistence.
-     * If provided, thresholds will be loaded from state.
-     */
-    stateDir?: string;
-}
-/**
- * Dreamer output — multiple candidate corrections.
- * Each candidate represents an alternative "better decision" approach.
- */
-export interface DreamerCandidate {
-    /** Unique index for this candidate within the Dreamer output */
-    candidateIndex: number;
-    /** The bad decision this candidate addresses */
-    badDecision: string;
-    /** The alternative/better decision */
-    betterDecision: string;
-    /** Why this alternative is better (brief) */
-    rationale: string;
-    /** Confidence that this candidate is valid (0-1) */
-    confidence: number;
-}
-export interface DreamerOutput {
-    /** Whether Dreamer succeeded */
-    valid: boolean;
-    /** List of candidate corrections */
-    candidates: DreamerCandidate[];
-    /** Why Dreamer could not generate (if valid === false) */
-    reason?: string;
-    /** Timestamp of generation */
-    generatedAt: string;
-}
-/**
- * Philosopher output — principle-grounded critique and ranking.
- * Philosopher evaluates Dreamer's candidates and ranks them.
- */
-export interface PhilosopherJudgment {
-    /** Index of the judged candidate (references DreamerCandidate.candidateIndex) */
-    candidateIndex: number;
-    /** Principle-grounded critique of this candidate */
-    critique: string;
-    /** Whether this candidate aligns with the target principle */
-    principleAligned: boolean;
-    /** Ranking score (higher = better, 0-1) */
-    score: number;
-    /** Rank among all candidates (1 = best) */
-    rank: number;
-}
-export interface PhilosopherOutput {
-    /** Whether Philosopher succeeded */
-    valid: boolean;
-    /** Judgments for each candidate */
-    judgments: PhilosopherJudgment[];
-    /** Overall assessment of the candidate set */
-    overallAssessment: string;
-    /** Why Philosopher could not judge (if valid === false) */
-    reason?: string;
-    /** Timestamp of generation */
-    generatedAt: string;
-}
-/**
- * Scribe output — final structured artifact draft.
- * Scribe synthesizes the best candidate into an approved artifact format.
- */
-export interface TrinityDraftArtifact {
-    /** The selected winning candidate index */
-    selectedCandidateIndex: number;
-    /** The final badDecision */
-    badDecision: string;
-    /** The final betterDecision */
-    betterDecision: string;
-    /** The final rationale */
-    rationale: string;
-    /** Source session from snapshot */
-    sessionId: string;
-    /** Target principle ID */
-    principleId: string;
-    /** Reference to snapshot used */
-    sourceSnapshotRef: string;
-    /** Chain telemetry */
-    telemetry: TrinityTelemetry;
-    /** Reflection quality: delta in thinking model activation (-1 to 1) */
-    thinkingModelDelta?: number;
-    /** Reflection quality: gain in planning ratio (-1 to 1) */
-    planningRatioGain?: number;
-}
-export interface TrinityTelemetry {
-    /** Whether Trinity or single-reflector was used */
-    chainMode: 'trinity' | 'single-reflector';
-    /** Whether stub implementations were used (always true in Phase 8) */
-    usedStubs: boolean;
-    /** Whether each stage passed */
-    dreamerPassed: boolean;
-    philosopherPassed: boolean;
-    scribePassed: boolean;
-    /** Number of candidates generated */
-    candidateCount: number;
-    /** Final selected candidate index */
-    selectedCandidateIndex: number;
-    /** Stage failure reasons (if any) */
-    stageFailures: string[];
-    /** Tournament trace for explainability (optional) */
-    tournamentTrace?: TournamentTraceEntry[];
-    /** Winner aggregate score (optional) */
-    winnerAggregateScore?: number;
-    /** Whether winner passed all thresholds (optional) */
-    winnerThresholdPassed?: boolean;
-    /** Number of eligible candidates after threshold check (optional) */
-    eligibleCandidateCount?: number;
-}
-/**
- * Validation failure for a Trinity stage.
- */
-export interface TrinityStageFailure {
-    stage: 'dreamer' | 'philosopher' | 'scribe';
-    reason: string;
-}
-/**
- * Result of Trinity chain execution.
- */
-export interface TrinityResult {
-    /** Whether Trinity chain completed successfully */
-    success: boolean;
-    /** The final draft artifact (if success) */
-    artifact?: TrinityDraftArtifact;
-    /** Telemetry about the chain execution */
-    telemetry: TrinityTelemetry;
-    /** Stage failures (if any) */
-    failures: TrinityStageFailure[];
-    /** Whether fallback to single-reflector occurred */
-    fallbackOccurred: boolean;
-}
-export interface RunTrinityOptions {
-    /** Snapshot to generate candidates from */
-    snapshot: NocturnalSessionSnapshot;
-    /** Target principle ID */
-    principleId: string;
-    /** Trinity configuration */
-    config: TrinityConfig;
-}
-/**
- * Execute the Trinity chain using stubs (synchronous).
- * Use runTrinityAsync for real subagent execution via runtime adapter.
- *
- * @param options - Trinity execution options
- * @returns TrinityResult with final artifact or failure info
- */
-export declare function runTrinity(options: RunTrinityOptions): TrinityResult;
-/**
- * Execute the Trinity chain with real subagent runtime (asynchronous).
- * Requires config.runtimeAdapter to be set.
- *
- * @param options - Trinity execution options
- * @returns Promise<TrinityResult> with final artifact or failure info
- */
-export declare function runTrinityAsync(options: RunTrinityOptions): Promise<TrinityResult>;
-/**
- * Validate that a Trinity draft artifact can pass final arbiter validation.
- * This checks the draft against the same rules as single-reflector artifacts.
- */
-export interface DraftValidationResult {
-    valid: boolean;
-    failures: string[];
-}
-/**
- * Validate a TrinityDraftArtifact before passing to arbiter.
- */
-export declare function validateDraftArtifact(draft: TrinityDraftArtifact): DraftValidationResult;
-/**
- * Convert a TrinityDraftArtifact to a NocturnalArtifact-compatible structure.
- */
-export declare function draftToArtifact(draft: TrinityDraftArtifact): {
-    artifactId: string;
-    sessionId: string;
-    principleId: string;
-    sourceSnapshotRef: string;
-    badDecision: string;
-    betterDecision: string;
-    rationale: string;
-    createdAt: string;
-    thinkingModelDelta?: number;
-    planningRatioGain?: number;
-};
-export declare const DEFAULT_TRINITY_CONFIG: TrinityConfig;