backtest-kit 2.0.7 → 2.0.8

package/build/index.mjs

@@ -7,6 +7,7 @@ import path, { join, dirname } from 'path';
 import crypto from 'crypto';
 import os from 'os';
 import { createWriteStream } from 'fs';
+import { createRequire } from 'module';
 import { parseArgs as parseArgs$1 } from 'util';
 
 const { init, inject, provide } = createActivator("backtest");
@@ -131,6 +132,16 @@ const validationServices$1 = {
 const templateServices$1 = {
     optimizerTemplateService: Symbol('optimizerTemplateService'),
 };
+const promptServices$1 = {
+    signalPromptService: Symbol('signalPromptService'),
+    riskPromptService: Symbol('riskPromptService'),
+    trailingTakePromptService: Symbol('trailingTakePromptService'),
+    trailingStopPromptService: Symbol('trailingStopPromptService'),
+    partialProfitPromptService: Symbol('partialProfitPromptService'),
+    partialLossPromptService: Symbol('partialLossPromptService'),
+    breakevenPromptService: Symbol('breakevenPromptService'),
+    scheduleCancelPromptService: Symbol('scheduleCancelPromptService'),
+};
 const TYPES = {
     ...baseServices$1,
     ...contextServices$1,
@@ -145,6 +156,7 @@ const TYPES = {
     ...reportServices$1,
     ...validationServices$1,
     ...templateServices$1,
+    ...promptServices$1,
 };
 
 /**
@@ -22965,264 +22977,1137 @@ class RiskReportService {
     }
 }
 
-{
-    provide(TYPES.loggerService, () => new LoggerService());
-}
-{
-    provide(TYPES.executionContextService, () => new ExecutionContextService());
-    provide(TYPES.methodContextService, () => new MethodContextService());
-}
-{
-    provide(TYPES.exchangeConnectionService, () => new ExchangeConnectionService());
-    provide(TYPES.strategyConnectionService, () => new StrategyConnectionService());
-    provide(TYPES.frameConnectionService, () => new FrameConnectionService());
-    provide(TYPES.sizingConnectionService, () => new SizingConnectionService());
-    provide(TYPES.riskConnectionService, () => new RiskConnectionService());
-    provide(TYPES.actionConnectionService, () => new ActionConnectionService());
-    provide(TYPES.optimizerConnectionService, () => new OptimizerConnectionService());
-    provide(TYPES.partialConnectionService, () => new PartialConnectionService());
-    provide(TYPES.breakevenConnectionService, () => new BreakevenConnectionService());
-}
-{
-    provide(TYPES.exchangeSchemaService, () => new ExchangeSchemaService());
-    provide(TYPES.strategySchemaService, () => new StrategySchemaService());
-    provide(TYPES.frameSchemaService, () => new FrameSchemaService());
-    provide(TYPES.walkerSchemaService, () => new WalkerSchemaService());
-    provide(TYPES.sizingSchemaService, () => new SizingSchemaService());
-    provide(TYPES.riskSchemaService, () => new RiskSchemaService());
-    provide(TYPES.actionSchemaService, () => new ActionSchemaService());
-    provide(TYPES.optimizerSchemaService, () => new OptimizerSchemaService());
-}
-{
-    provide(TYPES.exchangeCoreService, () => new ExchangeCoreService());
-    provide(TYPES.strategyCoreService, () => new StrategyCoreService());
-    provide(TYPES.actionCoreService, () => new ActionCoreService());
-    provide(TYPES.frameCoreService, () => new FrameCoreService());
-}
-{
-    provide(TYPES.sizingGlobalService, () => new SizingGlobalService());
-    provide(TYPES.riskGlobalService, () => new RiskGlobalService());
-    provide(TYPES.optimizerGlobalService, () => new OptimizerGlobalService());
-    provide(TYPES.partialGlobalService, () => new PartialGlobalService());
-    provide(TYPES.breakevenGlobalService, () => new BreakevenGlobalService());
-}
-{
-    provide(TYPES.liveCommandService, () => new LiveCommandService());
-    provide(TYPES.backtestCommandService, () => new BacktestCommandService());
-    provide(TYPES.walkerCommandService, () => new WalkerCommandService());
-}
-{
-    provide(TYPES.backtestLogicPrivateService, () => new BacktestLogicPrivateService());
-    provide(TYPES.liveLogicPrivateService, () => new LiveLogicPrivateService());
-    provide(TYPES.walkerLogicPrivateService, () => new WalkerLogicPrivateService());
-}
-{
-    provide(TYPES.backtestLogicPublicService, () => new BacktestLogicPublicService());
-    provide(TYPES.liveLogicPublicService, () => new LiveLogicPublicService());
-    provide(TYPES.walkerLogicPublicService, () => new WalkerLogicPublicService());
-}
-{
-    provide(TYPES.backtestMarkdownService, () => new BacktestMarkdownService());
-    provide(TYPES.liveMarkdownService, () => new LiveMarkdownService());
-    provide(TYPES.scheduleMarkdownService, () => new ScheduleMarkdownService());
-    provide(TYPES.performanceMarkdownService, () => new PerformanceMarkdownService());
-    provide(TYPES.walkerMarkdownService, () => new WalkerMarkdownService());
-    provide(TYPES.heatMarkdownService, () => new HeatMarkdownService());
-    provide(TYPES.partialMarkdownService, () => new PartialMarkdownService());
-    provide(TYPES.breakevenMarkdownService, () => new BreakevenMarkdownService());
-    provide(TYPES.outlineMarkdownService, () => new OutlineMarkdownService());
-    provide(TYPES.riskMarkdownService, () => new RiskMarkdownService());
-}
-{
-    provide(TYPES.backtestReportService, () => new BacktestReportService());
-    provide(TYPES.liveReportService, () => new LiveReportService());
-    provide(TYPES.scheduleReportService, () => new ScheduleReportService());
-    provide(TYPES.performanceReportService, () => new PerformanceReportService());
-    provide(TYPES.walkerReportService, () => new WalkerReportService());
-    provide(TYPES.heatReportService, () => new HeatReportService());
-    provide(TYPES.partialReportService, () => new PartialReportService());
-    provide(TYPES.breakevenReportService, () => new BreakevenReportService());
-    provide(TYPES.riskReportService, () => new RiskReportService());
-}
-{
-    provide(TYPES.exchangeValidationService, () => new ExchangeValidationService());
-    provide(TYPES.strategyValidationService, () => new StrategyValidationService());
-    provide(TYPES.frameValidationService, () => new FrameValidationService());
-    provide(TYPES.walkerValidationService, () => new WalkerValidationService());
-    provide(TYPES.sizingValidationService, () => new SizingValidationService());
-    provide(TYPES.riskValidationService, () => new RiskValidationService());
-    provide(TYPES.actionValidationService, () => new ActionValidationService());
-    provide(TYPES.optimizerValidationService, () => new OptimizerValidationService());
-    provide(TYPES.configValidationService, () => new ConfigValidationService());
-    provide(TYPES.columnValidationService, () => new ColumnValidationService());
-}
-{
-    provide(TYPES.optimizerTemplateService, () => new OptimizerTemplateService());
-}
-
-const baseServices = {
-    loggerService: inject(TYPES.loggerService),
-};
-const contextServices = {
-    executionContextService: inject(TYPES.executionContextService),
-    methodContextService: inject(TYPES.methodContextService),
-};
-const connectionServices = {
-    exchangeConnectionService: inject(TYPES.exchangeConnectionService),
-    strategyConnectionService: inject(TYPES.strategyConnectionService),
-    frameConnectionService: inject(TYPES.frameConnectionService),
-    sizingConnectionService: inject(TYPES.sizingConnectionService),
-    riskConnectionService: inject(TYPES.riskConnectionService),
-    actionConnectionService: inject(TYPES.actionConnectionService),
-    optimizerConnectionService: inject(TYPES.optimizerConnectionService),
-    partialConnectionService: inject(TYPES.partialConnectionService),
-    breakevenConnectionService: inject(TYPES.breakevenConnectionService),
-};
-const schemaServices = {
-    exchangeSchemaService: inject(TYPES.exchangeSchemaService),
-    strategySchemaService: inject(TYPES.strategySchemaService),
-    frameSchemaService: inject(TYPES.frameSchemaService),
-    walkerSchemaService: inject(TYPES.walkerSchemaService),
-    sizingSchemaService: inject(TYPES.sizingSchemaService),
-    riskSchemaService: inject(TYPES.riskSchemaService),
-    actionSchemaService: inject(TYPES.actionSchemaService),
-    optimizerSchemaService: inject(TYPES.optimizerSchemaService),
-};
-const coreServices = {
-    exchangeCoreService: inject(TYPES.exchangeCoreService),
-    strategyCoreService: inject(TYPES.strategyCoreService),
-    actionCoreService: inject(TYPES.actionCoreService),
-    frameCoreService: inject(TYPES.frameCoreService),
-};
-const globalServices = {
-    sizingGlobalService: inject(TYPES.sizingGlobalService),
-    riskGlobalService: inject(TYPES.riskGlobalService),
-    optimizerGlobalService: inject(TYPES.optimizerGlobalService),
-    partialGlobalService: inject(TYPES.partialGlobalService),
-    breakevenGlobalService: inject(TYPES.breakevenGlobalService),
-};
-const commandServices = {
-    liveCommandService: inject(TYPES.liveCommandService),
-    backtestCommandService: inject(TYPES.backtestCommandService),
-    walkerCommandService: inject(TYPES.walkerCommandService),
-};
-const logicPrivateServices = {
-    backtestLogicPrivateService: inject(TYPES.backtestLogicPrivateService),
-    liveLogicPrivateService: inject(TYPES.liveLogicPrivateService),
-    walkerLogicPrivateService: inject(TYPES.walkerLogicPrivateService),
-};
-const logicPublicServices = {
-    backtestLogicPublicService: inject(TYPES.backtestLogicPublicService),
-    liveLogicPublicService: inject(TYPES.liveLogicPublicService),
-    walkerLogicPublicService: inject(TYPES.walkerLogicPublicService),
-};
-const markdownServices = {
-    backtestMarkdownService: inject(TYPES.backtestMarkdownService),
-    liveMarkdownService: inject(TYPES.liveMarkdownService),
-    scheduleMarkdownService: inject(TYPES.scheduleMarkdownService),
-    performanceMarkdownService: inject(TYPES.performanceMarkdownService),
-    walkerMarkdownService: inject(TYPES.walkerMarkdownService),
-    heatMarkdownService: inject(TYPES.heatMarkdownService),
-    partialMarkdownService: inject(TYPES.partialMarkdownService),
-    breakevenMarkdownService: inject(TYPES.breakevenMarkdownService),
-    outlineMarkdownService: inject(TYPES.outlineMarkdownService),
-    riskMarkdownService: inject(TYPES.riskMarkdownService),
-};
-const reportServices = {
-    backtestReportService: inject(TYPES.backtestReportService),
-    liveReportService: inject(TYPES.liveReportService),
-    scheduleReportService: inject(TYPES.scheduleReportService),
-    performanceReportService: inject(TYPES.performanceReportService),
-    walkerReportService: inject(TYPES.walkerReportService),
-    heatReportService: inject(TYPES.heatReportService),
-    partialReportService: inject(TYPES.partialReportService),
-    breakevenReportService: inject(TYPES.breakevenReportService),
-    riskReportService: inject(TYPES.riskReportService),
-};
-const validationServices = {
-    exchangeValidationService: inject(TYPES.exchangeValidationService),
-    strategyValidationService: inject(TYPES.strategyValidationService),
-    frameValidationService: inject(TYPES.frameValidationService),
-    walkerValidationService: inject(TYPES.walkerValidationService),
-    sizingValidationService: inject(TYPES.sizingValidationService),
-    riskValidationService: inject(TYPES.riskValidationService),
-    actionValidationService: inject(TYPES.actionValidationService),
-    optimizerValidationService: inject(TYPES.optimizerValidationService),
-    configValidationService: inject(TYPES.configValidationService),
-    columnValidationService: inject(TYPES.columnValidationService),
-};
-const templateServices = {
-    optimizerTemplateService: inject(TYPES.optimizerTemplateService),
-};
-const backtest = {
-    ...baseServices,
-    ...contextServices,
-    ...connectionServices,
-    ...schemaServices,
-    ...coreServices,
-    ...globalServices,
-    ...commandServices,
-    ...logicPrivateServices,
-    ...logicPublicServices,
-    ...markdownServices,
-    ...reportServices,
-    ...validationServices,
-    ...templateServices,
-};
-init();
-var backtest$1 = backtest;
-
-const GET_TIMEFRAME_METHOD_NAME = "get.getBacktestTimeframe";
-/**
- * Retrieves current backtest timeframe for given symbol.
- * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
- * @returns Promise resolving to array of Date objects representing tick timestamps
- * @throws Error if called outside of backtest execution context
- */
-async function getBacktestTimeframe(symbol) {
-    backtest$1.loggerService.info(GET_TIMEFRAME_METHOD_NAME, { symbol });
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("getBacktestTimeframe requires an execution context");
-    }
-    if (!MethodContextService.hasContext()) {
-        throw new Error("getBacktestTimeframe requires a method context");
-    }
-    if (!backtest$1.executionContextService.context.backtest) {
-        throw new Error("getBacktestTimeframe can only be used during backtest execution");
-    }
-    return await backtest$1.frameCoreService.getTimeframe(symbol, backtest$1.methodContextService.context.frameName);
-}
-
-const METHOD_NAME = "validate.validate";
+const require$7 = createRequire(import.meta.url);
 /**
- * Retrieves all registered exchanges as a map
- * @private
- * @returns Map of exchange names
+ * Default fallback prompt configuration.
+ * Used when signal.prompt.cjs file is not found.
  */
-const getExchangeMap = async () => {
-    const exchangeMap = {};
-    for (const { exchangeName } of await backtest$1.exchangeValidationService.list()) {
-        Object.assign(exchangeMap, { [exchangeName]: exchangeName });
-    }
-    return exchangeMap;
+const DEFAULT_PROMPT$7 = {
+    user: "",
+    system: [],
 };
 /**
- * Retrieves all registered frames as a map
- * @private
- * @returns Map of frame names
+ * Lazy-loads and caches signal prompt configuration.
+ * Attempts to load from config/prompt/signal.prompt.cjs, falls back to DEFAULT_PROMPT if not found.
+ * Uses singleshot pattern to ensure configuration is loaded only once.
+ * @returns Prompt configuration with system and user prompts
  */
-const getFrameMap = async () => {
-    const frameMap = {};
-    for (const { frameName } of await backtest$1.frameValidationService.list()) {
-        Object.assign(frameMap, { [frameName]: frameName });
+const GET_PROMPT_FN$7 = singleshot(() => {
+    try {
+        const modulePath = require$7.resolve(path.join(process.cwd(), `./config/prompt/signal.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as signal.prompt.cjs`);
+        return require$7(modulePath);
     }
-    return frameMap;
-};
+    catch (error) {
+        console.log(`Using empty fallback for signal.prompt.cjs`, error);
+        return DEFAULT_PROMPT$7;
+    }
+});
 /**
- * Retrieves all registered strategies as a map
- * @private
- * @returns Map of strategy names
- */
+ * Service for managing signal prompts for AI/LLM integrations.
+ *
+ * Provides access to system and user prompts configured in signal.prompt.cjs.
+ * Supports both static prompt arrays and dynamic prompt functions.
+ *
+ * Key responsibilities:
+ * - Lazy-loads prompt configuration from config/prompt/signal.prompt.cjs
+ * - Resolves system prompts (static arrays or async functions)
+ * - Provides user prompt strings
+ * - Falls back to empty prompts if configuration is missing
+ *
+ * Used for AI-powered signal analysis and strategy recommendations.
+ */
+class SignalPromptService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Retrieves system prompts for AI context.
+         *
+         * System prompts can be:
+         * - Static array of strings (returned directly)
+         * - Async/sync function returning string array (executed and awaited)
+         * - Undefined (returns empty array)
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to array of system prompt strings
+         */
+        this.getSystemPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("signalPromptService getSystemPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { system } = GET_PROMPT_FN$7();
+            if (Array.isArray(system)) {
+                return system;
+            }
+            if (typeof system === "function") {
+                return await system(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return [];
+        };
+        /**
+         * Retrieves user prompt string for AI input.
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to user prompt string
+         */
+        this.getUserPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("signalPromptService getUserPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { user } = GET_PROMPT_FN$7();
+            if (typeof user === "string") {
+                return user;
+            }
+            if (typeof user === "function") {
+                return await user(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return "";
+        };
+    }
+}
+
+const require$6 = createRequire(import.meta.url);
+/**
+ * Default fallback prompt configuration.
+ * Used when risk.prompt.cjs file is not found.
+ */
+const DEFAULT_PROMPT$6 = {
+    user: "",
+    system: [],
+};
+/**
+ * Lazy-loads and caches risk rejection prompt configuration.
+ * Attempts to load from config/prompt/risk.prompt.cjs, falls back to DEFAULT_PROMPT if not found.
+ * Uses singleshot pattern to ensure configuration is loaded only once.
+ * @returns Prompt configuration with system and user prompts
+ */
+const GET_PROMPT_FN$6 = singleshot(() => {
+    try {
+        const modulePath = require$6.resolve(path.join(process.cwd(), `./config/prompt/risk.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as risk.prompt.cjs`);
+        return require$6(modulePath);
+    }
+    catch (error) {
+        console.log(`Using empty fallback for risk.prompt.cjs`, error);
+        return DEFAULT_PROMPT$6;
+    }
+});
+/**
+ * Service for managing risk rejection prompts for AI/LLM integrations.
+ *
+ * Provides access to system and user prompts configured in risk.prompt.cjs.
+ * Supports both static prompt arrays and dynamic prompt functions.
+ *
+ * Key responsibilities:
+ * - Lazy-loads prompt configuration from config/prompt/risk.prompt.cjs
+ * - Resolves system prompts (static arrays or async functions)
+ * - Provides user prompt strings
+ * - Falls back to empty prompts if configuration is missing
+ *
+ * Used for AI-powered analysis when signals fail risk validation.
+ * Triggered by: riskRejection() events in ActionBase
+ * Use cases: Analyze rejection reasons, suggest risk adjustments, track rejection patterns
+ */
+class RiskPromptService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Retrieves system prompts for AI context.
+         *
+         * System prompts can be:
+         * - Static array of strings (returned directly)
+         * - Async/sync function returning string array (executed and awaited)
+         * - Undefined (returns empty array)
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to array of system prompt strings
+         */
+        this.getSystemPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("riskPromptService getSystemPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { system } = GET_PROMPT_FN$6();
+            if (Array.isArray(system)) {
+                return system;
+            }
+            if (typeof system === "function") {
+                return await system(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return [];
+        };
+        /**
+         * Retrieves user prompt string for AI input.
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to user prompt string
+         */
+        this.getUserPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("riskPromptService getUserPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { user } = GET_PROMPT_FN$6();
+            if (typeof user === "string") {
+                return user;
+            }
+            if (typeof user === "function") {
+                return await user(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return "";
+        };
+    }
+}
+
+const require$5 = createRequire(import.meta.url);
+/**
+ * Default fallback prompt configuration.
+ * Used when trailing-take.prompt.cjs file is not found.
+ */
+const DEFAULT_PROMPT$5 = {
+    user: "",
+    system: [],
+};
+/**
+ * Lazy-loads and caches trailing take-profit prompt configuration.
+ * Attempts to load from config/prompt/trailing-take.prompt.cjs, falls back to DEFAULT_PROMPT if not found.
+ * Uses singleshot pattern to ensure configuration is loaded only once.
+ * @returns Prompt configuration with system and user prompts
+ */
+const GET_PROMPT_FN$5 = singleshot(() => {
+    try {
+        const modulePath = require$5.resolve(path.join(process.cwd(), `./config/prompt/trailing-take.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as trailing-take.prompt.cjs`);
+        return require$5(modulePath);
+    }
+    catch (error) {
+        console.log(`Using empty fallback for trailing-take.prompt.cjs`, error);
+        return DEFAULT_PROMPT$5;
+    }
+});
+/**
+ * Service for managing trailing take-profit prompts for AI/LLM integrations.
+ *
+ * Provides access to system and user prompts configured in trailing-take.prompt.cjs.
+ * Supports both static prompt arrays and dynamic prompt functions.
+ *
+ * Key responsibilities:
+ * - Lazy-loads prompt configuration from config/prompt/trailing-take.prompt.cjs
+ * - Resolves system prompts (static arrays or async functions)
+ * - Provides user prompt strings
+ * - Falls back to empty prompts if configuration is missing
+ *
+ * Used for AI-powered analysis of trailing take-profit adjustments.
+ * Use cases: Suggest optimal trailing levels, analyze profit-taking strategies, optimize exit timing
+ */
+class TrailingTakePromptService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Retrieves system prompts for AI context.
+         *
+         * System prompts can be:
+         * - Static array of strings (returned directly)
+         * - Async/sync function returning string array (executed and awaited)
+         * - Undefined (returns empty array)
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to array of system prompt strings
+         */
+        this.getSystemPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("trailingTakePromptService getSystemPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { system } = GET_PROMPT_FN$5();
+            if (Array.isArray(system)) {
+                return system;
+            }
+            if (typeof system === "function") {
+                return await system(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return [];
+        };
+        /**
+         * Retrieves user prompt string for AI input.
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to user prompt string
+         */
+        this.getUserPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("trailingTakePromptService getUserPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { user } = GET_PROMPT_FN$5();
+            if (typeof user === "string") {
+                return user;
+            }
+            if (typeof user === "function") {
+                return await user(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return "";
+        };
+    }
+}
+
+const require$4 = createRequire(import.meta.url);
+/**
+ * Default fallback prompt configuration.
+ * Used when trailing-stop.prompt.cjs file is not found.
+ */
+const DEFAULT_PROMPT$4 = {
+    user: "",
+    system: [],
+};
+/**
+ * Lazy-loads and caches trailing stop-loss prompt configuration.
+ * Attempts to load from config/prompt/trailing-stop.prompt.cjs, falls back to DEFAULT_PROMPT if not found.
+ * Uses singleshot pattern to ensure configuration is loaded only once.
+ * @returns Prompt configuration with system and user prompts
+ */
+const GET_PROMPT_FN$4 = singleshot(() => {
+    try {
+        const modulePath = require$4.resolve(path.join(process.cwd(), `./config/prompt/trailing-stop.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as trailing-stop.prompt.cjs`);
+        return require$4(modulePath);
+    }
+    catch (error) {
+        console.log(`Using empty fallback for trailing-stop.prompt.cjs`, error);
+        return DEFAULT_PROMPT$4;
+    }
+});
+/**
+ * Service for managing trailing stop-loss prompts for AI/LLM integrations.
+ *
+ * Provides access to system and user prompts configured in trailing-stop.prompt.cjs.
+ * Supports both static prompt arrays and dynamic prompt functions.
+ *
+ * Key responsibilities:
+ * - Lazy-loads prompt configuration from config/prompt/trailing-stop.prompt.cjs
+ * - Resolves system prompts (static arrays or async functions)
+ * - Provides user prompt strings
+ * - Falls back to empty prompts if configuration is missing
+ *
+ * Used for AI-powered analysis of trailing stop-loss adjustments.
+ * Use cases: Suggest optimal trailing distances, analyze risk protection strategies, optimize stop placement
+ */
+class TrailingStopPromptService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Retrieves system prompts for AI context.
+         *
+         * System prompts can be:
+         * - Static array of strings (returned directly)
+         * - Async/sync function returning string array (executed and awaited)
+         * - Undefined (returns empty array)
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to array of system prompt strings
+         */
+        this.getSystemPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("trailingStopPromptService getSystemPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { system } = GET_PROMPT_FN$4();
+            if (Array.isArray(system)) {
+                return system;
+            }
+            if (typeof system === "function") {
+                return await system(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return [];
+        };
+        /**
+         * Retrieves user prompt string for AI input.
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to user prompt string
+         */
+        this.getUserPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("trailingStopPromptService getUserPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { user } = GET_PROMPT_FN$4();
+            if (typeof user === "string") {
+                return user;
+            }
+            if (typeof user === "function") {
+                return await user(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return "";
+        };
+    }
+}
+
+const require$3 = createRequire(import.meta.url);
+/**
+ * Default fallback prompt configuration.
+ * Used when partial-profit.prompt.cjs file is not found.
+ */
+const DEFAULT_PROMPT$3 = {
+    user: "",
+    system: [],
+};
+/**
+ * Lazy-loads and caches partial profit prompt configuration.
+ * Attempts to load from config/prompt/partial-profit.prompt.cjs, falls back to DEFAULT_PROMPT if not found.
+ * Uses singleshot pattern to ensure configuration is loaded only once.
+ * @returns Prompt configuration with system and user prompts
+ */
+const GET_PROMPT_FN$3 = singleshot(() => {
+    try {
+        const modulePath = require$3.resolve(path.join(process.cwd(), `./config/prompt/partial-profit.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as partial-profit.prompt.cjs`);
+        return require$3(modulePath);
+    }
+    catch (error) {
+        console.log(`Using empty fallback for partial-profit.prompt.cjs`, error);
+        return DEFAULT_PROMPT$3;
+    }
+});
+/**
+ * Service for managing partial profit prompts for AI/LLM integrations.
+ *
+ * Provides access to system and user prompts configured in partial-profit.prompt.cjs.
+ * Supports both static prompt arrays and dynamic prompt functions.
+ *
+ * Key responsibilities:
+ * - Lazy-loads prompt configuration from config/prompt/partial-profit.prompt.cjs
+ * - Resolves system prompts (static arrays or async functions)
+ * - Provides user prompt strings
+ * - Falls back to empty prompts if configuration is missing
+ *
+ * Used for AI-powered analysis when profit milestones are reached (10%, 20%, 30%, etc).
+ * Triggered by: partialProfitAvailable() events in ActionBase
+ * Use cases: Suggest position adjustments, analyze profit-taking opportunities, optimize milestone actions
+ */
+class PartialProfitPromptService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Retrieves system prompts for AI context.
+         *
+         * System prompts can be:
+         * - Static array of strings (returned directly)
+         * - Async/sync function returning string array (executed and awaited)
+         * - Undefined (returns empty array)
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to array of system prompt strings
+         */
+        this.getSystemPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("partialProfitPromptService getSystemPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { system } = GET_PROMPT_FN$3();
+            if (Array.isArray(system)) {
+                return system;
+            }
+            if (typeof system === "function") {
+                return await system(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return [];
+        };
+        /**
+         * Retrieves user prompt string for AI input.
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to user prompt string
+         */
+        this.getUserPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("partialProfitPromptService getUserPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { user } = GET_PROMPT_FN$3();
+            if (typeof user === "string") {
+                return user;
+            }
+            if (typeof user === "function") {
+                return await user(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return "";
+        };
+    }
+}
+
+const require$2 = createRequire(import.meta.url);
+/**
+ * Default fallback prompt configuration.
+ * Used when partial-loss.prompt.cjs file is not found.
+ */
+const DEFAULT_PROMPT$2 = {
+    user: "",
+    system: [],
+};
+/**
+ * Lazy-loads and caches partial loss prompt configuration.
+ * Attempts to load from config/prompt/partial-loss.prompt.cjs, falls back to DEFAULT_PROMPT if not found.
+ * Uses singleshot pattern to ensure configuration is loaded only once.
+ * @returns Prompt configuration with system and user prompts
+ */
+const GET_PROMPT_FN$2 = singleshot(() => {
+    try {
+        const modulePath = require$2.resolve(path.join(process.cwd(), `./config/prompt/partial-loss.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as partial-loss.prompt.cjs`);
+        return require$2(modulePath);
+    }
+    catch (error) {
+        console.log(`Using empty fallback for partial-loss.prompt.cjs`, error);
+        return DEFAULT_PROMPT$2;
+    }
+});
+/**
+ * Service for managing partial loss prompts for AI/LLM integrations.
+ *
+ * Provides access to system and user prompts configured in partial-loss.prompt.cjs.
+ * Supports both static prompt arrays and dynamic prompt functions.
+ *
+ * Key responsibilities:
+ * - Lazy-loads prompt configuration from config/prompt/partial-loss.prompt.cjs
+ * - Resolves system prompts (static arrays or async functions)
+ * - Provides user prompt strings
+ * - Falls back to empty prompts if configuration is missing
+ *
+ * Used for AI-powered analysis when loss milestones are reached (-10%, -20%, -30%, etc).
+ * Triggered by: partialLossAvailable() events in ActionBase
+ * Use cases: Suggest risk management actions, analyze loss mitigation strategies, optimize exit decisions
+ */
+class PartialLossPromptService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Retrieves system prompts for AI context.
+         *
+         * System prompts can be:
+         * - Static array of strings (returned directly)
+         * - Async/sync function returning string array (executed and awaited)
+         * - Undefined (returns empty array)
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to array of system prompt strings
+         */
+        this.getSystemPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("partialLossPromptService getSystemPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { system } = GET_PROMPT_FN$2();
+            if (Array.isArray(system)) {
+                return system;
+            }
+            if (typeof system === "function") {
+                return await system(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return [];
+        };
+        /**
+         * Retrieves user prompt string for AI input.
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to user prompt string
+         */
+        this.getUserPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("partialLossPromptService getUserPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { user } = GET_PROMPT_FN$2();
+            if (typeof user === "string") {
+                return user;
+            }
+            if (typeof user === "function") {
+                return await user(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return "";
+        };
+    }
+}
+
+const require$1 = createRequire(import.meta.url);
+/**
+ * Default fallback prompt configuration.
+ * Used when breakeven.prompt.cjs file is not found.
+ */
+const DEFAULT_PROMPT$1 = {
+    user: "",
+    system: [],
+};
+/**
+ * Lazy-loads and caches breakeven prompt configuration.
+ * Attempts to load from config/prompt/breakeven.prompt.cjs, falls back to DEFAULT_PROMPT if not found.
+ * Uses singleshot pattern to ensure configuration is loaded only once.
+ * @returns Prompt configuration with system and user prompts
+ */
+const GET_PROMPT_FN$1 = singleshot(() => {
+    try {
+        const modulePath = require$1.resolve(path.join(process.cwd(), `./config/prompt/breakeven.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as breakeven.prompt.cjs`);
+        return require$1(modulePath);
+    }
+    catch (error) {
+        console.log(`Using empty fallback for breakeven.prompt.cjs`, error);
+        return DEFAULT_PROMPT$1;
+    }
+});
+/**
+ * Service for managing breakeven prompts for AI/LLM integrations.
+ *
+ * Provides access to system and user prompts configured in breakeven.prompt.cjs.
+ * Supports both static prompt arrays and dynamic prompt functions.
+ *
+ * Key responsibilities:
+ * - Lazy-loads prompt configuration from config/prompt/breakeven.prompt.cjs
+ * - Resolves system prompts (static arrays or async functions)
+ * - Provides user prompt strings
+ * - Falls back to empty prompts if configuration is missing
+ *
+ * Used for AI-powered analysis when stop-loss is moved to entry price (risk-free position).
+ * Triggered by: breakevenAvailable() events in ActionBase
+ * Use cases: Suggest position management after breakeven, analyze profit potential, optimize trailing strategies
+ */
+class BreakevenPromptService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Retrieves system prompts for AI context.
+         *
+         * System prompts can be:
+         * - Static array of strings (returned directly)
+         * - Async/sync function returning string array (executed and awaited)
+         * - Undefined (returns empty array)
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to array of system prompt strings
+         */
+        this.getSystemPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("breakevenPromptService getSystemPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { system } = GET_PROMPT_FN$1();
+            if (Array.isArray(system)) {
+                return system;
+            }
+            if (typeof system === "function") {
+                return await system(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return [];
+        };
+        /**
+         * Retrieves user prompt string for AI input.
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to user prompt string
+         */
+        this.getUserPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("breakevenPromptService getUserPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { user } = GET_PROMPT_FN$1();
+            if (typeof user === "string") {
+                return user;
+            }
+            if (typeof user === "function") {
+                return await user(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return "";
+        };
+    }
+}
+
+const require = createRequire(import.meta.url);
+/**
+ * Default fallback prompt configuration.
+ * Used when schedule-cancel.prompt.cjs file is not found.
+ */
+const DEFAULT_PROMPT = {
+    user: "",
+    system: [],
+};
+/**
+ * Lazy-loads and caches schedule cancellation prompt configuration.
+ * Attempts to load from config/prompt/schedule-cancel.prompt.cjs, falls back to DEFAULT_PROMPT if not found.
+ * Uses singleshot pattern to ensure configuration is loaded only once.
+ * @returns Prompt configuration with system and user prompts
+ */
+const GET_PROMPT_FN = singleshot(() => {
+    try {
+        const modulePath = require.resolve(path.join(process.cwd(), `./config/prompt/schedule-cancel.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as schedule-cancel.prompt.cjs`);
+        return require(modulePath);
+    }
+    catch (error) {
+        console.log(`Using empty fallback for schedule-cancel.prompt.cjs`, error);
+        return DEFAULT_PROMPT;
+    }
+});
+/**
+ * Service for managing schedule cancellation prompts for AI/LLM integrations.
+ *
+ * Provides access to system and user prompts configured in schedule-cancel.prompt.cjs.
+ * Supports both static prompt arrays and dynamic prompt functions.
+ *
+ * Key responsibilities:
+ * - Lazy-loads prompt configuration from config/prompt/schedule-cancel.prompt.cjs
+ * - Resolves system prompts (static arrays or async functions)
+ * - Provides user prompt strings
+ * - Falls back to empty prompts if configuration is missing
+ *
+ * Used for AI-powered analysis when scheduled signals are cancelled before activation.
+ * Triggered by: signal() events with action='cancelled' in ActionBase
+ * Use cases: Analyze cancellation reasons, track signal invalidation patterns, optimize scheduling logic
+ */
+class ScheduleCancelPromptService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Retrieves system prompts for AI context.
+         *
+         * System prompts can be:
+         * - Static array of strings (returned directly)
+         * - Async/sync function returning string array (executed and awaited)
+         * - Undefined (returns empty array)
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to array of system prompt strings
+         */
+        this.getSystemPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("scheduleCancelPromptService getSystemPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { system } = GET_PROMPT_FN();
+            if (Array.isArray(system)) {
+                return system;
+            }
+            if (typeof system === "function") {
+                return await system(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return [];
+        };
+        /**
+         * Retrieves user prompt string for AI input.
+         *
+         * @param symbol - Trading symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Timeframe identifier
+         * @param backtest - Whether running in backtest mode
+         * @returns Promise resolving to user prompt string
+         */
+        this.getUserPrompt = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("scheduleCancelPromptService getUserPrompt", {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest,
+            });
+            const { user } = GET_PROMPT_FN();
+            if (typeof user === "string") {
+                return user;
+            }
+            if (typeof user === "function") {
+                return await user(symbol, strategyName, exchangeName, frameName, backtest);
+            }
+            return "";
+        };
+    }
+}
+
+{
+    provide(TYPES.loggerService, () => new LoggerService());
+}
+{
+    provide(TYPES.executionContextService, () => new ExecutionContextService());
+    provide(TYPES.methodContextService, () => new MethodContextService());
+}
+{
+    provide(TYPES.exchangeConnectionService, () => new ExchangeConnectionService());
+    provide(TYPES.strategyConnectionService, () => new StrategyConnectionService());
+    provide(TYPES.frameConnectionService, () => new FrameConnectionService());
+    provide(TYPES.sizingConnectionService, () => new SizingConnectionService());
+    provide(TYPES.riskConnectionService, () => new RiskConnectionService());
+    provide(TYPES.actionConnectionService, () => new ActionConnectionService());
+    provide(TYPES.optimizerConnectionService, () => new OptimizerConnectionService());
+    provide(TYPES.partialConnectionService, () => new PartialConnectionService());
+    provide(TYPES.breakevenConnectionService, () => new BreakevenConnectionService());
+}
+{
+    provide(TYPES.exchangeSchemaService, () => new ExchangeSchemaService());
+    provide(TYPES.strategySchemaService, () => new StrategySchemaService());
+    provide(TYPES.frameSchemaService, () => new FrameSchemaService());
+    provide(TYPES.walkerSchemaService, () => new WalkerSchemaService());
+    provide(TYPES.sizingSchemaService, () => new SizingSchemaService());
+    provide(TYPES.riskSchemaService, () => new RiskSchemaService());
+    provide(TYPES.actionSchemaService, () => new ActionSchemaService());
+    provide(TYPES.optimizerSchemaService, () => new OptimizerSchemaService());
+}
+{
+    provide(TYPES.exchangeCoreService, () => new ExchangeCoreService());
+    provide(TYPES.strategyCoreService, () => new StrategyCoreService());
+    provide(TYPES.actionCoreService, () => new ActionCoreService());
+    provide(TYPES.frameCoreService, () => new FrameCoreService());
+}
+{
+    provide(TYPES.sizingGlobalService, () => new SizingGlobalService());
+    provide(TYPES.riskGlobalService, () => new RiskGlobalService());
+    provide(TYPES.optimizerGlobalService, () => new OptimizerGlobalService());
+    provide(TYPES.partialGlobalService, () => new PartialGlobalService());
+    provide(TYPES.breakevenGlobalService, () => new BreakevenGlobalService());
+}
+{
+    provide(TYPES.liveCommandService, () => new LiveCommandService());
+    provide(TYPES.backtestCommandService, () => new BacktestCommandService());
+    provide(TYPES.walkerCommandService, () => new WalkerCommandService());
+}
+{
+    provide(TYPES.backtestLogicPrivateService, () => new BacktestLogicPrivateService());
+    provide(TYPES.liveLogicPrivateService, () => new LiveLogicPrivateService());
+    provide(TYPES.walkerLogicPrivateService, () => new WalkerLogicPrivateService());
+}
+{
+    provide(TYPES.backtestLogicPublicService, () => new BacktestLogicPublicService());
+    provide(TYPES.liveLogicPublicService, () => new LiveLogicPublicService());
+    provide(TYPES.walkerLogicPublicService, () => new WalkerLogicPublicService());
+}
+{
+    provide(TYPES.backtestMarkdownService, () => new BacktestMarkdownService());
+    provide(TYPES.liveMarkdownService, () => new LiveMarkdownService());
+    provide(TYPES.scheduleMarkdownService, () => new ScheduleMarkdownService());
+    provide(TYPES.performanceMarkdownService, () => new PerformanceMarkdownService());
+    provide(TYPES.walkerMarkdownService, () => new WalkerMarkdownService());
+    provide(TYPES.heatMarkdownService, () => new HeatMarkdownService());
+    provide(TYPES.partialMarkdownService, () => new PartialMarkdownService());
+    provide(TYPES.breakevenMarkdownService, () => new BreakevenMarkdownService());
+    provide(TYPES.outlineMarkdownService, () => new OutlineMarkdownService());
+    provide(TYPES.riskMarkdownService, () => new RiskMarkdownService());
+}
+{
+    provide(TYPES.backtestReportService, () => new BacktestReportService());
+    provide(TYPES.liveReportService, () => new LiveReportService());
+    provide(TYPES.scheduleReportService, () => new ScheduleReportService());
+    provide(TYPES.performanceReportService, () => new PerformanceReportService());
+    provide(TYPES.walkerReportService, () => new WalkerReportService());
+    provide(TYPES.heatReportService, () => new HeatReportService());
+    provide(TYPES.partialReportService, () => new PartialReportService());
+    provide(TYPES.breakevenReportService, () => new BreakevenReportService());
+    provide(TYPES.riskReportService, () => new RiskReportService());
+}
+{
+    provide(TYPES.exchangeValidationService, () => new ExchangeValidationService());
+    provide(TYPES.strategyValidationService, () => new StrategyValidationService());
+    provide(TYPES.frameValidationService, () => new FrameValidationService());
+    provide(TYPES.walkerValidationService, () => new WalkerValidationService());
+    provide(TYPES.sizingValidationService, () => new SizingValidationService());
+    provide(TYPES.riskValidationService, () => new RiskValidationService());
+    provide(TYPES.actionValidationService, () => new ActionValidationService());
+    provide(TYPES.optimizerValidationService, () => new OptimizerValidationService());
+    provide(TYPES.configValidationService, () => new ConfigValidationService());
+    provide(TYPES.columnValidationService, () => new ColumnValidationService());
+}
+{
+    provide(TYPES.optimizerTemplateService, () => new OptimizerTemplateService());
+}
+{
+    provide(TYPES.signalPromptService, () => new SignalPromptService());
+    provide(TYPES.riskPromptService, () => new RiskPromptService());
+    provide(TYPES.trailingTakePromptService, () => new TrailingTakePromptService());
+    provide(TYPES.trailingStopPromptService, () => new TrailingStopPromptService());
+    provide(TYPES.partialProfitPromptService, () => new PartialProfitPromptService());
+    provide(TYPES.partialLossPromptService, () => new PartialLossPromptService());
+    provide(TYPES.breakevenPromptService, () => new BreakevenPromptService());
+    provide(TYPES.scheduleCancelPromptService, () => new ScheduleCancelPromptService());
+}
+
+const baseServices = {
+    loggerService: inject(TYPES.loggerService),
+};
+const contextServices = {
+    executionContextService: inject(TYPES.executionContextService),
+    methodContextService: inject(TYPES.methodContextService),
+};
+const connectionServices = {
+    exchangeConnectionService: inject(TYPES.exchangeConnectionService),
+    strategyConnectionService: inject(TYPES.strategyConnectionService),
+    frameConnectionService: inject(TYPES.frameConnectionService),
+    sizingConnectionService: inject(TYPES.sizingConnectionService),
+    riskConnectionService: inject(TYPES.riskConnectionService),
+    actionConnectionService: inject(TYPES.actionConnectionService),
+    optimizerConnectionService: inject(TYPES.optimizerConnectionService),
+    partialConnectionService: inject(TYPES.partialConnectionService),
+    breakevenConnectionService: inject(TYPES.breakevenConnectionService),
+};
+const schemaServices = {
+    exchangeSchemaService: inject(TYPES.exchangeSchemaService),
+    strategySchemaService: inject(TYPES.strategySchemaService),
+    frameSchemaService: inject(TYPES.frameSchemaService),
+    walkerSchemaService: inject(TYPES.walkerSchemaService),
+    sizingSchemaService: inject(TYPES.sizingSchemaService),
+    riskSchemaService: inject(TYPES.riskSchemaService),
+    actionSchemaService: inject(TYPES.actionSchemaService),
+    optimizerSchemaService: inject(TYPES.optimizerSchemaService),
+};
+const coreServices = {
+    exchangeCoreService: inject(TYPES.exchangeCoreService),
+    strategyCoreService: inject(TYPES.strategyCoreService),
+    actionCoreService: inject(TYPES.actionCoreService),
+    frameCoreService: inject(TYPES.frameCoreService),
+};
+const globalServices = {
+    sizingGlobalService: inject(TYPES.sizingGlobalService),
+    riskGlobalService: inject(TYPES.riskGlobalService),
+    optimizerGlobalService: inject(TYPES.optimizerGlobalService),
+    partialGlobalService: inject(TYPES.partialGlobalService),
+    breakevenGlobalService: inject(TYPES.breakevenGlobalService),
+};
+const commandServices = {
+    liveCommandService: inject(TYPES.liveCommandService),
+    backtestCommandService: inject(TYPES.backtestCommandService),
+    walkerCommandService: inject(TYPES.walkerCommandService),
+};
+const logicPrivateServices = {
+    backtestLogicPrivateService: inject(TYPES.backtestLogicPrivateService),
+    liveLogicPrivateService: inject(TYPES.liveLogicPrivateService),
+    walkerLogicPrivateService: inject(TYPES.walkerLogicPrivateService),
+};
+const logicPublicServices = {
+    backtestLogicPublicService: inject(TYPES.backtestLogicPublicService),
+    liveLogicPublicService: inject(TYPES.liveLogicPublicService),
+    walkerLogicPublicService: inject(TYPES.walkerLogicPublicService),
+};
+const markdownServices = {
+    backtestMarkdownService: inject(TYPES.backtestMarkdownService),
+    liveMarkdownService: inject(TYPES.liveMarkdownService),
+    scheduleMarkdownService: inject(TYPES.scheduleMarkdownService),
+    performanceMarkdownService: inject(TYPES.performanceMarkdownService),
+    walkerMarkdownService: inject(TYPES.walkerMarkdownService),
+    heatMarkdownService: inject(TYPES.heatMarkdownService),
+    partialMarkdownService: inject(TYPES.partialMarkdownService),
+    breakevenMarkdownService: inject(TYPES.breakevenMarkdownService),
+    outlineMarkdownService: inject(TYPES.outlineMarkdownService),
+    riskMarkdownService: inject(TYPES.riskMarkdownService),
+};
+const reportServices = {
+    backtestReportService: inject(TYPES.backtestReportService),
+    liveReportService: inject(TYPES.liveReportService),
+    scheduleReportService: inject(TYPES.scheduleReportService),
+    performanceReportService: inject(TYPES.performanceReportService),
+    walkerReportService: inject(TYPES.walkerReportService),
+    heatReportService: inject(TYPES.heatReportService),
+    partialReportService: inject(TYPES.partialReportService),
+    breakevenReportService: inject(TYPES.breakevenReportService),
+    riskReportService: inject(TYPES.riskReportService),
+};
+const validationServices = {
+    exchangeValidationService: inject(TYPES.exchangeValidationService),
+    strategyValidationService: inject(TYPES.strategyValidationService),
+    frameValidationService: inject(TYPES.frameValidationService),
+    walkerValidationService: inject(TYPES.walkerValidationService),
+    sizingValidationService: inject(TYPES.sizingValidationService),
+    riskValidationService: inject(TYPES.riskValidationService),
+    actionValidationService: inject(TYPES.actionValidationService),
+    optimizerValidationService: inject(TYPES.optimizerValidationService),
+    configValidationService: inject(TYPES.configValidationService),
+    columnValidationService: inject(TYPES.columnValidationService),
+};
+const templateServices = {
+    optimizerTemplateService: inject(TYPES.optimizerTemplateService),
+};
+const promptServices = {
+    signalPromptService: inject(TYPES.signalPromptService),
+    riskPromptService: inject(TYPES.riskPromptService),
+    trailingTakePromptService: inject(TYPES.trailingTakePromptService),
+    trailingStopPromptService: inject(TYPES.trailingStopPromptService),
+    partialProfitPromptService: inject(TYPES.partialProfitPromptService),
+    partialLossPromptService: inject(TYPES.partialLossPromptService),
+    breakevenPromptService: inject(TYPES.breakevenPromptService),
+    scheduleCancelPromptService: inject(TYPES.scheduleCancelPromptService),
+};
+const backtest = {
+    ...baseServices,
+    ...contextServices,
+    ...connectionServices,
+    ...schemaServices,
+    ...coreServices,
+    ...globalServices,
+    ...commandServices,
+    ...logicPrivateServices,
+    ...logicPublicServices,
+    ...markdownServices,
+    ...reportServices,
+    ...validationServices,
+    ...templateServices,
+    ...promptServices,
+};
+init();
+var backtest$1 = backtest;
+
+const GET_TIMEFRAME_METHOD_NAME = "get.getBacktestTimeframe";
+/**
+ * Retrieves current backtest timeframe for given symbol.
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @returns Promise resolving to array of Date objects representing tick timestamps
+ * @throws Error if called outside of backtest execution context
+ */
+async function getBacktestTimeframe(symbol) {
+    backtest$1.loggerService.info(GET_TIMEFRAME_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getBacktestTimeframe requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getBacktestTimeframe requires a method context");
+    }
+    if (!backtest$1.executionContextService.context.backtest) {
+        throw new Error("getBacktestTimeframe can only be used during backtest execution");
+    }
+    return await backtest$1.frameCoreService.getTimeframe(symbol, backtest$1.methodContextService.context.frameName);
+}
+
+const METHOD_NAME = "validate.validate";
+/**
+ * Retrieves all registered exchanges as a map
+ * @private
+ * @returns Map of exchange names
+ */
+const getExchangeMap = async () => {
+    const exchangeMap = {};
+    for (const { exchangeName } of await backtest$1.exchangeValidationService.list()) {
+        Object.assign(exchangeMap, { [exchangeName]: exchangeName });
+    }
+    return exchangeMap;
+};
+/**
+ * Retrieves all registered frames as a map
+ * @private
+ * @returns Map of frame names
+ */
+const getFrameMap = async () => {
+    const frameMap = {};
+    for (const { frameName } of await backtest$1.frameValidationService.list()) {
+        Object.assign(frameMap, { [frameName]: frameName });
+    }
+    return frameMap;
+};
+/**
+ * Retrieves all registered strategies as a map
+ * @private
+ * @returns Map of strategy names
+ */
 const getStrategyMap = async () => {
     const strategyMap = {};
     for (const { strategyName } of await backtest$1.strategyValidationService.list()) {
@@ -26405,6 +27290,446 @@ function listenActivePingOnce(filterFn, fn) {
     return activePingSubject.filter(filterFn).once(fn);
 }
 
+const METHOD_NAME_SIGNAL = "history.commitSignalPromptHistory";
+const METHOD_NAME_RISK = "history.commitRiskPromptHistory";
+const METHOD_NAME_TRAILING_TAKE = "history.commitTrailingTakePromptHistory";
+const METHOD_NAME_TRAILING_STOP = "history.commitTrailingStopPromptHistory";
+const METHOD_NAME_PARTIAL_PROFIT = "history.commitPartialProfitPromptHistory";
+const METHOD_NAME_PARTIAL_LOSS = "history.commitPartialLossPromptHistory";
+const METHOD_NAME_BREAKEVEN = "history.commitBreakevenPromptHistory";
+const METHOD_NAME_SCHEDULE_CANCEL = "history.commitScheduleCancelPromptHistory";
+/**
+ * Commits signal prompt history to the message array.
+ *
+ * Extracts trading context from ExecutionContext and MethodContext,
+ * then adds signal-specific system prompts at the beginning and user prompt
+ * at the end of the history array if they are not empty.
+ *
+ * Context extraction:
+ * - symbol: Provided as parameter for debugging convenience
+ * - backtest mode: From ExecutionContext
+ * - strategyName, exchangeName, frameName: From MethodContext
+ *
+ * @param symbol - Trading symbol (e.g., "BTCUSDT") for debugging convenience
+ * @param history - Message array to append prompts to
+ * @returns Promise that resolves when prompts are added
+ * @throws Error if ExecutionContext or MethodContext is not active
+ *
+ * @example
+ * ```typescript
+ * const messages: MessageModel[] = [];
+ * await commitSignalPromptHistory("BTCUSDT", messages);
+ * // messages now contains system prompts at start and user prompt at end
+ * ```
+ */
+async function commitSignalPromptHistory(symbol, history) {
+    backtest$1.loggerService.log(METHOD_NAME_SIGNAL, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitSignalPromptHistory requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitSignalPromptHistory requires a method context");
+    }
+    const { backtest: isBacktest } = backtest$1.executionContextService.context;
+    const { strategyName, exchangeName, frameName } = backtest$1.methodContextService.context;
+    const systemPrompts = await backtest$1.signalPromptService.getSystemPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    const userPrompt = await backtest$1.signalPromptService.getUserPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    if (systemPrompts.length > 0) {
+        for (const content of systemPrompts) {
+            history.unshift({
+                role: "system",
+                content,
+            });
+        }
+    }
+    if (userPrompt && userPrompt.trim() !== "") {
+        history.push({
+            role: "user",
+            content: userPrompt,
+        });
+    }
+}
+/**
+ * Commits risk rejection prompt history to the message array.
+ *
+ * Extracts trading context from ExecutionContext and MethodContext,
+ * then adds risk-specific system prompts at the beginning and user prompt
+ * at the end of the history array if they are not empty.
+ *
+ * Context extraction:
+ * - symbol: Provided as parameter for debugging convenience
+ * - backtest mode: From ExecutionContext
+ * - strategyName, exchangeName, frameName: From MethodContext
+ *
+ * Used for AI-powered analysis when signals fail risk validation.
+ *
+ * @param symbol - Trading symbol (e.g., "BTCUSDT") for debugging convenience
+ * @param history - Message array to append prompts to
+ * @returns Promise that resolves when prompts are added
+ * @throws Error if ExecutionContext or MethodContext is not active
+ *
+ * @example
+ * ```typescript
+ * const messages: MessageModel[] = [];
+ * await commitRiskPromptHistory("BTCUSDT", messages);
+ * ```
+ */
+async function commitRiskPromptHistory(symbol, history) {
+    backtest$1.loggerService.log(METHOD_NAME_RISK, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitRiskPromptHistory requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitRiskPromptHistory requires a method context");
+    }
+    const { backtest: isBacktest } = backtest$1.executionContextService.context;
+    const { strategyName, exchangeName, frameName } = backtest$1.methodContextService.context;
+    const systemPrompts = await backtest$1.riskPromptService.getSystemPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    const userPrompt = await backtest$1.riskPromptService.getUserPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    if (systemPrompts.length > 0) {
+        for (const content of systemPrompts) {
+            history.unshift({
+                role: "system",
+                content,
+            });
+        }
+    }
+    if (userPrompt && userPrompt.trim() !== "") {
+        history.push({
+            role: "user",
+            content: userPrompt,
+        });
+    }
+}
+/**
+ * Commits trailing take-profit prompt history to the message array.
+ *
+ * Extracts trading context from ExecutionContext and MethodContext,
+ * then adds trailing take-profit specific system prompts at the beginning
+ * and user prompt at the end of the history array if they are not empty.
+ *
+ * Context extraction:
+ * - symbol: Provided as parameter for debugging convenience
+ * - backtest mode: From ExecutionContext
+ * - strategyName, exchangeName, frameName: From MethodContext
+ *
+ * Used for AI-powered analysis of trailing take-profit adjustments.
+ *
+ * @param symbol - Trading symbol (e.g., "BTCUSDT") for debugging convenience
+ * @param history - Message array to append prompts to
+ * @returns Promise that resolves when prompts are added
+ * @throws Error if ExecutionContext or MethodContext is not active
+ *
+ * @example
+ * ```typescript
+ * const messages: MessageModel[] = [];
+ * await commitTrailingTakePromptHistory("BTCUSDT", messages);
+ * ```
+ */
+async function commitTrailingTakePromptHistory(symbol, history) {
+    backtest$1.loggerService.log(METHOD_NAME_TRAILING_TAKE, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitTrailingTakePromptHistory requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitTrailingTakePromptHistory requires a method context");
+    }
+    const { backtest: isBacktest } = backtest$1.executionContextService.context;
+    const { strategyName, exchangeName, frameName } = backtest$1.methodContextService.context;
+    const systemPrompts = await backtest$1.trailingTakePromptService.getSystemPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    const userPrompt = await backtest$1.trailingTakePromptService.getUserPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    if (systemPrompts.length > 0) {
+        for (const content of systemPrompts) {
+            history.unshift({
+                role: "system",
+                content,
+            });
+        }
+    }
+    if (userPrompt && userPrompt.trim() !== "") {
+        history.push({
+            role: "user",
+            content: userPrompt,
+        });
+    }
+}
+/**
+ * Commits trailing stop-loss prompt history to the message array.
+ *
+ * Extracts trading context from ExecutionContext and MethodContext,
+ * then adds trailing stop-loss specific system prompts at the beginning
+ * and user prompt at the end of the history array if they are not empty.
+ *
+ * Context extraction:
+ * - symbol: Provided as parameter for debugging convenience
+ * - backtest mode: From ExecutionContext
+ * - strategyName, exchangeName, frameName: From MethodContext
+ *
+ * Used for AI-powered analysis of trailing stop-loss adjustments.
+ *
+ * @param symbol - Trading symbol (e.g., "BTCUSDT") for debugging convenience
+ * @param history - Message array to append prompts to
+ * @returns Promise that resolves when prompts are added
+ * @throws Error if ExecutionContext or MethodContext is not active
+ *
+ * @example
+ * ```typescript
+ * const messages: MessageModel[] = [];
+ * await commitTrailingStopPromptHistory("BTCUSDT", messages);
+ * ```
+ */
+async function commitTrailingStopPromptHistory(symbol, history) {
+    backtest$1.loggerService.log(METHOD_NAME_TRAILING_STOP, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitTrailingStopPromptHistory requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitTrailingStopPromptHistory requires a method context");
+    }
+    const { backtest: isBacktest } = backtest$1.executionContextService.context;
+    const { strategyName, exchangeName, frameName } = backtest$1.methodContextService.context;
+    const systemPrompts = await backtest$1.trailingStopPromptService.getSystemPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    const userPrompt = await backtest$1.trailingStopPromptService.getUserPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    if (systemPrompts.length > 0) {
+        for (const content of systemPrompts) {
+            history.unshift({
+                role: "system",
+                content,
+            });
+        }
+    }
+    if (userPrompt && userPrompt.trim() !== "") {
+        history.push({
+            role: "user",
+            content: userPrompt,
+        });
+    }
+}
+/**
+ * Commits partial profit prompt history to the message array.
+ *
+ * Extracts trading context from ExecutionContext and MethodContext,
+ * then adds partial profit specific system prompts at the beginning
+ * and user prompt at the end of the history array if they are not empty.
+ *
+ * Context extraction:
+ * - symbol: Provided as parameter for debugging convenience
+ * - backtest mode: From ExecutionContext
+ * - strategyName, exchangeName, frameName: From MethodContext
+ *
+ * Used for AI-powered analysis of partial profit milestones.
+ *
+ * @param symbol - Trading symbol (e.g., "BTCUSDT") for debugging convenience
+ * @param history - Message array to append prompts to
+ * @returns Promise that resolves when prompts are added
+ * @throws Error if ExecutionContext or MethodContext is not active
+ *
+ * @example
+ * ```typescript
+ * const messages: MessageModel[] = [];
+ * await commitPartialProfitPromptHistory("BTCUSDT", messages);
+ * ```
+ */
+async function commitPartialProfitPromptHistory(symbol, history) {
+    backtest$1.loggerService.log(METHOD_NAME_PARTIAL_PROFIT, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitPartialProfitPromptHistory requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitPartialProfitPromptHistory requires a method context");
+    }
+    const { backtest: isBacktest } = backtest$1.executionContextService.context;
+    const { strategyName, exchangeName, frameName } = backtest$1.methodContextService.context;
+    const systemPrompts = await backtest$1.partialProfitPromptService.getSystemPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    const userPrompt = await backtest$1.partialProfitPromptService.getUserPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    if (systemPrompts.length > 0) {
+        for (const content of systemPrompts) {
+            history.unshift({
+                role: "system",
+                content,
+            });
+        }
+    }
+    if (userPrompt && userPrompt.trim() !== "") {
+        history.push({
+            role: "user",
+            content: userPrompt,
+        });
+    }
+}
+/**
+ * Commits partial loss prompt history to the message array.
+ *
+ * Extracts trading context from ExecutionContext and MethodContext,
+ * then adds partial loss specific system prompts at the beginning
+ * and user prompt at the end of the history array if they are not empty.
+ *
+ * Context extraction:
+ * - symbol: Provided as parameter for debugging convenience
+ * - backtest mode: From ExecutionContext
+ * - strategyName, exchangeName, frameName: From MethodContext
+ *
+ * Used for AI-powered analysis of partial loss milestones.
+ *
+ * @param symbol - Trading symbol (e.g., "BTCUSDT") for debugging convenience
+ * @param history - Message array to append prompts to
+ * @returns Promise that resolves when prompts are added
+ * @throws Error if ExecutionContext or MethodContext is not active
+ *
+ * @example
+ * ```typescript
+ * const messages: MessageModel[] = [];
+ * await commitPartialLossPromptHistory("BTCUSDT", messages);
+ * ```
+ */
+async function commitPartialLossPromptHistory(symbol, history) {
+    backtest$1.loggerService.log(METHOD_NAME_PARTIAL_LOSS, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitPartialLossPromptHistory requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitPartialLossPromptHistory requires a method context");
+    }
+    const { backtest: isBacktest } = backtest$1.executionContextService.context;
+    const { strategyName, exchangeName, frameName } = backtest$1.methodContextService.context;
+    const systemPrompts = await backtest$1.partialLossPromptService.getSystemPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    const userPrompt = await backtest$1.partialLossPromptService.getUserPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    if (systemPrompts.length > 0) {
+        for (const content of systemPrompts) {
+            history.unshift({
+                role: "system",
+                content,
+            });
+        }
+    }
+    if (userPrompt && userPrompt.trim() !== "") {
+        history.push({
+            role: "user",
+            content: userPrompt,
+        });
+    }
+}
+/**
+ * Commits breakeven prompt history to the message array.
+ *
+ * Extracts trading context from ExecutionContext and MethodContext,
+ * then adds breakeven specific system prompts at the beginning
+ * and user prompt at the end of the history array if they are not empty.
+ *
+ * Context extraction:
+ * - symbol: Provided as parameter for debugging convenience
+ * - backtest mode: From ExecutionContext
+ * - strategyName, exchangeName, frameName: From MethodContext
+ *
+ * Used for AI-powered analysis of breakeven events.
+ *
+ * @param symbol - Trading symbol (e.g., "BTCUSDT") for debugging convenience
+ * @param history - Message array to append prompts to
+ * @returns Promise that resolves when prompts are added
+ * @throws Error if ExecutionContext or MethodContext is not active
+ *
+ * @example
+ * ```typescript
+ * const messages: MessageModel[] = [];
+ * await commitBreakevenPromptHistory("BTCUSDT", messages);
+ * ```
+ */
+async function commitBreakevenPromptHistory(symbol, history) {
+    backtest$1.loggerService.log(METHOD_NAME_BREAKEVEN, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitBreakevenPromptHistory requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitBreakevenPromptHistory requires a method context");
+    }
+    const { backtest: isBacktest } = backtest$1.executionContextService.context;
+    const { strategyName, exchangeName, frameName } = backtest$1.methodContextService.context;
+    const systemPrompts = await backtest$1.breakevenPromptService.getSystemPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    const userPrompt = await backtest$1.breakevenPromptService.getUserPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    if (systemPrompts.length > 0) {
+        for (const content of systemPrompts) {
+            history.unshift({
+                role: "system",
+                content,
+            });
+        }
+    }
+    if (userPrompt && userPrompt.trim() !== "") {
+        history.push({
+            role: "user",
+            content: userPrompt,
+        });
+    }
+}
+/**
+ * Commits schedule cancellation prompt history to the message array.
+ *
+ * Extracts trading context from ExecutionContext and MethodContext,
+ * then adds schedule cancellation specific system prompts at the beginning
+ * and user prompt at the end of the history array if they are not empty.
+ *
+ * Context extraction:
+ * - symbol: Provided as parameter for debugging convenience
+ * - backtest mode: From ExecutionContext
+ * - strategyName, exchangeName, frameName: From MethodContext
+ *
+ * Used for AI-powered analysis of schedule cancellation events.
+ *
+ * @param symbol - Trading symbol (e.g., "BTCUSDT") for debugging convenience
+ * @param history - Message array to append prompts to
+ * @returns Promise that resolves when prompts are added
+ * @throws Error if ExecutionContext or MethodContext is not active
+ *
+ * @example
+ * ```typescript
+ * const messages: MessageModel[] = [];
+ * await commitScheduleCancelPromptHistory("BTCUSDT", messages);
+ * ```
+ */
+async function commitScheduleCancelPromptHistory(symbol, history) {
+    backtest$1.loggerService.log(METHOD_NAME_SCHEDULE_CANCEL, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitScheduleCancelPromptHistory requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitScheduleCancelPromptHistory requires a method context");
+    }
+    const { backtest: isBacktest } = backtest$1.executionContextService.context;
+    const { strategyName, exchangeName, frameName } = backtest$1.methodContextService.context;
+    const systemPrompts = await backtest$1.scheduleCancelPromptService.getSystemPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    const userPrompt = await backtest$1.scheduleCancelPromptService.getUserPrompt(symbol, strategyName, exchangeName, frameName, isBacktest);
+    if (systemPrompts.length > 0) {
+        for (const content of systemPrompts) {
+            history.unshift({
+                role: "system",
+                content,
+            });
+        }
+    }
+    if (userPrompt && userPrompt.trim() !== "") {
+        history.push({
+            role: "user",
+            content: userPrompt,
+        });
+    }
+}
+
 const DUMP_SIGNAL_METHOD_NAME = "dump.dumpSignal";
 /**
  * Dumps signal data and LLM conversation history to markdown files.
@@ -31873,4 +33198,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addOptimizerSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancel, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, dumpSignalData, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOptimizerSchema, getOrderBook, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listOptimizerSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideOptimizerSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stop, validate };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addOptimizerSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitBreakevenPromptHistory, commitCancel, commitPartialLoss, commitPartialLossPromptHistory, commitPartialProfit, commitPartialProfitPromptHistory, commitRiskPromptHistory, commitScheduleCancelPromptHistory, commitSignalPromptHistory, commitTrailingStop, commitTrailingStopPromptHistory, commitTrailingTake, commitTrailingTakePromptHistory, dumpSignalData, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOptimizerSchema, getOrderBook, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listOptimizerSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideOptimizerSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stop, validate };