chore: bump to v1.1.2 — AMA refit, optimizer chart output, constant tuning

## AMA Constants Refit (pool 133 1h, λ=0.0022/step=0.0002)
- AMA1: slowPeriod 93.1→80.6, AMA2: 102.4→84.6, AMA3: 112.7→93.1, AMA4: 136.4→107.4
- DYNAMIC_WEIGHT_AMA_MAX_SLOPE_PCT: 0.08→0.085

## Optimizer Improvements
- Auto-generates interactive HTML chart via lp_chart_core alongside results JSON
- Output filenames include λ/step suffix for multi-run comparison
- Fixed tsx v4 strip-mode compat (export= → module.exports)
- Removed hardcoded REPOS_THRESHOLD=0.004; wired trackRepositions to production AMA_DELTA_THRESHOLD_PERCENT
- Restored DISTANCE_WEIGHT_STEP=0.0002 so AMA1-4 form a distinct tight-to-loose spectrum

## amaS% Knob (dynamic weight chart)
- Range narrowed from 0.01-0.5 to 0.04-0.12

## Docs
- Swept outdated AMA slow values (112.7→93.1), tsx→node dist commands, amaS% research range

## Testing
- tsc compiles cleanly, optimizer runs on pool 133 1h, chart generator produces valid HTML

Author: froooze

CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.1.2] - 2026-07-13 - AMA Optimizer Improvements, Constants Tuning & Doc Sync
+
+### 2026-07-13
+
+- **Feat**: optimizer now auto-generates an interactive HTML chart alongside results JSON — uses `generateHTML` from `lp_chart_core` to render the four winning AMAs against LP price data (`analysis/ama_fitting/optimizer_high_resolution.ts`).
+- **Feat**: output filenames include λ and step suffix (e.g. `_l0_0022_s0_0002`) for easy comparison across runs (`analysis/ama_fitting/optimizer_high_resolution.ts`).
+- **Feat**: `export =` replaced with `module.exports =` in optimizer to fix `tsx v4` strip-only mode compatibility (`analysis/ama_fitting/optimizer_high_resolution.ts`).
+- **Fix**: hardcoded `REPOS_THRESHOLD = 0.004` (0.4%) removed — `calcReposRate` replaced by `trackRepositions` wired to `MARKET_ADAPTER.AMA_DELTA_THRESHOLD_PERCENT`. Analyzer now uses the production threshold (`analysis/ama_fitting/optimizer_high_resolution.ts`, `analysis/ama_fitting/analyze_ama_price_changes.ts`).
+- **Fix**: `trackRepositions` extracted to shared utility then inlined back as a simplified single-threshold function — removed untracked shared file, kept logic in `analyze_ama_price_changes.ts`.
+- **Fix**: all four AMA cap quantiles produced identical winners with constant λ — re-enabled `DISTANCE_WEIGHT_STEP = 0.0002` so λ varies per AMA for a clean tight-to-loose spectrum (`analysis/ama_fitting/optimizer_high_resolution.ts`).
+- **Tune**: AMA1–AMA4 slow periods refitted on pool 133 1h data (2023-05 → 2026-05) with optimizer λ=0.0022/step=0.0002. Results: AMA1=80.6, AMA2=84.6, AMA3=93.1, AMA4=107.4 (`modules/constants.ts`).
+- **Tune**: `BASE_DISTANCE_WEIGHT` set to 0.0022, `DYNAMIC_WEIGHT_AMA_MAX_SLOPE_PCT` set to 0.085, amaS% knob range narrowed to 0.04–0.12 (`analysis/trend_detection/dynamic_weight_chart_generator.ts`, `modules/constants.ts`).
+- **Docs**: sweep AMA slow values (112.7→93.1), tsx→node dist command updates, unified comparison chart notes, and amaS% research range in 5 documentation files.
+- **Chore**: add `"tsx": { "tsconfig": true }` to root `package.json` (mitigation for `export =` in tsx v4).
+- **Chore**: version bumped to 1.1.2 across all manifests.
+
 ## [1.1.1] - 2026-07-12 - Auto-startup Migration, Error Handling & Cleanup
 
 ### 2026-07-12

analysis/README.md

@@ -27,7 +27,7 @@ Tools that inspect DEXBot trading behavior and the market data it operates on. O
 | [`analyze_volatility.ts`](#volatility-analyze_volatilityts) | "Both weights clipped too hard / not enough?" | `tsx analysis/analyze_volatility.ts --bot-key <bot-key>` |
 | [`analyze_regime.ts`](#supporting-sub-signals) | "Is the trend/chaos gate too aggressive?" | `tsx analysis/analyze_regime.ts --bot-key <bot-key>` |
 | [`analyze_kalman.ts`](#supporting-sub-signals) | "Is Kalman's contribution to the blend right?" | `tsx analysis/analyze_kalman.ts --bot-key <bot-key>` |
-| [`ama_fitting/`](#ama_fitting) | "Which AMA preset fits this market?" | `tsx analysis/ama_fitting/optimizer_high_resolution.ts --data <lp-file>` |
+| [`ama_fitting/`](#ama_fitting) | "Which AMA preset fits this market?" | `node dist/analysis/ama_fitting/optimizer_high_resolution.js --data <lp-file>` |
 | [`bot_fitting/`](#bot_fitting) | "What spread / increment / ratio for my grid?" | `tsx analysis/bot_fitting/backtest_ama_sweep.ts --data <lp-file>` |
 
 > `analyze_derivatives.ts` (SMA / MACD / RSI derivative layer) is legacy and not surfaced — kept for reference only.
@@ -355,7 +355,7 @@ AMA parameter optimization and comparison tools.
 | Script | Purpose |
 |--------|---------|
 | `optimizer_high_resolution.ts` | AMA parameter optimizer (erPeriod, fast/slow bounds) |
-| `generate_unified_comparison_chart.ts` | AMA comparison chart across multiple parameter sets |
+| `generate_unified_comparison_chart.ts` | AMA comparison chart (defaults from constants, use optimizer for fitted params) |
 | `analyze_ama_price_changes.ts` | AMA price-change analysis |
 | `fetch_lp_candles.ts` | LP candle data fetcher |
 | `calibrate_convergence_er.ts` | Calibrate AMA_CONVERGENCE_ER_AVG from LP data |
@@ -429,7 +429,7 @@ These npm scripts wrap common analysis runners:
 |--------|---------|
 | `npm run analysis:tradingview` | `tsx analysis/tradingview/analyze_tradingview.ts` |
 | `npm run analysis:trade-pnl` | `tsx analysis/trade_profitability.ts` |
-| `npm run ama:chart:lp-local` | `tsx analysis/ama_fitting/generate_unified_comparison_chart.ts` |
+| `npm run ama:chart:lp-local` | `tsx analysis/ama_fitting/generate_unified_comparison_chart.ts` (chart also auto-generated by optimizer) |
 
 All accept `--` forwarded flags.
 

analysis/ama_fitting/README.md

@@ -64,36 +64,46 @@ Output: `market_adapter/data/lp/<pair_folder>/lp_pool_<poolShort>_<interval>.jso
 
 `optimizer_high_resolution.ts` runs a parallel geometric grid search over
 ER × Fast × Slow combinations. Produces four AMA winners (AMA1–AMA4) using
-different distance-cap quantiles and writes results to a JSON file.
+different distance-cap quantiles and writes results to a JSON file + auto-generates
+an interactive HTML chart.
 
 By default this does **not** update runtime market-adapter profiles. Add
 `--write-profiles` when you intentionally want the fitted parameters exported
 to `profiles/market_profiles.json`.
 
 **Run on the fetched LP data:**
 ```bash
-tsx analysis/ama_fitting/optimizer_high_resolution.ts \
+npm run build && node dist/analysis/ama_fitting/optimizer_high_resolution.js \
   --data market_adapter/data/lp/<pair>/lp_pool_<id>_<interval>.json
 ```
 
+Or from the `analysis/ama_fitting/` directory using the local script shortcut:
+```bash
+npm run optimize -- --data ../../market_adapter/data/lp/<pair>/lp_pool_<id>_<interval>.json
+```
+
 **Export winners to the market adapter profile file:**
 ```bash
-tsx analysis/ama_fitting/optimizer_high_resolution.ts \
+npm run build && node dist/analysis/ama_fitting/optimizer_high_resolution.js \
   --data market_adapter/data/lp/<pair>/lp_pool_<id>_<interval>.json \
   --write-profiles
 ```
 
+> `npx tsx` does not work on this project due to `export =` syntax in dependency
+> modules (unsupported in tsx v4 strip-only mode). Always use the compiled output
+> via `node dist/...` or the `npm run optimize` shortcut.
+
 **Default search ranges:**
 
 | Param | Min  | Max  | Sampling | Quantum |
 |-------|------|------|----------|---------|
-| ER    | 50   | 500  | 40 geometric points | 1 |
-| Fast  | 1    | 10   | 40 geometric points | 0.01 |
-| Slow  | 500  | 5000 | 40 geometric points | 1 |
+| ER    | 500  | 1000 | 15 geometric points | 1 |
+| Fast  | 2    | 8    | 30 geometric points | 0.01 |
+| Slow  | 50   | 200  | 30 geometric points | 0.1 |
 
 Override ranges via CLI:
 ```bash
-tsx analysis/ama_fitting/optimizer_high_resolution.ts \
+npm run build && node dist/analysis/ama_fitting/optimizer_high_resolution.js \
   --data market_adapter/data/lp/<pair>/lp_pool_<id>_<interval>.json \
   --erMin 100 --erMax 600 \
   --slowMin 800 --slowMax 6000
@@ -138,17 +148,23 @@ Source: pool 133 `IOB.XRP/BTS`, 1h candles, 2023-05-05 22:00 UTC through
 2026-05-04 22:00 UTC.
 
 **Outputs:**
-- `analysis/ama_fitting/optimization_results_<datafile>.json` — full results
+- `analysis/ama_fitting/optimization_results_<datafile>_l<λ>_s<step>.json` — full results (e.g. `_l0020_s000` for λ=0.0020, step=0)
+- `analysis/charts/optimization_chart_<datafile>_l<λ>_s<step>.html` — interactive AMA overlay chart (auto-generated)
 - `profiles/market_profiles.json` — updated with new AMA parameters per pair only when `--write-profiles` is used
 
 **Boundary check:** If a winner lands on the edge of the search range, the
 optimizer warns you. Widen the affected range and re-run.
 
 ---
 
-## Step 3 — Visual Review (optional)
+## Step 3 — Visual Review
+
+A chart is auto-generated during Step 2 at
+`analysis/charts/optimization_chart_<datafile>.html`. Open it in a browser
+to compare all four optimized AMA overlays against the candlestick price.
 
-Recommended entrypoint:
+For a standalone chart without re-running the optimizer (uses current defaults
+from `modules/constants.ts` rather than optimized results):
 
 ```bash
 npm run lp:chart -- \
@@ -159,19 +175,6 @@ This generates both:
 - `analysis/charts/lp_AMA_chart_pool_133.html` — market-adapter style LP chart
 - `analysis/charts/lp_chart_1h_UNIFIED_COMPARISON.html` — unified comparison chart, with the interval derived from LP metadata
 
-Under the hood, LP-data chart generation now delegates into the shared runner in
-`market_adapter/lp_chart_runner.ts`. The analysis script keeps only:
-- the local LP comparison mode used for analysis-only review
-
-Local LP comparison entrypoint:
-
-```bash
-npm run ama:chart:lp-local -- \
-  --data market_adapter/data/lp/<pair>/lp_pool_<id>_<interval>.json
-```
-
-Open the generated HTML in a browser to compare all four AMA overlays against the candlestick price.
-
 ---
 
 ## How market_profiles.json is used

analysis/ama_fitting/analyze_ama_price_changes.ts

@@ -6,14 +6,8 @@
  * Simulates AMA_DELTA_THRESHOLD_PERCENT grid-reposition logic for all four AMA
  * series on LP candle data.
  *
- * For each threshold (1%, 2%, 3%, 4%):
- *   - Set a baseline at the first post-warmup AMA value
- *   - Count candle steps until the AMA drifts ≥ threshold from that baseline
- *   - Record the reposition event, reset baseline to current AMA value
- *   - Repeat for the full live window
- *
- * Reports: reposition count, avg/min/max steps between repositions, frequency
- * per 1000 live steps — for each AMA × threshold combination.
+ * Uses the production threshold from MARKET_ADAPTER.AMA_DELTA_THRESHOLD_PERCENT
+ * (modules/constants.ts).
  *
  * Usage:
  *   tsx analysis/ama_fitting/analyze_ama_price_changes.ts --data <path-to-lp-candles.json> --results <path-to-optimization-results.json>
@@ -22,7 +16,39 @@ const fs   = require('fs');
 const path = require('path');
 const { calculateAMA } = require('../../market_adapter/core/strategies/ama');
 const { readJSON } = require('../../modules/utils/fs_utils');
-const THRESHOLDS = [1, 2, 3, 4]; // percent
+const { MARKET_ADAPTER } = require('../../modules/constants');
+const REPOS_THRESHOLD_PCT = MARKET_ADAPTER.AMA_DELTA_THRESHOLD_PERCENT;
+
+/**
+ * Simulate AMA_DELTA_THRESHOLD_PERCENT reposition logic.
+ *
+ * Starting from the first post-warmup AMA value, track cumulative drift from
+ * the last reposition baseline.  When drift ≥ threshold, a reposition fires:
+ * record step-count since previous reposition, reset baseline to current AMA.
+ */
+function trackRepositions(amaValues, thresholdPct, warmup) {
+    let events = 0;
+    const steps = [];
+    let baseline = amaValues[warmup];
+    let stepCounter = 0;
+    for (let i = warmup + 1; i < amaValues.length; i++) {
+        const curr = amaValues[i];
+        if (baseline === 0) continue;
+        stepCounter++;
+        const driftPct = Math.abs((curr - baseline) / baseline) * 100;
+        if (driftPct >= thresholdPct) {
+            events++;
+            steps.push(stepCounter);
+            baseline = curr;
+            stepCounter = 0;
+        }
+    }
+    const min = steps.length > 0 ? Math.min(...steps) : 0;
+    const max = steps.length > 0 ? Math.max(...steps) : 0;
+    const avg = steps.length > 0 ? steps.reduce((a, b) => a + b, 0) / steps.length : 0;
+    return { events, steps, min, max, avg };
+}
+
 // ── Load data ─────────────────────────────────────────────────────────────────
 function loadData(filePath) {
     const json    = readJSON(filePath);
@@ -44,57 +70,7 @@ function loadAmaParams(resultsPath) {
     ];
 }
 // ── Analysis ──────────────────────────────────────────────────────────────────
-/**
- * Simulate AMA_DELTA_THRESHOLD_PERCENT reposition logic.
- *
- * Starting from the first post-warmup AMA value, track cumulative drift from
- * the last reposition baseline.  When drift reaches a threshold, a reposition
- * fires: record the step-count since the previous reposition, then reset the
- * baseline to the current AMA value.
- *
- * Returns { threshold -> { events, steps: number[], min, max, avg } }
- *   events  — total reposition count
- *   steps   — candle steps between consecutive repositions
- *   min/max/avg — statistics on those step-counts
- */
-function trackRepositions(amaValues, thresholds, erPeriod) {
-    const result = {};
-    for (const t of thresholds) {
-        result[t] = { events: 0, steps: [], min: Infinity, max: 0, avg: 0 };
-    }
-    // Each threshold has its own independent baseline + step counter
-    const baselines    = {};
-    const stepCounters = {};
-    for (const t of thresholds) {
-        baselines[t]    = amaValues[erPeriod];   // first post-warmup value
-        stepCounters[t] = 0;
-    }
-    for (let i = erPeriod + 1; i < amaValues.length; i++) {
-        const curr = amaValues[i];
-        for (const t of thresholds) {
-            const base = baselines[t];
-            if (base === 0) continue;
-            stepCounters[t]++;
-            const driftPct = Math.abs((curr - base) / base) * 100;
-            if (driftPct >= t) {
-                const r = result[t];
-                r.events++;
-                r.steps.push(stepCounters[t]);
-                baselines[t]    = curr;
-                stepCounters[t] = 0;
-            }
-        }
-    }
-    // Compute stats
-    for (const t of thresholds) {
-        const r = result[t];
-        if (r.steps.length === 0) { r.min = 0; r.avg = 0; continue; }
-        r.min = Math.min(...r.steps);
-        r.max = Math.max(...r.steps);
-        r.avg = r.steps.reduce((a, b) => a + b, 0) / r.steps.length;
-    }
-    return result;
-}
+
 // ── Main ──────────────────────────────────────────────────────────────────────
 function run() {
     const dataArgIdx    = process.argv.indexOf('--data');
@@ -123,67 +99,43 @@ function run() {
     console.log('════════════════════════════════════════════════════════════════════════════════');
     console.log(` Dataset:    ${label}  (${interval} candles)`);
     console.log(` Candles:    ${candles.length}  →  ${totalSteps} steps total`);
-    console.log(` Thresholds: ${THRESHOLDS.map(t => `${t}%`).join('  ')}`);
+    console.log(` Threshold:   ${REPOS_THRESHOLD_PCT}%  (from MARKET_ADAPTER.AMA_DELTA_THRESHOLD_PERCENT)`);
     console.log('');
     console.log(' Logic: set baseline at warmup end, count steps until AMA drifts ≥ threshold,');
     console.log('        record reposition + reset baseline.  Repeat for full live window.');
     console.log('');
-    const cW = 10;
-    const allResults = [];
+    const results = [];
     for (const params of amaParams) {
         const values = calculateAMA(closes, {
             erPeriod:   params.er,
             fastPeriod: params.fast,
             slowPeriod: params.slow,
         });
-        const repoData  = trackRepositions(values, THRESHOLDS, params.er);
+        const r = trackRepositions(values, REPOS_THRESHOLD_PCT, params.er);
         const liveSteps = totalSteps - params.er;
-        const suffix   = String(params.label).replace(/^AMA\d\s*/i, '').replace(/^[-:\s]+/, '').trim();
+        const freq = liveSteps > 0 ? (r.events / liveSteps * 1000).toFixed(1) : '–';
+        const avg  = r.events > 0 ? r.avg.toFixed(1) : '–';
+        const suffix = String(params.label).replace(/^AMA\d\s*/i, '').replace(/^[-:\s]+/, '').trim();
         const rowLabel = `${params.key} ${suffix}`;
         console.log(` ── ${rowLabel}  (warmup: ${params.er}  live: ${liveSteps} steps) ──`);
-        console.log(
-            '    ' +
-            'threshold'.padEnd(12) +
-            'repositions'.padStart(cW) +
-            'avg steps'.padStart(cW) +
-            'min steps'.padStart(cW) +
-            'max steps'.padStart(cW) +
-            ' /1000 steps'
-        );
-        console.log('    ' + '─'.repeat(12 + cW * 4 + 12));
-        for (const t of THRESHOLDS) {
-            const r    = repoData[t];
-            const freq = liveSteps > 0 ? (r.events / liveSteps * 1000).toFixed(1) : '–';
-            const avg  = r.events > 0 ? r.avg.toFixed(1) : '–';
-            const min  = r.events > 0 ? String(r.min) : '–';
-            const max  = r.events > 0 ? String(r.max) : '–';
-            console.log(
-                '    ' +
-                `≥${t}%`.padEnd(12) +
-                String(r.events).padStart(cW) +
-                avg.padStart(cW) +
-                min.padStart(cW) +
-                max.padStart(cW) +
-                `  ${freq}`
-            );
-            allResults.push({
-                label: `${params.key} ≥${t}%`,
-                events: r.events,
-                avg: r.avg,
-                freq: liveSteps > 0 ? r.events / liveSteps * 1000 : 0,
-            });
-        }
+        console.log(`    ≥${REPOS_THRESHOLD_PCT}%  repositions: ${r.events}  avg steps: ${avg}  min: ${r.events > 0 ? r.min : '–'}  max: ${r.events > 0 ? r.max : '–'}  freq: ${freq}/1k steps`);
         console.log('');
+        results.push({
+            label: rowLabel,
+            events: r.events,
+            avg: r.avg,
+            freq: liveSteps > 0 ? r.events / liveSteps * 1000 : 0,
+        });
     }
     console.log(' Note: warmup candles excluded (AMA initializes from SMA of the ER window).');
     console.log('');
     // ── Ranking: fewest repositions ────────────────────────────────────────────
-    allResults.sort((a, b) => a.events - b.events);
+    results.sort((a, b) => a.events - b.events);
     console.log(' Ranking — fewest repositions (least grid changes):');
     console.log('');
-    console.log('    ' + '#'.padEnd(4) + 'AMA + threshold'.padEnd(20) + 'repositions'.padStart(12) + 'avg steps'.padStart(10) + ' /1000 steps');
+    console.log('    ' + '#'.padEnd(4) + 'AMA'.padEnd(20) + 'repositions'.padStart(12) + 'avg steps'.padStart(10) + ' /1000 steps');
     console.log('    ' + '─'.repeat(4 + 20 + 12 + 10 + 12));
-    allResults.forEach((r, i) => {
+    results.forEach((r, i) => {
         console.log(
             '    ' +
             String(i + 1).padEnd(4) +