dexbot 1.4.20 → 1.4.22

package/dist/market_adapter/core/market_adapter_service.d.ts

@@ -1,12 +1,21 @@
 declare const AMA_SLOPE_PERCENT_MODE_PER_BAR = "perBar";
 declare function normalizeAmaSlopePercentMode(value: any): "perBar" | "window" | null;
-declare function normalizeAmaSlopeLookbackBars(value: any, fallback?: any): any;
 declare function convertSlopePercentToPerBar(value: any, lookbackBars: any, mode: any): number | null;
 declare class MarketAdapterService {
     deps: any;
     constructor(deps?: any);
     static isRetryableClosedCandleFailure(reason: any): boolean;
     getNowMs(): any;
+    /**
+     * Kibana bootstrap lookback in hours — exact conversion of the required
+     * candle count at the bot's interval, mirroring getGapRepairMaxHours().
+     * The caller passes rawKeepCount (getAmaWarmupBars() + 1 closed bar + 1
+     * in-progress raw bar); if Kibana returns fewer bars than amaWarmupBars
+     * (thin/gappy data), the existing native-backfill fallback handles it.
+     * cfg.bootstrapLookbackHours stays as a floor so operators can seed
+     * deeper history than the analytical minimum.
+     */
+    bootstrapKibanaLookbackHours(cfg: any, keepCount: any): number;
     selectClosedCandles(candles: any, intervalSeconds: any, nowMs?: any): {
         closedCandles: any[];
         currentBucketStartMs: null;
@@ -79,7 +88,7 @@ declare class MarketAdapterService {
                 slopePct: number | null;
                 slopeOffset: number;
                 rawSlopeOffset: any;
-                amaSlopeGated: number;
+                amaSlopeGated: any;
                 regimeMultiplier: number;
                 regimeSensitivity: any;
                 absoluteThreshold: any;
@@ -91,11 +100,11 @@ declare class MarketAdapterService {
                 maxSlopeOffset: any;
                 maxAsymmetryFactor: any;
                 minScaleSlots: any;
-                clipPercentile: any;
+                clipPercentile: number;
                 neutralZonePct: any;
                 volatilityThreshold: number;
-                volatilityExponent: any;
-                volatilityScaleX: any;
+                volatilityExponent: number;
+                volatilityScaleX: number;
                 amaSlope: {
                     maxSlopePct: any;
                 };
@@ -108,7 +117,7 @@ declare class MarketAdapterService {
                 kalmanDispThresholdMult: any;
                 kalmanSmoothSpanPct: any;
                 signalConfirmBars: any;
-                amaChannelContribution: number;
+                amaChannelContribution: any;
                 rawFinalOffset: any;
                 trendOffset: any;
                 finalOffset: any;
@@ -137,7 +146,7 @@ declare class MarketAdapterService {
             };
             slopeOffset: number;
             rawSlopeOffset: any;
-            amaSlopeGated: number;
+            amaSlopeGated: any;
             volatilityPenalty: number;
             finalOffset: any;
             alpha: any;
@@ -151,11 +160,11 @@ declare class MarketAdapterService {
             kalmanSlope: {
                 maxSlopePct: any;
             };
-            clipPercentile: any;
+            clipPercentile: number;
             neutralZonePct: any;
             volatilityThreshold: number;
-            volatilityExponent: any;
-            volatilityScaleX: any;
+            volatilityExponent: number;
+            volatilityScaleX: number;
             maxVolatilityOffset: number;
             kalmanSmoothPct: any;
             kalmanDispScaleMult: any;
@@ -165,7 +174,7 @@ declare class MarketAdapterService {
             rawFinalOffset: any;
             maxAsymmetryFactor: any;
             minScaleSlots: any;
-            amaChannelContribution: number;
+            amaChannelContribution: any;
             trend: string;
             confidence: number;
             slopePct: number | null;
@@ -195,7 +204,7 @@ declare class MarketAdapterService {
             slopePct: number | null;
             slopeOffset: number;
             rawSlopeOffset: any;
-            amaSlopeGated: number;
+            amaSlopeGated: any;
             regimeMultiplier: number;
             symmetricDelta: number;
             weightVariance: any;
@@ -222,5 +231,5 @@ declare class MarketAdapterService {
     };
     processBot(bot: any, state: any, cfg: any, contextCache: any, hooks?: any): Promise<any>;
 }
-export { MarketAdapterService, AMA_SLOPE_PERCENT_MODE_PER_BAR, normalizeAmaSlopePercentMode, normalizeAmaSlopeLookbackBars, convertSlopePercentToPerBar };
+export { MarketAdapterService, AMA_SLOPE_PERCENT_MODE_PER_BAR, normalizeAmaSlopePercentMode, convertSlopePercentToPerBar };
 //# sourceMappingURL=market_adapter_service.d.ts.map

package/dist/market_adapter/core/market_adapter_service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"market_adapter_service.d.ts","sourceRoot":"","sources":["../../../market_adapter/core/market_adapter_service.ts"],"names":[],"mappings":"AAkCA,QAAA,MAAM,8BAA8B,WAAW,CAAC;AAGhD,iBAAS,4BAA4B,CAAC,KAAK,EAAE,GAAG,8BAS/C;AAED,iBAAS,6BAA6B,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,GAAE,GAAqD,OAIjH;AAED,iBAAS,2BAA2B,CAAC,KAAK,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,iBAM5E;AA4DD,cAAM,oBAAoB;IACtB,IAAI,EAAE,GAAG,CAAC;gBACE,IAAI,GAAE,GAAQ;IAU1B,MAAM,CAAC,8BAA8B,CAAC,MAAM,EAAE,GAAG;IAOjD,QAAQ;IAIR,mBAAmB,CAAC,OAAO,EAAE,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,KAAK,GAAE,GAAqB;;;;;;;IAgBpF,wBAAwB,CAAC,GAAG,EAAE,GAAG;IAajC,uBAAuB,CAAC,iBAAiB,EAAE,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,WAAW,GAAE,GAAQ;;;;IAgB3F,mCAAmC,CAAC,iBAAiB,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG;IAQ1E,oBAAoB,CAAC,GAAG,EAAE,GAAG;IAe7B,oCAAoC,CAAC,GAAG,EAAE,GAAG;IAM7C,+BAA+B,CAAC,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,KAAK,GAAE,GAAqB;IAwBrH,+BAA+B,CAAC,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG;IAqB5D,+BAA+B,CAAC,OAAO,EAAE,GAAG,EAAE,iBAAiB,EAAE,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG;;;;IA4D9G,6BAA6B,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,GAAE,GAAO;IAoBzD,8BAA8B,CAAC,MAAM,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,iBAAiB,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,eAAe,EAAE,GAAG;IA+BhI,sBAAsB,CAAC,WAAW,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG;IAetE,8BAA8B,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG;;;;;;;;;IA4B9E,oBAAoB,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,GAAE,GAAQ;IA6ClD,kBAAkB,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,GAAE,GAAQ;IAgDjD,oCAAoC,CAAC,GAAG,EAAE,GAAG;IAU7C,yBAAyB,CAAC,eAAe,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG;;;;;;;;IAsB/E,0BAA0B,CAAC,QAAQ,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG;IAK3D,gCAAgC,CAAC,QAAQ,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG;;;;;;;;;;;;;IA+BjE,sBAAsB,CAAC,MAAM,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuV5B,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,KAAK,GAAE,GAAQ;CAihDtF;AAED,OAAO,EAAE,oBAAoB,EAAE,8BAA8B,EAAE,4BAA4B,EAAE,6BAA6B,EAAE,2BAA2B,EAAE,CAAA"}
+{"version":3,"file":"market_adapter_service.d.ts","sourceRoot":"","sources":["../../../market_adapter/core/market_adapter_service.ts"],"names":[],"mappings":"AAmCA,QAAA,MAAM,8BAA8B,WAAW,CAAC;AAGhD,iBAAS,4BAA4B,CAAC,KAAK,EAAE,GAAG,8BAS/C;AAQD,iBAAS,2BAA2B,CAAC,KAAK,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,iBAM5E;AA4DD,cAAM,oBAAoB;IACtB,IAAI,EAAE,GAAG,CAAC;gBACE,IAAI,GAAE,GAAQ;IAU1B,MAAM,CAAC,8BAA8B,CAAC,MAAM,EAAE,GAAG;IAOjD,QAAQ;IAIR;;;;;;;;OAQG;IACH,4BAA4B,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG;IAQrD,mBAAmB,CAAC,OAAO,EAAE,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,KAAK,GAAE,GAAqB;;;;;;;IAgBpF,wBAAwB,CAAC,GAAG,EAAE,GAAG;IAajC,uBAAuB,CAAC,iBAAiB,EAAE,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,WAAW,GAAE,GAAQ;;;;IAgB3F,mCAAmC,CAAC,iBAAiB,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG;IAQ1E,oBAAoB,CAAC,GAAG,EAAE,GAAG;IAe7B,oCAAoC,CAAC,GAAG,EAAE,GAAG;IAM7C,+BAA+B,CAAC,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,KAAK,GAAE,GAAqB;IAwBrH,+BAA+B,CAAC,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG;IAqB5D,+BAA+B,CAAC,OAAO,EAAE,GAAG,EAAE,iBAAiB,EAAE,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG;;;;IA4D9G,6BAA6B,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,GAAE,GAAO;IAoBzD,8BAA8B,CAAC,MAAM,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,iBAAiB,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,eAAe,EAAE,GAAG;IA+BhI,sBAAsB,CAAC,WAAW,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG;IAetE,8BAA8B,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG;;;;;;;;;IA4B9E,oBAAoB,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,GAAE,GAAQ;IA6ClD,kBAAkB,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,GAAE,GAAQ;IAgDjD,oCAAoC,CAAC,GAAG,EAAE,GAAG;IAU7C,yBAAyB,CAAC,eAAe,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG;;;;;;;;IAsB/E,0BAA0B,CAAC,QAAQ,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG;IAK3D,gCAAgC,CAAC,QAAQ,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG;;;;;;;;;;;;;IA+BjE,sBAAsB,CAAC,MAAM,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqX5B,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,KAAK,GAAE,GAAQ;CAiiDtF;AAED,OAAO,EAAE,oBAAoB,EAAE,8BAA8B,EAAE,4BAA4B,EAAE,2BAA2B,EAAE,CAAA"}

package/dist/market_adapter/core/market_adapter_service.js

@@ -1,3 +1,4 @@
+'use strict';
 import { calculateATR } from './strategies/atr/calculator.js';
 import { normalizeMarketSource, hasNumericStartPrice, resolveMarketSourceForBot } from '../utils/chain.js';
 import { computeRegimeMultiplier } from './strategies/regime_gate.js';
@@ -7,10 +8,10 @@ import { KalmanTrendAnalyzer } from './signals/kalman_trend_analyzer.js';
 import { adjustCollateralRatio } from './strategies/collateral_manager.js';
 import { DEFAULT_CONFIG, MARKET_ADAPTER } from '../../modules/constants.js';
 import { resolveConfiguredPriceBound } from '../../modules/order/utils/order.js';
+import { usesAmaGridPrice } from '../../modules/grid_price_source.js';
 import Logger from '../../modules/order/logger.js';
 import { roundTo } from '../../modules/order/utils/math.js';
-'use strict';
-import { computeAmaSlopeWeights, computeAverageAmaSlopePct, } from './strategies/ama_slope_model.js';
+import { computeAmaSlopeWeights, computeAmaSlopeClipThreshold, } from './strategies/ama_slope_model.js';
 import { normalizeAtrPeriod, normalizeMaxVolatilityOffset, normalizeVolatilityThreshold, } from './config_normalizers.js';
 import { buildKalmanVelocitySeries, computeAbsolutePercentileThreshold, } from './signals/kalman_velocity_smoothing.js';
 import { resolveMaxAsymmetryFactor, computeAsymmetricBoundsMetrics, } from './asymmetric_bounds.js';
@@ -113,6 +114,22 @@ class MarketAdapterService {
     getNowMs() {
         return typeof this.deps.getNowMs === 'function' ? this.deps.getNowMs() : Date.now();
     }
+    /**
+     * Kibana bootstrap lookback in hours — exact conversion of the required
+     * candle count at the bot's interval, mirroring getGapRepairMaxHours().
+     * The caller passes rawKeepCount (getAmaWarmupBars() + 1 closed bar + 1
+     * in-progress raw bar); if Kibana returns fewer bars than amaWarmupBars
+     * (thin/gappy data), the existing native-backfill fallback handles it.
+     * cfg.bootstrapLookbackHours stays as a floor so operators can seed
+     * deeper history than the analytical minimum.
+     */
+    bootstrapKibanaLookbackHours(cfg, keepCount) {
+        const intervalSeconds = Number(cfg?.intervalSeconds);
+        const intervalHours = Number.isFinite(intervalSeconds) && intervalSeconds > 0
+            ? intervalSeconds / 3600
+            : 1;
+        return Math.max(Number(cfg?.bootstrapLookbackHours) || 0, Number(keepCount) * intervalHours);
+    }
     selectClosedCandles(candles, intervalSeconds, nowMs = this.getNowMs()) {
         const bucketMs = Number(intervalSeconds) * 1000;
         if (!Number.isFinite(bucketMs) || bucketMs <= 0) {
@@ -533,7 +550,13 @@ class MarketAdapterService {
     }
     _computeDynamicWeights(params) {
         const { closes, amaValues, lookbackBars, botAma, weightVariance, nowIso, cfg, bot, atrPeriod } = params;
-        const clipPercentile = cfg.clipPercentile ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_CLIP_PERCENTILE;
+        // clipPercentile must stay inside (0, 100] — values above 100 would
+        // otherwise produce negative percentile indices (NaN thresholds)
+        // downstream, and <= 0 disables clipping.
+        const rawClipPercentile = cfg.clipPercentile ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_CLIP_PERCENTILE;
+        const clipPercentile = Number.isFinite(rawClipPercentile)
+            ? Math.max(0, Math.min(100, Number(rawClipPercentile)))
+            : MARKET_ADAPTER.DYNAMIC_WEIGHT_CLIP_PERCENTILE;
         const nz = cfg.amaSlope?.neutralZonePct ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_AMA_NEUTRAL_ZONE_PCT;
         const amaMaxS = cfg.amaSlope?.maxSlopePct ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_AMA_MAX_SLOPE_PCT;
         const kalMaxS = cfg.kalmanSlope?.maxSlopePct
@@ -541,29 +564,20 @@ class MarketAdapterService {
         const mo = cfg.maxSlopeOffset ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_ASYMMETRIC_OFFSET_CLAMP;
         const volatilityClamp = normalizeMaxVolatilityOffset(cfg.maxVolatilityOffset);
         const volatilityThreshold = normalizeVolatilityThreshold(cfg.volatilityThreshold);
-        const volatilityExponent = cfg.volatilityExponent ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_VOLATILITY_EXPONENT;
-        const volatilityScaleX = cfg.volatilityScaleX ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_VOLATILITY_SCALE_X_DEFAULT;
+        // Normalize volatility knobs into their effective ranges at the single
+        // read point so config, applied value and reported payload always
+        // agree (computeVolatilityShift hard-clamps to the same bounds).
+        const rawVolatilityExponent = cfg.volatilityExponent ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_VOLATILITY_EXPONENT;
+        const volatilityExponent = Number.isFinite(rawVolatilityExponent)
+            ? Math.max(MARKET_ADAPTER.DYNAMIC_WEIGHT_VOLATILITY_EXPONENT_MIN, Math.min(MARKET_ADAPTER.DYNAMIC_WEIGHT_VOLATILITY_EXPONENT_MAX, Number(rawVolatilityExponent)))
+            : MARKET_ADAPTER.DYNAMIC_WEIGHT_VOLATILITY_EXPONENT;
+        const rawVolatilityScaleX = cfg.volatilityScaleX ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_VOLATILITY_SCALE_X_DEFAULT;
+        const volatilityScaleX = Number.isFinite(rawVolatilityScaleX)
+            ? Math.max(MARKET_ADAPTER.DYNAMIC_WEIGHT_VOLATILITY_SCALE_X_MIN, Math.min(MARKET_ADAPTER.DYNAMIC_WEIGHT_VOLATILITY_SCALE_X_MAX, Number(rawVolatilityScaleX)))
+            : MARKET_ADAPTER.DYNAMIC_WEIGHT_VOLATILITY_SCALE_X_DEFAULT;
         // Compute separate clip thresholds for AMA (slopes) and Kalman (velocities)
-        let amaClipThreshold = Infinity;
+        let amaClipThreshold = computeAmaSlopeClipThreshold(amaValues, botAma.erPeriod, lookbackBars, clipPercentile);
         let kalClipThreshold = Infinity;
-        const amaSlopeReadyBars = Math.ceil(botAma.erPeriod) + lookbackBars;
-        if (clipPercentile > 0 && amaValues.length > amaSlopeReadyBars) {
-            // AMA clip threshold from slope distribution — skip the ER window,
-            // but do not require the full convergence-retention window.
-            const amaSlopes = [];
-            for (let i = amaSlopeReadyBars; i < amaValues.length; i++) {
-                const last = amaValues[i];
-                const past = amaValues[i - lookbackBars];
-                const slopePct = computeAverageAmaSlopePct(last, past, lookbackBars);
-                if (Number.isFinite(slopePct))
-                    amaSlopes.push(Math.abs(slopePct));
-            }
-            if (amaSlopes.length > 0) {
-                const sorted = amaSlopes.sort((a, b) => a - b);
-                const idx = Math.min(Math.floor((100 - clipPercentile) / 100 * sorted.length), sorted.length - 1);
-                amaClipThreshold = sorted[idx];
-            }
-        }
         const slopeCfg = {
             ...(cfg.amaSlope || {}),
             erPeriod: botAma.erPeriod,
@@ -581,7 +595,7 @@ class MarketAdapterService {
             rNoise: cfg.kalman?.rNoise ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_KALMAN_R_NOISE_DEFAULT,
             qTactical: cfg.kalman?.qTactical ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_KALMAN_Q_TACTICAL_DEFAULT,
             qModal: cfg.kalman?.qModal ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_KALMAN_Q_MODAL_DEFAULT,
-            warmupBars: cfg.kalman?.warmupBars ?? 20,
+            warmupBars: cfg.kalman?.warmupBars ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_KALMAN_WARMUP_BARS_DEFAULT,
         });
         const kalmanHistory = [];
         for (const price of closes) {
@@ -646,7 +660,6 @@ class MarketAdapterService {
                 : Infinity;
         }
         const offsetClamp = cfg.maxSlopeOffset ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_ASYMMETRIC_OFFSET_CLAMP;
-        const channelNorm = Math.max(Math.abs(offsetClamp), 1e-9);
         const outputThreshold = minOutputThreshold;
         // Per-bar directional offset series — canonical implementation shared
         // with the research chart and test harness (see dynamic_weight_series.ts).
@@ -672,14 +685,43 @@ class MarketAdapterService {
             signalConfirmBars,
             clampFinalOutput: true,
         });
-        const { amaOffsets, combinedOffSeries, gatedOffSeries, echoedOffSeries, echoedGatedOffSeries, } = seriesResult;
+        const { combinedOffSeries, gatedOffSeries, echoedOffSeries, echoedGatedOffSeries, } = seriesResult;
         const rawFinalOff = combinedOffSeries[combinedOffSeries.length - 1] ?? 0;
         const rawFinalPreGainOff = gatedOffSeries[gatedOffSeries.length - 1] ?? 0;
         const finalPreGainOff = echoedGatedOffSeries[echoedGatedOffSeries.length - 1] ?? rawFinalPreGainOff;
         const finalOff = echoedOffSeries[echoedOffSeries.length - 1] ?? rawFinalOff;
-        const lastAmaOffset = useAmaBlend ? (amaOffsets[amaOffsets.length - 1] ?? 0) : 0;
+        // Diagnostic: AMA channel contribution derived from the canonical
+        // pipeline with the Kalman channel disabled, so the dead-band gate,
+        // per-bar regime multipliers, gain/clamp and echo latch all match the
+        // path that produces finalOffset. (The previous closed-form
+        // alpha*(offset/norm)*gain*regime recomputation diverged from
+        // finalOffset whenever gating or signal confirmation was active.)
+        const amaOnlySeriesResult = computeDynamicWeightSeries({
+            amaValues,
+            kalmanVelocityPct: kalmanSmoothedVelocityPct.map(() => null),
+            kalmanDisplacementPct: kalmanHistory.map(() => null),
+            kalmanIsReady: kalmanHistory.map(() => false),
+            regimeMultipliers,
+            lookbackBars,
+            amaErPeriod: botAma.erPeriod,
+            amaClipThreshold,
+            kalClipThreshold: Infinity,
+            neutralZonePct: nz,
+            amaMaxSlopePct: amaMaxS,
+            kalmanMaxSlopePct: kalMaxS,
+            offsetClamp,
+            dispScaleMinPct,
+            alpha,
+            dw,
+            gain,
+            minOutputThreshold,
+            signalConfirmBars,
+            clampFinalOutput: true,
+        });
         const amaSlopeGated = slopeResult.isReady
-            ? roundTo(alpha * (lastAmaOffset / channelNorm) * gain * regimeMultiplier, 1000)
+            ? (useAmaBlend
+                ? (amaOnlySeriesResult.echoedOffSeries[amaOnlySeriesResult.echoedOffSeries.length - 1] ?? 0)
+                : 0)
             : 0;
         const amaSlope = {
             trend: slopeResult.trend,
@@ -849,12 +891,19 @@ class MarketAdapterService {
         if ((!bot.assetA && !bot.assetAId) || (!bot.assetB && !bot.assetBId)) {
             return { ok: false, reason: 'missing asset pair' };
         }
+        // Persisted state files may predate the `bots` map (or hold a partial
+        // JSON) — normalize once here so every later state.bots access is safe.
+        if (!state || typeof state !== 'object') {
+            return { ok: false, reason: 'invalid adapter state' };
+        }
+        if (!state.bots || typeof state.bots !== 'object') {
+            state.bots = {};
+        }
         if (hasNumericStartPrice(bot?.startPrice)) {
             const nowIso = new Date().toISOString();
             const thresholdPercent = typeof deps.calculateBotThreshold === 'function'
                 ? deps.calculateBotThreshold(cfg)
                 : null;
-            state.bots = state.bots || {};
             state.bots[bot.botKey] = this.buildDefaultBotState(bot, {
                 startPrice: bot.startPrice,
                 priceMode: 'fixed',
@@ -913,6 +962,12 @@ class MarketAdapterService {
             return deps.kibanaSource.getLpCandlesForPool(ctx.poolId, ctx.assetA, ctx.assetB, kibanaOptions);
         };
         const staleTailVerifiedRangeFromMeta = () => {
+            // Meta fields are persisted as explicit null when absent — guard
+            // before Number() since Number(null) === 0 would masquerade as a
+            // valid epoch timestamp.
+            if (existingMeta.staleTailVerifiedStartTs == null || existingMeta.staleTailVerifiedEndTs == null) {
+                return {};
+            }
             const startTs = Number(existingMeta.staleTailVerifiedStartTs);
             const endTs = Number(existingMeta.staleTailVerifiedEndTs);
             if (Number.isFinite(startTs) && Number.isFinite(endTs)) {
@@ -938,7 +993,7 @@ class MarketAdapterService {
             // Skip Kibana verification if this tail range was already confirmed flat
             // on a previous cycle (the current tail is contained within a verified range).
             const { startTs: vStart, endTs: vEnd } = verifiedRange;
-            if (Number.isFinite(vStart) && (Number.isFinite(vEnd) || vEnd === Number.POSITIVE_INFINITY)
+            if (Number.isFinite(vStart) && Number.isFinite(vEnd)
                 && tailStartTs >= vStart && tailEndTs <= vEnd) {
                 return { candles, keptStaleTailStartTs: tailStartTs, keptStaleTailEndTs: tailEndTs };
             }
@@ -1137,7 +1192,7 @@ class MarketAdapterService {
                 const nowMs = this.getNowMs();
                 if (needBootstrap) {
                     // Bootstrap: Kibana first (deep history), native as fallback
-                    const kibanaLookbackHours = Math.max(cfg.bootstrapLookbackHours, analysisKeepCount * 2);
+                    const kibanaLookbackHours = this.bootstrapKibanaLookbackHours(cfg, rawKeepCount);
                     let kibanaCandles = null;
                     try {
                         kibanaCandles = await deps.withRetries(() => fetchKibanaCandles({
@@ -1232,7 +1287,7 @@ class MarketAdapterService {
                 }
             }
             else if (needBootstrap) {
-                const lookbackHours = Math.max(cfg.bootstrapLookbackHours, analysisKeepCount * 2);
+                const lookbackHours = this.bootstrapKibanaLookbackHours(cfg, rawKeepCount);
                 // ── Step 1: Kibana first (deep history, handles large candle requirements) ──
                 let kibanaCandles = null;
                 try {
@@ -1773,7 +1828,7 @@ class MarketAdapterService {
         const isAsymmetricBoundsWhitelisted = isGridRangeScalingWhitelisted;
         const hasExplicitBaseWeights = Number.isFinite(bot.weightDistribution?.sell)
             && Number.isFinite(bot.weightDistribution?.buy);
-        const isAmaGridBot = /^ama(?:[1-4])?$/i.test(String(bot?.gridPrice || '').trim());
+        const isAmaGridBot = usesAmaGridPrice(bot);
         const shouldComputeDynamicWeightSignal = isAmaGridBot && hasExplicitBaseWeights
             && (isDynamicWeightWhitelisted || isGridRangeScalingWhitelisted);
         const canExposeDynamicWeights = isDynamicWeightWhitelisted && shouldComputeDynamicWeightSignal;
@@ -1848,6 +1903,11 @@ class MarketAdapterService {
         if (hasUnresolvedCandleGaps) {
             triggerSuppressedReason = 'unresolved_candle_gaps';
         }
+        else if (staleData) {
+            // Mirror the !hasNewClosedCandle path so state records why no
+            // trigger/snapshot write happened on a stale-but-new cycle.
+            triggerSuppressedReason = 'stale_candle_data';
+        }
         const buildDynamicGridOptions = (options = {}) => {
             const payload = {
                 gridCenterPrice: options.gridCenterPrice ?? null, // explicit baseline if provided
@@ -2118,9 +2178,7 @@ class MarketAdapterService {
         const stateAmaSlopeThresholdPercent = preserveRetryBaseline
             ? (botState.amaSlopeThresholdPercent ?? amaSlopeThresholdPercent ?? null)
             : (amaSlopeThresholdPercent ?? botState.amaSlopeThresholdPercent ?? null);
-        const stateGridRangeScalingAmaSlope = preserveRetryBaseline
-            ? (botState.gridRangeScalingAmaSlope || previousGridResetAmaSlope || null)
-            : (botState.gridRangeScalingAmaSlope || previousGridResetAmaSlope || null);
+        const stateGridRangeScalingAmaSlope = botState.gridRangeScalingAmaSlope || previousGridResetAmaSlope || null;
         state.bots[bot.botKey] = {
             ...botState,
             botName: bot.name,
@@ -2257,5 +2315,5 @@ class MarketAdapterService {
         };
     }
 }
-export { MarketAdapterService, AMA_SLOPE_PERCENT_MODE_PER_BAR, normalizeAmaSlopePercentMode, normalizeAmaSlopeLookbackBars, convertSlopePercentToPerBar };
+export { MarketAdapterService, AMA_SLOPE_PERCENT_MODE_PER_BAR, normalizeAmaSlopePercentMode, convertSlopePercentToPerBar };
 //# sourceMappingURL=market_adapter_service.js.map