@tradejs/node 1.0.2 → 1.0.4

package/dist/strategies.js

@@ -5546,7 +5546,7 @@ var init_aiShared = __esm({
 });
 
 // src/tradejsConfig.ts
-var import_fs, import_path, import_module, import_url, import_logger2, CONFIG_FILE_NAMES, TS_MODULE_RE, cachedByCwd, announcedConfigFile, tsNodeRegistered, getTradejsProjectCwd, normalizeConfig, getRequireFn, ensureTsNodeRegistered, toImportSpecifier, isTsModulePath, isRelativeModulePath, isBareModuleSpecifier, importConfigFile, importTradejsModule, resolveExportedConfig, findConfigFilePath, resolvePluginModuleSpecifier, loadTradejsConfig;
+var import_fs, import_path, import_module, import_url, import_logger2, CONFIG_FILE_NAMES, TS_MODULE_RE, cachedByCwd, announcedConfigFile, tsNodeRegistered, tsconfigPathsRegisteredByCwd, getTradejsProjectCwd, normalizeConfig, getRequireFn, ensureTsNodeRegistered, ensureTsconfigPathsRegistered, toImportSpecifier, isTsModulePath, isRelativeModulePath, isBareModuleSpecifier, importConfigFile, importTradejsModule, resolveExportedConfig, findConfigFilePath, resolvePluginModuleSpecifier, loadTradejsConfig;
 var init_tradejsConfig = __esm({
   "src/tradejsConfig.ts"() {
     "use strict";
@@ -5566,6 +5566,7 @@ var init_tradejsConfig = __esm({
     cachedByCwd = /* @__PURE__ */ new Map();
     announcedConfigFile = /* @__PURE__ */ new Set();
     tsNodeRegistered = false;
+    tsconfigPathsRegisteredByCwd = /* @__PURE__ */ new Set();
     getTradejsProjectCwd = (cwd) => {
       const explicit = String(cwd ?? "").trim();
       if (explicit) {
@@ -5607,6 +5608,28 @@ var init_tradejsConfig = __esm({
       });
       tsNodeRegistered = true;
     };
+    ensureTsconfigPathsRegistered = async (cwd = getTradejsProjectCwd()) => {
+      const projectRoot = getTradejsProjectCwd(cwd);
+      if (tsconfigPathsRegisteredByCwd.has(projectRoot)) {
+        return;
+      }
+      const tsconfigPathsModule = await import("tsconfig-paths");
+      const loadConfig = tsconfigPathsModule.loadConfig;
+      const register = tsconfigPathsModule.register;
+      if (typeof loadConfig !== "function" || typeof register !== "function") {
+        return;
+      }
+      const loadedConfig = loadConfig(projectRoot);
+      if (loadedConfig.resultType !== "success") {
+        return;
+      }
+      register({
+        baseUrl: loadedConfig.absoluteBaseUrl,
+        paths: loadedConfig.paths,
+        addMatchAll: false
+      });
+      tsconfigPathsRegisteredByCwd.add(projectRoot);
+    };
     toImportSpecifier = (moduleName) => {
       if (moduleName.startsWith("file://")) {
         return moduleName;
@@ -5634,6 +5657,7 @@ var init_tradejsConfig = __esm({
       if (ext === ".ts" || ext === ".mts") {
         const requireFn = getRequireFn(import_path.default.dirname(configFilePath));
         await ensureTsNodeRegistered();
+        await ensureTsconfigPathsRegistered(import_path.default.dirname(configFilePath));
         return requireFn(configFilePath);
       }
       return import(
@@ -5641,7 +5665,7 @@ var init_tradejsConfig = __esm({
         configFileUrl
       );
     };
-    importTradejsModule = async (moduleName) => {
+    importTradejsModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
       const normalized = String(moduleName ?? "").trim();
       if (!normalized) {
         return {};
@@ -5655,13 +5679,15 @@ var init_tradejsConfig = __esm({
         }
       }
       const requireFn = getRequireFn(
-        import_path.default.isAbsolute(modulePath) ? import_path.default.dirname(modulePath) : getTradejsProjectCwd()
+        import_path.default.isAbsolute(modulePath) ? import_path.default.dirname(modulePath) : cwd
       );
       if (isTsModulePath(modulePath)) {
         await ensureTsNodeRegistered();
+        await ensureTsconfigPathsRegistered(cwd);
         return requireFn(modulePath);
       }
       if (isBareModuleSpecifier(normalized)) {
+        await ensureTsconfigPathsRegistered(cwd);
         return requireFn(normalized);
       }
       try {
@@ -5672,6 +5698,7 @@ var init_tradejsConfig = __esm({
       } catch (error) {
         if (isTsModulePath(modulePath)) {
           await ensureTsNodeRegistered();
+          await ensureTsconfigPathsRegistered(cwd);
           return requireFn(modulePath);
         }
         throw error;
@@ -5751,7 +5778,7 @@ var init_tradejsConfig = __esm({
 });
 
 // src/strategy/manifests.ts
-var import_indicators, import_logger3, strategyCreators, strategyManifestsMap, pluginsLoadPromise, toUniqueModules, getConfiguredPluginModuleNames, extractModuleEntries, extractStrategyPluginDefinition, extractIndicatorPluginDefinition, registerEntries, importStrategyPluginModule, ensureStrategyPluginsLoaded, ensureIndicatorPluginsLoaded, getStrategyCreator, getAvailableStrategyNames, getRegisteredStrategies, getRegisteredManifests, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies;
+var import_indicators, import_logger3, createStrategyRegistryState, registryStateByProjectRoot, getStrategyRegistryState, toUniqueModules, getConfiguredPluginModuleNames, extractModuleEntries, extractStrategyPluginDefinition, extractIndicatorPluginDefinition, registerEntries, importStrategyPluginModule, ensureStrategyPluginsLoaded, ensureIndicatorPluginsLoaded, getStrategyCreator, getAvailableStrategyNames, getRegisteredStrategies, getRegisteredManifests, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies;
 var init_manifests = __esm({
   "src/strategy/manifests.ts"() {
     "use strict";
@@ -5759,14 +5786,29 @@ var init_manifests = __esm({
     import_logger3 = require("@tradejs/infra/logger");
     init_tradejsConfig();
     init_tradejsConfig();
-    strategyCreators = /* @__PURE__ */ new Map();
-    strategyManifestsMap = /* @__PURE__ */ new Map();
-    pluginsLoadPromise = null;
+    createStrategyRegistryState = () => ({
+      strategyCreators: /* @__PURE__ */ new Map(),
+      strategyManifestsMap: /* @__PURE__ */ new Map(),
+      pluginsLoadPromise: null
+    });
+    registryStateByProjectRoot = /* @__PURE__ */ new Map();
+    getStrategyRegistryState = (cwd = getTradejsProjectCwd()) => {
+      const projectRoot = getTradejsProjectCwd(cwd);
+      let state = registryStateByProjectRoot.get(projectRoot);
+      if (!state) {
+        state = createStrategyRegistryState();
+        registryStateByProjectRoot.set(projectRoot, state);
+      }
+      return {
+        projectRoot,
+        state
+      };
+    };
     toUniqueModules = (modules = []) => [
       ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
     ];
-    getConfiguredPluginModuleNames = async () => {
-      const config = await loadTradejsConfig();
+    getConfiguredPluginModuleNames = async (cwd = getTradejsProjectCwd()) => {
+      const config = await loadTradejsConfig(cwd);
       return {
         strategyModules: toUniqueModules(config.strategies),
         indicatorModules: toUniqueModules(config.indicators)
@@ -5800,14 +5842,14 @@ var init_manifests = __esm({
       );
       return indicatorEntries ? { indicatorEntries } : null;
     };
-    registerEntries = (entries, source) => {
+    registerEntries = (entries, source, state) => {
       for (const entry of entries) {
         const strategyName = entry.manifest?.name;
         if (!strategyName) {
           import_logger3.logger.warn("Skip strategy entry without name from %s", source);
           continue;
         }
-        if (strategyCreators.has(strategyName)) {
+        if (state.strategyCreators.has(strategyName)) {
           import_logger3.logger.warn(
             'Skip duplicate strategy "%s" from %s: already registered',
             strategyName,
@@ -5815,106 +5857,135 @@ var init_manifests = __esm({
           );
           continue;
         }
-        strategyCreators.set(strategyName, entry.creator);
-        strategyManifestsMap.set(strategyName, entry.manifest);
+        state.strategyCreators.set(strategyName, entry.creator);
+        state.strategyManifestsMap.set(strategyName, entry.manifest);
       }
     };
-    importStrategyPluginModule = async (moduleName) => {
+    importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
       if (typeof importTradejsModule === "function") {
-        return importTradejsModule(moduleName);
+        return importTradejsModule(moduleName, cwd);
       }
       return import(
         /* webpackIgnore: true */
         moduleName
       );
     };
-    ensureStrategyPluginsLoaded = async () => {
-      if (pluginsLoadPromise) {
-        return pluginsLoadPromise;
-      }
-      pluginsLoadPromise = (async () => {
-        const { strategyModules, indicatorModules } = await getConfiguredPluginModuleNames();
-        const strategySet = new Set(strategyModules);
-        const indicatorSet = new Set(indicatorModules);
-        const pluginModuleNames = [
-          .../* @__PURE__ */ new Set([...strategyModules, ...indicatorModules])
-        ];
-        if (!pluginModuleNames.length) return;
-        for (const moduleName of pluginModuleNames) {
-          try {
-            const resolvedModuleName = resolvePluginModuleSpecifier(moduleName);
-            const moduleExport = await importStrategyPluginModule(resolvedModuleName);
-            if (strategySet.has(moduleName)) {
-              const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
-              if (!pluginDefinition) {
-                import_logger3.logger.warn(
-                  'Skip strategy plugin "%s": export { strategyEntries } is missing',
-                  moduleName
-                );
-              } else {
-                registerEntries(pluginDefinition.strategyEntries, moduleName);
+    ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
+      const { projectRoot, state } = getStrategyRegistryState(cwd);
+      if (!state.pluginsLoadPromise) {
+        (0, import_indicators.resetIndicatorRegistryCache)(projectRoot);
+        state.pluginsLoadPromise = (async () => {
+          const { strategyModules, indicatorModules } = await getConfiguredPluginModuleNames(projectRoot);
+          const strategySet = new Set(strategyModules);
+          const indicatorSet = new Set(indicatorModules);
+          const pluginModuleNames = [
+            .../* @__PURE__ */ new Set([...strategyModules, ...indicatorModules])
+          ];
+          if (!pluginModuleNames.length) {
+            return;
+          }
+          for (const moduleName of pluginModuleNames) {
+            try {
+              const resolvedModuleName = resolvePluginModuleSpecifier(
+                moduleName,
+                projectRoot
+              );
+              const moduleExport = await importStrategyPluginModule(
+                resolvedModuleName,
+                projectRoot
+              );
+              if (strategySet.has(moduleName)) {
+                const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
+                if (!pluginDefinition) {
+                  import_logger3.logger.warn(
+                    'Skip strategy plugin "%s": export { strategyEntries } is missing',
+                    moduleName
+                  );
+                } else {
+                  registerEntries(
+                    pluginDefinition.strategyEntries,
+                    moduleName,
+                    state
+                  );
+                }
               }
-            }
-            if (indicatorSet.has(moduleName)) {
-              const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
-              if (!indicatorPluginDefinition) {
+              if (indicatorSet.has(moduleName)) {
+                const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
+                if (!indicatorPluginDefinition) {
+                  import_logger3.logger.warn(
+                    'Skip indicator plugin "%s": export { indicatorEntries } is missing',
+                    moduleName
+                  );
+                } else {
+                  (0, import_indicators.registerIndicatorEntries)(
+                    indicatorPluginDefinition.indicatorEntries,
+                    moduleName,
+                    projectRoot
+                  );
+                }
+              }
+              if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
                 import_logger3.logger.warn(
-                  'Skip indicator plugin "%s": export { indicatorEntries } is missing',
-                  moduleName
-                );
-              } else {
-                (0, import_indicators.registerIndicatorEntries)(
-                  indicatorPluginDefinition.indicatorEntries,
+                  'Skip plugin "%s": no strategy/indicator sections requested in config',
                   moduleName
                 );
               }
-            }
-            if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
+            } catch (error) {
               import_logger3.logger.warn(
-                'Skip plugin "%s": no strategy/indicator sections requested in config',
-                moduleName
+                'Failed to load plugin "%s": %s',
+                moduleName,
+                String(error)
               );
             }
-          } catch (error) {
-            import_logger3.logger.warn(
-              'Failed to load plugin "%s": %s',
-              moduleName,
-              String(error)
-            );
           }
-        }
-      })();
-      return pluginsLoadPromise;
+        })();
+      }
+      await state.pluginsLoadPromise;
     };
-    ensureIndicatorPluginsLoaded = ensureStrategyPluginsLoaded;
-    getStrategyCreator = async (name) => {
-      await ensureStrategyPluginsLoaded();
-      return strategyCreators.get(name);
+    ensureIndicatorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => ensureStrategyPluginsLoaded(cwd);
+    getStrategyCreator = async (name, cwd = getTradejsProjectCwd()) => {
+      await ensureStrategyPluginsLoaded(cwd);
+      const { state } = getStrategyRegistryState(cwd);
+      return state.strategyCreators.get(name);
     };
-    getAvailableStrategyNames = async () => {
-      await ensureStrategyPluginsLoaded();
-      return [...strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
+    getAvailableStrategyNames = async (cwd = getTradejsProjectCwd()) => {
+      await ensureStrategyPluginsLoaded(cwd);
+      const { state } = getStrategyRegistryState(cwd);
+      return [...state.strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
     };
-    getRegisteredStrategies = () => {
-      return Object.fromEntries(strategyCreators.entries());
+    getRegisteredStrategies = (cwd = getTradejsProjectCwd()) => {
+      const { state } = getStrategyRegistryState(cwd);
+      return Object.fromEntries(state.strategyCreators.entries());
     };
-    getRegisteredManifests = () => {
-      return [...strategyManifestsMap.values()];
+    getRegisteredManifests = (cwd = getTradejsProjectCwd()) => {
+      const { state } = getStrategyRegistryState(cwd);
+      return [...state.strategyManifestsMap.values()];
     };
-    getStrategyManifest = (name) => {
-      return name ? strategyManifestsMap.get(name) : void 0;
+    getStrategyManifest = (name, cwd = getTradejsProjectCwd()) => {
+      if (!name) {
+        return void 0;
+      }
+      const { state } = getStrategyRegistryState(cwd);
+      return state.strategyManifestsMap.get(name);
     };
-    isKnownStrategy = (name) => {
-      return strategyCreators.has(name);
+    isKnownStrategy = (name, cwd = getTradejsProjectCwd()) => {
+      const { state } = getStrategyRegistryState(cwd);
+      return state.strategyCreators.has(name);
     };
-    registerStrategyEntries = (entries) => {
-      registerEntries(entries, "runtime");
+    registerStrategyEntries = (entries, cwd = getTradejsProjectCwd()) => {
+      const { state } = getStrategyRegistryState(cwd);
+      registerEntries(entries, "runtime", state);
     };
-    resetStrategyRegistryCache = () => {
-      strategyCreators.clear();
-      strategyManifestsMap.clear();
-      (0, import_indicators.resetIndicatorRegistryCache)();
-      pluginsLoadPromise = null;
+    resetStrategyRegistryCache = (cwd) => {
+      const normalizedCwd = String(cwd ?? "").trim();
+      if (!normalizedCwd) {
+        registryStateByProjectRoot.clear();
+        (0, import_indicators.resetIndicatorRegistryCache)();
+        return;
+      }
+      const projectRoot = getTradejsProjectCwd(normalizedCwd);
+      registryStateByProjectRoot.delete(projectRoot);
+      (0, import_indicators.resetIndicatorRegistryCache)(projectRoot);
     };
     strategies = new Proxy(
       {},
@@ -5923,10 +5994,10 @@ var init_manifests = __esm({
           if (typeof property !== "string") {
             return void 0;
           }
-          return strategyCreators.get(property);
+          return getStrategyRegistryState().state.strategyCreators.get(property);
         },
         ownKeys: () => {
-          return [...strategyCreators.keys()];
+          return [...getStrategyRegistryState().state.strategyCreators.keys()];
         },
         getOwnPropertyDescriptor: () => ({
           enumerable: true,
@@ -6399,6 +6470,7 @@ var buildMlPayload = (payload) => {
 };
 
 // src/strategyHelpers/runtime.ts
+init_tradejsConfig();
 var formatAiError = (err) => {
   const error = err;
   const safeJson = (value) => {
@@ -6440,7 +6512,8 @@ var enrichSignalWithMl = async ({
     const mlResult = await (0, import_ml2.fetchMlThreshold)({
       strategy,
       features,
-      threshold: ml.mlThreshold
+      threshold: ml.mlThreshold,
+      projectRoot: getTradejsProjectCwd()
     });
     if (mlResult) {
       signal.ml = mlResult;
@@ -6545,6 +6618,7 @@ var createLoadPineScript = (baseDir) => {
 
 // src/strategyRuntime.ts
 init_manifests();
+init_tradejsConfig();
 
 // src/strategyHelpers/config.ts
 var import_lodash2 = __toESM(require_lodash());
@@ -6634,10 +6708,151 @@ var getEntrySkipReason = ({
   }
   return "ENTRY_POLICY_BLOCKED";
 };
+var buildHookCtx = ({
+  connector,
+  strategyName,
+  userName,
+  symbol,
+  strategyConfig,
+  env,
+  isConfigFromBacktest
+}) => ({
+  connector,
+  strategyName,
+  userName,
+  symbol,
+  strategyConfig,
+  env,
+  isConfigFromBacktest
+});
+var buildHookEntry = ({
+  decision,
+  runtime
+}) => ({
+  context: decision.entryContext,
+  orderPlan: decision.orderPlan,
+  signal: decision.signal,
+  runtime: {
+    raw: decision.runtime,
+    resolved: runtime
+  }
+});
+var buildHookPolicy = ({
+  quality,
+  makeOrdersEnabled,
+  minAiQuality
+}) => ({
+  aiQuality: quality,
+  makeOrdersEnabled,
+  minAiQuality
+});
+var buildMlHookContext = ({
+  signal,
+  env,
+  ml
+}) => {
+  if (env === "BACKTEST") {
+    return {
+      config: ml,
+      attempted: false,
+      applied: false,
+      skippedReason: "BACKTEST"
+    };
+  }
+  if (!ml) {
+    return {
+      attempted: false,
+      applied: false,
+      skippedReason: "NO_RUNTIME"
+    };
+  }
+  if (ml.enabled === false) {
+    return {
+      config: ml,
+      attempted: false,
+      applied: false,
+      skippedReason: "DISABLED"
+    };
+  }
+  if (!ml.strategyConfig) {
+    return {
+      config: ml,
+      attempted: false,
+      applied: false,
+      skippedReason: "NO_STRATEGY_CONFIG"
+    };
+  }
+  if (typeof ml.mlThreshold !== "number") {
+    return {
+      config: ml,
+      attempted: false,
+      applied: false,
+      skippedReason: "NO_THRESHOLD"
+    };
+  }
+  if (signal.ml) {
+    return {
+      config: ml,
+      attempted: true,
+      applied: true,
+      result: signal.ml
+    };
+  }
+  return {
+    config: ml,
+    attempted: true,
+    applied: false,
+    skippedReason: "NO_RESULT"
+  };
+};
+var buildAiHookContext = ({
+  env,
+  ai,
+  quality
+}) => {
+  if (env === "BACKTEST") {
+    return {
+      config: ai,
+      attempted: false,
+      applied: false,
+      skippedReason: "BACKTEST"
+    };
+  }
+  if (!ai) {
+    return {
+      attempted: false,
+      applied: false,
+      skippedReason: "NO_RUNTIME"
+    };
+  }
+  if (ai.enabled === false) {
+    return {
+      config: ai,
+      attempted: false,
+      applied: false,
+      skippedReason: "DISABLED"
+    };
+  }
+  if (typeof quality === "number") {
+    return {
+      config: ai,
+      attempted: true,
+      applied: true,
+      quality
+    };
+  }
+  return {
+    config: ai,
+    attempted: true,
+    applied: false,
+    skippedReason: "NO_QUALITY"
+  };
+};
 var handleExitDecision = async ({
   connector,
   symbol,
   decision,
+  market,
   onRuntimeError
 }) => {
   try {
@@ -6651,7 +6866,8 @@ var handleExitDecision = async ({
     await onRuntimeError?.({
       stage: "closePosition",
       error: err,
-      decision
+      decision,
+      market
     });
     import_logger5.logger.error("close order error: %s %s", symbol, err);
     return "ORDER_ERROR";
@@ -6664,7 +6880,12 @@ var executeEntryDecision = async ({
   decision,
   runtime,
   manifest,
-  hookBase,
+  hookCtx,
+  market,
+  entry,
+  policy,
+  ml,
+  ai,
   invokeHook,
   notifyRuntimeError
 }) => {
@@ -6674,13 +6895,15 @@ var executeEntryDecision = async ({
       "beforePlaceOrder",
       manifest?.hooks?.beforePlaceOrder,
       {
-        ...hookBase,
-        entryContext: decision.entryContext,
-        runtime,
+        ctx: hookCtx,
+        market,
         decision,
-        signal
+        entry,
+        policy,
+        ml,
+        ai
       },
-      { decision, signal }
+      { decision, entry, market }
     );
     try {
       await runtime.beforePlaceOrder?.();
@@ -6689,7 +6912,8 @@ var executeEntryDecision = async ({
         stage: "runtime.beforePlaceOrder",
         error,
         decision,
-        signal
+        entry,
+        market
       });
       throw error;
     }
@@ -6712,13 +6936,18 @@ var executeEntryDecision = async ({
         "afterPlaceOrder",
         manifest?.hooks?.afterPlaceOrder,
         {
-          ...hookBase,
+          ctx: hookCtx,
+          market,
           decision,
-          runtime,
-          signal,
-          orderResult: signal
+          entry,
+          policy,
+          ml,
+          ai,
+          order: {
+            result: signal
+          }
         },
-        { decision, signal }
+        { decision, entry, market }
       );
       return signal;
     }
@@ -6738,13 +6967,18 @@ var executeEntryDecision = async ({
       "afterPlaceOrder",
       manifest?.hooks?.afterPlaceOrder,
       {
-        ...hookBase,
+        ctx: hookCtx,
+        market,
         decision,
-        runtime,
-        signal,
-        orderResult: decision.code
+        entry,
+        policy,
+        ml,
+        ai,
+        order: {
+          result: decision.code
+        }
       },
-      { decision, signal }
+      { decision, entry, market }
     );
   } catch (err) {
     if (signal) {
@@ -6754,7 +6988,8 @@ var executeEntryDecision = async ({
       stage: "placeOrder",
       error: err,
       decision,
-      signal
+      entry,
+      market
     });
     import_logger5.logger.error("order error: %s %s", symbol, err);
     return signal ?? "ORDER_ERROR";
@@ -6768,6 +7003,7 @@ var createStrategyRuntime = ({
   manifest: staticManifest,
   strategyDirectory
 }) => {
+  const projectRoot = getTradejsProjectCwd();
   const resolveManifest = (name) => {
     if (!name) {
       return void 0;
@@ -6775,11 +7011,11 @@ var createStrategyRuntime = ({
     if (staticManifest?.name === name) {
       return staticManifest;
     }
-    return getStrategyManifest(name);
+    return getStrategyManifest(name, projectRoot);
   };
   const loadPineScript2 = createLoadPineScript(
     strategyDirectory ? import_node_path2.default.resolve(strategyDirectory) : import_node_path2.default.resolve(
-      process.cwd(),
+      projectRoot,
       "packages",
       "strategies",
       "src",
@@ -6810,33 +7046,37 @@ var createStrategyRuntime = ({
       strategyName,
       userName,
       symbol,
-      config,
+      strategyConfig: config,
       env,
       isConfigFromBacktest
     };
+    const getHookCtx = (name = strategyName) => buildHookCtx({
+      ...hookBase,
+      strategyName: name
+    });
     const notifyRuntimeError = async ({
       stage,
       error,
       decision,
-      signal
+      entry,
+      market
     }) => {
       const errorStrategyName = decision?.kind === "entry" ? decision.entryContext.strategy : strategyName;
       const errorManifest = resolveManifest(errorStrategyName) ?? strategyManifest;
-      const errorHookBase = {
-        ...hookBase,
-        strategyName: errorStrategyName
-      };
       const onRuntimeError = errorManifest?.hooks?.onRuntimeError;
       if (!onRuntimeError) {
         return;
       }
       try {
         await onRuntimeError({
-          ...errorHookBase,
-          stage,
-          error,
+          ctx: getHookCtx(errorStrategyName),
+          market,
           decision,
-          signal
+          entry,
+          error: {
+            stage,
+            cause: error
+          }
         });
       } catch (hookError) {
         import_logger5.logger.error(
@@ -6863,7 +7103,8 @@ var createStrategyRuntime = ({
           stage,
           error,
           decision: errorContext.decision,
-          signal: errorContext.signal
+          entry: errorContext.entry,
+          market: errorContext.market
         });
         return void 0;
       }
@@ -6874,7 +7115,8 @@ var createStrategyRuntime = ({
       btcData,
       btcBinanceData,
       btcCoinbaseData,
-      periods: (0, import_strategies.buildDefaultIndicatorPeriods)(config)
+      periods: (0, import_strategies.buildDefaultIndicatorPeriods)(config),
+      pluginRegistryScope: projectRoot
     });
     const strategyApi = (0, import_strategies.createStrategyAPI)({
       strategy: strategyName,
@@ -6901,39 +7143,45 @@ var createStrategyRuntime = ({
       indicatorsState
     });
     await invokeHook("onInit", strategyManifest?.hooks?.onInit, {
-      ...hookBase,
-      data,
-      btcData
+      ctx: getHookCtx(),
+      market: {
+        data,
+        btcData
+      }
     });
     return async (candle, btcCandle) => {
       data.push(candle);
       btcData.push(btcCandle);
       indicatorsState.setCurrentBar(candle, btcCandle);
+      const market = {
+        candle,
+        btcCandle
+      };
       const decision = await core(candle, btcCandle);
       const decisionStrategyName = decision.kind === "entry" ? decision.entryContext.strategy : strategyName;
       const decisionManifest = resolveManifest(decisionStrategyName) ?? strategyManifest;
-      const decisionHookBase = {
-        ...hookBase,
-        strategyName: decisionStrategyName
-      };
+      const decisionHookCtx = getHookCtx(decisionStrategyName);
       await invokeHook(
         "afterCoreDecision",
         decisionManifest?.hooks?.afterCoreDecision,
         {
-          ...decisionHookBase,
-          decision,
-          candle,
-          btcCandle
+          ctx: decisionHookCtx,
+          market,
+          decision
         },
-        { decision }
+        { decision, market }
       );
       if (decision.kind === "skip") {
-        await invokeHook("onSkip", decisionManifest?.hooks?.onSkip, {
-          ...decisionHookBase,
-          decision,
-          candle,
-          btcCandle
-        });
+        await invokeHook(
+          "onSkip",
+          decisionManifest?.hooks?.onSkip,
+          {
+            ctx: decisionHookCtx,
+            market,
+            decision
+          },
+          { decision, market }
+        );
         return decision.code;
       }
       const makeOrdersEnabled = typeof config.MAKE_ORDERS === "boolean" ? config.MAKE_ORDERS : true;
@@ -6945,10 +7193,11 @@ var createStrategyRuntime = ({
           "beforeClosePosition",
           decisionManifest?.hooks?.beforeClosePosition,
           {
-            ...decisionHookBase,
+            ctx: decisionHookCtx,
+            market,
             decision
           },
-          { decision }
+          { decision, market }
         );
         if (closeGate?.allow === false) {
           return closeGate.reason ? `CLOSE_BLOCKED_BY_HOOK:${closeGate.reason}` : "CLOSE_BLOCKED_BY_HOOK";
@@ -6957,11 +7206,18 @@ var createStrategyRuntime = ({
           connector,
           symbol,
           decision,
-          onRuntimeError: async ({ stage, error, decision: exitDecision }) => {
+          market,
+          onRuntimeError: async ({
+            stage,
+            error,
+            decision: exitDecision,
+            market: errorMarket
+          }) => {
             await notifyRuntimeError({
               stage,
               error,
-              decision: exitDecision
+              decision: exitDecision,
+              market: errorMarket
             });
           }
         });
@@ -6972,6 +7228,11 @@ var createStrategyRuntime = ({
         manifest: decisionManifest
       });
       const signal = decision.signal;
+      const entry = buildHookEntry({
+        decision,
+        runtime
+      });
+      let ml;
       if (signal) {
         try {
           await enrichSignalWithMl({
@@ -6984,23 +7245,31 @@ var createStrategyRuntime = ({
             stage: "enrichSignalWithMl",
             error,
             decision,
-            signal
+            entry,
+            market
           });
           throw error;
         }
+        ml = buildMlHookContext({
+          signal,
+          env,
+          ml: runtime.ml
+        });
         await invokeHook(
           "afterEnrichMl",
           decisionManifest?.hooks?.afterEnrichMl,
           {
-            ...decisionHookBase,
+            ctx: decisionHookCtx,
+            market,
             decision,
-            runtime,
-            signal
+            entry,
+            ml
           },
-          { decision, signal }
+          { decision, entry, market }
         );
       }
       let quality;
+      let ai;
       if (signal) {
         try {
           quality = await enrichSignalWithAi({
@@ -7015,24 +7284,36 @@ var createStrategyRuntime = ({
             stage: "enrichSignalWithAi",
             error,
             decision,
-            signal
+            entry,
+            market
           });
           throw error;
         }
+        ai = buildAiHookContext({
+          env,
+          ai: runtime.ai,
+          quality
+        });
         await invokeHook(
           "afterEnrichAi",
           decisionManifest?.hooks?.afterEnrichAi,
           {
-            ...decisionHookBase,
+            ctx: decisionHookCtx,
+            market,
             decision,
-            runtime,
-            signal,
-            quality
+            entry,
+            ml: ml ?? buildMlHookContext({ signal, env, ml: runtime.ml }),
+            ai
           },
-          { decision, signal }
+          { decision, entry, market }
         );
       }
       const minAiQuality = runtime.ai?.minQuality ?? 4;
+      const policy = buildHookPolicy({
+        quality,
+        makeOrdersEnabled,
+        minAiQuality
+      });
       const shouldMakeOrder = shouldExecuteEntryDecision({
         makeOrdersEnabled,
         env,
@@ -7056,15 +7337,15 @@ var createStrategyRuntime = ({
         "beforeEntryGate",
         decisionManifest?.hooks?.beforeEntryGate,
         {
-          ...decisionHookBase,
+          ctx: decisionHookCtx,
+          market,
           decision,
-          runtime,
-          signal,
-          quality,
-          makeOrdersEnabled,
-          minAiQuality
+          entry,
+          policy,
+          ml,
+          ai
         },
-        { decision, signal }
+        { decision, entry, market }
       );
       if (entryGate?.allow === false) {
         const skipReason = entryGate.reason ? `HOOK_BEFORE_ENTRY_GATE:${entryGate.reason}` : "HOOK_BEFORE_ENTRY_GATE";
@@ -7080,7 +7361,12 @@ var createStrategyRuntime = ({
         decision,
         runtime,
         manifest: decisionManifest,
-        hookBase: decisionHookBase,
+        hookCtx: decisionHookCtx,
+        market,
+        entry,
+        policy,
+        ml,
+        ai,
         invokeHook,
         notifyRuntimeError
       });
@@ -7092,13 +7378,13 @@ var createStrategyRuntime = ({
 var createCloseOppositeBeforePlaceOrderHook = ({
   isEnabled
 }) => {
-  return async ({ connector, entryContext, config }) => {
-    if (!isEnabled(config)) {
+  return async ({ ctx, entry }) => {
+    if (!isEnabled(ctx.strategyConfig)) {
       return;
     }
     await closeOppositePositionsBeforeOpen({
-      connector,
-      entryContext
+      connector: ctx.connector,
+      entryContext: entry.context
     });
   };
 };