dexbot 1.4.21 → 1.4.23

package/analysis/analyze_dynamic_weight.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+'use strict';
 
 /**
  * DYNAMIC WEIGHT RESEARCH TOOL
@@ -7,7 +8,7 @@
  * interactive HTML chart for researching dynamic weight parameters.
  *
  * Usage:
- *   tsx analysis/analyze_dynamic_weight.ts \
+ *   node dist/analysis/analyze_dynamic_weight.js \
  *     --source json \
  *     --file market_adapter/data/lp/<path>/<to>/<lp-candles>.json
  */
@@ -18,14 +19,13 @@ import { HurstAnalyzer } from './trend_detection/hurst_analyzer.js';
 import { PermutationEntropyAnalyzer } from './trend_detection/permutation_entropy_analyzer.js';
 import { generateHTML } from './trend_detection/dynamic_weight_chart_generator.js';
 import { calculateAMA } from '../market_adapter/core/strategies/ama.js';
-import { computeAmaSlopeWeights } from '../market_adapter/core/strategies/ama_slope_model.js';
+import { computeAmaSlopeWeights, createAmaSlopeClipTracker } from '../market_adapter/core/strategies/ama_slope_model.js';
 import { MARKET_ADAPTER } from '../modules/constants.js';
 import { PATHS } from '../modules/paths.js';
 import { writeChartFile } from './chart_utils.js';
 import { getCandleClose } from './math_utils.js';
 import { resolveSource, listAvailableBots, type SourceConfig } from './resolve_source.js';
 
-'use strict';
 
 // AMA Slope weight calculation config — use DEFAULTS from market adapter
 const AMA_WEIGHT_CONFIG = {
@@ -149,15 +149,30 @@ async function main() {
         // ── AMA weight calculation ───────────────────────────────────────────
         const closes = candles.map(c => getCandleClose(c) ?? 0);
         const amaValues = calculateAMA(closes, AMA_CONFIG);
+        const lbBars = config.lookbackBars ?? AMA_WEIGHT_CONFIG.lookbackBars;
+        const clipPercentile = config.clipPct ?? MARKET_ADAPTER.DYNAMIC_WEIGHT_CLIP_PERCENTILE;
+
+        // Incremental percentile clip threshold (shared with the market adapter)
+        // so the research offset matches the live asymmetry. Feeding bar-by-bar
+        // keeps the pool prefix-only — no look-ahead, same thresholds the live
+        // service would have seen at each point in time.
+        const clipTracker = createAmaSlopeClipTracker(AMA_CONFIG.erPeriod, lbBars, clipPercentile);
+        // Minimal history window computeAmaSlopeWeights can act on (guard is
+        // erPeriod + lookbackBars + 1 and it only reads the last two sampled
+        // bars), so a rolling slice avoids O(n²) prefix copies.
+        const weightWindowBars = Math.ceil(AMA_CONFIG.erPeriod) + lbBars + 1;
+
         for (let i = 0; i < allResults.length; i++) {
             // The research chart keeps ATR out of the Kalman branch on purpose.
             // Production applies ATR later as a separate symmetric volatility penalty.
             const atr = 0;
             const weightVariance = 0;
+            const amaClipThreshold = clipTracker.push(amaValues[i] ?? NaN);
+            const slice = amaValues.slice(Math.max(0, i + 1 - weightWindowBars), i + 1);
 
-            const weights = computeAmaSlopeWeights(amaValues.slice(0, i + 1), weightVariance, {
+            const weights = computeAmaSlopeWeights(slice, weightVariance, {
                 erPeriod: AMA_CONFIG.erPeriod,
-                lookbackBars: config.lookbackBars ?? AMA_WEIGHT_CONFIG.lookbackBars,
+                lookbackBars: lbBars,
                 maxSlopePct: AMA_WEIGHT_CONFIG.amaMaxSlopePct,
                 neutralZonePct: AMA_WEIGHT_CONFIG.neutralZonePct,
                 volatilityExponent: AMA_WEIGHT_CONFIG.volatilityExponent,
@@ -165,6 +180,7 @@ async function main() {
                 volatilityThreshold: AMA_WEIGHT_CONFIG.volatilityThreshold,
                 maxSlopeOffset: AMA_WEIGHT_CONFIG.maxSlopeOffset,
                 maxVolatilityOffset: AMA_WEIGHT_CONFIG.maxVolatilityOffset,
+                clipThreshold: amaClipThreshold,
             });
 
             (allResults[i] as any).ama3Price = amaValues[i] ?? null;

package/analysis/analyze_kalman.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+'use strict';
 
 /**
  * KALMAN TREND ANALYSIS RUNNER
@@ -6,7 +7,7 @@
  * Runs KalmanTrendAnalyzer over candle data and generates an interactive HTML chart.
  *
  * Usage:
- *   tsx analysis/analyze_kalman.ts \
+ *   node dist/analysis/analyze_kalman.js \
  *     --source json \
  *     --file market_adapter/data/lp/<path>/<to>/<lp-candles>.json
  */
@@ -15,32 +16,35 @@ import path from 'node:path';
 import { KalmanTrendAnalyzer } from './trend_detection/kalman_trend_analyzer.js';
 import { generateHTML } from './trend_detection/kalman_chart_generator.js';
 import { calculateAMA } from '../market_adapter/core/strategies/ama.js';
-import { computeAverageAmaSlopePct } from '../market_adapter/core/strategies/dynamic_weight_series.js';
+import { computeAmaSlopeWeights, createAmaSlopeClipTracker } from '../market_adapter/core/strategies/ama_slope_model.js';
+import { MARKET_ADAPTER } from '../modules/constants.js';
 import { getCandleClose } from './math_utils.js';
 import { writeChartFile } from './chart_utils.js';
 import { PATHS } from '../modules/paths.js';
 import { resolveSource, listAvailableBots, type SourceConfig } from './resolve_source.js';
 
-'use strict';
 
-const LOOKBACK_BARS   = 72;
-const NEUTRAL_ZONE    = 0.15;
-const MAX_SLOPE_PCT   = 3.0;
-const MAX_SLOPE_OFFSET = 0.5;
 
 function parseArgs() {
     const args = process.argv.slice(2);
     const config: {
         source: { type: string; config: SourceConfig };
-        rNoise: number;
-        qNoise: number;
+        rNoise: number | null;
+        qTactical: number | null;
+        qModal: number | null;
+        qNoise: number | null;
         chartFile: string;
         quiet: boolean;
         listBots: boolean;
     } = {
         source: { type: 'market_adapter', config: { botKey: '' } },
-        rNoise: 0.05,
-        qNoise: 0.005,
+        // Defaults resolve to the live MARKET_ADAPTER Kalman constants so
+        // runs are directly comparable with production (qTactical 0.01,
+        // qModal 0.0001 — NOT a single shared Q for both filters).
+        rNoise: null,
+        qTactical: null,
+        qModal: null,
+        qNoise: null,
         chartFile: path.join(PATHS.ANALYSIS.CHARTS_DIR, 'kalman_chart.html'),
         quiet: false,
         listBots: false,
@@ -56,6 +60,8 @@ function parseArgs() {
         }
         else if (arg === '--r') config.rNoise = parseFloat(args[++i]);
         else if (arg === '--q') config.qNoise = parseFloat(args[++i]);
+        else if (arg === '--q-tactical') config.qTactical = parseFloat(args[++i]);
+        else if (arg === '--q-modal') config.qModal = parseFloat(args[++i]);
         else if (arg === '--chart') config.chartFile = args[++i];
         else if (arg === '--list-bots') config.listBots = true;
         else if (arg === '--quiet') config.quiet = true;
@@ -82,9 +88,15 @@ async function main() {
         }
 
         // ── Kalman analysis ──────────────────────────────────────────────────
+        // Unset flags fall through to the live KalmanTrendAnalyzer defaults
+        // (MARKET_ADAPTER.DYNAMIC_WEIGHT_KALMAN_*_DEFAULT). --q still maps to
+        // both filters for quick what-ifs, but per-filter overrides
+        // (--q-tactical / --q-modal) exist so runs can mirror production
+        // exactly: Q = (0.01 tactical, 0.0001 modal).
         const analyzer = new KalmanTrendAnalyzer({
-            rNoise: config.rNoise,
-            qNoise: config.qNoise
+            rNoise: config.rNoise ?? undefined,
+            qTactical: config.qTactical ?? config.qNoise ?? undefined,
+            qModal: config.qModal ?? config.qNoise ?? undefined,
         });
 
         const allResults: any[] = [];
@@ -96,26 +108,43 @@ async function main() {
         }
 
         // ── AMA weight offset (for comparison panel) ─────────────────────────
+        // Runs the production path (computeAmaSlopeWeights + percentile clip)
+        // so this panel is directly comparable to the live amaSlopeOffset.
         const closes    = candles.map(c => getCandleClose(c) ?? 0);
         const amaValues = calculateAMA(closes, amaConfig);
-        const warmup    = amaConfig.erPeriod + LOOKBACK_BARS + 1;
+        const amaLb     = MARKET_ADAPTER.DYNAMIC_WEIGHT_AMA_LOOKBACK_BARS;
+        const clipPct   = MARKET_ADAPTER.DYNAMIC_WEIGHT_CLIP_PERCENTILE;
+        // Ceil to match the readiness guard in computeAmaSlopeWeights
+        // (it uses Math.ceil(opts.erPeriod)), so fractional ER periods don't
+        // leave a 1-bar window that computes a weight where the model is not ready.
+        const warmup    = Math.ceil(amaConfig.erPeriod) + amaLb + 1;
+
+        // Incremental, prefix-only clip pool (no look-ahead) — same thresholds
+        // the live service would have seen at each point in time.
+        const clipTracker = createAmaSlopeClipTracker(amaConfig.erPeriod, amaLb, clipPct);
+        const weightWindowBars = Math.ceil(amaConfig.erPeriod) + amaLb + 1;
 
         for (let i = 0; i < allResults.length; i++) {
+            const amaClipThreshold = clipTracker.push(amaValues[i] ?? NaN);
             if (i < warmup) { allResults[i].amaWeightOffset = null; continue; }
-            const last = amaValues[i];
-            const past = amaValues[i - LOOKBACK_BARS];
-            if (!last || !past || past === 0) { allResults[i].amaWeightOffset = null; continue; }
-            const slopePct = computeAverageAmaSlopePct(last, past, LOOKBACK_BARS)! * LOOKBACK_BARS;
-            if (Math.abs(slopePct) < NEUTRAL_ZONE) {
-                allResults[i].amaWeightOffset = 0;
-            } else {
-                allResults[i].amaWeightOffset = Math.max(-MAX_SLOPE_OFFSET,
-                    Math.min(MAX_SLOPE_OFFSET, (slopePct / MAX_SLOPE_PCT) * MAX_SLOPE_OFFSET));
-            }
+            const slice = amaValues.slice(Math.max(0, i + 1 - weightWindowBars), i + 1);
+            const weights = computeAmaSlopeWeights(slice, 0, {
+                erPeriod:              amaConfig.erPeriod,
+                lookbackBars:          amaLb,
+                maxSlopePct:           MARKET_ADAPTER.DYNAMIC_WEIGHT_AMA_MAX_SLOPE_PCT,
+                neutralZonePct:        MARKET_ADAPTER.DYNAMIC_WEIGHT_AMA_NEUTRAL_ZONE_PCT,
+                volatilityExponent:    MARKET_ADAPTER.DYNAMIC_WEIGHT_VOLATILITY_EXPONENT,
+                volatilityScaleX:      MARKET_ADAPTER.DYNAMIC_WEIGHT_VOLATILITY_SCALE_X_DEFAULT,
+                volatilityThreshold:   MARKET_ADAPTER.DYNAMIC_WEIGHT_SYMMETRIC_SHIFT_THRESHOLD,
+                maxSlopeOffset:        MARKET_ADAPTER.DYNAMIC_WEIGHT_ASYMMETRIC_OFFSET_CLAMP,
+                maxVolatilityOffset:   MARKET_ADAPTER.DYNAMIC_WEIGHT_SYMMETRIC_SHIFT_CLAMP,
+                clipThreshold:         amaClipThreshold,
+            });
+            allResults[i].amaWeightOffset = weights.rawSlopeOffset;
         }
 
         // ── Generate chart ───────────────────────────────────────────────────
-        const html = generateHTML({ allResults }, 'Kalman Trend Analysis');
+        const html = generateHTML({ allResults, amaConfig, clipPct: MARKET_ADAPTER.DYNAMIC_WEIGHT_CLIP_PERCENTILE }, 'Kalman Trend Analysis');
         writeChartFile(config.chartFile, html);
 
         if (!config.quiet) console.log(`[Kalman] ✓ Chart saved to ${config.chartFile}`);

package/analysis/analyze_regime.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+'use strict';
 
 /**
  * REGIME ANALYSIS TOOL
@@ -13,7 +14,7 @@
  *   Norm. PE > 0.85 = noise                 → no exploitable structure
  *
  * Usage:
- *   tsx analysis/analyze_regime.ts \
+ *   node dist/analysis/analyze_regime.js \
  *     --source json \
  *     --file market_adapter/data/lp/<path>/<to>/<lp-candles>.json
  */
@@ -32,7 +33,6 @@ import { resolveSource, listAvailableBots, type SourceConfig } from './resolve_s
 const HURST_CONFIG = MARKET_ADAPTER.HURST_CONFIG;
 const PE_CONFIG = MARKET_ADAPTER.PE_CONFIG;
 
-'use strict';
 
 function parseArgs() {
     const args = process.argv.slice(2);

package/analysis/analyze_regime_windows.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+'use strict';
 
 /**
  * REGIME WINDOW OPTIMIZER
@@ -12,13 +13,13 @@
  *   - entropyDefect: penalty for being stuck in the "random" band (H 0.45–0.55)
  *
  * Usage:
- *   tsx analysis/analyze_regime_windows.ts \
+ *   node dist/analysis/analyze_regime_windows.js \
  *     --source json \
  *     --file market_adapter/data/lp/<path>/<to>/<lp-candles>.json
  */
 
 import path from 'node:path';
-import { HurstAnalyzer }              from './trend_detection/hurst_analyzer.js';
+import { HurstAnalyzer, classifyHurst }  from './trend_detection/hurst_analyzer.js';
 import { PermutationEntropyAnalyzer } from './trend_detection/permutation_entropy_analyzer.js';
 import { MARKET_ADAPTER } from '../modules/constants.js';
 import { PATHS } from '../modules/paths.js';
@@ -30,7 +31,6 @@ import { resolveSource, listAvailableBots, type SourceConfig } from './resolve_s
 const HURST_CONFIG = MARKET_ADAPTER.HURST_CONFIG;
 const PE_CONFIG = MARKET_ADAPTER.PE_CONFIG;
 
-'use strict';
 
 const HURST_CENTER   = HURST_CONFIG.window;
 const PE_CENTER      = PE_CONFIG.window;
@@ -48,9 +48,9 @@ function geoRange(center: number, factor: number, n: number) {
 
 const HURST_WINDOWS  = geoRange(HURST_CENTER, RANGE_FACTOR, N_POINTS);
 const PE_WINDOWS     = geoRange(PE_CENTER, RANGE_FACTOR, N_POINTS);
-const HURST_SCALES   = [8, 16, 32, 64];
-const PE_M           = 5;
-const PE_DELAY       = 1;
+const HURST_SCALES   = HURST_CONFIG.scales;
+const PE_M           = PE_CONFIG.m;
+const PE_DELAY       = PE_CONFIG.delay;
 
 function parseArgs() {
     const args = process.argv.slice(2);
@@ -82,14 +82,16 @@ function parseArgs() {
     return config;
 }
 
-const H_UPPER = 0.5 + MARKET_ADAPTER.HURST_ZONE_BAND;
-const H_LOWER = 0.5 - MARKET_ADAPTER.HURST_ZONE_BAND;
+// Signal-quality bands from MARKET_ADAPTER.PE_NODES (structured / mixed / noise).
+const PE_STRUCTURED = MARKET_ADAPTER.PE_NODES[0];
+const PE_NOISE = MARKET_ADAPTER.PE_NODES[MARKET_ADAPTER.PE_NODES.length - 1];
 
+// Hurst band classification delegates to the production classifyHurst
+// (market_adapter/core/signals/hurst_analyzer.ts) so boundary semantics
+// (inclusive >=/<=) and zone width stay on one logic path.
 function regimeBand(H: number | null): string {
     if (H === null) return 'RANDOM';
-    if (H > H_UPPER) return 'TRENDING';
-    if (H < H_LOWER) return 'MEAN_REVERTING';
-    return 'RANDOM';
+    return classifyHurst(H).regime;
 }
 
 function rankNormalize(arr: number[]) {
@@ -119,14 +121,20 @@ function scoreWindowPair(prices: number[], hurstWindow: number, peWindow: number
     const firstReady = hArr.findIndex(v => v !== null);
     if (firstReady < 0) return null;
 
-    const readyH = hArr.slice(firstReady);
-    const readyP = pArr.slice(firstReady).filter((v): v is number => v !== null);
-    const m = readyH.length;
+    // ── Regime sequences ──────────────────────────────────────────────────
+    // Pair H and PE strictly per bar: both analyzers become ready on different
+    // schedules (PE window vs Hurst window), so slicing from Hurst readiness
+    // and independently null-filtering PE would index-shift the pairing.
+    const hBands: string[] = [];
+    const pBands: string[] = [];
+    for (let i = 0; i < n; i++) {
+        if (hArr[i] === null || pArr[i] === null) continue;
+        hBands.push(regimeBand(hArr[i]));
+        pBands.push(pArr[i]! < PE_STRUCTURED ? 'STRUCTURED' : pArr[i]! > PE_NOISE ? 'NOISE' : 'MIXED');
+    }
+    const m = hBands.length;
     if (m < 50) return null;
 
-    // ── Regime sequences ──────────────────────────────────────────────────
-    const hBands = readyH.map(regimeBand);
-    const pBands = readyP.map(v => v < 0.60 ? 'STRUCTURED' : v > 0.85 ? 'NOISE' : 'MIXED');
     const combined = hBands.map((h, i) => `${h}|${pBands[i]}`);
 
     // ── Stability: mean run-length of combined regime ───────────────────
@@ -397,8 +405,8 @@ noise=${(r.entropyDefect*100).toFixed(1)}%">
         <table class="params-table">
             <tr><td>Hurst range</td><td>${Math.round(hurstVals[0])} – ${Math.round(hurstVals[hurstVals.length-1])} (center=${defaultH})</td></tr>
             <tr><td>PE range</td><td>${Math.round(peVals[0])} – ${Math.round(peVals[peVals.length-1])} (center=${defaultP})</td></tr>
-            <tr><td>Hurst scales</td><td>[8, 16, 32, 64]</td></tr>
-            <tr><td>PE embedding</td><td>m=5, delay=1</td></tr>
+            <tr><td>Hurst scales</td><td>[${HURST_SCALES.join(', ')}]</td></tr>
+            <tr><td>PE embedding</td><td>m=${PE_M}, delay=${PE_DELAY}</td></tr>
             <tr><td>Spacing</td><td>geometric (ratio=${geoRatio.toFixed(3)})</td></tr>
         </table>
     </div>

package/analysis/analyze_risk_profile.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+'use strict';
 /**
  * RISK PROFILE ANALYZER
  *
@@ -9,8 +10,8 @@
  * (σ_ama_delta) for calibrating AMA_DELTA_THRESHOLD_PERCENT.
  *
  * Usage:
- *   tsx analysis/analyze_risk_profile.ts --source market_adapter --bot-key <key> [options]
- *   tsx analysis/analyze_risk_profile.ts --file <path_to_json> [options]
+ *   node dist/analysis/analyze_risk_profile.js --source market_adapter --bot-key <key> [options]
+ *   node dist/analysis/analyze_risk_profile.js --file <path_to_json> [options]
  */
 import { calculateAMA } from '../market_adapter/core/strategies/ama.js';
 import { MARKET_ADAPTER } from '../modules/constants.js';
@@ -19,7 +20,6 @@ import { calcStdDev, getCandleClose } from './math_utils.js';
 import { writeChartFile } from './chart_utils.js';
 import { resolveSource, listAvailableBots, type SourceConfig } from './resolve_source.js';
 
-'use strict';
 
 function normSInv(p: number) {
     if (p <= 0 || p >= 1) return p <= 0 ? -Infinity : Infinity;

package/analysis/analyze_trade_heatmap.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+'use strict';
 /**
  * TRADE HEATMAP ANALYZER
  *
@@ -7,8 +8,8 @@
  * a summed volume histogram with threshold annotations.
  *
  * Usage:
- *   tsx analysis/analyze_trade_heatmap.ts --source market_adapter --bot-key <key> [options]
- *   tsx analysis/analyze_trade_heatmap.ts --file <path> [options]
+ *   node dist/analysis/analyze_trade_heatmap.js --source market_adapter --bot-key <key> [options]
+ *   node dist/analysis/analyze_trade_heatmap.js --file <path> [options]
  *
  * Output:
  *   Self-contained HTML file with inline CSS (no JS dependencies).
@@ -20,7 +21,6 @@ import { calcStdDev, getCandleClose } from './math_utils.js';
 import { writeChartFile } from './chart_utils.js';
 import { resolveSource, listAvailableBots, type SourceConfig } from './resolve_source.js';
 
-'use strict';
 
 function parseArgs() {
     const args = process.argv.slice(2);

package/analysis/analyze_volatility.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+'use strict';
 
 /**
  * VOLATILITY / SYMMETRIC SHIFT RESEARCH TOOL
@@ -16,7 +17,7 @@
  * effect can be researched in isolation.
  *
  * Usage:
- *   tsx analysis/analyze_volatility.ts \
+ *   node dist/analysis/analyze_volatility.js \
  *     --file market_adapter/data/lp/<path>/<to>/<lp-candles>.json
  */
 
@@ -33,7 +34,6 @@ import { getCandleClose } from './math_utils.js';
 import { writeChartFile } from './chart_utils.js';
 import { resolveSource, listAvailableBots, type SourceConfig } from './resolve_source.js';
 
-'use strict';
 
 const DEFAULT_ATR_PERIOD = MARKET_ADAPTER.DYNAMIC_WEIGHT_ATR_PERIOD_DEFAULT;
 const MIN_WEIGHT = MARKET_ADAPTER.DYNAMIC_WEIGHT_MIN_WEIGHT;

package/analysis/bot_fitting/README.md

@@ -6,15 +6,65 @@ This folder contains parameter sweep backtests that simulate grid fills for the
 
 For each of the 4 AMA strategies, it searches for best:
 
-- `spread` (% target round-trip spread)
-- `increment` (% grid step)
+- `spread` (% target spread for the gapSlots spread zone)
+- `increment` (% geometric rail step)
 - `max/min ratio` (symmetric range around AMA, e.g. `2.0` means `[AMA/2, AMA*2]`)
 
 ### Scripts
 
-- `backtest_bot_fitting.ts` — lightweight sweep across spread / increment / ratio with basic risk scoring
-- `backtest_ama_sweep.ts` — persistent grid simulation with fixed-chain-price mechanics, reposition thresholds, and worker-thread parallelization
-- `shared_utils.ts` — shared helpers (argument parsing, data loading, formatting) used by both scripts
+- `backtest_bot_fitting.ts` — lightweight sweep across spread / increment / ratio with unit-size percentage-point accounting and risk scoring
+- `backtest_ama_sweep.ts` — persistent grid simulation with capital-weighted sizing, weight profiles, and worker-thread parallelization
+- `shared_utils.ts` — shared helpers (argument parsing, data loading, formatting)
+
+Both simulators share the same production grid model (ported once in
+`backtest_bot_fitting.ts` and imported by the sweep), so identical params
+build byte-identical grids in both tools.
+
+### Production alignment
+
+Both simulators port the live bot lifecycle end to end:
+
+- **Grid geometry** — `createOrderGrid` (modules/order/grid.ts): master rail at
+  `√(1±inc)` offsets bounded by `[center/ratio, center×ratio]` with a
+  `calculateGapSlots` spread zone centered on the placement price; order prices
+  are placement-time constants.
+- **Slot rotation (anchor-&-refill)** — a filled buy at rail node `k` instantly
+  re-offers its base at the adjacent master-rail node `k+1`; when that refill
+  sells, exactly one rail hop minus the round-trip fee is booked and the freed
+  quote re-bids node `k−1`. A slot keeps cycling on small oscillations between
+  resets — this is what a refilled live slot earns, not a cross-gap
+  differential. Re-armed orders carry a one-bar replacement-lag cooldown.
+  Sub-note: because rails chain by `×(1+inc)` above center and `×(1−inc)`
+  below, a down-chain hop equals `inc/(1−inc)` (e.g. 1.0101% at inc=1%), not
+  exactly `inc` — matching real rail adjacency.
+- **Inventory-funded selling** — unlinked (initial-grid) sells execute only
+  against held base, priced against the weighted-average entry of the position;
+  unfundable sells stay open and retry (never shorting).
+- **Inventory carry** — resets cancel ALL live orders (initial leftovers plus
+  armed refills/rebids); bought-and-held base merges into a weighted-average-
+  entry pool that survives resets (production resync never market-sells). The
+  end-of-run inventory mark is reported as an INFORMATIONAL field — it is real
+  carried risk but excluded from scoring/ranking.
+- **Reset triggers** (MARKET_ADAPTER):
+  - Trigger A: AMA drift ≥ `AMA_DELTA_THRESHOLD_PERCENT` (1%) from the recorded
+    center, ratchet semantics — always on.
+  - Trigger B: slope-delta reset (`|slope − baseline| ≥
+    AMA_SLOPE_DELTA_THRESHOLD_PERCENT/100 × DYNAMIC_WEIGHT_AMA_MAX_SLOPE_PCT`
+    over the `DYNAMIC_WEIGHT_AMA_LOOKBACK_BARS` average-slope series, baseline
+    re-seeded every reset) plus the slope-ratio grid price offset
+    (`direction × min(|slope|/maxSlopePct,1) × targetSpread/2`, applied to the
+    placement center). Both are gated behind `--asymmetric-bounds`, mirroring
+    the production per-bot asymmetricBounds whitelist — default OFF for a
+    typical non-whitelisted bot.
+- **BTS operation fees** — every order placement (initial grid + armed
+  refills + rebids) pays a maker create fee, every reset cancel pays a cancel
+  fee; totals are deducted from net capture (bot_fitting converts against
+  `--bts-fee-capital`, the sweep converts via `--tx-fee-price` in capital units).
+
+Documented remaining deltas (inherent to OHLC research sims): bar-granularity
+triggers, all-or-nothing fills on raw hi/lo touch, unit/capital sizing instead
+of live balance + dynamic-weight sizing, pool-price fills without
+microstructure, and no consolidation/dust-cancel/COW/collision mechanics.
 
 ### Input dependencies
 
@@ -53,6 +103,7 @@ node dist/analysis/bot_fitting/backtest_bot_fitting.js \
   --active-orders 5 \
   --fee 0.20 \
   --min-spread-factor 2.1 \
+  --asymmetric-bounds \
   --risk-duration 1.0 \
   --risk-peak-open 2.0 \
   --risk-imbalance 1.2 \
@@ -60,32 +111,53 @@ node dist/analysis/bot_fitting/backtest_bot_fitting.js \
 ```
 
 > Default `--ratio` is `1.5,1.75,2,2.5,3,4,5,8,10` (includes `1.75`).
+> Default `--active-orders` sizes EVERY rail slot in bounds (production
+> behavior); pass a number to cap the search to the slots nearest the gap.
 
 ### Output
 
-Results are written to `analysis/bot_fitting/` (filenames derived from the input data file: `bot_fitting_results_<base>.json` for the lightweight sweep, `ama_sweep_results_<base>.json` for the persistent grid simulation).
+Results are written to `analysis/results/` (filenames derived from the input
+data file: `bot_fitting_results_<base>.json` and `ama_sweep_results_<base>.json`).
 
-The console also prints best parameter set per AMA with matched pairs, fill efficiency, net capture and score.
+The console also prints best parameter set per AMA with matched pairs (cycles),
+fill efficiency, net capture and score.
 
 ### Notes
 
 - This is an offline simulation proxy, not a full chain execution model.
-- Reposition reset is modeled when AMA changes by more than increment in one candle.
-- Pair search enforces bot rule: `spread >= 2.1 x increment` by default
-  (`--min-spread-factor` to override).
-- Score used for ranking:
-  - `totalNetCapturePct = matchedPairs * (spread - increment - fee)`
-  - `baseScore = totalNetCapturePct * (fillEfficiency / 100)`
+- Hop granularity: the sim arms each refill at the ADJACENT master-rail node
+  (one increment). Production derives leg spacing from the gap-aware
+  boundary crawl (`deriveTargetBoundary`: one slot per non-partial fill,
+  burst-capped), so for wide-gap configs live legs may span `gapSlots` rail
+  steps (~targetSpread) instead of one. Calibrate against real bot fills
+  before trusting absolute magnitudes; rankings remain internally consistent.
+- `--min-spread-factor 2.1` enforces `spread >= 2.1 x increment`
+  (`GRID_LIMITS.MIN_SPREAD_FACTOR`), matching `calculateGapSlots`.
+- Score used for ranking (bot_fitting):
+  - `totalNetCaptureAfterFeesPct` = realized per-rotation gross (one rail hop
+    or weighted-average-entry sale) − round-trip fee − BTS op fees; the
+    end-of-run inventory mark is NOT included
+  - `baseScore = totalNetCaptureAfterFeesPct * (fillEfficiency / 100)`
   - `riskPenalty = avgOpenDurationBars*1.0 + peakOpenOrders*2.0 + avgImbalance*1.2 + canceledOnReposition*0.15`
   - `finalScore = baseScore - riskPenalty`
+- Score used for ranking (sweep): realized profit only —
+  - `netProfitPerCapital * 100 * log10(max(1, matchedPairs)) - maxDrawdownPct * 0.5`
+    (`maxDrawdown` tracks REALIZED equity swings; carried-bag risk stays
+    visible through `finalInventoryUnits` / `finalInventoryMarkUnits`)
 
 ## Persistent Grid Simulation Details
 
 `backtest_ama_sweep.ts` models the real bot mechanics:
 
 - Orders sit at FIXED chain prices until canceled or filled
-- When AMA drifts past reposition threshold, grid re-centers
-- Grid compression: AMA shift pushes one side's orders closer to market
+- Slot rotation: a filled buy re-offers the adjacent rail node above; its fill
+  books one rail hop net of fees and re-bids the node below (anchor-&-refill)
+- Unlinked sells execute only against held inventory at weighted-average entry;
+  bought-and-held base carries across resets and is marked to close
+  informationally (excluded from profit; drawdown also tracks realized equity
+  only — bag risk stays visible through the info fields)
+- When triggers fire (A drift, B slope under `--asymmetric-bounds`), the grid
+  re-centers and all live orders cancel
 - Order sizing depends on capital, ratio (range width), and weight profile
 - Three weight profiles: valley, neutral, mountain (symmetric buy/sell)
 
@@ -96,8 +168,8 @@ Search grid defaults — centered around bot defaults (spread=2%, increment=0.5%
 | Spread | 0.5:4:0.25 + 5:12:1 (%) |
 | Increment | 0.2:2:0.1 + 2.5:8:0.5 (%) |
 | Max/min ratio | 1.05, 1.1, 1.15, 1.2, 1.3, 1.5, 2, 3, 5, 10 |
-| Reposition threshold | 2.5% |
-| Max orders per side | 20 |
+| Reposition threshold | 1% (production `AMA_DELTA_THRESHOLD_PERCENT`) |
+| Max orders per side | 20 (size cap) |
 | Round-trip fee | 0.20% |
 | Spread ≥ factor × increment | 2.1 |
 
@@ -106,7 +178,8 @@ All parameters above are tunable via CLI flags. Additional tuning flags:
 | Flag | Default | Description |
 |------|---------|-------------|
 | `--capital <n>` | 10000 | Notional capital per side |
-| `--reposition <pct>` | 2.5 | AMA drift % to trigger re-center |
+| `--reposition <pct>` | 1 | AMA drift % to trigger re-center |
+| `--asymmetric-bounds` | off | Enable slope-delta reset (B) + grid price offset |
 | `--bts-create-fee <n>` | 0.48260 | BTS create order fee |
 | `--bts-cancel-fee <n>` | 0.00482 | BTS cancel order fee |
 | `--maker-create-factor <n>` | 0.10 | Maker share of create fee |
@@ -114,7 +187,8 @@ All parameters above are tunable via CLI flags. Additional tuning flags:
 | `--top <n>` | 15 | Top N results displayed per AMA |
 | `--help` | — | Print full usage |
 
-The sweep parallelizes across combos using worker threads (one per CPU core). Use `--help` for the complete option list.
+The sweep parallelizes across AMAs using worker threads (one per AMA strategy).
+Use `--help` for the complete option list.
 
 ```bash
 node dist/analysis/bot_fitting/backtest_ama_sweep.js \