backtest-kit 5.6.7 → 5.9.0

package/types.d.ts

@@ -2119,8 +2119,12 @@ interface ISignalDto {
     priceTakeProfit: number;
     /** Stop loss exit price (must be < priceOpen for long, > priceOpen for short) */
     priceStopLoss: number;
-    /** Expected duration in minutes before time_expired */
-    minuteEstimatedTime: number;
+    /**
+     * Expected duration in minutes before time_expired.
+     * Use `Infinity` for no timeout — position stays open until TP/SL or explicit closePending().
+     * Default: GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES
+     */
+    minuteEstimatedTime?: number;
     /** Cost of this entry in USD. Default: GLOBAL_CONFIG.CC_POSITION_ENTRY_COST */
     cost?: number;
 }
@@ -2135,6 +2139,8 @@ interface ISignalRow extends ISignalDto {
     cost: number;
     /** Entry price for the position */
     priceOpen: number;
+    /** Expected duration in minutes before time_expired (required in row, defaults applied in ClientStrategy) */
+    minuteEstimatedTime: number;
     /** Unique exchange identifier for execution */
     exchangeName: ExchangeName;
     /** Unique strategy identifier for execution */
@@ -2679,6 +2685,8 @@ interface IStrategyTickResultActive {
     backtest: boolean;
     /** Unix timestamp in milliseconds when this tick result was created (from candle timestamp in backtest or execution context when in live) */
     createdAt: number;
+    /** Unix timestamp in milliseconds of the last processed candle. Used by BacktestLogicPrivateService to advance chunkStart for the next chunk request. */
+    _backtestLastTimestamp: number;
 }
 /**
  * Tick result: signal closed with PNL.
@@ -2748,9 +2756,10 @@ interface IStrategyTickResultCancelled {
  */
 type IStrategyTickResult = IStrategyTickResultIdle | IStrategyTickResultScheduled | IStrategyTickResultWaiting | IStrategyTickResultOpened | IStrategyTickResultActive | IStrategyTickResultClosed | IStrategyTickResultCancelled;
 /**
- * Backtest returns closed result (TP/SL or time_expired) or cancelled result (scheduled signal never activated).
+ * Backtest returns closed result (TP/SL or time_expired), cancelled result (scheduled signal never activated),
+ * or active result (candles exhausted but signal still open — only for minuteEstimatedTime = Infinity).
  */
-type IStrategyBacktestResult = IStrategyTickResultOpened | IStrategyTickResultScheduled | IStrategyTickResultClosed | IStrategyTickResultCancelled;
+type IStrategyBacktestResult = IStrategyTickResultOpened | IStrategyTickResultScheduled | IStrategyTickResultActive | IStrategyTickResultClosed | IStrategyTickResultCancelled;
 /**
  * Strategy interface implemented by ClientStrategy.
  * Defines core strategy execution methods.
@@ -4874,7 +4883,7 @@ declare function getTotalCostClosed(symbol: string): Promise<number>;
  * }
  * ```
  */
-declare function getPendingSignal(symbol: string): Promise<IPublicSignalRow>;
+declare function getPendingSignal(symbol: string): Promise<IPublicSignalRow | null>;
 /**
  * Returns the currently active scheduled signal for the strategy.
  * If no scheduled signal exists, returns null.
@@ -5513,8 +5522,10 @@ declare const GLOBAL_CONFIG: {
      */
     CC_MAX_STOPLOSS_DISTANCE_PERCENT: number;
     /**
-     * Maximum signal lifetime in minutes
-     * Prevents eternal signals that block risk limits for weeks/months
+     * Maximum signal lifetime in minutes.
+     * Also used as the default when minuteEstimatedTime is not provided in ISignalDto.
+     * Prevents eternal signals that block risk limits for weeks/months.
+     * Use Infinity to allow signals to live indefinitely (until TP/SL or explicit close).
      * Default: 1440 minutes (1 day)
      */
     CC_MAX_SIGNAL_LIFETIME_MINUTES: number;
@@ -8380,54 +8391,344 @@ declare function getNextCandles(symbol: string, interval: CandleInterval, limit:
  */
 declare function getAggregatedTrades(symbol: string, limit?: number): Promise<IAggregatedTradeData[]>;
 
-/** Unique identifier for a dump result. Can be a string or numeric ID. */
-type ResultId = string | number;
-/** Role of the message sender in LLM chat history. */
-type BaseRole = "assistant" | "system" | "user";
 /**
- * A single message in the chat history.
- * Used to represent system instructions, user input, or LLM responses.
+ * Writes a value to memory scoped to the current signal.
+ *
+ * Reads symbol from execution context and signalId from the active pending signal.
+ * If no pending signal exists, logs a warning and returns without writing.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param dto.bucketName - Memory bucket name
+ * @param dto.memoryId - Unique memory entry identifier
+ * @param dto.value - Value to store
+ * @returns Promise that resolves when write is complete
+ *
+ * @deprecated Better use Memory.writeMemory with manual signalId argument
+ *
+ * @example
+ * ```typescript
+ * import { writeMemory } from "backtest-kit";
+ *
+ * await writeMemory({ bucketName: "my-strategy", memoryId: "context", value: { trend: "up", confidence: 0.9 } });
+ * ```
  */
-interface Message<Role extends BaseRole = BaseRole> {
-    /**
-     * The sender of the message.
-     * - "system": System instructions and context
-     * - "user": User input and questions
-     * - "assistant": LLM responses
-     */
+declare function writeMemory<T extends object = object>(dto: {
+    bucketName: string;
+    memoryId: string;
+    value: T;
+}): Promise<void>;
+/**
+ * Reads a value from memory scoped to the current signal.
+ *
+ * Reads symbol from execution context and signalId from the active pending signal.
+ * If no pending signal exists, logs a warning and returns null.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param dto.bucketName - Memory bucket name
+ * @param dto.memoryId - Unique memory entry identifier
+ * @returns Promise resolving to stored value or null if no signal
+ * @throws Error if entry not found within an active signal
+ *
+ * @deprecated Better use Memory.readMemory with manual signalId argument
+ *
+ * @example
+ * ```typescript
+ * import { readMemory } from "backtest-kit";
+ *
+ * const ctx = await readMemory<{ trend: string }>({ bucketName: "my-strategy", memoryId: "context" });
+ * ```
+ */
+declare function readMemory<T extends object = object>(dto: {
+    bucketName: string;
+    memoryId: string;
+}): Promise<T | null>;
+/**
+ * Searches memory entries for the current signal using BM25 full-text scoring.
+ *
+ * Reads symbol from execution context and signalId from the active pending signal.
+ * If no pending signal exists, logs a warning and returns an empty array.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param dto.bucketName - Memory bucket name
+ * @param dto.query - Search query string
+ * @returns Promise resolving to matching entries sorted by relevance, or empty array if no signal
+ *
+ * @deprecated Better use Memory.searchMemory with manual signalId argument
+ *
+ * @example
+ * ```typescript
+ * import { searchMemory } from "backtest-kit";
+ *
+ * const results = await searchMemory({ bucketName: "my-strategy", query: "bullish trend" });
+ * ```
+ */
+declare function searchMemory<T extends object = object>(dto: {
+    bucketName: string;
+    query: string;
+}): Promise<Array<{
+    memoryId: string;
+    score: number;
+    content: T;
+}>>;
+/**
+ * Lists all memory entries for the current signal.
+ *
+ * Reads symbol from execution context and signalId from the active pending signal.
+ * If no pending signal exists, logs a warning and returns an empty array.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param dto.bucketName - Memory bucket name
+ * @returns Promise resolving to all stored entries, or empty array if no signal
+ *
+ * @deprecated Better use Memory.listMemory with manual signalId argument
+ *
+ * @example
+ * ```typescript
+ * import { listMemory } from "backtest-kit";
+ *
+ * const entries = await listMemory({ bucketName: "my-strategy" });
+ * ```
+ */
+declare function listMemory<T extends object = object>(dto: {
+    bucketName: string;
+}): Promise<Array<{
+    memoryId: string;
+    content: T;
+}>>;
+/**
+ * Removes a memory entry for the current signal.
+ *
+ * Reads symbol from execution context and signalId from the active pending signal.
+ * If no pending signal exists, logs a warning and returns without removing.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param dto.bucketName - Memory bucket name
+ * @param dto.memoryId - Unique memory entry identifier
+ * @returns Promise that resolves when removal is complete
+ *
+ * @deprecated Better use Memory.removeMemory with manual signalId argument
+ *
+ * @example
+ * ```typescript
+ * import { removeMemory } from "backtest-kit";
+ *
+ * await removeMemory({ bucketName: "my-strategy", memoryId: "context" });
+ * ```
+ */
+declare function removeMemory(dto: {
+    bucketName: string;
+    memoryId: string;
+}): Promise<void>;
+
+/** Role of the message sender in an LLM chat history. */
+type MessageRole = "assistant" | "system" | "tool" | "user";
+/**
+ * A tool call requested by the assistant.
+ * Represents a single function invocation emitted in an assistant message.
+ */
+type MessageToolCall = {
+    /** Unique identifier for this tool call, referenced by the tool result message via tool_call_id. */
+    id: string;
+    /** Always "function" — the only supported tool call type. */
+    type: "function";
+    /** The function to invoke. */
+    function: {
+        /** Name of the function to call. */
+        name: string;
+        /** Arguments passed to the function, keyed by parameter name. */
+        arguments: {
+            [key: string]: any;
+        };
+    };
+};
+/**
+ * A single message in an LLM chat history.
+ * Covers all roles: system instructions, user input, assistant responses, and tool results.
+ */
+interface MessageModel<Role extends MessageRole = MessageRole> {
+    /** Sender role — determines how the message is interpreted by the model. */
     role: Role;
-    /**
-     * The text content of the message.
-     * Contains the actual message text sent or received.
-     */
+    /** Text content of the message. Empty string for assistant messages that only contain tool_calls. */
     content: string;
+    /** Chain-of-thought / reasoning exposed by some providers (e.g. DeepSeek). */
+    reasoning_content?: string | null;
+    /** Tool calls emitted by the assistant. Present only on assistant messages. */
+    tool_calls?: MessageToolCall[];
+    /** Images attached to the message. Supported as Blob, raw bytes, or base64 strings. */
+    images?: Blob[] | Uint8Array[] | string[];
+    /** ID of the tool call this message is responding to. Present only on tool messages. */
+    tool_call_id?: string;
 }
+
+/**
+ * Dumps the full agent message history scoped to the current signal.
+ *
+ * Reads signalId from the active pending signal via execution and method context.
+ * If no pending signal exists, logs a warning and returns without writing.
+ *
+ * @param dto.bucketName - Bucket name grouping dumps by strategy or agent name
+ * @param dto.dumpId - Unique identifier for this agent invocation
+ * @param dto.messages - Full chat history (system, user, assistant, tool)
+ * @param dto.description - Human-readable label describing the agent invocation context; included in the BM25 index for Memory search
+ * @returns Promise that resolves when the dump is complete
+ *
+ * @deprecated Better use Dump.dumpAgentAnswer with manual signalId argument
+ *
+ * @example
+ * ```typescript
+ * import { dumpAgentAnswer } from "backtest-kit";
+ *
+ * await dumpAgentAnswer({ bucketName: "my-strategy", dumpId: "reasoning-1", messages, description: "BTC long signal reasoning" });
+ * ```
+ */
+declare function dumpAgentAnswer(dto: {
+    bucketName: string;
+    dumpId: string;
+    messages: MessageModel[];
+    description: string;
+}): Promise<void>;
+/**
+ * Dumps a flat key-value record scoped to the current signal.
+ *
+ * Reads signalId from the active pending signal via execution and method context.
+ * If no pending signal exists, logs a warning and returns without writing.
+ *
+ * @param dto.bucketName - Bucket name grouping dumps by strategy or agent name
+ * @param dto.dumpId - Unique identifier for this dump entry
+ * @param dto.record - Arbitrary flat object to persist
+ * @param dto.description - Human-readable label describing the record contents; included in the BM25 index for Memory search
+ * @returns Promise that resolves when the dump is complete
+ *
+ * @deprecated Better use Dump.dumpRecord with manual signalId argument
+ *
+ * @example
+ * ```typescript
+ * import { dumpRecord } from "backtest-kit";
+ *
+ * await dumpRecord({ bucketName: "my-strategy", dumpId: "context", record: { price: 42000, signal: "long" }, description: "Signal context at entry" });
+ * ```
+ */
+declare function dumpRecord(dto: {
+    bucketName: string;
+    dumpId: string;
+    record: Record<string, unknown>;
+    description: string;
+}): Promise<void>;
+/**
+ * Dumps an array of objects as a table scoped to the current signal.
+ *
+ * Reads signalId from the active pending signal via execution and method context.
+ * If no pending signal exists, logs a warning and returns without writing.
+ *
+ * Column headers are derived from the union of all keys across all rows.
+ *
+ * @param dto.bucketName - Bucket name grouping dumps by strategy or agent name
+ * @param dto.dumpId - Unique identifier for this dump entry
+ * @param dto.rows - Array of arbitrary objects to render as a table
+ * @param dto.description - Human-readable label describing the table contents; included in the BM25 index for Memory search
+ * @returns Promise that resolves when the dump is complete
+ *
+ * @deprecated Better use Dump.dumpTable with manual signalId argument
+ *
+ * @example
+ * ```typescript
+ * import { dumpTable } from "backtest-kit";
+ *
+ * await dumpTable({ bucketName: "my-strategy", dumpId: "candles", rows: [{ time: 1234, close: 42000 }], description: "Recent candle history" });
+ * ```
+ */
+declare function dumpTable(dto: {
+    bucketName: string;
+    dumpId: string;
+    rows: Record<string, unknown>[];
+    description: string;
+}): Promise<void>;
+/**
+ * Dumps raw text content scoped to the current signal.
+ *
+ * Reads signalId from the active pending signal via execution and method context.
+ * If no pending signal exists, logs a warning and returns without writing.
+ *
+ * @param dto.bucketName - Bucket name grouping dumps by strategy or agent name
+ * @param dto.dumpId - Unique identifier for this dump entry
+ * @param dto.content - Arbitrary text content to persist
+ * @param dto.description - Human-readable label describing the content; included in the BM25 index for Memory search
+ * @returns Promise that resolves when the dump is complete
+ *
+ * @deprecated Better use Dump.dumpText with manual signalId argument
+ *
+ * @example
+ * ```typescript
+ * import { dumpText } from "backtest-kit";
+ *
+ * await dumpText({ bucketName: "my-strategy", dumpId: "summary", content: "Agent concluded: bullish", description: "Agent final summary" });
+ * ```
+ */
+declare function dumpText(dto: {
+    bucketName: string;
+    dumpId: string;
+    content: string;
+    description: string;
+}): Promise<void>;
+/**
+ * Dumps an error description scoped to the current signal.
+ *
+ * Reads signalId from the active pending signal via execution and method context.
+ * If no pending signal exists, logs a warning and returns without writing.
+ *
+ * @param dto.bucketName - Bucket name grouping dumps by strategy or agent name
+ * @param dto.dumpId - Unique identifier for this dump entry
+ * @param dto.content - Error message or description to persist
+ * @param dto.description - Human-readable label describing the error context; included in the BM25 index for Memory search
+ * @returns Promise that resolves when the dump is complete
+ *
+ * @deprecated Better use Dump.dumpError with manual signalId argument
+ *
+ * @example
+ * ```typescript
+ * import { dumpError } from "backtest-kit";
+ *
+ * await dumpError({ bucketName: "my-strategy", dumpId: "error-1", content: "Tool call failed: timeout", description: "Tool execution error" });
+ * ```
+ */
+declare function dumpError(dto: {
+    bucketName: string;
+    dumpId: string;
+    content: string;
+    description: string;
+}): Promise<void>;
 /**
- * Dumps chat history and result data to markdown files in a structured directory.
+ * Dumps an arbitrary nested object as a fenced JSON block scoped to the current signal.
  *
- * Creates a subfolder named after `resultId` inside `outputDir`.
- * If the subfolder already exists, the function returns early without overwriting.
- * Writes:
- * - `00_system_prompt.md` — system messages and output data summary
- * - `NN_user_message.md` — each user message as a separate file
- * - `NN_llm_output.md` — final LLM output data
+ * Reads signalId from the active pending signal via execution and method context.
+ * If no pending signal exists, logs a warning and returns without writing.
  *
- * Warns via logger if any user message exceeds 30 KB.
+ * @param dto.bucketName - Bucket name grouping dumps by strategy or agent name
+ * @param dto.dumpId - Unique identifier for this dump entry
+ * @param dto.json - Arbitrary nested object to serialize with JSON.stringify
+ * @param dto.description - Human-readable label describing the object contents; included in the BM25 index for Memory search
+ * @returns Promise that resolves when the dump is complete
  *
- * @param resultId - Unique identifier for the result (used as subfolder name)
- * @param history - Full chat history containing system, user, and assistant messages
- * @param result - Structured output data to include in the dump
- * @param outputDir - Base directory for output files (default: `./dump/strategy`)
- * @returns Promise that resolves when all files are written
+ * @deprecated Prefer dumpRecord — flat key-value structure maps naturally to markdown tables and SQL storage
  *
  * @example
  * ```typescript
- * import { dumpMessages } from "backtest-kit";
+ * import { dumpJson } from "backtest-kit";
  *
- * await dumpMessages("result-123", history, { profit: 42 });
+ * await dumpJson({ bucketName: "my-strategy", dumpId: "signal-state", json: { entries: [], partials: [] }, description: "Signal state snapshot" });
  * ```
  */
-declare function dumpMessages<Data extends object = any>(resultId: ResultId, history: Message[], result: Data, outputDir?: string): Promise<void>;
+declare function dumpJson(dto: {
+    bucketName: string;
+    dumpId: string;
+    json: object;
+    description: string;
+}): Promise<void>;
 
 /**
  * Portfolio heatmap statistics for a single symbol.
@@ -10346,6 +10647,7 @@ interface StrategyStatisticsModel {
     averageBuyCount: number;
 }
 
+/** Symbol key for the singleshot waitForInit function on PersistBase instances. */
 declare const BASE_WAIT_FOR_INIT_SYMBOL: unique symbol;
 /**
  * Signal data stored in persistence layer.
@@ -10355,7 +10657,10 @@ type SignalData = ISignalRow | null;
 /**
  * Cache.file data type stored in persistence layer.
  */
-type MeasureData = unknown;
+type MeasureData = {
+    id: string;
+    data: unknown;
+};
 /**
  * Type helper for PersistBase instance.
  */
@@ -11051,7 +11356,7 @@ type StorageData = IStorageSignalRow[];
  */
 declare class PersistStorageUtils {
     private PersistStorageFactory;
-    private getStorageStorage;
+    private getStorage;
     /**
      * Registers a custom persistence adapter.
      *
@@ -11246,7 +11551,7 @@ declare class PersistMeasureUtils {
      *
      * @param Ctor - Custom PersistBase constructor
      */
-    usePersistMeasureAdapter(Ctor: TPersistBaseCtor<string, unknown>): void;
+    usePersistMeasureAdapter(Ctor: TPersistBaseCtor<string, MeasureData>): void;
     /**
      * Reads cached measure data for a given bucket and key.
      *
@@ -11278,8 +11583,144 @@ declare class PersistMeasureUtils {
  * Used by Cache.file for persistent caching of external API responses.
  */
 declare const PersistMeasureAdapter: PersistMeasureUtils;
+/**
+ * Type for persisted memory entry data.
+ * Each memory entry is an arbitrary JSON-serializable object.
+ */
+type MemoryData = {
+    priority: number;
+    data: object;
+    removed: boolean;
+    index: string;
+};
+/**
+ * Utility class for managing memory entry persistence.
+ *
+ * Features:
+ * - Memoized storage instances per (signalId, bucketName) pair
+ * - Custom adapter support
+ * - Atomic read/write/remove operations
+ * - Async iteration over stored keys for index rebuilding
+ *
+ * Storage layout: ./dump/memory/<signalId>/<bucketName>/<memoryId>.json
+ *
+ * Used by MemoryPersistInstance for crash-safe memory persistence.
+ */
+declare class PersistMemoryUtils {
+    private PersistMemoryFactory;
+    private getMemoryStorage;
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     *
+     * @example
+     * ```typescript
+     * class RedisPersist extends PersistBase {
+     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
+     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
+     * }
+     * PersistMemoryAdapter.usePersistMemoryAdapter(RedisPersist);
+     * ```
+     */
+    usePersistMemoryAdapter(Ctor: TPersistBaseCtor<string, MemoryData>): void;
+    /**
+     * Initializes the storage for a given (signalId, bucketName) pair.
+     *
+     * @param signalId - Signal identifier (entity folder name)
+     * @param bucketName - Bucket name (subfolder under memory/)
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    waitForInit: (signalId: string, bucketName: string, initial: boolean) => Promise<void>;
+    /**
+     * Reads a memory entry from persistence storage.
+     *
+     * @param signalId - Signal identifier
+     * @param bucketName - Bucket name
+     * @param memoryId - Memory entry identifier
+     * @returns Promise resolving to entry data or null if not found
+     */
+    readMemoryData: (signalId: string, bucketName: string, memoryId: string) => Promise<MemoryData | null>;
+    /**
+     * Checks if a memory entry exists in persistence storage.
+     *
+     * @param signalId - Signal identifier
+     * @param bucketName - Bucket name
+     * @param memoryId - Memory entry identifier
+     * @returns Promise resolving to true if entry exists
+     */
+    hasMemoryData: (signalId: string, bucketName: string, memoryId: string) => Promise<boolean>;
+    /**
+     * Writes a memory entry to disk with atomic file writes.
+     *
+     * @param data - Entry data to persist
+     * @param signalId - Signal identifier
+     * @param bucketName - Bucket name
+     * @param memoryId - Memory entry identifier
+     * @returns Promise that resolves when write is complete
+     */
+    writeMemoryData: (data: MemoryData, signalId: string, bucketName: string, memoryId: string) => Promise<void>;
+    /**
+     * Marks a memory entry as removed (soft delete — file is kept on disk).
+     *
+     * @param signalId - Signal identifier
+     * @param bucketName - Bucket name
+     * @param memoryId - Memory entry identifier
+     * @returns Promise that resolves when removal is complete
+     */
+    removeMemoryData: (signalId: string, bucketName: string, memoryId: string) => Promise<void>;
+    /**
+     * Lists all memory entry IDs for a given (signalId, bucketName) pair.
+     * Used by MemoryPersistInstance to rebuild the BM25 index on init.
+     *
+     * @param signalId - Signal identifier
+     * @param bucketName - Bucket name
+     * @returns AsyncGenerator yielding memory entry IDs
+     */
+    listMemoryData(signalId: string, bucketName: string): AsyncGenerator<{
+        memoryId: string;
+        data: MemoryData;
+    }>;
+    /**
+     * Dispose persist adapter to prevent memory leak
+     *
+     * @param signalId - Signal identifier
+     * @param bucketName - Bucket name
+     */
+    clear: (signalId: string, bucketName: string) => void;
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson(): void;
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy(): void;
+}
+/**
+ * Global singleton instance of PersistMemoryUtils.
+ * Used by MemoryPersistInstance for crash-safe memory entry persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistMemoryAdapter.usePersistMemoryAdapter(RedisPersist);
+ *
+ * // Write entry
+ * await PersistMemoryAdapter.writeMemoryData({ foo: "bar" }, "sig-1", "strategy", "context");
+ *
+ * // Read entry
+ * const data = await PersistMemoryAdapter.readMemoryData("sig-1", "strategy", "context");
+ * ```
+ */
+declare const PersistMemoryAdapter: PersistMemoryUtils;
 
+/** Symbol key for the singleshot waitForInit function on ReportBase instances. */
 declare const WAIT_FOR_INIT_SYMBOL$1: unique symbol;
+/** Symbol key for the timeout-protected write function on ReportBase instances. */
 declare const WRITE_SAFE_SYMBOL$1: unique symbol;
 /**
  * Configuration interface for selective report service enablement.
@@ -11593,7 +12034,9 @@ interface IMarkdownTarget {
     /** Enable highest profit milestone tracking reports */
     highest_profit: boolean;
 }
+/** Symbol key for the singleshot waitForInit function on MarkdownFileBase instances. */
 declare const WAIT_FOR_INIT_SYMBOL: unique symbol;
+/** Symbol key for the timeout-protected write function on MarkdownFileBase instances. */
 declare const WRITE_SAFE_SYMBOL: unique symbol;
 /**
  * Union type of all valid markdown report names.
@@ -12236,7 +12679,7 @@ declare class BacktestUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => AsyncGenerator<IStrategyTickResultScheduled | IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, unknown>;
+    }) => AsyncGenerator<IStrategyTickResultScheduled | IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, any>;
     /**
      * Runs backtest in background without yielding results.
      *
@@ -12283,7 +12726,7 @@ declare class BacktestUtils {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => Promise<IPublicSignalRow>;
+    }) => Promise<IPublicSignalRow | null>;
     /**
      * Returns the percentage of the position currently held (not closed).
      * 100 = nothing has been closed (full position), 0 = fully closed.
@@ -13579,7 +14022,7 @@ declare class LiveUtils {
     getPendingSignal: (symbol: string, currentPrice: number, context: {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
-    }) => Promise<IPublicSignalRow>;
+    }) => Promise<IPublicSignalRow | null>;
     /**
      * Returns the percentage of the position currently held (not closed).
      * 100 = nothing has been closed (full position), 0 = fully closed.
@@ -15592,21 +16035,31 @@ declare class HeatMarkdownService {
      */
     unsubscribe: () => Promise<void>;
     /**
-     * Processes tick events and accumulates closed signals.
-     * Should be called from signal emitter subscription.
+     * Handles a single tick event emitted by `signalEmitter`.
      *
-     * Only processes closed signals - opened signals are ignored.
+     * Filters out every action except `"closed"` — idle, scheduled, waiting,
+     * opened, active, and cancelled ticks are silently ignored.
+     * For closed signals, routes the payload to the appropriate `HeatmapStorage`
+     * via `getStorage(exchangeName, frameName, backtest)` and calls `addSignal`.
      *
-     * @param data - Tick result from strategy execution (closed signals only)
+     * @param data - Union tick result from `signalEmitter`; only
+     *   `IStrategyTickResultClosed` payloads are processed
      */
     private tick;
     /**
-     * Gets aggregated portfolio heatmap statistics.
+     * Returns aggregated portfolio heatmap statistics for the given context.
      *
-     * @param exchangeName - Exchange name
-     * @param frameName - Frame name
-     * @param backtest - True if backtest mode, false if live mode
-     * @returns Promise resolving to heatmap statistics with per-symbol and portfolio-wide metrics
+     * Delegates to the `HeatmapStorage` instance identified by
+     * `(exchangeName, frameName, backtest)`. If no signals have been accumulated
+     * yet for that combination, the returned `symbols` array will be empty and
+     * portfolio-level fields will be `null` / `0`.
+     *
+     * @param exchangeName - Exchange identifier (e.g. `"binance"`)
+     * @param frameName - Backtest frame identifier (e.g. `"1m-btc"`)
+     * @param backtest - `true` for backtest mode, `false` for live mode
+     * @returns Promise resolving to `HeatmapStatisticsModel` with per-symbol rows
+     *   sorted by `sharpeRatio` descending and portfolio-wide aggregates
+     * @throws {Error} If `subscribe()` has not been called before this method
      *
      * @example
      * ```typescript
@@ -15623,73 +16076,86 @@ declare class HeatMarkdownService {
      */
     getData: (exchangeName: ExchangeName, frameName: FrameName, backtest: boolean) => Promise<HeatmapStatisticsModel>;
     /**
-     * Generates markdown report with portfolio heatmap table.
+     * Generates a markdown heatmap report for the given context.
      *
-     * @param strategyName - Strategy name for report title
-     * @param exchangeName - Exchange name
-     * @param frameName - Frame name
-     * @param backtest - True if backtest mode, false if live mode
-     * @param columns - Column configuration for formatting the table
-     * @returns Promise resolving to markdown formatted report string
+     * Delegates to `HeatmapStorage.getReport`. The resulting string includes a
+     * portfolio summary line followed by a markdown table with one row per
+     * symbol, ordered by `sharpeRatio` descending.
+     *
+     * @param strategyName - Strategy name rendered in the report heading
+     * @param exchangeName - Exchange identifier (e.g. `"binance"`)
+     * @param frameName - Backtest frame identifier (e.g. `"1m-btc"`)
+     * @param backtest - `true` for backtest mode, `false` for live mode
+     * @param columns - Column definitions controlling the table layout;
+     *   defaults to `COLUMN_CONFIG.heat_columns`
+     * @returns Promise resolving to the full markdown string
+     * @throws {Error} If `subscribe()` has not been called before this method
      *
      * @example
      * ```typescript
      * const service = new HeatMarkdownService();
      * const markdown = await service.getReport("my-strategy", "binance", "frame1", true);
      * console.log(markdown);
-     * // Output:
      * // # Portfolio Heatmap: my-strategy
      * //
      * // **Total Symbols:** 5 | **Portfolio PNL:** +45.3% | **Portfolio Sharpe:** 1.85 | **Total Trades:** 120
      * //
      * // | Symbol | Total PNL | Sharpe | Max DD | Trades |
-     * // |--------|-----------|--------|--------|--------|
-     * // | BTCUSDT | +15.5% | 2.10 | -2.5% | 45 |
-     * // | ETHUSDT | +12.3% | 1.85 | -3.1% | 38 |
-     * // ...
+     * // | ---    | ---       | ---    | ---    | ---    |
+     * // | BTCUSDT | +15.5%  | 2.10   | -2.5%  | 45     |
+     * // | ETHUSDT | +12.3%  | 1.85   | -3.1%  | 38     |
      * ```
      */
     getReport: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$6[]) => Promise<string>;
     /**
-     * Saves heatmap report to disk.
+     * Generates the heatmap report and writes it to disk.
      *
-     * Creates directory if it doesn't exist.
-     * Default filename: {strategyName}.md
+     * Delegates to `HeatmapStorage.dump`. The filename follows the pattern:
+     * - Backtest: `{strategyName}_{exchangeName}_{frameName}_backtest-{timestamp}.md`
+     * - Live:     `{strategyName}_{exchangeName}_live-{timestamp}.md`
      *
-     * @param strategyName - Strategy name for report filename
-     * @param exchangeName - Exchange name
-     * @param frameName - Frame name
-     * @param backtest - True if backtest mode, false if live mode
-     * @param path - Optional directory path to save report (default: "./dump/heatmap")
-     * @param columns - Column configuration for formatting the table
+     * @param strategyName - Strategy name used in the report heading and filename
+     * @param exchangeName - Exchange identifier (e.g. `"binance"`)
+     * @param frameName - Backtest frame identifier (e.g. `"1m-btc"`)
+     * @param backtest - `true` for backtest mode, `false` for live mode
+     * @param path - Directory to write the file into; defaults to `"./dump/heatmap"`
+     * @param columns - Column definitions for table formatting;
+     *   defaults to `COLUMN_CONFIG.heat_columns`
+     * @throws {Error} If `subscribe()` has not been called before this method
      *
      * @example
      * ```typescript
      * const service = new HeatMarkdownService();
      *
-     * // Save to default path: ./dump/heatmap/my-strategy.md
+     * // Save to default path
      * await service.dump("my-strategy", "binance", "frame1", true);
      *
-     * // Save to custom path: ./reports/my-strategy.md
+     * // Save to custom path
      * await service.dump("my-strategy", "binance", "frame1", true, "./reports");
      * ```
      */
     dump: (strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$6[]) => Promise<void>;
     /**
-     * Clears accumulated heatmap data from storage.
-     * If payload is provided, clears only that exchangeName+frameName+backtest combination's data.
-     * If payload is omitted, clears all data.
+     * Evicts memoized `HeatmapStorage` instances, releasing all accumulated signal data.
+     *
+     * - With `payload` — clears only the storage bucket identified by
+     *   `(payload.exchangeName, payload.frameName, payload.backtest)`;
+     *   subsequent calls to `getData` / `getReport` / `dump` for that combination
+     *   will start from an empty state.
+     * - Without `payload` — clears **all** storage buckets across every
+     *   exchange / frame / mode combination.
      *
-     * @param payload - Optional payload with exchangeName, frameName, backtest to clear specific data
+     * Also called internally by the unsubscribe closure returned from `subscribe()`.
+     *
+     * @param payload - Optional scope to restrict which bucket is cleared;
+     *   omit to clear everything
      *
      * @example
      * ```typescript
-     * const service = new HeatMarkdownService();
-     *
-     * // Clear specific exchange+frame+backtest data
+     * // Clear one specific context
      * await service.clear({ exchangeName: "binance", frameName: "frame1", backtest: true });
      *
-     * // Clear all data
+     * // Clear all contexts
      * await service.clear();
      * ```
      */
@@ -16343,12 +16809,129 @@ type Columns$4 = ColumnModel<HighestProfitEvent>;
 declare class HighestProfitMarkdownService {
     private readonly loggerService;
     private getStorage;
+    /**
+     * Subscribes to `highestProfitSubject` to start receiving `HighestProfitContract`
+     * events. Protected against multiple subscriptions via `singleshot` — subsequent
+     * calls return the same unsubscribe function without re-subscribing.
+     *
+     * The returned unsubscribe function clears the `singleshot` state, evicts all
+     * memoized `ReportStorage` instances, and detaches from `highestProfitSubject`.
+     *
+     * @returns Unsubscribe function; calling it tears down the subscription and
+     *   clears all accumulated data
+     *
+     * @example
+     * ```typescript
+     * const service = new HighestProfitMarkdownService();
+     * const unsubscribe = service.subscribe();
+     * // ... later
+     * unsubscribe();
+     * ```
+     */
     subscribe: (() => () => void) & functools_kit.ISingleshotClearable;
-    unsubscribe: () => Promise<void>;
-    private tick;
-    getData: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean) => Promise<HighestProfitStatisticsModel>;
+    /**
+     * Detaches from `highestProfitSubject` and clears all accumulated data.
+     *
+     * Calls the unsubscribe closure returned by `subscribe()`.
+     * If `subscribe()` was never called, does nothing.
+     *
+     * @example
+     * ```typescript
+     * const service = new HighestProfitMarkdownService();
+     * service.subscribe();
+     * // ... later
+     * await service.unsubscribe();
+     * ```
+     */
+    unsubscribe: () => Promise<void>;
+    /**
+     * Handles a single `HighestProfitContract` event emitted by `highestProfitSubject`.
+     *
+     * Routes the payload to the appropriate `ReportStorage` bucket via
+     * `getStorage(symbol, strategyName, exchangeName, frameName, backtest)` —
+     * where `strategyName` is taken from `data.signal.strategyName` — and
+     * delegates event construction to `ReportStorage.addEvent`.
+     *
+     * @param data - `HighestProfitContract` payload containing `symbol`,
+     *   `signal`, `currentPrice`, `backtest`, `timestamp`, `exchangeName`,
+     *   `frameName`
+     */
+    private tick;
+    /**
+     * Returns accumulated highest profit statistics for the given context.
+     *
+     * Delegates to the `ReportStorage` bucket identified by
+     * `(symbol, strategyName, exchangeName, frameName, backtest)`.
+     * If no events have been recorded yet for that combination, the returned
+     * model has an empty `eventList` and `totalEvents` of `0`.
+     *
+     * @param symbol - Trading pair symbol (e.g. `"BTCUSDT"`)
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier (e.g. `"binance"`)
+     * @param frameName - Backtest frame identifier; empty string for live mode
+     * @param backtest - `true` for backtest mode, `false` for live mode
+     * @returns Promise resolving to `HighestProfitStatisticsModel` with
+     *   `eventList` (newest first) and `totalEvents`
+     * @throws {Error} If `subscribe()` has not been called before this method
+     */
+    getData: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean) => Promise<HighestProfitStatisticsModel>;
+    /**
+     * Generates a markdown highest profit report for the given context.
+     *
+     * Delegates to `ReportStorage.getReport`. The resulting string includes a
+     * markdown table (newest events first) followed by the total event count.
+     *
+     * @param symbol - Trading pair symbol (e.g. `"BTCUSDT"`)
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier (e.g. `"binance"`)
+     * @param frameName - Backtest frame identifier; empty string for live mode
+     * @param backtest - `true` for backtest mode, `false` for live mode
+     * @param columns - Column definitions controlling the table layout;
+     *   defaults to `COLUMN_CONFIG.highest_profit_columns`
+     * @returns Promise resolving to the full markdown string
+     * @throws {Error} If `subscribe()` has not been called before this method
+     */
     getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$4[]) => Promise<string>;
+    /**
+     * Generates the highest profit report and writes it to disk.
+     *
+     * Delegates to `ReportStorage.dump`. The filename follows the pattern:
+     * - Backtest: `{symbol}_{strategyName}_{exchangeName}_{frameName}_backtest-{timestamp}.md`
+     * - Live:     `{symbol}_{strategyName}_{exchangeName}_live-{timestamp}.md`
+     *
+     * @param symbol - Trading pair symbol (e.g. `"BTCUSDT"`)
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier (e.g. `"binance"`)
+     * @param frameName - Backtest frame identifier; empty string for live mode
+     * @param backtest - `true` for backtest mode, `false` for live mode
+     * @param path - Directory to write the file into; defaults to `"./dump/highest_profit"`
+     * @param columns - Column definitions for table formatting;
+     *   defaults to `COLUMN_CONFIG.highest_profit_columns`
+     * @throws {Error} If `subscribe()` has not been called before this method
+     */
     dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$4[]) => Promise<void>;
+    /**
+     * Evicts memoized `ReportStorage` instances, releasing all accumulated event data.
+     *
+     * - With `payload` — clears only the storage bucket identified by
+     *   `(symbol, strategyName, exchangeName, frameName, backtest)`;
+     *   subsequent calls for that combination start from an empty state.
+     * - Without `payload` — clears **all** storage buckets.
+     *
+     * Also called internally by the unsubscribe closure returned from `subscribe()`.
+     *
+     * @param payload - Optional scope to restrict which bucket is cleared;
+     *   omit to clear everything
+     *
+     * @example
+     * ```typescript
+     * // Clear one specific context
+     * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy", exchangeName: "binance", frameName: "1m-btc", backtest: true });
+     *
+     * // Clear all contexts
+     * await service.clear();
+     * ```
+     */
     clear: (payload?: {
         symbol: string;
         strategyName: StrategyName;
@@ -16968,12 +17551,133 @@ type Columns$2 = ColumnModel<SyncEvent>;
 declare class SyncMarkdownService {
     private readonly loggerService;
     private getStorage;
+    /**
+     * Subscribes to `syncSubject` to start receiving `SignalSyncContract` events.
+     * Protected against multiple subscriptions via `singleshot` — subsequent calls
+     * return the same unsubscribe function without re-subscribing.
+     *
+     * The returned unsubscribe function clears the `singleshot` state, evicts all
+     * memoized `ReportStorage` instances, and detaches from `syncSubject`.
+     *
+     * @returns Unsubscribe function; calling it tears down the subscription and
+     *   clears all accumulated data
+     *
+     * @example
+     * ```typescript
+     * const service = new SyncMarkdownService();
+     * const unsubscribe = service.subscribe();
+     * // ... later
+     * unsubscribe();
+     * ```
+     */
     subscribe: (() => () => void) & functools_kit.ISingleshotClearable;
+    /**
+     * Detaches from `syncSubject` and clears all accumulated data.
+     *
+     * Calls the unsubscribe closure returned by `subscribe()`.
+     * If `subscribe()` was never called, does nothing.
+     *
+     * @example
+     * ```typescript
+     * const service = new SyncMarkdownService();
+     * service.subscribe();
+     * // ... later
+     * await service.unsubscribe();
+     * ```
+     */
     unsubscribe: () => Promise<void>;
+    /**
+     * Handles a single `SignalSyncContract` event emitted by `syncSubject`.
+     *
+     * Maps the contract fields to a `SyncEvent`, enriching it with a
+     * `createdAt` ISO timestamp from `getContextTimestamp()` (backtest clock
+     * or real clock aligned to the nearest minute).
+     * For `"signal-close"` events, `closeReason` is preserved; for
+     * `"signal-open"` events it is set to `undefined`.
+     *
+     * Routes the constructed event to the appropriate `ReportStorage` bucket
+     * via `getStorage(symbol, strategyName, exchangeName, frameName, backtest)`.
+     *
+     * @param data - Discriminated union `SignalSyncContract`
+     *   (`SignalOpenContract | SignalCloseContract`)
+     */
     private tick;
+    /**
+     * Returns accumulated sync statistics for the given context.
+     *
+     * Delegates to the `ReportStorage` bucket identified by
+     * `(symbol, strategyName, exchangeName, frameName, backtest)`.
+     * If no events have been recorded yet for that combination, the returned
+     * model has an empty `eventList` and all counters set to `0`.
+     *
+     * @param symbol - Trading pair symbol (e.g. `"BTCUSDT"`)
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier (e.g. `"binance"`)
+     * @param frameName - Backtest frame identifier; empty string for live mode
+     * @param backtest - `true` for backtest mode, `false` for live mode
+     * @returns Promise resolving to `SyncStatisticsModel` with `eventList`,
+     *   `totalEvents`, `openCount`, `closeCount`
+     * @throws {Error} If `subscribe()` has not been called before this method
+     */
     getData: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean) => Promise<SyncStatisticsModel>;
+    /**
+     * Generates a markdown sync report for the given context.
+     *
+     * Delegates to `ReportStorage.getReport`. The resulting string includes a
+     * markdown table (newest events first) followed by total / open / close
+     * counters.
+     *
+     * @param symbol - Trading pair symbol (e.g. `"BTCUSDT"`)
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier (e.g. `"binance"`)
+     * @param frameName - Backtest frame identifier; empty string for live mode
+     * @param backtest - `true` for backtest mode, `false` for live mode
+     * @param columns - Column definitions controlling the table layout;
+     *   defaults to `COLUMN_CONFIG.sync_columns`
+     * @returns Promise resolving to the full markdown string
+     * @throws {Error} If `subscribe()` has not been called before this method
+     */
     getReport: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, columns?: Columns$2[]) => Promise<string>;
+    /**
+     * Generates the sync report and writes it to disk.
+     *
+     * Delegates to `ReportStorage.dump`. The filename follows the pattern:
+     * - Backtest: `{symbol}_{strategyName}_{exchangeName}_{frameName}_backtest-{timestamp}.md`
+     * - Live:     `{symbol}_{strategyName}_{exchangeName}_live-{timestamp}.md`
+     *
+     * @param symbol - Trading pair symbol (e.g. `"BTCUSDT"`)
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier (e.g. `"binance"`)
+     * @param frameName - Backtest frame identifier; empty string for live mode
+     * @param backtest - `true` for backtest mode, `false` for live mode
+     * @param path - Directory to write the file into; defaults to `"./dump/sync"`
+     * @param columns - Column definitions for table formatting;
+     *   defaults to `COLUMN_CONFIG.sync_columns`
+     * @throws {Error} If `subscribe()` has not been called before this method
+     */
     dump: (symbol: string, strategyName: StrategyName, exchangeName: ExchangeName, frameName: FrameName, backtest: boolean, path?: string, columns?: Columns$2[]) => Promise<void>;
+    /**
+     * Evicts memoized `ReportStorage` instances, releasing all accumulated event data.
+     *
+     * - With `payload` — clears only the storage bucket identified by
+     *   `(symbol, strategyName, exchangeName, frameName, backtest)`;
+     *   subsequent calls for that combination start from an empty state.
+     * - Without `payload` — clears **all** storage buckets.
+     *
+     * Also called internally by the unsubscribe closure returned from `subscribe()`.
+     *
+     * @param payload - Optional scope to restrict which bucket is cleared;
+     *   omit to clear everything
+     *
+     * @example
+     * ```typescript
+     * // Clear one specific context
+     * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy", exchangeName: "binance", frameName: "1m-btc", backtest: true });
+     *
+     * // Clear all contexts
+     * await service.clear();
+     * ```
+     */
     clear: (payload?: {
         symbol: string;
         strategyName: StrategyName;
@@ -17153,6 +17857,18 @@ interface IStorageUtils {
      * @returns Array of all signal rows
      */
     list(): Promise<IStorageSignalRow[]>;
+    /**
+     * Handles active ping event for opened signals.
+     * Updates updatedAt for the signal if it is currently opened.
+     * @param event - The active ping event data
+     */
+    handleActivePing(event: ActivePingContract): Promise<void>;
+    /**
+     * Handles schedule ping event for scheduled signals.
+     * Updates updatedAt for the signal if it is currently scheduled.
+     * @param event - The schedule ping event data
+     */
+    handleSchedulePing(event: SchedulePingContract): Promise<void>;
 }
 /**
  * Constructor type for storage adapters.
@@ -17208,6 +17924,8 @@ declare class StorageBacktestAdapter implements IStorageUtils {
      * @returns Array of all signal rows
      */
     list: () => Promise<IStorageSignalRow[]>;
+    handleActivePing: (event: ActivePingContract) => Promise<void>;
+    handleSchedulePing: (event: SchedulePingContract) => Promise<void>;
     /**
      * Sets the storage adapter constructor.
      * All future storage operations will use this adapter.
@@ -17280,6 +17998,8 @@ declare class StorageLiveAdapter implements IStorageUtils {
      * @returns Array of all signal rows
      */
     list: () => Promise<IStorageSignalRow[]>;
+    handleActivePing: (event: ActivePingContract) => Promise<void>;
+    handleSchedulePing: (event: SchedulePingContract) => Promise<void>;
     /**
      * Sets the storage adapter constructor.
      * All future storage operations will use this adapter.
@@ -17699,6 +18419,370 @@ declare const NotificationLive: NotificationLiveAdapter;
  */
 declare const NotificationBacktest: NotificationBacktestAdapter;
 
+/**
+ * Tuning parameters for BM25 full-text search scoring.
+ * Controls term frequency saturation, document length normalization, and minimum score threshold.
+ */
+type SearchSettings = {
+    /**
+     * Term frequency saturation parameter.
+     * Higher values give more weight to repeated terms; lower values saturate faster.
+     * Typical range: 1.2–2.0. Default: 1.5.
+     */
+    BM25_K1: number;
+    /**
+     * Document length normalization factor.
+     * 0 = no normalization, 1 = full normalization by average document length.
+     * Default: 0.75.
+     */
+    BM25_B: number;
+    /**
+     * Minimum BM25 score threshold for a result to be included in the output.
+     * Results with score below this value are filtered out.
+     * Default: 0.5.
+     */
+    BM25_SCORE: number;
+};
+
+/**
+ * Interface for memory instance implementations.
+ * Defines the contract for local, persist, and dummy backends.
+ */
+interface IMemoryInstance {
+    /**
+     * Initialize the memory instance.
+     * @param initial - Whether this is the first initialization
+     */
+    waitForInit(initial: boolean): Promise<void>;
+    /**
+     * Write a value to memory.
+     * @param memoryId - Unique entry identifier
+     * @param value - Value to store
+     * @param index - Optional BM25 index string; defaults to JSON.stringify(value)
+     */
+    writeMemory<T extends object = object>(memoryId: string, value: T, index?: string): Promise<void>;
+    /**
+     * Search memory using BM25 full-text scoring.
+     * @param query - Search query string
+     * @returns Array of matching entries with scores
+     */
+    searchMemory<T extends object = object>(query: string, settings?: SearchSettings): Promise<Array<{
+        memoryId: string;
+        score: number;
+        content: T;
+    }>>;
+    /**
+     * List all entries in memory.
+     * @returns Array of all stored entries
+     */
+    listMemory<T extends object = object>(): Promise<Array<{
+        memoryId: string;
+        content: T;
+    }>>;
+    /**
+     * Remove an entry from memory.
+     * @param memoryId - Unique entry identifier
+     */
+    removeMemory(memoryId: string): Promise<void>;
+    /**
+     * Read a single entry from memory.
+     * @param memoryId - Unique entry identifier
+     * @returns Entry value
+     * @throws Error if entry not found
+     */
+    readMemory<T extends object = object>(memoryId: string): Promise<T>;
+    /**
+     * Releases any resources held by this instance.
+     */
+    dispose(): void;
+}
+/**
+ * Constructor type for memory instance implementations.
+ * Used for swapping backends via MemoryAdapter.
+ */
+type TMemoryInstanceCtor = new (signalId: string, bucketName: string) => IMemoryInstance;
+/**
+ * Public surface of MemoryAdapter - IMemoryInstance minus waitForInit.
+ * waitForInit is managed internally by the adapter.
+ */
+type TMemoryInstance = Omit<{
+    [key in keyof IMemoryInstance]: any;
+}, keyof {
+    waitForInit: never;
+}>;
+/**
+ * Facade for memory instances scoped per (signalId, bucketName).
+ * Manages lazy initialization and instance lifecycle.
+ *
+ * Features:
+ * - Memoized instances per (signalId, bucketName) pair
+ * - Swappable backend via useLocal(), usePersist(), useDummy()
+ * - Default backend: MemoryPersistInstance (in-memory BM25 + persist storage)
+ */
+declare class MemoryAdapter implements TMemoryInstance {
+    private MemoryFactory;
+    private getInstance;
+    /**
+     * Activates the adapter by subscribing to signal lifecycle events.
+     * Clears memoized instances for a signalId when it is cancelled or closed,
+     * preventing stale instances from accumulating in memory.
+     * Idempotent — subsequent calls return the same subscription handle.
+     * Must be called before any memory method is used.
+     */
+    enable: (() => (...args: any[]) => any) & functools_kit.ISingleshotClearable;
+    /**
+     * Deactivates the adapter by unsubscribing from signal lifecycle events.
+     * No-op if enable() was never called.
+     */
+    disable: () => void;
+    /**
+     * Write a value to memory.
+     * @param dto.memoryId - Unique entry identifier
+     * @param dto.value - Value to store
+     * @param dto.signalId - Signal identifier
+     * @param dto.bucketName - Bucket name
+     * @param dto.index - Optional BM25 index string; defaults to JSON.stringify(value)
+     */
+    writeMemory: <T extends object = object>(dto: {
+        memoryId: string;
+        value: T;
+        signalId: string;
+        bucketName: string;
+        index?: string;
+    }) => Promise<void>;
+    /**
+     * Search memory using BM25 full-text scoring.
+     * @param dto.query - Search query string
+     * @param dto.signalId - Signal identifier
+     * @param dto.bucketName - Bucket name
+     * @returns Matching entries sorted by relevance score
+     */
+    searchMemory: <T extends object = object>(dto: {
+        query: string;
+        signalId: string;
+        bucketName: string;
+        settings?: SearchSettings;
+    }) => Promise<{
+        memoryId: string;
+        score: number;
+        content: T;
+    }[]>;
+    /**
+     * List all entries in memory.
+     * @param dto.signalId - Signal identifier
+     * @param dto.bucketName - Bucket name
+     * @returns Array of all stored entries
+     */
+    listMemory: <T extends object = object>(dto: {
+        signalId: string;
+        bucketName: string;
+    }) => Promise<{
+        memoryId: string;
+        content: T;
+    }[]>;
+    /**
+     * Remove an entry from memory.
+     * @param dto.memoryId - Unique entry identifier
+     * @param dto.signalId - Signal identifier
+     * @param dto.bucketName - Bucket name
+     */
+    removeMemory: (dto: {
+        memoryId: string;
+        signalId: string;
+        bucketName: string;
+    }) => Promise<void>;
+    /**
+     * Read a single entry from memory.
+     * @param dto.memoryId - Unique entry identifier
+     * @param dto.signalId - Signal identifier
+     * @param dto.bucketName - Bucket name
+     * @returns Entry value
+     * @throws Error if entry not found
+     */
+    readMemory: <T extends object = object>(dto: {
+        memoryId: string;
+        signalId: string;
+        bucketName: string;
+    }) => Promise<T>;
+    /**
+     * Switches to in-memory BM25 adapter (default).
+     * All data lives in process memory only.
+     */
+    useLocal: () => void;
+    /**
+     * Switches to file-system backed adapter.
+     * Data is persisted to ./dump/memory/<signalId>/<bucketName>/.
+     */
+    usePersist: () => void;
+    /**
+     * Switches to dummy adapter that discards all writes.
+     */
+    useDummy: () => void;
+    /**
+     * Releases resources held by this adapter.
+     * Delegates to disable() to unsubscribe from signal lifecycle events.
+     */
+    dispose: () => void;
+}
+declare const Memory: MemoryAdapter;
+
+/**
+ * Context required to identify a dump entry.
+ * Passed only through DumpAdapter - instances receive signalId and bucketName via constructor.
+ */
+interface IDumpContext {
+    /** Signal identifier - scopes the dump to a specific trade */
+    signalId: string;
+    /** Bucket name - groups dumps by strategy or agent name */
+    bucketName: string;
+    /** Unique identifier for this dump entry */
+    dumpId: string;
+    /** Human-readable label describing the dump contents; included in the BM25 index for Memory search and rendered in Markdown output */
+    description: string;
+}
+/**
+ * Interface for dump instance implementations.
+ * Instances are scoped to (signalId, bucketName) via constructor.
+ * Methods receive only the payload and dumpId.
+ */
+interface IDumpInstance {
+    /**
+     * Persist the full message history of one agent invocation.
+     * @param messages - Full chat history (system, user, assistant, tool)
+     * @param dumpId - Unique identifier for this dump entry
+     * @param description - Human-readable label describing the agent invocation context; included in the BM25 index for Memory search
+     */
+    dumpAgentAnswer(messages: MessageModel[], dumpId: string, description: string): Promise<void>;
+    /**
+     * Persist a flat key-value record.
+     * @param record - Arbitrary flat object to dump
+     * @param dumpId - Unique identifier for this dump entry
+     * @param description - Human-readable label describing the record contents; included in the BM25 index for Memory search
+     */
+    dumpRecord(record: Record<string, unknown>, dumpId: string, description: string): Promise<void>;
+    /**
+     * Persist an array of objects as a table.
+     * Column headers are derived from the union of all keys across all rows.
+     * @param rows - Array of arbitrary objects to dump
+     * @param dumpId - Unique identifier for this dump entry
+     * @param description - Human-readable label describing the table contents; included in the BM25 index for Memory search
+     */
+    dumpTable(rows: Record<string, unknown>[], dumpId: string, description: string): Promise<void>;
+    /**
+     * Persist a raw text or markdown string.
+     * @param content - Arbitrary text content to dump
+     * @param dumpId - Unique identifier for this dump entry
+     * @param description - Human-readable label describing the content; included in the BM25 index for Memory search
+     */
+    dumpText(content: string, dumpId: string, description: string): Promise<void>;
+    /**
+     * Persist an error description.
+     * @param content - Error message or description to dump
+     * @param dumpId - Unique identifier for this dump entry
+     * @param description - Human-readable label describing the error context; included in the BM25 index for Memory search
+     */
+    dumpError(content: string, dumpId: string, description: string): Promise<void>;
+    /**
+     * Persist an arbitrary nested object as a fenced JSON block.
+     * @param json - Arbitrary object to serialize with JSON.stringify
+     * @param dumpId - Unique identifier for this dump entry
+     * @param description - Human-readable label describing the object contents; included in the BM25 index for Memory search
+     * @deprecated Prefer dumpRecord - flat key-value structure maps naturally to markdown tables and SQL storage
+     */
+    dumpJson(json: object, dumpId: string, description: string): Promise<void>;
+    /**
+     * Releases any resources held by this instance.
+     */
+    dispose(): void;
+}
+/**
+ * Constructor type for dump instance implementations.
+ * Used for swapping backends via DumpAdapter.useDumpAdapter().
+ */
+type TDumpInstanceCtor = new (signalId: string, bucketName: string) => IDumpInstance;
+/**
+ * Facade for dump instances with swappable backend.
+ * Default backend: DumpMarkdownInstance.
+ *
+ * Accepts IDumpContext on every call, constructs a scoped instance per (signalId, bucketName),
+ * and delegates with only the dumpId.
+ *
+ * Switch backends via:
+ * - useMarkdown() - write one .md file per call (default)
+ * - useMemory()   - store data in Memory
+ * - useDummy()    - no-op, discard all writes
+ * - useDumpAdapter(Ctor) - inject a custom implementation
+ */
+declare class DumpAdapter {
+    private DumpFactory;
+    private getInstance;
+    /**
+     * Activates the adapter by subscribing to signal lifecycle events.
+     * Clears memoized instances for a signalId when it is cancelled or closed,
+     * preventing stale instances from accumulating in memory.
+     * Idempotent — subsequent calls return the same subscription handle.
+     * Must be called before any dump method is used.
+     */
+    enable: (() => (...args: any[]) => any) & functools_kit.ISingleshotClearable;
+    /**
+     * Deactivates the adapter by unsubscribing from signal lifecycle events.
+     * No-op if enable() was never called.
+     */
+    disable: () => void;
+    /**
+     * Persist the full message history of one agent invocation.
+     */
+    dumpAgentAnswer: (messages: MessageModel[], context: IDumpContext) => Promise<void>;
+    /**
+     * Persist a flat key-value record.
+     */
+    dumpRecord: (record: Record<string, unknown>, context: IDumpContext) => Promise<void>;
+    /**
+     * Persist an array of objects as a table.
+     */
+    dumpTable: (rows: Record<string, unknown>[], context: IDumpContext) => Promise<void>;
+    /**
+     * Persist raw text content.
+     */
+    dumpText: (content: string, context: IDumpContext) => Promise<void>;
+    /**
+     * Persist an error description.
+     */
+    dumpError: (content: string, context: IDumpContext) => Promise<void>;
+    /**
+     * Persist an arbitrary nested object as a fenced JSON block.
+     * @deprecated Prefer dumpRecord - flat key-value structure maps naturally to markdown tables and SQL storage
+     */
+    dumpJson: (json: object, context: IDumpContext) => Promise<void>;
+    /**
+     * Switches to markdown backend (default).
+     * Writes one .md file per call to ./dump/agent/{signalId}/{bucketName}/{dumpId}.md
+     */
+    useMarkdown: () => void;
+    /**
+     * Switches to memory backend.
+     * Stores data via Memory.writeMemory.
+     */
+    useMemory: () => void;
+    /**
+     * Switches to dummy backend.
+     * All writes are discarded.
+     */
+    useDummy: () => void;
+    /**
+     * Switches to dual-write backend.
+     * Writes to both Memory and Markdown simultaneously.
+     */
+    useMarkdownMemoryBoth: () => void;
+    /**
+     * Injects a custom dump adapter implementation.
+     * Uses Reflect.construct for ES3/ES6 interop compatibility.
+     * @param Ctor - Constructor for the custom dump implementation
+     */
+    useDumpAdapter: (Ctor: TDumpInstanceCtor) => void;
+}
+declare const Dump: DumpAdapter;
+
 /**
  * Utility class for exchange operations.
  *
@@ -19940,15 +21024,49 @@ type BrokerAverageBuyPayload = {
     /** true when called during a backtest run — adapter should skip exchange calls */
     backtest: boolean;
 };
+/**
+ * Broker adapter interface for live order execution.
+ *
+ * Implement this interface to connect the framework to a real exchange or broker.
+ * All methods are called BEFORE the corresponding DI-core state mutation, so if any
+ * method throws, the internal state remains unchanged (transaction semantics).
+ *
+ * In backtest mode all calls are silently skipped by BrokerAdapter — the adapter
+ * never receives backtest traffic.
+ *
+ * @example
+ * ```typescript
+ * class MyBroker implements IBroker {
+ *   async waitForInit() {
+ *     await this.exchange.connect();
+ *   }
+ *   async onSignalOpenCommit(payload) {
+ *     await this.exchange.placeOrder({ symbol: payload.symbol, side: payload.position });
+ *   }
+ *   // ... other methods
+ * }
+ *
+ * Broker.useBrokerAdapter(MyBroker);
+ * ```
+ */
 interface IBroker {
+    /** Called once before first use. Connect to exchange, load credentials, etc. */
     waitForInit(): Promise<void>;
+    /** Called when a new signal is closed (take-profit, stop-loss, or manual close). */
     onSignalCloseCommit(payload: BrokerSignalClosePayload): Promise<void>;
+    /** Called when a new signal is opened (position entry confirmed). */
     onSignalOpenCommit(payload: BrokerSignalOpenPayload): Promise<void>;
+    /** Called when a partial profit close is committed. */
     onPartialProfitCommit(payload: BrokerPartialProfitPayload): Promise<void>;
+    /** Called when a partial loss close is committed. */
     onPartialLossCommit(payload: BrokerPartialLossPayload): Promise<void>;
+    /** Called when a trailing stop update is committed. */
     onTrailingStopCommit(payload: BrokerTrailingStopPayload): Promise<void>;
+    /** Called when a trailing take-profit update is committed. */
     onTrailingTakeCommit(payload: BrokerTrailingTakePayload): Promise<void>;
+    /** Called when a breakeven stop is committed (stop loss moved to entry price). */
     onBreakevenCommit(payload: BrokerBreakevenPayload): Promise<void>;
+    /** Called when a DCA (average-buy) entry is committed. */
     onAverageBuyCommit(payload: BrokerAverageBuyPayload): Promise<void>;
 }
 type TBrokerCtor = new () => Partial<IBroker>;
@@ -22532,7 +23650,7 @@ declare class StrategyConnectionService implements TStrategy$1 {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }, candles: ICandleData[]) => Promise<IStrategyTickResultClosed | IStrategyTickResultCancelled>;
+    }, candles: ICandleData[]) => Promise<IStrategyTickResultClosed | IStrategyTickResultCancelled | IStrategyTickResultActive>;
     /**
      * Stops the specified strategy from generating new signals.
      *
@@ -23932,7 +25050,7 @@ declare class StrategyCoreService implements TStrategy {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => Promise<IStrategyTickResultClosed | IStrategyTickResultCancelled>;
+    }) => Promise<IStrategyTickResultClosed | IStrategyTickResultCancelled | IStrategyTickResultActive>;
     /**
      * Stops the strategy from generating new signals.
      *
@@ -25091,12 +26209,14 @@ declare class WalkerSchemaService {
  * Supports early termination via break in consumer.
  */
 declare class BacktestLogicPrivateService {
-    private readonly loggerService;
-    private readonly strategyCoreService;
-    private readonly exchangeCoreService;
-    private readonly frameCoreService;
-    private readonly methodContextService;
-    private readonly actionCoreService;
+    readonly loggerService: LoggerService;
+    readonly strategyCoreService: StrategyCoreService;
+    readonly exchangeCoreService: ExchangeCoreService;
+    readonly frameCoreService: FrameCoreService;
+    readonly methodContextService: {
+        readonly context: IMethodContext;
+    };
+    readonly actionCoreService: ActionCoreService;
     /**
      * Runs backtest for a symbol, streaming closed signals as async generator.
      *
@@ -25111,7 +26231,7 @@ declare class BacktestLogicPrivateService {
      * }
      * ```
      */
-    run(symbol: string): AsyncGenerator<IStrategyTickResultScheduled | IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, unknown>;
+    run(symbol: string): AsyncGenerator<IStrategyTickResultScheduled | IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, any>;
 }
 
 /**
@@ -25168,6 +26288,7 @@ type IBacktestLogicPrivateService = Omit<BacktestLogicPrivateService, keyof {
     strategyCoreService: never;
     exchangeCoreService: never;
     frameCoreService: never;
+    actionCoreService: never;
     methodContextService: never;
 }>;
 /**
@@ -25218,7 +26339,7 @@ declare class BacktestLogicPublicService implements TBacktestLogicPrivateService
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => AsyncGenerator<IStrategyTickResultScheduled | IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, unknown>;
+    }) => AsyncGenerator<IStrategyTickResultScheduled | IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, any>;
 }
 
 /**
@@ -25357,7 +26478,7 @@ declare class BacktestCommandService implements TBacktestLogicPublicService {
         strategyName: StrategyName;
         exchangeName: ExchangeName;
         frameName: FrameName;
-    }) => AsyncGenerator<IStrategyTickResultScheduled | IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, unknown>;
+    }) => AsyncGenerator<IStrategyTickResultScheduled | IStrategyTickResultOpened | IStrategyTickResultClosed | IStrategyTickResultCancelled, void, any>;
 }
 
 /**
@@ -26940,8 +28061,57 @@ declare class SyncReportService {
  */
 declare class HighestProfitReportService {
     private readonly loggerService;
+    /**
+     * Handles a single `HighestProfitContract` event emitted by `highestProfitSubject`.
+     *
+     * Writes a JSONL record to the `"highest_profit"` report database via
+     * `Report.writeData`, capturing the full signal snapshot at the moment
+     * the new profit record was set:
+     * - `timestamp`, `symbol`, `strategyName`, `exchangeName`, `frameName`, `backtest`
+     * - `signalId`, `position`, `currentPrice`
+     * - `priceOpen`, `priceTakeProfit`, `priceStopLoss` (effective values from the signal)
+     *
+     * `strategyName` and signal-level fields are sourced from `data.signal`
+     * rather than the contract root.
+     *
+     * @param data - `HighestProfitContract` payload containing `symbol`,
+     *   `signal`, `currentPrice`, `backtest`, `timestamp`, `exchangeName`,
+     *   `frameName`
+     */
     private tick;
+    /**
+     * Subscribes to `highestProfitSubject` to start persisting profit records.
+     * Protected against multiple subscriptions via `singleshot` — subsequent
+     * calls return the same unsubscribe function without re-subscribing.
+     *
+     * The returned unsubscribe function clears the `singleshot` state and
+     * detaches from `highestProfitSubject`.
+     *
+     * @returns Unsubscribe function; calling it tears down the subscription
+     *
+     * @example
+     * ```typescript
+     * const service = new HighestProfitReportService();
+     * const unsubscribe = service.subscribe();
+     * // ... later
+     * unsubscribe();
+     * ```
+     */
     subscribe: (() => () => void) & functools_kit.ISingleshotClearable;
+    /**
+     * Detaches from `highestProfitSubject`, stopping further JSONL writes.
+     *
+     * Calls the unsubscribe closure returned by `subscribe()`.
+     * If `subscribe()` was never called, does nothing.
+     *
+     * @example
+     * ```typescript
+     * const service = new HighestProfitReportService();
+     * service.subscribe();
+     * // ... later
+     * await service.unsubscribe();
+     * ```
+     */
     unsubscribe: () => Promise<void>;
 }
 
@@ -27098,4 +28268,4 @@ declare const getTotalClosed: (signal: Signal) => {
     remainingCostBasis: number;
 };
 
-export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AverageBuyCommit, type AverageBuyCommitNotification, Backtest, type BacktestStatisticsModel, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, type BreakevenEvent, type BreakevenStatisticsModel, Broker, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, Cache, type CancelScheduledCommit, type CancelScheduledCommitNotification, type CandleData, type CandleInterval, type ClosePendingCommit, type ClosePendingCommitNotification, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, HighestProfit, type HighestProfitContract, type HighestProfitEvent, type HighestProfitStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type IBroker, type ICandleData, type ICommitRow, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type INotificationUtils, type IOrderBookData, type IPartialLossCommitRow, type IPartialProfitCommitRow, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicAction, type IPublicCandleData, type IPublicSignalRow, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskSignalRow, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingParams, type ISizingParamsATR, type ISizingParamsFixedPercentage, type ISizingParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStorageSignalRow, type IStorageUtils, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IStrategyTickResultWaiting, type ITrailingStopCommitRow, type ITrailingTakeCommitRow, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type InfoErrorNotification, Live, type LiveStatisticsModel, Log, type LogData, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, type MeasureData, MethodContextService, type MetricStats, Notification, NotificationBacktest, type NotificationData, NotificationLive, type NotificationModel, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossAvailableNotification, type PartialLossCommit, type PartialLossCommitNotification, type PartialLossContract, type PartialProfitAvailableNotification, type PartialProfitCommit, type PartialProfitCommitNotification, type PartialProfitContract, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, type ProgressBacktestContract, type ProgressWalkerContract, Report, ReportBase, type ReportName, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, Schedule, type ScheduleData, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, type SignalCancelledNotification, type SignalCloseContract, type SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenContract, type SignalOpenedNotification, type SignalScheduledNotification, type SignalSyncCloseNotification, type SignalSyncContract, type SignalSyncOpenNotification, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, Sync, type SyncEvent, type SyncStatisticsModel, type TBrokerCtor, type TLogCtor, type TMarkdownBase, type TNotificationUtilsCtor, type TPersistBase, type TPersistBaseCtor, type TReportBase, type TStorageUtilsCtor, type TickEvent, type TrailingStopCommit, type TrailingStopCommitNotification, type TrailingTakeCommit, type TrailingTakeCommitNotification, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, roundTicks, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, waitForCandle, warmCandles };
+export { ActionBase, type ActivateScheduledCommit, type ActivateScheduledCommitNotification, type ActivePingContract, type AverageBuyCommit, type AverageBuyCommitNotification, Backtest, type BacktestStatisticsModel, Breakeven, type BreakevenAvailableNotification, type BreakevenCommit, type BreakevenCommitNotification, type BreakevenContract, type BreakevenData, type BreakevenEvent, type BreakevenStatisticsModel, Broker, type BrokerAverageBuyPayload, BrokerBase, type BrokerBreakevenPayload, type BrokerPartialLossPayload, type BrokerPartialProfitPayload, type BrokerSignalClosePayload, type BrokerSignalOpenPayload, type BrokerTrailingStopPayload, type BrokerTrailingTakePayload, Cache, type CancelScheduledCommit, type CancelScheduledCommitNotification, type CandleData, type CandleInterval, type ClosePendingCommit, type ClosePendingCommitNotification, type ColumnConfig, type ColumnModel, Constant, type CriticalErrorNotification, type DoneContract, Dump, type EntityId, Exchange, ExecutionContextService, type FrameInterval, type GlobalConfig, Heat, type HeatmapStatisticsModel, HighestProfit, type HighestProfitContract, type HighestProfitEvent, type HighestProfitStatisticsModel, type IActionSchema, type IActivateScheduledCommitRow, type IAggregatedTradeData, type IBidData, type IBreakevenCommitRow, type IBroker, type ICandleData, type ICommitRow, type IDumpContext, type IDumpInstance, type IExchangeSchema, type IFrameSchema, type IHeatmapRow, type ILog, type ILogEntry, type ILogger, type IMarkdownDumpOptions, type IMemoryInstance, type INotificationUtils, type IOrderBookData, type IPartialLossCommitRow, type IPartialProfitCommitRow, type IPersistBase, type IPositionSizeATRParams, type IPositionSizeFixedPercentageParams, type IPositionSizeKellyParams, type IPublicAction, type IPublicCandleData, type IPublicSignalRow, type IReportDumpOptions, type IRiskActivePosition, type IRiskCheckArgs, type IRiskSchema, type IRiskSignalRow, type IRiskValidation, type IRiskValidationFn, type IRiskValidationPayload, type IScheduledSignalCancelRow, type IScheduledSignalRow, type ISignalDto, type ISignalRow, type ISizingCalculateParams, type ISizingCalculateParamsATR, type ISizingCalculateParamsFixedPercentage, type ISizingCalculateParamsKelly, type ISizingParams, type ISizingParamsATR, type ISizingParamsFixedPercentage, type ISizingParamsKelly, type ISizingSchema, type ISizingSchemaATR, type ISizingSchemaFixedPercentage, type ISizingSchemaKelly, type IStorageSignalRow, type IStorageUtils, type IStrategyPnL, type IStrategyResult, type IStrategySchema, type IStrategyTickResult, type IStrategyTickResultActive, type IStrategyTickResultCancelled, type IStrategyTickResultClosed, type IStrategyTickResultIdle, type IStrategyTickResultOpened, type IStrategyTickResultScheduled, type IStrategyTickResultWaiting, type ITrailingStopCommitRow, type ITrailingTakeCommitRow, type IWalkerResults, type IWalkerSchema, type IWalkerStrategyResult, type InfoErrorNotification, Live, type LiveStatisticsModel, Log, type LogData, Markdown, MarkdownFileBase, MarkdownFolderBase, type MarkdownName, type MeasureData, Memory, type MemoryData, type MessageModel, type MessageRole, type MessageToolCall, MethodContextService, type MetricStats, Notification, NotificationBacktest, type NotificationData, NotificationLive, type NotificationModel, Partial$1 as Partial, type PartialData, type PartialEvent, type PartialLossAvailableNotification, type PartialLossCommit, type PartialLossCommitNotification, type PartialLossContract, type PartialProfitAvailableNotification, type PartialProfitCommit, type PartialProfitCommitNotification, type PartialProfitContract, type PartialStatisticsModel, Performance, type PerformanceContract, type PerformanceMetricType, type PerformanceStatisticsModel, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistMemoryAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, type ProgressBacktestContract, type ProgressWalkerContract, Report, ReportBase, type ReportName, Risk, type RiskContract, type RiskData, type RiskEvent, type RiskRejectionNotification, type RiskStatisticsModel, Schedule, type ScheduleData, type SchedulePingContract, type ScheduleStatisticsModel, type ScheduledEvent, type SignalCancelledNotification, type SignalCloseContract, type SignalClosedNotification, type SignalData, type SignalInterval, type SignalOpenContract, type SignalOpenedNotification, type SignalScheduledNotification, type SignalSyncCloseNotification, type SignalSyncContract, type SignalSyncOpenNotification, Storage, StorageBacktest, type StorageData, StorageLive, Strategy, type StrategyActionType, type StrategyCancelReason, type StrategyCloseReason, type StrategyCommitContract, type StrategyEvent, type StrategyStatisticsModel, Sync, type SyncEvent, type SyncStatisticsModel, type TBrokerCtor, type TDumpInstanceCtor, type TLogCtor, type TMarkdownBase, type TMemoryInstanceCtor, type TNotificationUtilsCtor, type TPersistBase, type TPersistBaseCtor, type TReportBase, type TStorageUtilsCtor, type TickEvent, type TrailingStopCommit, type TrailingStopCommitNotification, type TrailingTakeCommit, type TrailingTakeCommitNotification, type ValidationErrorNotification, Walker, type WalkerCompleteContract, type WalkerContract, type WalkerMetric, type SignalData$1 as WalkerSignalData, type WalkerStatisticsModel, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, searchMemory, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, waitForCandle, warmCandles, writeMemory };