dexbot 1.4.16 → 1.4.17

package/analysis/ama_fitting/analyze_lambda_vs_slow.ts

@@ -0,0 +1,407 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { calculateAMA } from '../../market_adapter/core/strategies/ama.js';
+import { loadLpDataFile } from '../../market_adapter/lp_chart_runner.js';
+import { ensureDir } from '../../modules/order/utils/system.js';
+import { PATHS } from '../../modules/paths.js';
+import { MARKET_ADAPTER } from '../../modules/constants.js';
+import { getErrorMessage } from '../../modules/utils/errors.js';
+'use strict';
+
+/**
+ * LAMBDA vs SLOW ANALYSIS
+ *
+ * Fixes ER and Fast, then scans lambda values over a linear range.
+ * For each lambda, finds the optimal Slow period that minimizes
+ * score = amaMovementTotal + lambda * distanceTotal.
+ *
+ * The start lambda is derived from --maxSlow: finds the lambda at
+ * which the optimal slow first drops below maxSlow. Only --lambdaEnd
+ * needs to be set as the upper bound.
+ *
+ * Output: console table + interactive HTML chart (uPlot).
+ *
+ * Defaults: ER/Fast from MARKET_ADAPTER.AMAS.AMA1 (constants.ts).
+ *
+ * Usage:
+ *   tsx analysis/ama_fitting/analyze_lambda_vs_slow.ts \
+ *     --data market_adapter/data/lp/1_3_5537_1_3_0/lp_pool_133_1h_3y.json \
+ *     --maxSlow 1000 --lambdaEnd 0.0045 --lambdaSteps 50
+ */
+
+
+
+const DEFAULT_ER = MARKET_ADAPTER.AMAS.AMA1.erPeriod;
+const DEFAULT_FAST = MARKET_ADAPTER.AMAS.AMA1.fastPeriod;
+
+// ── CLI ────────────────────────────────────────────────────────────────────────
+
+function parseArgs(argv = process.argv.slice(2)) {
+    const out: {
+        dataFile: string | null;
+        fixEr: number;
+        fixFast: number;
+        maxSlow: number;
+        lambdaEnd: number;
+        lambdaSteps: number;
+        outFile: string | null;
+    } = {
+        dataFile: null,
+        fixEr: DEFAULT_ER,
+        fixFast: DEFAULT_FAST,
+        maxSlow: 1000,
+        lambdaEnd: 0.0045,
+        lambdaSteps: 50,
+        outFile: null,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i], v = argv[i + 1];
+        switch (a) {
+            case '--data': out.dataFile = v; i++; break;
+            case '--fixEr': out.fixEr = Number(v); i++; break;
+            case '--fixFast': out.fixFast = Number(v); i++; break;
+            case '--maxSlow': out.maxSlow = Number(v); i++; break;
+            case '--lambdaEnd': out.lambdaEnd = Number(v); i++; break;
+            case '--lambdaSteps': out.lambdaSteps = Math.floor(Number(v)); i++; break;
+            case '--out': case '--output': out.outFile = v; i++; break;
+            case '--help': case '-h': showHelp(); process.exit(0);
+        }
+    }
+    if (!out.dataFile) throw new Error('--data <file> is required');
+    return out;
+}
+
+function showHelp() {
+    console.log(`
+Lambda vs Slow Analysis
+  Fixes ER + Fast, varies lambda, finds optimal Slow per lambda.
+  Start lambda derived from --maxSlow; only --lambdaEnd is the upper bound.
+
+Usage:
+  tsx analysis/ama_fitting/analyze_lambda_vs_slow.ts --data <lp-file.json> [options]
+
+Options:
+  --data FILE          LP candle JSON file (required)
+  --fixEr N            Fixed ER period (default: ${DEFAULT_ER})
+  --fixFast N          Fixed Fast period (default: ${DEFAULT_FAST})
+  --maxSlow N          Max slow value; start lambda derived from it (default: 1000)
+  --lambdaEnd N        End lambda / distanceWeight (default: 0.0045)
+  --lambdaSteps N      Number of lambda steps (default: 50)
+  --output FILE        Output HTML chart path (optional)
+  --help               Show this help
+`);
+}
+
+// ── Metrics ─────────────────────────────────────────────────────────────────────
+
+function calcTotalAmaMovement(amaValues: any, erPeriod: any) {
+    const skip = erPeriod + 1;
+    let total = 0;
+    for (let i = skip + 1; i < amaValues.length; i++) {
+        total += Math.abs(amaValues[i] - amaValues[i - 1]) / amaValues[i - 1];
+    }
+    return total;
+}
+
+function calcTotalRelativeDistance(amaValues: any, candles: any, erPeriod: any) {
+    const skip = erPeriod + 1;
+    let total = 0;
+    for (let i = skip; i < candles.length; i++) {
+        const ama = amaValues[i];
+        total += Math.abs(candles[i].close - ama) / ama;
+    }
+    return total;
+}
+
+// ── Geometric range ─────────────────────────────────────────────────────────────
+
+function geometricRange(min: any, max: any, count: any) {
+    const ratio = Math.pow(max / min, 1 / (count - 1));
+    const out: number[] = [];
+    for (let i = 0; i < count; i++) {
+        let v = min * Math.pow(ratio, i);
+        if (i === 0) v = min;
+        if (i === count - 1) v = max;
+        out.push(parseFloat(v.toFixed(10)));
+    }
+    return [...new Set(out)].sort((a, b) => a - b);
+}
+
+// ── Precompute (movement, distance) per slow ───────────────────────────────────
+
+function precomputeMetrics(closes: any, candles: any, erPeriod: any, fastPeriod: any, slowValues: any) {
+    const cache: any[] = [];
+    for (const slow of slowValues) {
+        if (fastPeriod >= slow) continue;
+        const ama = calculateAMA(closes, { erPeriod, fastPeriod, slowPeriod: slow });
+        const movement = calcTotalAmaMovement(ama, erPeriod);
+        const distance = calcTotalRelativeDistance(ama, candles, erPeriod);
+        cache.push({ slow, movement, distance });
+    }
+    return cache;
+}
+
+function findBestForLambda(lambda: any, metricCache: any) {
+    let best: any = null;
+    for (const m of metricCache) {
+        const score = m.movement + lambda * m.distance;
+        if (!best || score < best.score) {
+            best = { slow: m.slow, movement: m.movement, distance: m.distance, score, lambda };
+        }
+    }
+    return best;
+}
+
+// ── Derive start lambda from maxSlow ───────────────────────────────────────────
+// Binary search: find the smallest lambda where optimal slow < maxSlow.
+
+function findStartLambda(metricCache: any, maxSlow: any, lambdaEnd: any) {
+    let lo = 0;
+    let hi = 1;
+    // Expand hi until the best slow drops below maxSlow
+    while ((findBestForLambda(hi, metricCache)?.slow ?? Infinity) >= maxSlow && hi < 1e6) hi *= 2;
+    if (hi >= 1e6) return null;
+
+    for (let i = 0; i < 60; i++) {
+        const mid = (lo + hi) / 2;
+        const best = findBestForLambda(mid, metricCache);
+        if (best && best.slow < maxSlow) hi = mid;
+        else lo = mid;
+    }
+    // When cache max equals maxSlow, hi converges near 0 — ensure a minimum gap
+    if (hi < lambdaEnd / 1e6) hi = lambdaEnd / 1000;
+    return hi;
+}
+
+// ── HTML Chart (λ → Slow) ──────────────────────────────────────────────────────
+
+function generateChartHtml(results: any, metricCache: any, fixEr: any, fixFast: any, dataLabel: any, _chartOutPath: any) {
+    const xs = results.map((r: any) => r.lambda);
+    const ys = results.map((r: any) => r.slow);
+    const dist = results.map((r: any) => r.distance);
+    const move = results.map((r: any) => r.movement);
+    const cacheSlow = metricCache.map((m: any) => m.slow);
+    const cacheMove = metricCache.map((m: any) => m.movement);
+
+    const uplotCode = fs.readFileSync(path.resolve(__dirname, '..', 'uplot', 'uPlot.iife.min.js'), 'utf8');
+    const uplotCSS = fs.readFileSync(path.resolve(__dirname, '..', 'uplot', 'uPlot.min.css'), 'utf8');
+
+    const amaAnnotations = [
+        { label: 'AMA1', lambda: 0.0031, slow: 62.1, color: '#ef5350' },
+        { label: 'AMA2', lambda: 0.0025, slow: 71.7, color: '#fb8c00' },
+        { label: 'AMA3', lambda: 0.00185, slow: 82.7, color: '#5c9ee6' },
+        { label: 'AMA4', lambda: 0.0013, slow: 95.5, color: '#26a69a' },
+    ].filter(a => a.lambda >= xs[0] && a.lambda <= xs[xs.length - 1]);
+
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>λ → Slow — ER=${fixEr} Fast=${fixFast}</title>
+<style>
+  ${uplotCSS}
+  body { font-family: system-ui, sans-serif; margin: 20px; background: #1e1e2e; color: #cdd6f4; }
+  h1 { font-size: 16px; margin: 0 0 2px 0; }
+  .subtitle { color: #a6adc8; font-size: 12px; margin-bottom: 12px; }
+  .chart-wrap { background: #181825; padding: 20px; border-radius: 8px; display: inline-block; min-width: 1140px; }
+  .chart-row { display: flex; gap: 8px; flex-direction: column; }
+  .legend { display: flex; gap: 20px; margin: 10px 0; font-size: 12px; }
+  .legend-item { display: flex; align-items: center; gap: 4px; }
+  .legend-dot { width: 8px; height: 8px; border-radius: 50%; display: inline-block; }
+  .legend-line { width: 16px; height: 2px; display: inline-block; }
+</style>
+</head>
+<body>
+<div class="chart-wrap">
+  <h1>λ (distanceWeight) Analysis</h1>
+  <div class="subtitle">${dataLabel} · ER=${fixEr} · Fast=${fixFast} · ${results.length} λ steps</div>
+  <div class="chart-row">
+    <div id="chart-slow"></div>
+    <div id="chart-dist"></div>
+    <div id="chart-compare"></div>
+  </div>
+  <div class="legend">
+    <span class="legend-item"><span class="legend-line" style="background:#26a69a"></span> Slow</span>
+    <span class="legend-item"><span class="legend-line" style="background:#fb8c00"></span> Movement (λ)</span>
+<span class="legend-item"><span class="legend-line" style="background:#5c9ee6"></span> Movement (Slow)</span>
+${amaAnnotations.map(a => `<span class="legend-item"><span class="legend-dot" style="background:${a.color}"></span> ${a.label}</span>`).join('\n')}
+  </div>
+</div>
+<script>${uplotCode}</script>
+<script>
+(function() {
+  const xs = ${JSON.stringify(xs)};
+  const slow = ${JSON.stringify(ys)};
+  const dist = ${JSON.stringify(dist)};
+  const move = ${JSON.stringify(move)};
+  const amaPts = ${JSON.stringify(amaAnnotations)};
+  const cacheSlow = ${JSON.stringify(cacheSlow)};
+  const cacheMove = ${JSON.stringify(cacheMove)};
+  const revSlow = slow.slice().reverse();
+  const revMove = move.slice().reverse();
+  const revDist = dist.slice().reverse();
+
+  const slowOpts = {
+    width: 1100, height: 440,
+    cursor: { drag: { x: true, y: true } },
+    select: { show: true },
+    legend: { show: true },
+    axes: [
+      { label: "λ", stroke: "#cdd6f4", grid: { stroke: "rgba(205,214,244,0.06)" }, size: 50 },
+      { label: "Slow Period", stroke: "#cdd6f4", grid: { stroke: "rgba(205,214,244,0.06)" }, size: 50 },
+    ],
+    series: [
+      { label: "λ" },
+      { label: "Slow", stroke: "#26a69a", width: 2, fill: "rgba(38,166,154,0.06)", points: { show: false } },
+    ],
+    scales: { x: { time: false }, y: { range: [10, null] } },
+  };
+  new uPlot(slowOpts, [xs, slow], document.getElementById('chart-slow'));
+
+  const moveOpts = {
+    width: 1100, height: 280,
+    cursor: { drag: { x: true, y: true } },
+    select: { show: true },
+    legend: { show: true },
+    axes: [
+      { label: "λ", stroke: "#cdd6f4", grid: { stroke: "rgba(205,214,244,0.06)" }, size: 50 },
+      { label: "AMA Movement (path length)", stroke: "#cdd6f4", grid: { stroke: "rgba(205,214,244,0.06)" }, size: 50 },
+    ],
+    series: [
+      { label: "λ" },
+      { label: "Movement", stroke: "#fb8c00", width: 2, points: { show: false } },
+    ],
+    scales: { x: { time: false }, y: { range: [0, null] } },
+  };
+  new uPlot(moveOpts, [xs, move], document.getElementById('chart-dist'));
+
+  try {
+    new uPlot({
+      width: 1100, height: 300,
+      cursor: { drag: { x: true, y: true } },
+      select: { show: true },
+      legend: { show: true },
+      axes: [
+        { label: "Slow Period", stroke: "#cdd6f4", grid: { stroke: "rgba(205,214,244,0.06)" }, size: 50 },
+        { label: "AMA Movement (path length)", stroke: "#cdd6f4", grid: { stroke: "rgba(205,214,244,0.06)" }, size: 50 },
+      ],
+      series: [
+        { label: "Slow" },
+      { label: "Movement", stroke: "#5c9ee6", width: 2, points: { show: false } },
+      ],
+      scales: { x: { time: false }, y: { range: [0, null] } },
+    }, [cacheSlow, cacheMove], document.getElementById('chart-compare'));
+  } catch(e) {
+    const el = document.getElementById('chart-compare');
+    el.textContent = 'Chart error: ' + e.message;
+    el.style.color = '#ef5350';
+  }
+})();
+</script>
+</body>
+</html>`;
+}
+
+// ── Main ────────────────────────────────────────────────────────────────────────
+
+async function run() {
+    const cfg = parseArgs();
+
+    // Load data
+    const dataFile = cfg.dataFile!;
+    const loaded = loadLpDataFile(path.resolve(dataFile));
+    const candles = loaded.candleObjects;
+    const meta = loaded.meta;
+    const dataLabel = meta
+        ? `LP Pool ${meta.pool} (${meta.assetA?.symbol || '?'}/${meta.assetB?.symbol || '?'})`
+        : path.basename(dataFile);
+    const closes = candles.map(c => c.close);
+
+    console.log('══════════════════════════════════════════════════════════');
+    console.log(' Lambda vs Slow Analysis');
+    console.log('══════════════════════════════════════════════════════════');
+    console.log(`  Data:        ${cfg.dataFile} (${candles.length} candles)`);
+    console.log(`  Fixed:       ER=${cfg.fixEr}  Fast=${cfg.fixFast}`);
+    console.log(`  MaxSlow:     ${cfg.maxSlow}`);
+    console.log(`  Lambda end:  ${cfg.lambdaEnd}  (${cfg.lambdaSteps} steps)`);
+    console.log('');
+
+    // Build internal slow range (geometric, extends past maxSlow)
+    const internalSlowMax = cfg.maxSlow;
+    const internalSlowCount = Math.max(200, Math.ceil(internalSlowMax / 2.5));
+    const slowValues = geometricRange(10, internalSlowMax, internalSlowCount);
+
+    // Precompute movement + distance per slow (once)
+    console.log('  Precomputing AMA metrics per slow value...');
+    const metricCache = precomputeMetrics(closes, candles, cfg.fixEr, cfg.fixFast, slowValues);
+    console.log(`  Cached ${metricCache.length} slow profiles`);
+
+    // Derive start lambda from maxSlow
+    const lambdaStart = findStartLambda(metricCache, cfg.maxSlow, cfg.lambdaEnd);
+    if (lambdaStart === null) {
+        console.log('  Could not determine start lambda — maxSlow too low.');
+        process.exit(1);
+    }
+    if (lambdaStart >= cfg.lambdaEnd) {
+        console.log(`  Start lambda (${lambdaStart.toFixed(6)}) >= end lambda (${cfg.lambdaEnd}) — increase --lambdaEnd or decrease --maxSlow.`);
+        process.exit(1);
+    }
+    console.log(`  Derived start λ: ${lambdaStart.toFixed(6)}  (optimal slow first drops below ${cfg.maxSlow})`);
+
+    // Verify start lambda produces slow ~= maxSlow
+    const checkStart = findBestForLambda(lambdaStart, metricCache)!;
+    console.log(`  At start λ:      slow=${checkStart.slow.toFixed(1)}  (should be near ${cfg.maxSlow})\n`);
+
+    // Build geometric lambda range
+    const lambdaValues = geometricRange(lambdaStart, cfg.lambdaEnd, cfg.lambdaSteps);
+
+    // Score each lambda against the cache — no AMA recalculation
+    const results: any[] = [];
+    for (let idx = 0; idx < lambdaValues.length; idx++) {
+        const lambda = lambdaValues[idx];
+        const best = findBestForLambda(lambda, metricCache);
+
+        if (!best) {
+            console.log(`  λ=${lambda.toFixed(6)}  →  NO VALID`);
+            continue;
+        }
+
+        results.push(best);
+
+        const pct = ((idx + 1) / lambdaValues.length * 100).toFixed(0);
+        console.log(`  [${pct}%] λ=${best.lambda.toFixed(6)}  →  slow=${best.slow.toFixed(1)}  move=${best.movement.toFixed(4)}  dist=${best.distance.toFixed(4)}  score=${best.score.toFixed(4)}`);
+    }
+
+    console.log('\n═══ Summary ═══');
+    console.log('  λ (input)     | Slow (output) | Movement | Distance | Score');
+    console.log('  ──────────────┼───────────────┼──────────┼──────────┼────────');
+    for (const r of results) {
+        console.log(`  ${r.lambda.toFixed(8).padStart(12)} | ${r.slow.toFixed(1).padStart(13)} | ${r.movement.toFixed(4).padStart(8)} | ${r.distance.toFixed(4).padStart(8)} | ${r.score.toFixed(4).padStart(8)}`);
+    }
+
+    // Generate chart
+    const chartName = cfg.outFile || path.join(
+        PATHS.ANALYSIS.CHARTS_DIR,
+        `lambda_vs_slow_er${cfg.fixEr}_fast${cfg.fixFast}_${cfg.lambdaSteps}steps.html`
+    );
+    const chartPath = path.resolve(chartName);
+    ensureDir(path.dirname(chartPath));
+    const html = generateChartHtml(results, metricCache, cfg.fixEr, cfg.fixFast, dataLabel, chartPath);
+    fs.writeFileSync(chartPath, html, 'utf8');
+    console.log(`\n  Chart: ${path.relative(process.cwd(), chartPath)}`);
+    console.log('');
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    run().catch(err => {
+        console.error('Fatal:', getErrorMessage(err));
+        process.exit(1);
+    });
+}
+
+export { parseArgs }
+

package/analysis/ama_fitting/calibrate_convergence_er.ts

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { MARKET_ADAPTER } from '../../modules/constants.js';
+import { getStorage } from '../../modules/storage/index.js';
+const { readJSON } = getStorage();
+import { PATHS } from '../../modules/paths.js';
+import { roundTo } from '../../modules/order/utils/math.js';
+
+'use strict';
+/**
+ * AMA CONVERGENCE ER CALIBRATION
+ *
+ * Computes the correct AMA_CONVERGENCE_ER_AVG from real LP candle data.
+ *
+ * The formula `(ER_avg × deltaSC + slowSC)²` suffers from Jensen's inequality:
+ * E[f(ER)] ≠ f(E[ER]) when f is convex (x²). The arithmetic mean ER
+ * underestimates the true average SC because high-ER periods contribute
+ * quadratically more to convergence.
+ *
+ * This script computes the implied ER — the value that, when plugged into
+ * the formula, reproduces the empirical arithmetic SC_avg — and prints
+ * the recommended constant for modules/constants.ts.
+ *
+ * Usage:
+ *   tsx analysis/ama_fitting/calibrate_convergence_er.ts
+ *   tsx analysis/ama_fitting/calibrate_convergence_er.ts --data <lp-file.json>
+ *   tsx analysis/ama_fitting/calibrate_convergence_er.ts --data <lp-file.json> --amas AMA3
+ */
+const DEFAULT_DATA = path.join(PATHS.MARKET_ADAPTER.LP_DATA_DIR,
+    '1_3_5537_1_3_0', 'lp_pool_133_1h.json');
+const FALLBACK_ER_PERIOD = 781;
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const opts: { data: string; amas: string[] | null } = { data: DEFAULT_DATA, amas: null };
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--data' && args[i + 1]) opts.data = args[++i];
+        if (args[i] === '--amas' && args[i + 1]) opts.amas = args[++i].split(',');
+    }
+    return opts;
+}
+/**
+ * Compute per-bar SC values and return { scAvg, erValues, avgER }.
+ * scAvg = mean of (ER × deltaSC + slowSC)² across all bars.
+ */
+function computeSCstats(closes: any, erPeriod: any, fastPeriod: any, slowPeriod: any) {
+    const fastSC = 2 / (fastPeriod + 1);
+    const slowSC = 2 / (slowPeriod + 1);
+    const deltaSC = fastSC - slowSC;
+    let sumSC = 0;
+    const erValues: number[] = [];
+    for (let i = erPeriod; i < closes.length; i++) {
+        const dir = Math.abs(closes[i] - closes[i - erPeriod]);
+        let vol = 0;
+        for (let j = i - erPeriod + 1; j <= i; j++) {
+            vol += Math.abs(closes[j] - closes[j - 1]);
+        }
+        const er = vol === 0 ? 0 : dir / vol;
+        erValues.push(er);
+        sumSC += (er * deltaSC + slowSC) ** 2;
+    }
+    const count = erValues.length;
+    const scAvg = count > 0 ? sumSC / count : 0;
+    const avgER = count > 0 ? erValues.reduce((a, b) => a + b) / count : 0;
+    return { scAvg, erValues, avgER, count };
+}
+/**
+ * Format a column-aligned markdown table row.
+ */
+function row(cells: any, widths: any) {
+    const parts = cells.map((c: any, i: any) => {
+        const s = String(c);
+        return i < widths.length ? s.padEnd(widths[i]) : s;
+    });
+    return `| ${parts.join(' | ')} |`;
+}
+function main() {
+    const opts = parseArgs();
+    // ── Load and validate data ──────────────────────────────────────────
+    let data;
+    try {
+        data = readJSON(opts.data);
+    } catch (err: unknown) {
+        const e = err as any;
+        if (e.code === 'ENOENT') {
+            console.error(`Data file not found: ${opts.data}`);
+            console.error('Export LP candles first, or point --data at an existing file.');
+            console.error('  tsx market_adapter/inputs/fetch_lp_data.ts --pool 133 --precA 4 --precB 5 --interval 1h --lookback 26280h');
+        } else if (e instanceof SyntaxError) {
+            console.error(`Failed to parse JSON from: ${opts.data}`);
+            console.error(e.message);
+        } else {
+            console.error(`Error reading data file: ${e.message}`);
+        }
+        process.exit(1);
+    }
+    const closes = (data.candles || []).map((c: any) => Number(c[4]))
+        .filter((v: any) => Number.isFinite(v) && v > 0);
+    if (closes.length < 100) {
+        console.error(`Not enough candles (need > 100, got ${closes.length})`);
+        process.exit(1);
+    }
+    const amas = MARKET_ADAPTER.AMAS as Record<string, typeof MARKET_ADAPTER.AMAS.AMA1>;
+    const keys = opts.amas || Object.keys(amas);
+    const eps = MARKET_ADAPTER.AMA_CONVERGENCE_EPSILON;
+    console.log(`Data:    ${opts.data}`);
+    console.log(`Candles: ${closes.length}  |  EPSILON: ${eps}`);
+    console.log('');
+    // ── ER distribution display (using first AMA's erPeriod) ──────────
+    const refKey = keys[0];
+    const refCfg = amas[refKey];
+    const erP = refCfg?.erPeriod || FALLBACK_ER_PERIOD;
+    const { erValues, avgER: refAvgER } = computeSCstats(closes, erP, refCfg.fastPeriod, refCfg.slowPeriod);
+    erValues.sort((a, b) => a - b);
+    const n = erValues.length;
+    const p5  = erValues[Math.floor(0.05 * n)].toFixed(4);
+    const p50 = erValues[Math.floor(0.50 * n)].toFixed(4);
+    const p95 = erValues[Math.floor(0.95 * n)].toFixed(4);
+    console.log(`--- ER distribution (erPeriod=${erP}) ---`);
+    console.log(`  p5 ${p5}  p50 ${p50}  p95 ${p95}  avg ${refAvgER.toFixed(4)}`);
+    console.log('');
+    // ── Per-AMA analysis (compute once, cache results) ─────────────────
+    const results: any[] = [];
+    // Validate erPeriod / fastPeriod consistency for meaningful naiveSC comparison
+    const erPeriods = new Set();
+    const fastPeriods = new Set();
+    for (const key of keys) {
+        if (amas[key]) {
+            erPeriods.add(amas[key].erPeriod);
+            fastPeriods.add(amas[key].fastPeriod);
+        }
+    }
+    const consistentER = erPeriods.size === 1 && fastPeriods.size === 1;
+    for (const key of keys) {
+        const cfg = amas[key];
+        if (!cfg) continue;
+        const { scAvg, avgER, count } = computeSCstats(closes, cfg.erPeriod, cfg.fastPeriod, cfg.slowPeriod);
+        const fastSC = 2 / (cfg.fastPeriod + 1);
+        const slowSC = 2 / (cfg.slowPeriod + 1);
+        const deltaSC = fastSC - slowSC;
+        const naiveSC = (avgER * deltaSC + slowSC) ** 2;
+        const impliedER = Math.max(0, Math.min(1, (Math.sqrt(scAvg) - slowSC) / deltaSC));
+        const convBars = Math.ceil(Math.log(eps) / Math.log(1 - scAvg));
+        results.push({ key, cfg, fastSC, slowSC, deltaSC, scAvg, avgER, naiveSC, impliedER, convBars, count });
+    }
+    // ── Print analysis table ───────────────────────────────────────────
+    console.log('--- Per-AMA SC analysis ---');
+    if (!consistentER) {
+        console.log('(note: selected AMAs have different erPeriod/fastPeriod — naiveSC column is per-AMA)');
+    }
+    const hdr = row(['AMA', 'fastSC', 'slowSC', 'emp SC_avg', 'naive SC (E[ER])', 'implied ER', 'conv bars'],
+        [5, 8, 8, 11, 17, 11, 10]);
+    const sep = row(['-----', '--------', '--------', '-----------', '-----------------', '-----------', '----------'],
+        [5, 8, 8, 11, 17, 11, 10]);
+    console.log(hdr);
+    console.log(sep);
+    for (const r of results) {
+        console.log(row([
+            r.key,
+            r.fastSC.toFixed(4),
+            r.slowSC.toFixed(4),
+            r.scAvg.toExponential(4),
+            r.naiveSC.toExponential(4),
+            r.impliedER.toFixed(4),
+            r.convBars,
+        ], [5, 8, 8, 11, 17, 11, 10]));
+    }
+    // ── Recommended constant ───────────────────────────────────────────
+    const avgImpliedER = results.reduce((a, r) => a + r.impliedER, 0) / results.length;
+    const recRounded = roundTo(avgImpliedER, 1000);
+    console.log('');
+    console.log('--- Recommended constant ---');
+    console.log(`  Average implied ER: ${avgImpliedER.toFixed(4)}`);
+    console.log(`  Rounded:            ${recRounded.toFixed(3)}`);
+    console.log('');
+    console.log(`  Current in constants.ts: AMA_CONVERGENCE_ER_AVG = ${MARKET_ADAPTER.AMA_CONVERGENCE_ER_AVG}`);
+    console.log(`  Suggested update:        AMA_CONVERGENCE_ER_AVG = ${recRounded.toFixed(3)}`);
+    // ── Convergence bars comparison (using cached results) ─────────────
+    console.log('');
+    console.log('--- Convergence bars comparison (current vs recommended ER) ---');
+    const cmpHdr = row(['AMA', `curr ER=${MARKET_ADAPTER.AMA_CONVERGENCE_ER_AVG}`, `rec ER=${recRounded.toFixed(3)}`, 'empirical'],
+        [5, 14, 14, 10]);
+    const cmpSep = row(['-----', '--------------', '--------------', '----------'],
+        [5, 14, 14, 10]);
+    console.log(cmpHdr);
+    console.log(cmpSep);
+    for (const r of results) {
+        const curSC = (MARKET_ADAPTER.AMA_CONVERGENCE_ER_AVG * r.deltaSC + r.slowSC) ** 2;
+        const curBars = Math.ceil(Math.log(eps) / Math.log(1 - curSC));
+        const recSC = (recRounded * r.deltaSC + r.slowSC) ** 2;
+        const recBars = Math.ceil(Math.log(eps) / Math.log(1 - recSC));
+        console.log(row([
+            r.key,
+            curBars + r.cfg.erPeriod,
+            recBars + r.cfg.erPeriod,
+            r.convBars + r.cfg.erPeriod,
+        ], [5, 14, 14, 10]));
+    }
+}
+main();