backtest-kit 2.0.7 → 2.0.8

package/build/index.cjs

@@ -8,8 +8,10 @@ var path = require('path');
 var crypto = require('crypto');
 var os = require('os');
 var fs$1 = require('fs');
+var module$1 = require('module');
 var util = require('util');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
     if (e) {
@@ -151,6 +153,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,
@@ -165,6 +177,7 @@ const TYPES = {
     ...reportServices$1,
     ...validationServices$1,
     ...templateServices$1,
+    ...promptServices$1,
 };
 
 /**
@@ -22985,264 +22998,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$8 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 /**
- * 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 = functoolsKit.singleshot(() => {
+    try {
+        const modulePath = require$8.resolve(path.join(process.cwd(), `./config/prompt/signal.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as signal.prompt.cjs`);
+        return require$8(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$7 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+/**
+ * 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 = functoolsKit.singleshot(() => {
+    try {
+        const modulePath = require$7.resolve(path.join(process.cwd(), `./config/prompt/risk.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as risk.prompt.cjs`);
+        return require$7(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$6 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+/**
+ * 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 = functoolsKit.singleshot(() => {
+    try {
+        const modulePath = require$6.resolve(path.join(process.cwd(), `./config/prompt/trailing-take.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as trailing-take.prompt.cjs`);
+        return require$6(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$5 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+/**
+ * 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 = functoolsKit.singleshot(() => {
+    try {
+        const modulePath = require$5.resolve(path.join(process.cwd(), `./config/prompt/trailing-stop.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as trailing-stop.prompt.cjs`);
+        return require$5(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$4 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+/**
+ * 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 = functoolsKit.singleshot(() => {
+    try {
+        const modulePath = require$4.resolve(path.join(process.cwd(), `./config/prompt/partial-profit.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as partial-profit.prompt.cjs`);
+        return require$4(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$3 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+/**
+ * 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 = functoolsKit.singleshot(() => {
+    try {
+        const modulePath = require$3.resolve(path.join(process.cwd(), `./config/prompt/partial-loss.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as partial-loss.prompt.cjs`);
+        return require$3(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$2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+/**
+ * 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 = functoolsKit.singleshot(() => {
+    try {
+        const modulePath = require$2.resolve(path.join(process.cwd(), `./config/prompt/breakeven.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as breakeven.prompt.cjs`);
+        return require$2(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$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+/**
+ * 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 = functoolsKit.singleshot(() => {
+    try {
+        const modulePath = require$1.resolve(path.join(process.cwd(), `./config/prompt/schedule-cancel.prompt.cjs`));
+        console.log(`Using ${modulePath} implementation as schedule-cancel.prompt.cjs`);
+        return require$1(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()) {
@@ -26425,6 +27311,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.
@@ -31931,11 +33257,19 @@ exports.addSizingSchema = addSizingSchema;
 exports.addStrategySchema = addStrategySchema;
 exports.addWalkerSchema = addWalkerSchema;
 exports.commitBreakeven = commitBreakeven;
+exports.commitBreakevenPromptHistory = commitBreakevenPromptHistory;
 exports.commitCancel = commitCancel;
 exports.commitPartialLoss = commitPartialLoss;
+exports.commitPartialLossPromptHistory = commitPartialLossPromptHistory;
 exports.commitPartialProfit = commitPartialProfit;
+exports.commitPartialProfitPromptHistory = commitPartialProfitPromptHistory;
+exports.commitRiskPromptHistory = commitRiskPromptHistory;
+exports.commitScheduleCancelPromptHistory = commitScheduleCancelPromptHistory;
+exports.commitSignalPromptHistory = commitSignalPromptHistory;
 exports.commitTrailingStop = commitTrailingStop;
+exports.commitTrailingStopPromptHistory = commitTrailingStopPromptHistory;
 exports.commitTrailingTake = commitTrailingTake;
+exports.commitTrailingTakePromptHistory = commitTrailingTakePromptHistory;
 exports.dumpSignalData = dumpSignalData;
 exports.emitters = emitters;
 exports.formatPrice = formatPrice;