dexbot 1.4.20 → 1.4.22

package/CHANGELOG.md

@@ -2,6 +2,59 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.4.22] - 2026-08-25 - tsx Removal Completion, Exact AMA Bootstrap, Research Parity, Canonical Grid Bounds, Modules-Wide Audit
+
+### 2026-08-26
+
+- **Feat(analysis)**: TradingView-style price-axis interaction in the tradingview chart exporter — mouse wheel over the right price gutter zooms Y around the cursor (0.91/1.10 factors) and a vertical drag on the axis sets a manual Y range (multiplicative on log scale, additive offset otherwise), while double-clicking the axis restores auto-fit through the existing `visiblePriceRange` range callback; the plot area keeps pure time pan/zoom via `UPLOT_SHARED_SCRIPT` using page-local hoisted overrides so the shared script stays untouched, axis hit-testing uses `chart.bbox` geometry (the `.u-over` overlay spans the axis gutters too), the manual range resets automatically when dataset/timeframe/pair changes (sticky-manual guard keyed on first-time:last-time:count), and the price axis renders larger labels at a fixed 84px width matching the volume axis (`analysis/tradingview/tradingview_uplot_chart_generator.ts`).
+- **Fix(market-adapter)**: keep Kibana LP fetches alive under proxy connection resets — the kibana.bitshares.dev console proxy kills responses mid-transfer once a single search page streams enough data (~8k docs with full `_source`, observed even at ~2k with `_source: true`), and `doKibanaRequest` only listened for request-phase errors, so an aborted response body left the promise pending forever and `fetch_lp_data` hung silently with no retry; the response stream now settles exactly once on 'aborted'/'error' with an actionable message, candle queries send a minimal `_source` projection derived from the field map (legacy `_source: true` preserved when no projection is passed), default page size drops 10000 → 2000, and transient page failures (aborted/reset/socket/timeout) retry up to `kibanaPageRetries` attempts (4) with linear backoff — safe because search_after pagination is stateless server-side; adapted from upstream contribution bitshares/DEXBot2#4 / froooze/DEXBot2#12 (`market_adapter/core/kibana_client.ts`, `market_adapter/core/kibana_candles.ts`, new `tests/test_kibana_candles.ts`).
+- **Refactor(analysis)**: dedupe tradingview fork CSS fragments and zoom-pan stack — the fork hand-cloned zoom/pan logic shared by every other uPlot generator and re-wrote a CSS fragment with identical shape: chart_css export surface narrowed to `sharedChartCSS`/`uplotBgCSS`/`cursorCSS` (dead fragments un-exported, `uplotBgCSS` gains an optional bg color parameter keeping the default), the `.uplot` background rule is interpolated via `uplotBgCSS('#0b0f14')`, local clampRange/syncXRange/bindWheelZoom/bindPan clones plus a bespoke Ctrl+0 handler are replaced by embedding `UPLOT_SHARED_SCRIPT`/`zoomResetScript()` (~90 lines removed) with xMin/xMax maintained in buildData per contract (`analysis/chart_css.ts`, `analysis/tradingview/tradingview_uplot_chart_generator.ts`, `analysis/chart_ui.ts`).
+- **Feat(analysis)**: model bot fitting backtests on the production grid lifecycle — both simulators previously ranked parameters by unrealized inventory marks (>99% phantom profit from cross-gap pair differentials no live slot earns); they now run production-style SLOT ROTATION on `createOrderGrid` geometry where scoring counts realized economics only: a filled buy arms the next rail-node sell booking one hop minus round-trip fees with the freed quote re-bidding behind it, out-of-range falls back to x(1±inc), initial-grid sells execute only against held base at weighted-average entry, production reset triggers fire from MARKET_ADAPTER constants (drift ratchet + slope delta gated behind the asymmetric-bounds whitelist like production) cancelling all orders with fees, BTS op fees are charged at every placement and reset cancel, drawdown tracks realized equity only, and the end-of-run inventory mark is informational/excluded from score; backtest_ama_sweep ports its sized worker simulation to the same model fixing a worker-result race (`analysis/bot_fitting/*`, `tests/test_backtest_ama_sweep_logic.ts`, new `tests/test_backtest_bot_fitting_logic.ts`).
+- **Refactor(analysis)**: align research tools with market_adapter sources to stop signal drift — kalman_chart_generator computes the dynamic-weight channel via the canonical `computeDynamicWeightSeries`/percentile threshold with live config rendered in the legend, regime_chart_generator sources windows/thresholds/boundaries from MARKET_ADAPTER matching `classifyHurst` instead of drifted local copies, dynamic_weight_chart_generator yields Infinity from empty percentile pools like the live path and fixes an axis tick color typo, generate_unified_comparison_chart reuses `findLatestLpData`/`calculateMetrics` from lp_chart_runner, and optimizer_high_resolution/analyzer imports consolidated onto canonical implementations — behavioral changes only where the drifted copies were wrong (`analysis/trend_detection/*_chart_generator.ts`, `analysis/ama_fitting/*`, `market_adapter/lp_chart_runner.ts`).
+- **Fix(analysis)**: correct research-tooling bugs surfaced by a full folder audit — analyze_regime_windows paired Hurst/PE bands sliced from different readiness offsets shifting classification into RANDOM|undefined regimes (now strictly per-bar via the production `classifyHurst` with MARKET_ADAPTER knobs); trade_profitability time bounds went through blind string surgery producing invalid dates for offset ISO strings, date-only --end dropped the final day, zero-amount fills poisoned LIFO lots with infinite prices, and `--fee-per-order 0` was ignored (proper Date parsing, end-of-day expansion, positive-amount guard, nullable fee override); analyze_kalman's --q conflated tactical/modal values with divergent defaults (split into --q-tactical/--q-modal falling through to production); derivative_analyzer used macdMinHist as both histogram threshold and MACD line gate so explicit 0 was ignored; fetch_lp_candles rejects non-numeric --interval instead of NaN-ing requests; discover_bot_accounts uses the node management pool instead of a hardcoded websocket endpoint; price_sources resolves the centers filename through PATHS.MARKET_ADAPTER (`analysis/analyze_regime_windows.ts`, `analysis/trade_profitability.ts`, `analysis/analyze_kalman.ts`, `analysis/trend_detection/derivative_analyzer.ts`, `analysis/ama_fitting/fetch_lp_candles.ts`, `analysis/bot_usage/discover_bot_accounts.ts`, `analysis/price_sources.ts`, `tests/test_trade_profitability.ts`).
+- **Fix(modules)**: correct runtime defects from a modules-wide audit — `accounting.ts` null-guards the fund-invariant baseline so a missing snapshot degrades safe instead of NaN-comparing; `credit_runtime.ts` resolves full accounts wrapper-first, unifies LP collateral-ratio math on `collateralValueInDebtAsset / borrowAmountFloat` across offer and maintenance paths, drops a stale `pendingRepayAmount` when reborrow policies change, requires all groups resolved before prune treats missing deals as closed, honors lowercase `TIMING.*` overrides for credit-deal expiry thresholds, and passes explicit null defaults at nullable numeric reads; `chain_orders.ts` sends the correctly-named `collateral_asset`/`collateral_amount` fields for `includeCreditDeals`, stops caching null resolutions in asset/order resolvers, scopes `listenForFills` prefetch to subscribed accounts, and fetches `get_full_accounts` once per cycle extracting the account id from `full[0][1]`; `dexbot_class.ts` single-flights shutdown flush through a promise holder so concurrent shutdown requests share one drain and awaits `fundRegistry.releaseAllocation` before exit; `dexbot_state_recovery.ts` keys batch abort on the live illegal-state signal (`consumeIllegalStateSignal()`) instead of an error code nothing emits, mirroring the maintenance-path recovery contract; `dexbot_startup_runtime.ts` runs credit-runtime maintenance on the trigger-reset branch like every other reset path; `graceful_shutdown.ts` bounds each cleanup handler at 10s (resolve-mode) instead of one global race that could starve later handlers; `settings_merge.ts` deep-merges EXPERT `GRID_LIMITS.GRID_COMPARISON` over the prior subtree so partial expert overrides keep untouched comparison keys and scalar overrides are ignored rather than char-spreading; `credential_policy.ts` merges policy layers per-op so partial `allowedOps` constraints no longer replace the builtin op map, and skips `__proto__`/`constructor`/`prototype` own-keys from JSON config (pollution-safe); `settings_merge.ts` `deepMerge` skips the same prototype-dangerous keys at every level so crafted config files cannot pollute `Object.prototype`; `fund_registry.ts` reloads the shared registry file on mtime change instead of serving stale cross-bot state and clamps collateral releases like buy/sell sides; `validate_profiles.ts` reports profile syntax errors as `ok:false` issues instead of crashing validation; `bot_settings.ts` shares one duplicate-bot-key detector between assert and collect paths (`modules/order/accounting.ts`, `modules/credit_runtime.ts`, `modules/chain_orders.ts`, `modules/dexbot_class.ts`, `modules/dexbot_state_recovery.ts`, `modules/dexbot_startup_runtime.ts`, `modules/graceful_shutdown.ts`, `modules/settings_merge.ts`, `modules/credential_policy.ts`, `modules/fund_registry.ts`, `modules/validate_profiles.ts`, `modules/bot_settings.ts`).
+- **Fix(orders)**: order-pipeline corrections — `format.ts` gives `toFiniteNumber` proper overload semantics so an explicit null default returns null for non-finite input (previously `undefined` triggered the default-0 overload and nullable call sites silently read 0), with sync_engine residual/drift chain reads converted to the null form and re-guarded; `logger.ts` CSV-quotes exported cells containing delimiters/quotes/newlines, captures fee data timestamps from the log line instead of wall clock, and closes the log-flush race; `processed_fill_store.ts` invokes the explicit flush immediately when configured; `async_lock.ts` makes forceRelease of an orphaned lock a no-op instead of throwing; `utils/order.ts` drops the always-equal gridIndex clause from ordersEqual (it masked real content differences) and rewrites initial-order activation as filter-then-select so underfunded candidates skip cleanly; `grid_reconcile_internal.ts` and `utils/validate.ts` add missing null guards on chain responses (`modules/order/format.ts`, `modules/order/sync_engine.ts`, `modules/order/logger.ts`, `modules/order/processed_fill_store.ts`, `modules/order/async_lock.ts`, `modules/order/utils/order.ts`, `modules/order/grid_reconcile_internal.ts`, `modules/order/utils/validate.ts`).
+- **Fix(launcher)**: launcher and native-client hardening — `process_discovery.ts` adds a pid-liveness fallback discovery (`runtime.kill(pid, 0)`, EPERM counts alive) for environments where tool-based discovery is unavailable; the market-adapter watchdog runs children with the scoped child-env builder; unreachable ESRCH catch branches are removed from bot_supervisor, monolithic_runtime and foreign_cred_daemon stop paths (a pid cannot be observed dead then reused before kill); `bitshares-native/resolvers.ts` invalidation completes alias invalidation and drops unused size getters; `node_manager.ts` updates health stats before the rate-limited early return; `socket_json_client.ts` contains synchronous throws inside request dispatch; `signing_client.ts` exposes an accountId getter used by credential flows; `tx/tx_cache.ts` excludes broadcast fees from cache keys so fee changes are not served stale results; `subscriptions.ts` removes dead open/closing subscription branches and resets history flags per batch; `storage/browser_adapter.ts` warns when degraded to in-memory mode; `storage/index.ts` header corrected (`modules/process_discovery.ts`, `modules/launcher/market_adapter_watchdog.ts`, `modules/launcher/*`, `modules/bitshares-native/resolvers.ts`, `modules/node_manager.ts`, `bitshares-native/socket_json_client.ts`, `bitshares-native/signing_client.ts`, `bitshares-native/tx/tx_cache.ts`, `bitshares-native/subscriptions.ts`, `modules/storage/*`).
+- **Chore(browser-boundary)**: align the browser-safe surface with reality — `package.json` browser-map exclusions added for `modules/runtime_settings.js`, all five Node-bound `bitshares-native` entry files (`transport`, `signing_client`, `subscriptions`, `tx/builder`, `tx/tx_cache`) and `market_adapter/utils/chain.js` (top-level `createRequire(import.meta.url)`); AGENTS.md Node-only list extended with the same files so convention docs match the bundler config (`package.json`, `AGENTS.md`).
+- **Refactor(dead-code)**: remove unreferenced symbols surfaced by the audit — `constants.ts` prunes the ECC mirror block, unused timing/network constants (`SUBSCRIPTION_SILENT_THRESHOLD_MS`, `STARTUP_CONNECT_TIMEOUT_MS`, `MAX_TRANSACTION_SIZE`, `MAX_TIME_UNTIL_EXPIRATION`, `PERCENT_1`) and the supervisor `MAX_MEMORY_MB` fallback, and aligns OBJECT_TYPES with the BitShares enum (`CUSTOM_AUTHORITY` 17 … `CREDIT_DEAL` 22) adding the credit-offer/deal object types used by credit flows; `cr_planner.ts` drops the legacy CR-formula exports (`planCrAdjustment`, collateral/debt target helpers) while keeping `calculateCollateralRatio` internal; `credit_runtime.ts` removes the test-only `openCreditPosition`/`getCollateralOffsets` wrappers (renewOnly coverage retargeted to `buildCreditOfferAcceptOperation`); `key_store.ts` removes the unused `DirectKeyStore`; `crypto/index.ts` drops dead pure-primitive re-exports; `dexbot_fill_runtime.ts` collapses tautological FILL_PROCESSING.MODE comparisons (history processing unconditional, open-orders fallback gated solely on `requiresOpenOrdersSync`); `bots_file_lock.ts` fixes the writeJsonFileAtomic doc drift (`modules/constants.ts`, `modules/cr_planner.ts`, `modules/credit_runtime.ts`, `modules/key_store.ts`, `modules/crypto/index.ts`, `modules/dexbot_fill_runtime.ts`, `modules/bots_file_lock.ts`).
+- **Test**: add regression coverage for the trickier audit fixes — `test_to_finite_number_null.ts` locks the nullable-read semantics, `test_credential_policy_layer_merge.ts` covers per-op allowedOps merging plus `__proto__` rejection, settings-merge tests cover EXPERT GRID_COMPARISON preservation and scalar-override immunity plus deep-merge `__proto__` pollution rejection at nested levels, and the fill-batch suite asserts a deferred fill restores the exact pre-call `_fillBatchInFlight` count so concurrent batches cannot zero each other's guard; fixtures updated for the removed `getSizingContext` wrapper and the signal-based abort path (`tests/test_to_finite_number_null.ts`, `tests/test_credential_policy_layer_merge.ts`, `tests/test_settings_merge.ts`, `tests/test_sync_fill_history_batch.ts`, `tests/*`).
+- **Tune**: raise the AMA slope ceiling default 0.085 → 0.09 and narrow the research slider floor 0.04 → 0.06 — de-sensitizes the AMA trend channel by ~5.6% (factor 0.85/0.9) so grid range-scaling asymmetry, grid price offset, and buy/sell weight tilt react proportionally weaker to the same slope magnitude; applied asymmetry at the current XRP-BTS slope drops ~21.25% → ~20.1% and the AMA-slope grid-reset trigger threshold rises 0.0068 → 0.0072 %/bar; behavior unchanged at |slopePct| ≥ 0.09 (identical saturation cap), research chart paste payloads with amaS% in [0.04, 0.06) clamp up to 0.06 (`modules/constants.ts`, `analysis/trend_detection/dynamic_weight_chart_generator.ts`, `analysis/trend_detection/DYNAMIC_WEIGHT_RESEARCH.md`).
+- **Fix(market-adapter)**: harden locking, signal math, and input tools from a full module review — Hurst buffer cap window+2 → window+1 so the newest candle is always included with shared `classifyHurst()` and a `HURST_STRENGTH_NORMALIZER` strength scale; ATR re-warms per chain segment so a bad candle no longer leaks pre-break values across the gap; dynamic-weight/slope dead-band boundaries inclusive on both sides with exact-zero slopes staying NEUTRAL at the default `neutralZonePct` of 0; permutation entropy validates m/delay/window against `PE_ANALYZER_LIMITS` at construction instead of running degenerate configs silently; Kalman filter defaults unified through a single `_initState()` with beams returned as a copy and null-safe displacement; a malformed custom regimeTable throws at construction instead of producing silent NaN multipliers. File locks gain an ownership token (fresh UUID per holder written into every payload; release only unlinks when the token still matches) so a stolen lock can no longer be deleted by its previous holder, including pid collisions across containers sharing a mounted volume — legacy token-less payloads stay releasable; partial acquisitions clean up their orphaned lock file instead of locking out later contenders, heartbeat derives as clamp(staleMs/2, 1s..30s) so it always fires inside the staleness window, and the holder heuristic recognizes dexbot-embedded adapters while anchoring entrypoint names to argv/path boundaries so unrelated scripts such as robot.js no longer match. Service wiring clamps clipPercentile to (0,100] at the read point, normalizes volatility exponent/scaleX to their effective ranges at the single configured point, derives amaSlopeGated/amaChannelContribution diagnostics from the canonical Kalman-disabled weight series so diagnostics agree with finalOffset whenever gating is active, records `triggerSuppressedReason=stale_candle_data` for stale-but-new cycles, and config normalizers treat null/empty as unset before `Number()` coercion so explicit JSON null no longer means "disabled". Input tools: fetch_lp_data completes the interval map (30m..7d) with loud validation instead of parsing "30m" as 30 seconds, adds linear retry backoff and honest range labels in --start/--end mode; fetch_cex_synthetic_data fixes the dead HTX endpoint (/market/history/kline), honors exchange page caps via `CEX_PAGE_LIMIT_CAPS`, corrects MEXC intervals (6h/12h/1W), rejects zero-price leg candles, and handles --help before bot resolution. Constants: new keys centralized (`FILE_LOCK_HEARTBEAT_MIN/MAX_MS`, `LP_FETCH_RETRY_BACKOFF_BASE_MS`, `CEX_PAGE_LIMIT_CAPS`, `PE_ANALYZER_LIMITS`, `HURST_STRENGTH_NORMALIZER`, `DYNAMIC_WEIGHT_KALMAN_WARMUP_BARS_DEFAULT`, `DYNAMIC_WEIGHT_KALMAN_BEAM_COUNT_DEFAULT`, `DYNAMIC_WEIGHT_VOLATILITY_EXPONENT/SCALE_X_MIN/MAX`), sourceRetries default 3 → 4; misc: kibana_client releases redirect bodies, data_discovery skips unreadable entries and dangling symlinks, asymmetric_bounds/collateral_manager share previously duplicated math, analysis/bot_key_utils delegates to the production createBotKey so unnamed bots resolve identical keys, vestigial exports removed, and 'use strict' hoisted above imports across ~90 files where it sat as a no-op (`market_adapter/**`, `modules/constants.ts`, `analysis/bot_key_utils.ts`).
+
+### 2026-08-25
+
+- **Fix(grid)**: route root-level range scaling through canonical asymmetric bounds — the `initializeGrid` root-fallback hand-rolled the DOWN/UP scaling formulas instead of calling `applyAsymmetricBounds`, dropping its geometric safe-clamp: a persisted `appliedAsymmetryFactor` clamped at adapter time against AMA-centered geometry was applied to gridCenter-centered rebuild geometry, so an over-limit factor could distort the widened side and diverge from UI display. The fallback now feeds the persisted factor back through `applyAsymmetricBounds` with neutral caps (keeping the safe-clamp active against rebuild geometry), and the dynamicWeights path prefers rawSlopeOffset over the 2dp-rounded value matching the market adapter service; regression test covers a persisted DOWN factor 0.6 against '2x' bounds (safe limit 0.5) being clamped to 0.5 with correct widened min (`modules/order/grid.ts`, `tests/test_grid_logic.ts`).
+- **Feat(build)**: remove the tsx dependency entirely — every entry point and the full test suite now executes from compiled `dist/` under plain node, making test execution identical to production execution. New `tsconfig.tests.json` compiles tests/ to dist/tests/ with package markers and ESM mock hook files copied in; frozen-ESM-safe production seams replace export patching (`setDerivePriceTestHook`, `_setFeeCache`, bot-level `_submitCancelOrder`/`_syncMarketAdapterHook`/`_readOpenOrdersHook`/`_gridModule`/`_listenForFillsHook`, all no-ops when unset); loader-hook based cross-process ESM mocking lands in `tests/helpers/esm_mocks.ts`; run-tests gains a 240s per-test watchdog; `clean-dist.js` deletes stale tsbuildinfo caches that made tsc emit nothing after clean; ~60 tests converted off tsx-era patterns and the lockfile sheds 78 orphaned @esbuild/* platform packages. Full suite 237/237 green (`package.json`, `tsconfig.tests.json`, `tests/helpers/*`, `scripts/clean-dist.js`, modules seam sites).
+- **Fix(market-adapter)**: code-health sweep and exact AMA bootstrap sizing — persisted adapter state is normalized once at processBot entry, explicit-null meta timestamps are guarded before `Number()` (null masqueraded as epoch 1970), kibana client promises settle once (no timeout+error double rejection), unparseable lock-holder pids are treated as alive, and dead helpers are dropped; the one-shot cold-start Kibana bootstrap now requests exactly rawKeepCount × interval hours instead of the old max() heuristic — sub-hourly bots no longer over-fetch ~4x+ and >1h intervals were previously under-fetching; shared browser-safe `usesAmaGridPrice()` extracted to `modules/grid_price_source.ts` (previously duplicated as regexes in two modules); fetch_lp_data probe output now describes the window actually queried and unknown ama_signal_runner CLI args throw instead of being ignored (`market_adapter/*`, `modules/grid_price_source.ts`).
+- **Fix(analysis)**: align research tools with production AMA slope and range-scaling — `computeAmaSlopeClipThreshold` moves to the import-free `ama_slope_model.ts` as the single source of truth (plus an incremental `createAmaSlopeClipTracker` with identical thresholds via binary insertion), analyze_dynamic_weight uses prefix-only clip pools so research reproduces live asymmetry without look-ahead, the analyze_kalman comparison panel feeds production constants instead of hardcoded drift values (72-bar lookback, MAX_SLOPE_PCT=3.0, NEUTRAL_ZONE=0.15), dynamic_weight_chart_generator drops its hand-copied clip loop for the injected canonical function, and scripts/analyze-orders delegates asymmetric-bounds math to canonical `applyAsymmetricBounds` so displayed bounds stay in lockstep with live grid scaling (`market_adapter/core/strategies/ama_slope_model.ts`, `analysis/*`, `scripts/analyze-orders.ts`).
+- **Docs**: refresh reference documentation against the v1.4.21 codebase — all 15 doc files re-verified against source before editing: stale API references fixed (SPREAD_LIMITS → `GRID_LIMITS.MIN_SPREAD_ORDERS`; validateIndices/_repairIndices snippets → `_gridVersion` cache invalidation + `assertOrdersStructurallySound()`; rebalanceSideRobust fund validation → `validateOperationFunds()`; `_reconcileGridCOW` → `WorkingGrid.buildDelta()`; periodic refresh rewritten around the real `setupBlockchainFetchInterval()` flow; LendingEntryBase → DebtFirstCrPlanOptions; offer cache TTL corrected to 10 minutes; dead BotLoggingOverrides ref → actual runtime_settings merge wiring); ~24 GRID_RECONCILE.md line anchors plus LIFECYCLE/COW_INVARIANTS/FUND_MOVEMENT_AND_ACCOUNTING function anchors re-verified; legacy narrative removed (vault-migration section and masterPasswordHash row dropped from CREDENTIAL_SECURITY.md, FUND_MOVEMENT_AND_ACCOUNTING fix anecdotes rewritten as present-tense rules, archival appendixes trimmed in GRID_RECALCULATION.md/COPY_ON_WRITE_MASTER_PLAN.md/architecture.md); statistics and version context synced (252 test files, v1.4.21). Docs-only change, no runtime code touched (`docs/*`).
+- **Feat(analysis)**: clickable report path in the order-analysis export output — the --export HTML report lives in analysis/charts/ since output-dir centralization, but the console printed a bare absolute path terminals render as plain text; analyze-orders now wraps it in an OSC 8 hyperlink targeting the file:// URL when stdout is a TTY, falling back to the plain file:// URL for pipes and logs (visible label stays the absolute path so copy-paste works even without OSC 8 support), and README corrects the stale claim that --export writes to the repo root (`scripts/analyze-orders.ts`, `README.md`).
+- **Fix(scripts)**: repair native release gates and stale tsx-era docs after the dist migration — `native_release_gates.ts` used bare `__dirname`, undefined in compiled ESM, crashing every run with ReferenceError (now derived via `fileURLToPath(import.meta.url)`); the native:serial-snapshots / native:ecc-invariants / native:release-gates scripts invoked `dist/tests/*.js` after only `npm run build`, which excludes tests/, so all three failed on a fresh build (they now chain `npm run build:tests` matching the npm test order); runner.ts usage docs and scripts/README.md converted off tsx-era invocation examples — the wrapper table points at the dist shims the wrappers actually run, build/test rows describe the compiled flow, and a Native Release Gates section documents the native:* scripts plus the corpus report requirement (passed=true, transactionCount≥50) (`scripts/native_release_gates.ts`, `package.json`, `scripts/runner.ts`, `scripts/README.md`).
+
+
+## [1.4.21] - 2026-08-24 - Runtime Audit Fixes, Claw Dedup Hardening, Boundary Ceiling Alignment, Editor Color Feedback
+
+### 2026-08-23
+
+- **Feat(ui)**: red/green highlight for botFunds percentage inputs — extend the price-multiplier live color feedback to the Funding section of the account bots editor: percentage allocations ("100%") render green while fixed absolute amounts render red, matching the existing min/maxPrice multiplier treatment. New `isPercentageString`/`colorPercentageInput` helpers mirror `isMultiplierString`/`colorMultiplierInput` (the local percentage check is stricter than `order/utils/math.ts` so partial input like "x%" never flashes green mid-typing); `askNumberOrPercentage` colors its default suffix and wires the `readInput` colorize option, and the Funding summary line renders Sell/Buy values through the same colorizer (`modules/account_bots.ts`).
+
+### 2026-08-24
+
+- **Fix**: correct runtime defects found in a modules-wide audit — silent-failure and initialization-order defects could disable safety checks, defeat batching, or poison configuration at load time: `accounting.ts` falls back to `GRID_LIMITS.FUND_INVARIANT_PERCENT_TOLERANCE` when unset (undefined/100 produced NaN and silently disabled the fund invariant); `processed_fill_store.ts` flushes on batch size only when configured (previous `?? 0` comparison made `size >= 0` always true, flushing every write); `sync_engine.ts` tracks per-invocation `fillGuardLowered` so inner and outer finally blocks cannot double-decrement the shared `_fillBatchInFlight` counter under concurrent batches; `bitshares_client.ts` applies the configured node list even when node management is disabled, races node refresh against the remaining wait budget so it cannot overshoot the connection timeout, preserves `lastConnectionError` across disconnects, and reuses the shared `withTimeout` util; `config.ts` `num()` returns the default on empty or non-finite values instead of 0/NaN; `settings_merge.ts` keeps the base value when a raw override for an object section is not an object instead of spreading char-indexed garbage; `fund_registry.ts` clamps `totalAllocatedPct` at zero in `releaseAllocation` and logs loudly before resetting a corrupt registry file; `account_orders.ts` warns on corrupt profile files before falling back to empty state; `credential_policy.ts` uses `Object.hasOwn` for the allowedOps lookup; `dexbot_state_recovery.ts` normalizes stale-id input through a Set; `runtime_settings.ts` warns with bot-name context when market-adapter override resolution fails (`modules/order/accounting.ts`, `modules/order/processed_fill_store.ts`, `modules/order/sync_engine.ts`, `modules/bitshares_client.ts`, `modules/config.ts`, `modules/settings_merge.ts`, `modules/fund_registry.ts`, `modules/account_orders.ts`, `modules/credential_policy.ts`, `modules/dexbot_state_recovery.ts`, `modules/runtime_settings.ts`).
+- **Fix(grid)**: align boundary writers and add a sell-rail ceiling to the commit gate — `deriveTargetBoundary` clamped to length−1 while `calculateFundDrivenBoundary` clamped to N−gapSlots−1, so fill-driven updates could walk the boundary onto or past the SELL rail where `resolveGapBand` re-derives zero-SELL geometry permanently on every cycle. `deriveTargetBoundary` now caps at N−gapSlots−1 matching the fund-driven writer (degenerate geometries fall back to the legacy ceiling preserving the current boundary); `validateBoundaryCommit` rejects proposals past the shared writer ceiling with stable reason `sell_rail_ceiling_exceeded`; `validatePersistedBoundary` inherits the rule so loadGrid restore and `recoverFromPersistedGrid` refuse past-ceiling snapshots and fall through to clean rebuild — legacy persisted snapshots whose boundary sits past the ceiling now trigger the documented rebuild path instead of silently re-legalizing broken geometry (`modules/order/utils/order.ts`, `modules/order/utils/math.ts`, `tests/test_boundary_restore_validation.ts`).
+- **Refactor(claw)**: dedupe shared logic, remove dead code, harden error paths — bug fixes: `position_manager` guards `syncPosition` against unresolved MPA assets and persists close events before the catch-guarded sync; `dexbot_profiles` fixes spread order in `normalizeBotEntries` so active coercion actually applies; `chain_actions.listenForFills` awaits the subscribe promise before registering callbacks so failures surface as errors instead of unhandled rejections; `memu_mcp_server` redacts malformed `--llm-profile`/`--db-config` values in parse errors (secret leak); `claw_launcher.spawnDetached()` waits one macrotask for async spawn errors instead of returning false `started:true`; `mcp_utils` treats stdin EPIPE/EIO as EOF rather than crashing mid-session and maps tools/list catalog failures to −32603; `decision_loop.resetAnalyzers` clears marketPremiums; honest-ecosystem logs live pool-reserve fetch failures and returns null for unhonorable pinned poolRefs; `position_discovery` actually resolves asset triples in parallel; `memu_bridge` adds an EPIPE guard and the openclaw plugin returns isError results. Deduplication: shared `createJsonRpcToolsHandler()`/`jsonRpcError()`, single `validateMemuCommandArgs()` spec, extracted `viaCredentialDaemon()` broadcast path, unified `computeCallOrderAmounts()` call-order math; ~25 unused exports removed across profiles/infra/launcher/ecosystem/bridge modules plus the orphan `claw/openclaw.plugin.json` stale copy (`claw/modules/*`, `claw/scripts/memu_mcp_server.ts`, `claw/openclaw.plugin.json`).
+- **Fix(launcher)**: supervisor and runtime lifecycle corrections — `bot_supervisor.ts` enforces memory limits only for apps that define one (the previous global fallback restarted unlimited apps at MAX_MEMORY_MB) and the status banner prints real per-app limits; `foreign_cred_daemon.ts` SIGKILL path polls liveness until timeout like SIGTERM instead of a single immediate check that could race process exit; `monolithic_runtime.ts` resolves the updater close promise on spawn error (ENOENT left it pending forever and hung the update flow); `market_adapter_runtime.ts` simplifies `isLockStale` to pid-liveness semantics (the mtime branch was unreachable dead logic) (`modules/launcher/bot_supervisor.ts`, `modules/launcher/foreign_cred_daemon.ts`, `modules/launcher/monolithic_runtime.ts`, `modules/launcher/market_adapter_runtime.ts`).
+- **Fix(storage)**: persist deletions, debounce flushes, guard ingest in the browser adapter — deleted files resurrected after reload because unlink never reached IndexedDB; writes required a manual flush call to persist at all; records mutated before the startup load cursor reached them were clobbered by stale IndexedDB state. Deletions are now tracked as tombstones replayed as IndexedDB deletes on flush (cleared only after a successful transaction, so failed flushes replay deletes on the next cycle), mutations schedule a debounced 500ms flush, and the initial load skips tombstoned and locally-mutated keys so pre-load unlinks and writes win over stored records (`modules/storage/browser_adapter.ts`).
+- **Fix(paths)**: stop hardcoding repo-relative `profiles/*` paths in docs and user-facing messages — docs and runtime/error strings still referenced the legacy repo-relative `profiles/logs`, `profiles/bots.json`, and `profiles/keys.json` locations after state resolution moved to the PATHS resolver in v1.4.15/1.4.16, landing npm-install users on paths that do not exist. BITSHARES_ONBOARDING.md rewrites "Where are the logs?" with the resolver-aware location and completes the log-file table (dexbot-cred.log, dexbot-adapter/-error.log, market_adapter.log, dexbot-update/-error.log were undocumented); WORKFLOW.md and scripts/README.md rows corrected; key-vault/bots-not-found/watchdog/update/analyze error messages now print resolver-derived paths; CLI help documents the `<profiles>` resolution rule. No behavioral change: all file I/O already routed through the resolver (`docs/BITSHARES_ONBOARDING.md`, `docs/WORKFLOW.md`, `scripts/README.md`, `credential-daemon.ts`, `modules/chain_keys.ts`, `pm2.ts`, `bot.ts`, `claw/modules/claw_launcher.ts`, `modules/dexbot_class.ts`, `scripts/update.ts`, `dexbot.ts`).
+- **Feat(ui)**: live green/red highlighting for price inputs in the bot editor — extends the bot-editor color feedback to the remaining price fields: startPrice and gridPrice inputs colorize live (green for dynamic sources "pool"/"book"/AMA keywords, red for fixed numeric anchors); null gridPrice resolves through startPrice so the default label inherits the matching color; Active/DryRun flags render green in their healthy state; targetSpreadPercent prompt rounds minimum/validation/input display to 2 decimals instead of surfacing 6-decimal floats (`modules/account_bots.ts`).
+- **Fix(client)**: skip disconnect teardown when the client was never initialized — `disconnectClient()` called `ensureInitialized()`, which lazily built the whole client stack (including the node-config log) just to discard it immediately, e.g. running `dexbot bot` after an idle bot-manager session; it now returns early when not initialized (`modules/bitshares_client.ts`).
+- **Refactor(orders)**: remove the sub-unit price nudge from `buildUpdateOrderOp` — sub-unit price changes that round to the same `min_to_receive` were nudged by one unit to force an update operation; dust orders are cancelled rather than updated now, so the nudge only produced churn broadcasts with no economic effect and masked genuine no-op skips. Unchanged rounded amount+price is treated as no-op returning null; callers count the skip and restore affected slots via `restoreSkippedUpdateSlotsInWorkingGrid` (`modules/chain_orders.ts`).
+- **Refactor**: remove dead code and consolidate duplicated helpers across analysis/market_adapter — delete `market_adapter/merge_lp_data.ts` and `market_adapter/utils/paths.ts` (no importers); prune ~180 lines of unused query builders/wrappers from `analysis/bot_usage/kibana_bot_queries.ts`; un-export zero-consumer symbols (kibana_client INDEX/KIBANA_URL, `normalizeAmaSlopeLookbackBars`, `loadStrategiesFromResults`, kibanaSearch/bilinearInterpolate re-exports, candle high/low/ATR re-exports, internal CSS fragments, `toCandles`); add `modules/utils/sanitize_key.ts` as the single sanitizeKey source; make the candleFileForBot filename template canonical in `analysis/bot_key_utils.ts` eliminating three-way filename drift; fix stale tsx invocation comments to node dist/ paths (`market_adapter/*`, `analysis/*`, `modules/utils/sanitize_key.ts`).
+- **Chore(logging)**: remove dead state-change history and stale docs — logger_state changeHistory/maxHistory fields were written but never read anywhere; drop them plus the phantom audit-trail doc section and the now-unused `GRID_LIMITS.STATE_CHANGE_HISTORY_MAX`; console fund-status output keeps ANSI colors while the file drain strips them as before (`modules/order/logger_state.ts`, `modules/constants.ts`, `modules/order/logger.ts`).
+- **Refactor(ui)**: centralize bot editor ANSI colors into a shared palette — the account-bots editor scattered raw ANSI escape sequences across ~40 lines; a module-level COLORS palette (13 named entries) now routes all ~152 highlight usages, input/error/OFF highlights use bold red matching the Pair line, rendering stays byte-identical for all other colors (`modules/account_bots.ts`).
+- **Docs**: sync tuning guidance between the root README and the BitShares onboarding tutorial — README adds weightDistribution as optional setup step 3 (super-valley..super-mountain legend vocabulary), anchors steps 1–2 on the cycle-profit formula spread − increment − fees and the increment speed/fee tradeoff, documents ama1–ama4 presets in the gridPrice row, and adds a "prefer relative values" callout with editor green/red hints; BITSHARES_ONBOARDING.md mirrors the relative-values guidance, expands its tuning list to match, and fixes the broken prerequisite anchor link (`README.md`, `docs/BITSHARES_ONBOARDING.md`).
+- **Test**: mute intentional failure-path logs in negative-path fixtures — the run diagnostics listed scary FAILED lines that were assertion-passing fixtures exercising failure branches, making real regressions harder to spot; `test_orphan_fill_death_spiral.ts` filters its two expected underfunding warnings and `test_patch17_invariants.ts` mutes expected COW/persist ERROR logs with restore-on-finally semantics; production log wording untouched (`tests/test_orphan_fill_death_spiral.ts`, `tests/test_patch17_invariants.ts`).
+
 ## [1.4.20] - 2026-08-23 - Grid Boundary Hardening, Recovery Poison Gate, Analysis Path Centralization
 
 ### 2026-08-22

package/README.md

@@ -147,18 +147,26 @@ Both installs use the same CLI and store all user state — keys, `bots.json`, l
 
 Keep the default settings first, and tune these:
 
-1. **Tune `targetSpreadPercent`** — controls profit room per completed cycle. A
-   wider spread targets more profit per cycle but trades less often.
+1. **Tune `targetSpreadPercent`** — controls profit room per completed cycle:
+   profit ≈ `spread - increment - fees`. A wider spread targets more profit per
+   cycle but trades less often.
 
-2. **Tune `incrementPercent`** — controls grid density and order size. Smaller
+2. **Tune `incrementPercent`** — controls order steps and order size. Smaller
    increments create more grid levels and smaller orders; larger increments
-   create fewer levels and larger orders.
+   create fewer levels and larger orders. Smaller increments cycle faster —
+   higher profits, but more fees.
 
-3. **Set `gridPrice` to `"ama"`** — so the market adapter can center the grid
+3. **Tune `weightDistribution`** (optional) — per-side sizing control. Higher
+   weight = more funds in orders near the market price; lower weight = funds
+   shifted toward the grid edge. Range `-1` (super-valley) to `2`
+   (super-mountain); the default `{ "sell": 1.0, "buy": 1.0 }` suits most
+   setups.
+
+4. **Set `gridPrice` to `"ama"`** — so the market adapter can center the grid
    on AMA. Pick a specific preset if desired: `"ama1"` is the fastest,
    `"ama4"` the slowest, and `"ama"` uses the pair's default preset.
 
-4. **Generate the market-adapter whitelist:**
+5. **Generate the market-adapter whitelist:**
 
    ```bash
    dexbot white
@@ -168,9 +176,9 @@ Keep the default settings first, and tune these:
    live writes and range scaling. Use `dexbot white --dynamic-weight` for
    newly generated dynamic-weight entries; existing entries are preserved.
 
-5. **Start DEXBot2** with `dexbot start`.
+6. **Start DEXBot2** with `dexbot start`.
 
-6. **Tune `minPrice` / `maxPrice`** around the market's volatility range. Once
+7. **Tune `minPrice` / `maxPrice`** around the market's volatility range. Once
    AMA is active, tighten them around the maximum expected market volatility
    instead of using an unnecessarily wide range.
 
@@ -178,6 +186,8 @@ Keep the default settings first, and tune these:
 
 Configuration options from `dexbot bot`, stored in `bots.json` in the profiles directory:
 
+> **Prefer relative values** — use dynamic price sources where available: `"pool"` (liquidity-pool price) or `"book"` (order-book mid) for `startPrice`, `"ama"` for `gridPrice`, `"2x"`-style multipliers for `minPrice` / `maxPrice`, and `"100%"`-style percentages for funds (`botFunds`). Relative values rescale automatically as the market moves; fixed numbers do not. The bot editor highlights these inputs live: **green** = relative/dynamic (recommended), **red** = fixed absolute value.
+
 <details><summary><mark>Full parameter reference (click to expand)</mark></summary>
 
 | Parameter | Type | Description |
@@ -192,10 +202,10 @@ Configuration options from `dexbot bot`, stored in `bots.json` in the profiles d
 | **`poolRef`** | string \| null | Optional pinned pool ID for `startPrice: "pool"`. Overrides pool discovery with a direct fetch (e.g. `"1.19.48"` or `"48"`). Useful when the trading pair has no native pool. Default `null`. |
 | **`minPrice`** | num \| str | Lower bound. Default `"2x"` means `gridPrice / 2` when AMA is active, otherwise `startPrice / 2`. |
 | **`maxPrice`** | num \| str | Upper bound. Default `"2x"` means `gridPrice * 2` when AMA is active, otherwise `startPrice * 2`. |
-| **`gridPrice`** | num \| str \| null | Grid reference. Use `"ama"` for the recommended AMA center; `null` falls back to `startPrice`; numeric values use that fixed value. |
-| **`incrementPercent`** | number | Geometric step between layers. Default `0.5` = 0.5%. |
-| **`targetSpreadPercent`** | number | Width of the empty spread zone between buy and sell orders. Default `2` = 2%. |
-| **`weightDistribution`** | object | Advanced sizing control. Default `{ "sell": 1.0, "buy": 1.0 }`; leave unchanged for normal setup. |
+| **`gridPrice`** | num \| str \| null | Grid reference. Use `"ama"` for the recommended AMA center (`"ama"` picks the pair's default preset; `"ama1"`–`"ama4"` pin fastest to slowest); `null` falls back to `startPrice`; numeric values use that fixed value. |
+| **`incrementPercent`** | number | Geometric step between orders. Default `0.5` = 0.5%. |
+| **`targetSpreadPercent`** | number | Width of the empty spread zone between buy and sell orders. Default `2` = 2%. Profit per completed cycle ≈ `spread - increment - fees`. |
+| **`weightDistribution`** | object | Advanced sizing control per side. Range `-1` to `2`: `-1` = super-valley, `0` = valley, `0.5` = neutral, `1` = mountain (default), `2` = super-mountain. Higher weight = more funds in orders near the market price; lower weight = more funds shifted toward the grid edge. Default `{ "sell": 1.0, "buy": 1.0 }`; leave unchanged for normal setup. |
 | **`botFunds`** | object | Capital: `{ "sell": "100%", "buy": 1000 }`. Numbers or percentage strings |
 | **`activeOrders`** | object | Target active orders per side: `{ "sell": 20, "buy": 20 }` |
 
@@ -245,7 +255,7 @@ dexbot enable {all|<bot>}  # Enable bot in config
 
 dexbot stat                # Runtime status (unlock or PM2)
 dexbot order [<bot>]       # Analyze order grids
-dexbot order --export      # Export as HTML to root folder
+dexbot order --export      # Export as HTML to analysis/charts/
 
 dexbot update              # Update DEXBot2
 dexbot clear               # Clear log files

package/analysis/ama_fitting/analyze_ama_price_changes.ts

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
+'use strict';
 import path from 'node:path';
 import { calculateAMA } from '../../market_adapter/core/strategies/ama.js';
 import { getStorage } from '../../modules/storage/index.js';
 const { readJSON } = getStorage();
+import { normalizeCandle } from '../math_utils.js';
 import { MARKET_ADAPTER } from '../../modules/constants.js';
 
-'use strict';
 /**
  * AMA REPOSITION FREQUENCY ANALYSIS
  *
@@ -16,7 +17,7 @@ import { MARKET_ADAPTER } from '../../modules/constants.js';
  * (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>
+ *   node dist/analysis/ama_fitting/analyze_ama_price_changes.js --data <path-to-lp-candles.json> --results <path-to-optimization-results.json>
  */
 const REPOS_THRESHOLD_PCT = MARKET_ADAPTER.AMA_DELTA_THRESHOLD_PERCENT;
 
@@ -55,7 +56,10 @@ function loadData(filePath: any) {
     const json    = readJSON(filePath);
     const candles = json.candles ?? json;
     return {
-        candles: candles.map((c: any) => ({ timestamp: c[0], close: c[4] })),
+        candles: candles
+            .map((c: any) => normalizeCandle(c))
+            .filter(Boolean)
+            .map((c: any) => ({ timestamp: c.time * 1000, close: c.close })),
         meta: json.meta ?? null,
     };
 }

package/analysis/ama_fitting/analyze_lambda_vs_slow.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+'use strict';
 
 import fs from 'node:fs';
 import path from 'node:path';
@@ -9,7 +10,6 @@ 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
@@ -27,7 +27,7 @@ import { getErrorMessage } from '../../modules/utils/errors.js';
  * Defaults: ER/Fast from MARKET_ADAPTER.AMAS.AMA1 (constants.ts).
  *
  * Usage:
- *   tsx analysis/ama_fitting/analyze_lambda_vs_slow.ts \
+ *   node dist/analysis/ama_fitting/analyze_lambda_vs_slow.js \
  *     --data market_adapter/data/lp/1_3_5537_1_3_0/lp_pool_133_1h_3y.json \
  *     --maxSlow 1000 --lambdaEnd 0.0045 --lambdaSteps 50
  */
@@ -81,7 +81,7 @@ Lambda vs Slow Analysis
   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]
+  node dist/analysis/ama_fitting/analyze_lambda_vs_slow.js --data <lp-file.json> [options]
 
 Options:
   --data FILE          LP candle JSON file (required)

package/analysis/ama_fitting/calibrate_convergence_er.ts

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
+'use strict';
 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';
+import { getCandleClose } from '../math_utils.js';
 
-'use strict';
 /**
  * AMA CONVERGENCE ER CALIBRATION
  *
@@ -22,9 +23,9 @@ import { roundTo } from '../../modules/order/utils/math.js';
  * 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
+ *   node dist/analysis/ama_fitting/calibrate_convergence_er.js
+ *   node dist/analysis/ama_fitting/calibrate_convergence_er.js --data <lp-file.json>
+ *   node dist/analysis/ama_fitting/calibrate_convergence_er.js --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');
@@ -84,7 +85,7 @@ function main() {
         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');
+            console.error('  node dist/market_adapter/inputs/fetch_lp_data.js --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);
@@ -93,7 +94,8 @@ function main() {
         }
         process.exit(1);
     }
-    const closes = (data.candles || []).map((c: any) => Number(c[4]))
+    // Canonical candle accessor (handles array rows and object candles alike).
+    const closes = (data.candles || []).map((c: any) => Number(getCandleClose(c)))
         .filter((v: any) => Number.isFinite(v) && v > 0);
     if (closes.length < 100) {
         console.error(`Not enough candles (need > 100, got ${closes.length})`);

package/analysis/ama_fitting/fetch_lp_candles.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+'use strict';
 import fs from 'node:fs';
 import path from 'node:path';
 import { normalizePoolId } from '../../market_adapter/utils/chain.js';
@@ -10,7 +11,6 @@ import { getStorage } from '../../modules/storage/index.js';
 const { ensureDir, writeJSON } = getStorage();
 import { getErrorMessage } from '../../modules/utils/errors.js';
 
-'use strict';
 /**
  * Fetch LP pool candles from Kibana for AMA optimizer input.
  *
@@ -18,7 +18,7 @@ import { getErrorMessage } from '../../modules/utils/errors.js';
  * the full uncut dataset (no pruning) for optimizer use.
  *
  * Usage:
- *   tsx analysis/ama_fitting/fetch_lp_candles.ts \
+ *   node dist/analysis/ama_fitting/fetch_lp_candles.js \
  *     --pool 1.19.133 \
  *     --assetA IOB.XRP --assetAId 1.3.3926 --assetAPrecision 4 \
  *     --assetB BTS     --assetBId 1.3.0    --assetBPrecision 5 \
@@ -91,7 +91,7 @@ function printHelp() {
     console.log('fetch_lp_candles.ts — fetch LP pool candles from Kibana for AMA optimizer');
     console.log('');
     console.log('Usage:');
-    console.log('  tsx fetch_lp_candles.ts --pool 1.19.133 \\');
+    console.log('  node dist/analysis/ama_fitting/fetch_lp_candles.js --pool 1.19.133 \\');
     console.log('    --assetA IOB.XRP --assetAId 1.3.3926 --assetAPrecision 4 \\');
     console.log('    --assetB BTS     --assetBId 1.3.0    --assetBPrecision 5');
     console.log('');
@@ -114,6 +114,11 @@ function validateArgs(args: Record<string, any>) {
     if (!args.assetBId)        throw new Error('--assetBId is required');
     if (!Number.isFinite(args.assetBPrecision)) throw new Error('--assetBPrecision is required');
     if (!Number.isFinite(args.hours) || args.hours <= 0) throw new Error('--hours must be > 0');
+    // Reject unknown/NaN intervals here instead of letting NaN flow silently
+    // into Kibana range queries (production throws on unsupported intervals).
+    if (!Number.isFinite(args.intervalSeconds) || args.intervalSeconds <= 0) {
+        throw new Error('Unsupported --interval: use one of 1m, 5m, 15m, 1h, 4h, 1d or a positive number of seconds');
+    }
 }
 async function main() {
     const args = parseArgs();

package/analysis/ama_fitting/generate_unified_comparison_chart.ts

@@ -1,16 +1,18 @@
+'use strict';
 
 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 { generateHTML } from '../../market_adapter/lp_chart_core.js';
+import { calculateMetrics } from '../../market_adapter/lp_chart_runner.js';
+import { findLatestLpData } from '../../market_adapter/utils/data_discovery.js';
 import { toIntervalLabel } from '../../market_adapter/interval_utils.js';
-import { loadCandleFile } from '../math_utils.js';
+import { loadCandleFile, normalizeCandle } from '../math_utils.js';
 import { MARKET_ADAPTER } from '../../modules/constants.js';
 import { getStorage } from '../../modules/storage/index.js';
 const { ensureDir } = getStorage();
 import { PATHS } from '../../modules/paths.js';
-'use strict';
 
 /**
  * UNIFIED COMPARISON CHART GENERATOR — Self-contained analysis chart
@@ -19,18 +21,20 @@ import { PATHS } from '../../modules/paths.js';
  * or {data: [...]}), computes AMA series, and writes an interactive HTML chart
  * via the shared lp_chart_core renderer.
  *
- * No Kibana fetch, no market_adapter runtime deps beyond the core renderer.
+ * No Kibana fetch. Candle normalization, LP data discovery, and drift metrics
+ * are imported from the canonical implementations (math_utils →
+ * market_adapter/candle_utils, market_adapter/utils/data_discovery,
+ * lp_chart_runner.calculateMetrics) instead of local copies.
  *
  * Usage:
- *   tsx analysis/ama_fitting/generate_unified_comparison_chart.ts --data <file.json>
- *   tsx analysis/ama_fitting/generate_unified_comparison_chart.ts  (auto-discovers newest lp_pool_*.json)
+ *   node dist/analysis/ama_fitting/generate_unified_comparison_chart.js --data <file.json>
+ *   node dist/analysis/ama_fitting/generate_unified_comparison_chart.js  (auto-discovers newest lp_pool_*.json)
  */
 
 
 
 // ── Config ─────────────────────────────────────────────────────────────────────
 
-const LP_DATA_DIR = PATHS.MARKET_ADAPTER.LP_DATA_DIR;
 const CHARTS_DIR = PATHS.ANALYSIS.CHARTS_DIR;
 
 const DEFAULT_COLORS = ['#26a69a', '#fb8c00', '#5c9ee6', '#ef5350'];
@@ -50,41 +54,7 @@ function buildDefaultStrategies() {
 
 const DEFAULT_STRATEGIES = buildDefaultStrategies();
 
-// ── Data loading (self-contained, no lp_chart_runner dep) ──────────────────────
-
-function findLatestLpDataFile() {
-    if (!fs.existsSync(LP_DATA_DIR)) return null;
-    const stack = [LP_DATA_DIR];
-    const matches: { path: string; mtime: number }[] = [];
-    while (stack.length > 0) {
-        const dir = stack.pop();
-        if (!dir) continue;
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory()) { stack.push(full); continue; }
-            if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
-            if (!entry.name.startsWith('lp_pool_')) continue;
-            matches.push({ path: full, mtime: fs.statSync(full).mtimeMs });
-        }
-    }
-    matches.sort((a, b) => b.mtime - a.mtime);
-    return matches.length > 0 ? matches[0].path : null;
-}
-
-function normalizeCandle(c: any, index: any) {
-    if (Array.isArray(c)) {
-        if (c.length < 5) throw new Error(`Invalid candle at index ${index}: need at least 5 entries`);
-        return { timestamp: c[0], open: c[1], high: c[2], low: c[3], close: c[4], volume: c[5] ?? 0 };
-    }
-    if (c && typeof c === 'object') {
-        const { timestamp, open, high, low, close, volume = 0 } = c;
-        if ([timestamp, open, high, low, close].some(v => v == null)) {
-            throw new Error(`Invalid candle object at index ${index}`);
-        }
-        return { timestamp, open, high, low, close, volume };
-    }
-    throw new Error(`Unsupported candle format at index ${index}`);
-}
+// ── Data loading (canonical implementations, no local copies) ────────────────
 
 function loadCandles(dataFile: any) {
     const resolved = path.resolve(dataFile);
@@ -96,33 +66,26 @@ function loadCandles(dataFile: any) {
         throw new Error('No candles found in file');
     }
 
-    const candleObjects = candles.map((c, i) => normalizeCandle(c, i));
-    const candleArrays = candleObjects.map(c => [c.timestamp, c.open, c.high, c.low, c.close, c.volume]);
+    // normalizeCandle is the canonical accessor transform (market_adapter/
+    // candle_utils.ts via math_utils re-export); it returns seconds-based time.
+    const normalized = candles.map((c: any, i: number) => {
+        const nc = normalizeCandle(c);
+        if (!nc) throw new Error(`Invalid candle at index ${i}`);
+        return nc;
+    });
+    const candleObjects = normalized.map(c => ({
+        timestamp: c.time * 1000,
+        open: c.open,
+        high: c.high,
+        low: c.low,
+        close: c.close,
+        volume: c.volume,
+    }));
+    const candleArrays = normalized.map(c => [c.time * 1000, c.open, c.high, c.low, c.close, c.volume]);
 
     return { dataFile: resolved, meta, candleObjects, candleArrays };
 }
 
-// ── Metrics ────────────────────────────────────────────────────────────────────
-
-function calculateMetrics(amaValues: any, candles: any) {
-    let maxDriftUp = 0, maxDriftDown = 0, areaAbove = 0, areaBelow = 0;
-    const skip = Math.max(20, Math.floor(candles.length * 0.1));
-    for (let i = skip; i < candles.length; i++) {
-        const ama = amaValues[i];
-        const driftUp = (candles[i].high - ama) / ama;
-        const driftDown = (ama - candles[i].low) / ama;
-        if (driftUp > maxDriftUp) maxDriftUp = driftUp;
-        if (driftDown > maxDriftDown) maxDriftDown = driftDown;
-        if (candles[i].high > ama) areaAbove += driftUp;
-        if (candles[i].low < ama) areaBelow += driftDown;
-    }
-    return {
-        maxDriftUp, maxDriftDown, areaAbove, areaBelow,
-        totalArea: areaAbove + areaBelow,
-        maxDistance: Math.max(maxDriftUp, maxDriftDown),
-    };
-}
-
 // ── Output path ────────────────────────────────────────────────────────────────
 
 function defaultChartPath(meta: any) {
@@ -142,7 +105,7 @@ function showHelp() {
 Unified Comparison Chart Generator
 
 Usage:
-  tsx generate_unified_comparison_chart.ts [options]
+  node dist/analysis/ama_fitting/generate_unified_comparison_chart.js [options]
 
 Options:
   --data FILE     LP candle export JSON file
@@ -187,7 +150,7 @@ function generateChart(options = {} as Record<string, any>) {
 
     const dataFile = options.dataFile
         ? path.resolve(options.dataFile)
-        : findLatestLpDataFile();
+        : findLatestLpData();
     if (!dataFile) {
         throw new Error(`No LP data file found. Use --data <path> or run fetch_lp_candles.ts first.`);
     }
@@ -217,7 +180,7 @@ function generateChart(options = {} as Record<string, any>) {
         amaResults.push({ ...strategy, lineWidth: index === 0 ? 2 : 1.5, values });
 
         logger.log(`${strategy.name}`);
-        logger.log(`   ├─ Total Area:     ${metrics.totalArea.toFixed(2)}%`);
+        logger.log(`   ├─ Total Area:     ${metrics.totalDeviation.toFixed(2)}%`);
         logger.log(`   ├─ Max UP:         ${(metrics.maxDriftUp * 100).toFixed(2)}%`);
         logger.log(`   ├─ Max DOWN:       ${(metrics.maxDriftDown * 100).toFixed(2)}%`);
         logger.log(`   └─ Band Factor:    ${(metrics.maxDistance * 200).toFixed(2)}%\n`);

package/analysis/ama_fitting/optimizer_high_resolution.ts

@@ -1,10 +1,11 @@
+'use strict';
 
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { pathToFileURL } from 'node:url';
+import { pathToFileURL, fileURLToPath } from 'node:url';
 import { Worker, isMainThread, parentPort, workerData } from 'node:worker_threads';
-import { calculateAMA } from '../../market_adapter/core/strategies/ama.js';
+import { calculateAMA, getAmaWarmupBars } from '../../market_adapter/core/strategies/ama.js';
 import { toIntervalLabel } from '../../market_adapter/interval_utils.js';
 import { generateHTML } from '../../market_adapter/lp_chart_core.js';
 import { PATHS } from '../../modules/paths.js';
@@ -12,7 +13,6 @@ import { ensureDir } from '../../modules/order/utils/system.js';
 import { range } from '../math_utils.js';
 import { getStorage } from '../../modules/storage/index.js';
 const { readJSON, writeJSON } = getStorage();
-'use strict';
 
 import {
     loadLpDataFile,
@@ -354,8 +354,15 @@ function updateAmaProfilesFile({ dataFile, meta, winners, sourceResultsFile }: {
     writeJSON(AMA_PROFILES_FILE, payload);
 }
 
-function calcTotalAmaMovement(amaValues: number[], erPeriod: number): number {
-    const skip = erPeriod + 1;
+// Warmup skips through the full production AMA seeding + convergence window
+// (getAmaWarmupBars) rather than just the ER seed boundary (erPeriod + 1), so
+// objective metrics are never measured on SMA-warmup or unconverged values.
+function amaWarmupSkip(erPeriod: number, fastPeriod: number, slowPeriod: number): number {
+    return getAmaWarmupBars(erPeriod, slowPeriod, 0, fastPeriod);
+}
+
+function calcTotalAmaMovement(amaValues: number[], erPeriod: number, fastPeriod: number, slowPeriod: number): number {
+    const skip = amaWarmupSkip(erPeriod, fastPeriod, slowPeriod);
     let total = 0;
     for (let i = skip + 1; i < amaValues.length; i++) {
         total += Math.abs(amaValues[i] - amaValues[i - 1]) / amaValues[i - 1];
@@ -365,8 +372,8 @@ function calcTotalAmaMovement(amaValues: number[], erPeriod: number): number {
 
 // ── Informational: area above/below AMA ──────────────────────────────────────
 
-function calcArea(amaValues: number[], candles: any[], erPeriod: number) {
-    const skip = erPeriod + 1;
+function calcArea(amaValues: number[], candles: any[], erPeriod: number, fastPeriod: number, slowPeriod: number) {
+    const skip = amaWarmupSkip(erPeriod, fastPeriod, slowPeriod);
     let above = 0, below = 0, maxUp = 0, maxDown = 0;
     for (let i = skip; i < candles.length; i++) {
         const ama = amaValues[i];
@@ -386,8 +393,8 @@ function calcArea(amaValues: number[], candles: any[], erPeriod: number) {
     return { above, below, total, maxUp, maxDown, maxDist };
 }
 
-function calcTotalRelativeDistance(amaValues: number[], candles: any[], erPeriod: number): number {
-    const skip = erPeriod + 1;
+function calcTotalRelativeDistance(amaValues: number[], candles: any[], erPeriod: number, fastPeriod: number, slowPeriod: number): number {
+    const skip = amaWarmupSkip(erPeriod, fastPeriod, slowPeriod);
     let total = 0;
     for (let i = skip; i < candles.length; i++) {
         const ama = amaValues[i];
@@ -428,9 +435,9 @@ function runSearchShard(payload: any, onProgress: ((msg: any) => void) | null =
                 valid++;
 
                 const ama = calculateAMA(closes, { erPeriod: er, fastPeriod: fast, slowPeriod: slow });
-                const area = calcArea(ama, candles, er);
-                const amaMovementTotal = calcTotalAmaMovement(ama, er);
-                const distanceTotal = calcTotalRelativeDistance(ama, candles, er);
+                const area = calcArea(ama, candles, er, fast, slow);
+                const amaMovementTotal = calcTotalAmaMovement(ama, er, fast, slow);
+                const distanceTotal = calcTotalRelativeDistance(ama, candles, er, fast, slow);
                 const bandFactorPct = area.maxDist * 200;
                 const entry = {
                     er, fast, slow,
@@ -454,7 +461,9 @@ function runSearchShard(payload: any, onProgress: ((msg: any) => void) | null =
 
 function spawnShardWorker(payload: any, onProgress: ((msg: any) => void) | null): Promise<any> {
     return new Promise((resolve, reject) => {
-        const worker = new Worker(__filename, { workerData: { type: 'search_shard', payload } });
+        // ESM: resolve this module's path from import.meta.url
+        // (__filename is undefined in ES modules).
+        const worker = new Worker(fileURLToPath(import.meta.url), { workerData: { type: 'search_shard', payload } });
         worker.on('message', (msg) => {
             if (!msg || typeof msg !== 'object') return;
             if (msg.type === 'progress') {

package/analysis/ama_fitting/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ama_fitting",
-  "version": "1.4.20",
+  "version": "1.4.22",
   "description": "Tools for fitting AMA parameters to market data",
   "main": "../../dist/analysis/ama_fitting/optimizer_high_resolution.js",
   "scripts": {