dexbot 1.4.24 → 1.5.0

package/CHANGELOG.md

@@ -2,6 +2,73 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.5.0] - 2026-09-05 - Credit Overview & Whitelist-Scoped CR, TradingView Shortcut, Reload Command, Guard & Rotation Hardening
+
+### 2026-09-02
+
+- **Fix(editor)**: bold Mountain weight in selector display (`modules/account_bots.ts`).
+
+### 2026-09-03
+
+- **Feat(cli)**: add `dexbot credit` live per-bot debt overview and centralize CLI color palette — new `scripts/analyze-credit.ts` (wired as `dexbot credit [<bot>]`) queries live `get_margin_positions` + paginated `get_credit_deals_by_borrower` per preferredAccount and prints summed debt/collateral per asset per bot (lending-asset filtered, shared accounts tagged, chain chatter muted, inclusive-pagination overlap dropped to avoid double-counting); new `modules/cli_colors.ts` (`CLI_COLORS`) is the single source of truth for every ANSI shade repo-wide with no visual change (`scripts/analyze-credit.ts`, `dexbot.ts`, `modules/cli_colors.ts`, `README.md`, `docs/WORKFLOW.md`, `tests/test_analyze_credit.ts`).
+
+### 2026-09-04
+
+- **Feat(credit)**: whitelist-scoped CR reporting and shared credit-pricing math — new browser-safe `modules/credit_pricing.ts` holds the canonical math (collateral-map normalization, core/legacy-reversed orientation, offer conversion rates, per-deal and value-weighted average CR, fee helpers) with `credit_runtime.ts` delegating to it (conversion-rate fallback extended offer → pool-derived → universal market price incl. BTS-bridge hops); analyzer per-pair `Curr. CR` and per-bot `Avar. CR` are now scoped to whitelisted `debtPolicy.lending` pairs priced on the current offer, color-coded vs `maxCollateralRatio`, with `Excluded` split by reason and uncapped offer pagination; new `derivePriceViaBridges`/`derivePriceWithBridges` in `modules/order/utils/system.ts` (LP legs bridge only on opt-in) (`modules/credit_pricing.ts`, `modules/credit_runtime.ts`, `modules/order/utils/system.ts`, new `tests/test_credit_pricing.ts`, `tests/test_price_bridges.ts`, `tests/test_credit_conversion_fallback.ts`).
+- **Feat(cli)**: add `dexbot reload` that leaves the credential daemon untouched — mirrors `restart` on every runtime surface (unlock `reload-all` recycles bots + market adapter via SIGUSR2 skipping the daemon re-unlock block, supervisor `reload`/`reload-all`, `pm2 restart` with no `ensureCredentialDaemon`, `reload dexbot-cred` rejected) so bot/adapter recycling no longer costs a password prompt (`unlock.ts`, `modules/launcher/bot_supervisor.ts`, `modules/launcher/launch_modes.ts`, `modules/launcher/monolithic_runtime.ts`, `pm2.ts`, `dexbot.ts`, `README.md`, `docs/WORKFLOW.md`).
+- **Fix(identity)**: enforce case-insensitive bot-name identity across lookups — new `isSameBotName` in `modules/utils/sanitize_key.ts` (sanitized compare with blank-input guard) used by bot_settings, dexbot, unlock, bot, pm2, claw launcher/profiles/credit adapter, maintenance runtime, market-adapter inputs and helper scripts; PM2 stop/delete/restart/reload resolve to the canonical stored name, example pair-derived bot names in comments/help/fixtures replaced with a generic placeholder (published changelog history untouched).
+- **Fix(update)**: run `npm install` only when dependencies actually changed — new `needsDepsInstall(preUpdateHead)` gate in `scripts/update.ts` (install only when node_modules missing/incomplete, manifests changed since pre-update commit, or manifests worktree-dirty; fail-open on git errors) plus a `lockRegenerated` double-install guard (`scripts/update.ts`).
+- **Fix(adapter)**: centralize market-adapter ownership in unlock wrapper on one 1min interval — new `modules/launcher/adapter_requirement.ts` (semantic name:gridPrice fingerprint, corrupt/unreadable bots.json reported not thrown); wrapper exports `DEXBOT_ADAPTER_OWNER=wrapper` so supervised bots skip adapter sync and create no poll timer (wrapper-less modes keep the in-bot fallback); `TIMING.BOTS_CONFIG_POLL_INTERVAL_MS` now 60s shared with the watchdog interval; fixes `''`-fingerprint false-change and corrupt-skip regressions (`modules/launcher/adapter_requirement.ts`, `unlock.ts`, `modules/constants.ts`, `modules/launcher/*`, `modules/dexbot_class.ts`).
+- **Feat(accounts)**: cache bot account IDs in bots.json for offline resolution — byte-preserving in-place `accountId` patch in `analysis/bot_key_utils.ts` (comment/string-aware scanner, re-parse assert, atomic write, full-rewrite fallback) with `persistBotAccountId`/`getStoredBotAccountId`/`findBotKeyByAccountRef`; new `analysis/resolve_bot_accounts.ts` batch backfill CLI (`npm run analysis:resolve-accounts`, `--dry-run`/`--refresh`/`--bot-key`/`--json`); editor stamps IDs via `ensureBotAccountId`, analysis tools and `test-credit-renewal` prefer the cache with `--refresh-account` re-verify; process-wide console floor (`setGlobalConsoleLevel`) silences node-init chatter during supervised lookups (`analysis/bot_key_utils.ts`, `analysis/resolve_bot_accounts.ts`, `modules/account_bots.ts`, `modules/order/logger.ts`, `modules/bitshares_client.ts`, `tests/test_bot_account_id.js`, `tests/test_logger_console_floor.js`).
+- **Fix(guard)**: close stale-pivot race in last-fill guard and harden spread correction — `refreshLastFillPivotFromQueue()` peeks the incoming fill queue before every COW guard check (CREATE, rotation UPDATE, fallback CREATE) and `recordLastFilledPrices()` now runs per chunk so later broadcast chunks gate on the true latest fill; per-action plan-origin stamping keeps spread-correction CREATE bypass while rotation UPDATEs never bypass; `determineOrderSideByFunds()` returns null instead of cross-asset raw-unit compare when priceless with both sides funded; spread check defers on post-gate fills with funds recalc before side decision; batch-level LAST-FILL-GUARD summary + per-batch pivot log lines added (`modules/dexbot_cow_runtime.ts`, `modules/dexbot_class.ts`, `modules/order/grid.ts`, `modules/dexbot_maintenance_runtime.ts`, `modules/order/manager.ts`, new `tests/test_stale_guard_pivot_fixes.js`).
+
+### 2026-09-05
+
+- **Feat(cli)**: add `dexbot tv` one-step TradingView chart command — `dexbot tv <bot|pool-id|AssetA/AssetB> [--month N]` pulls 1h candles in chunked 1-month windows and delegates rendering to the TradingView exporter, replacing the manual fetch-then-export two-step; fetcher chunking reused via exported `fetchCandlesSequentially`/`outputPath`/`buildFetchWindowsFromRange`, chain-log mute centralized in `modules/utils/chain_logs.ts`, saved-chart paths print as clickable `file://` links via `toFileUrl` (`scripts/tv.ts`, `dexbot.ts`, `market_adapter/inputs/fetch_lp_data.ts`, `modules/utils/chain_logs.ts`, `analysis/chart_utils.ts`, docs).
+- **Fix(cow)**: clamp COW rotation size to booked remainder for partial surplus — new `clampRotationSizeForPartial` in `modules/order/utils/validate.ts` applied at both rotation-pairing sites (`pairRotations`, `optimizeRebalanceActions`) so rotations sourced from PARTIAL surplus target the booked remainder instead of the hole size, ending the plan→skip→restore loop that stranded holes and left non-contiguous rails (`modules/order/utils/validate.ts`, `modules/order/manager.ts`, `modules/order/utils/system.ts`, `tests/test_cow_master_plan.ts` COW-019).
+- **Fix(credit)**: distinguish Avar/Curr CR lines in `dexbot credit` output — display-only: Avar. CR label orange+bold printed first, Curr. CR label grey+bold with trailing comma, values keep health colors (`scripts/analyze-credit.ts`).
+- **Feat(discovery)**: split HIGH discovery tier into DEXBot2 vs DEXBot1-style by op-77 usage — DEXBot2 broadcasts native `limit_order_update` ops (type 77) for COW re-prices while DEXBot1-style only cancels+recreates, so presence of op 77 in-window assigns flavor; display-only split (score formula unchanged) with Updates column in HIGH tier, summary and `--output-json` carrying flavor/updates (`analysis/bot_usage/kibana_bot_queries.ts`, `analysis/bot_usage/discover_bot_accounts.ts`).
+- **Fix(cli)**: forward `--help`/`-h` to the `credit` and `tv` sub-scripts — the CLI intercepted help flags anywhere in argv and always printed generic help, so `dexbot credit --help` / `dexbot tv --help` never reached the scripts that own their usage text; the dispatcher now resolves the requested command first and lets only scripts with offline help handling (`credit`, `tv`) keep the flag, everything else keeps the generic help (`dexbot.ts`).
+
+## [1.4.25] - 2026-09-02 - Genesis-Frozen Price-Slot Determinism, Self-Trade & Fill-Guard Hardening, Grid Orphan & Recovery Hardening
+
+### 2026-08-29
+
+- **Fix(grid)**: restore strict ERROR diagnostics by fixing hidden fund-invariant and precision failures — re-enables strict diagnostics that were masked by NaN fund-invariant comparisons and float precision drift; fixes fund-invariant tolerance fallback, amount precision helpers, and related silent-failure paths so ERROR logs fire correctly (`modules/order/accounting.ts`, `modules/order/utils/math.ts`, `modules/constants.ts`, etc.).
+- **Fix(gap-band)**: enforce gap-band invariant across COW plan, sync, reconcile and recovery (P1–P5) — introduces authoritative gap-band checks that reject placements violating the reserved gap, validates gap-band geometry in COW planning, sync adoption, startup reconcile and recovery persistence so boundaries cannot drift into the forbidden band (`modules/order/grid.ts`, `modules/order/utils/math.ts`, `modules/dexbot_cow_runtime.ts`, `modules/order/sync_engine.ts`, `modules/order/grid_reconcile*.ts`, `modules/dexbot_state_recovery.ts`).
+- **Fix(grid)**: prevent same-slot re-placement and truncation-drop orphans after COW commit — guards against re-creating an order on a slot that was just committed and against truncation-ambiguous reads dropping live orphans; keeps slot provenance across COW commit so placed orders are not re-issued or lost on a truncated read (`modules/dexbot_cow_runtime.ts`, `modules/order/sync_engine.ts`, `modules/order/grid_reconcile_internal.ts`).
+- **Fix(grid)**: make chain evidence authoritative and remove destructive gap-band cancellation — cancels that swept the gap band based on stale local state are removed; chain-observed orders are the sole authority for gap/rail membership and gap-band sweeps are no longer triggered from local-only evidence (`modules/order/grid_reconcile*.ts`, `modules/order/sync_engine.ts`).
+- **Fix(grid)**: heal and prevent sized-orphan phantom orders in spread and COW commit — spread-correction and COW commit paths that left VIRTUAL slots with `size>0` and no `orderId` (sized orphans causing 2.02% vs 3.04% spread divergence) are healed on reload (virtual-size zeroing with `createUncertain` preservation) and prevented at commit (or­phan exclusion from sizing denominator, durable markers) (`modules/order/grid.ts`, `modules/order/manager.ts`, `modules/account_orders.ts`, `modules/dexbot_cow_runtime.ts`).
+
+### 2026-08-30
+
+- **Fix(recovery)**: stop recovery re-anchoring and make orphan adoption durable — structural resync no longer re-anchors to the latest AMA center (state repair only); orphan adoption widened with `ORPHAN_ADOPTION_TOLERANCE_MULTIPLIER` (×4) on empty slots, reconcile prefers in-place price updates over pre-emptive cancels, and boundary/slot persistence is hardened (`modules/dexbot_maintenance_runtime.ts`, `modules/order/sync_engine.ts`, `modules/order/grid_reconcile.ts`, `modules/constants.ts`).
+- **Fix(engine)**: harden order engine against orphan-cascade failure modes — closes four unvalidated local-state paths (stale-slot fill price poisoning the anchor, off-market placement, phantom virtualization from empty reads, blind unknown-fill proceed credit) via broadcast orphan gates, anchor outlier rejection, price-sanity clamp, suspect empty-read guard (3 confirms), adoption retry, and durable `createUncertain` markers; placement now wrapped in `startBroadcasting` so fill-driven rebalances cannot duplicate plans (`modules/order/grid_reconcile.ts`, `modules/order/manager.ts`, `modules/dexbot_maintenance_runtime.ts`, `modules/constants.ts`, `modules/order/utils/order.ts`, `modules/dexbot_fill_runtime.ts`, `modules/dexbot_cow_runtime.ts`).
+- **Fix(maintenance)**: make trigger reset reliable — skip idle gate, drain stalled fills, repair infeasible boundaries — trigger-file resets now execute immediately (`skipIdle`), fill queues deferred by `batchInFlight`/`recoverySyncInFlight` are drained on pipeline clear via `_onBroadcastRegionEnd` (wired at both `OrderManager` creation sites), and `NO_FEASIBLE_BOUNDARY` (overlapping BUY/SELL inside gap) escalates to a minimal cancel ladder so placements resume instead of freezing in adoption-only mode (`modules/dexbot_maintenance_runtime.ts`, `modules/order/manager.ts`, `modules/dexbot_startup_runtime.ts`, `modules/order/utils/math.ts`, `modules/order/grid_reconcile*.ts`).
+- **Docs**: consolidate orphan-fix plans and add grid monotonicity gate — four test-branch incident/plan docs merged into `docs/CONSOLIDATED_ORPHAN_FIX_SUMMARY.md` (LANDED/REVERTED/SUPERSEDED annotated) and new `npm run analysis:grid-check` (`analysis/grid_correction_check.ts`) validates consecutive same-direction fills are monotonic (sell rising / buy falling) via Kibana `fill_order` history (`analysis/*`, `docs/*`, `modules/constants.ts`).
+
+### 2026-08-31
+
+- **Fix(launcher)**: ensure bot detection within 5min and correct disable/enable active check — new `TIMING.BOTS_CONFIG_POLL_INTERVAL_MS` (5min) decouples fingerprint polling from the heavy 240min chain fetch so new/reenabled bots are observed within 5min; `dexbot.ts` `setBotActiveState` now treats `undefined` as active (`active !== false`) fixing `enable all` churn on implicit-active bots (`modules/constants.ts`, `modules/dexbot_maintenance_runtime.ts`, `modules/dexbot_class.ts`, `modules/dexbot_startup_runtime.ts`, `dexbot.ts`).
+- **Fix(security)**: close shutdown race that wiped live signing tokens — `_shutdownImpl` no longer nulls `botHmacSecret` while deferred SAFE-REBALANCE continuations are pending; tokens are wiped only on process `exit` via `registerExitWipe`; `SOURCE_AUTH_DENIED` retries re-read `daemon-policies.json`, `OrderManager` gains `_shuttingDown`/`_awaitBroadcastIdle` abort, and monolithic mode retries failed bot startups bounded (3×30s) (`modules/dexbot_class.ts`, `modules/graceful_shutdown.ts`, `modules/key_store.ts`, `modules/order/manager.ts`, `modules/dexbot_fill_runtime.ts`, `modules/dexbot_cow_runtime.ts`, `dexbot.ts`).
+- **Fix(grid)**: block self-trading grid placements across all broadcast paths — adds tolerance-widened crossing guard (`findCrossedOrder` in `modules/order/utils/math.ts`, `buildCrossingCandidates` merging master/pending/chain) to COW CREATE/rotation NOT-FOUND fallback and to startup reconcile/relocation/price-correction paths; rotation now uses swept-band exclusion instead of stale slot-type rotation that caused chunked-broadcast self-fills (`modules/dexbot_cow_runtime.ts`, `modules/order/utils/math.ts`, `modules/order/grid_reconcile_internal.ts`, `modules/order/utils/order.ts`, `modules/order/strategy.ts`).
+- **Fix(fill)**: restore main fill queue handling stalled by broadcasting gate — removes `isBroadcastingActive` from `consumeFillQueue` defer gate (already serialized by `_fillProcessingLock`/stale-plan guard; defer had no reschedule and starved the queue during chunked broadcasts) and drains deferred fills when `_batchInFlight`/`_recoverySyncInFlight` clears (`modules/dexbot_fill_runtime.ts`, `modules/dexbot_maintenance_runtime.ts`, `modules/dexbot_class.ts`).
+- **Fix(grid)**: re-price duplicate-price grid stragglers instead of cancelling them — burst re-anchor that left multiple BUYs at the same level (e.g. 902.08089 ×2, 894.01113 ×3) and self-filled is now fixed by re-pricing stragglers to the next unique ladder step away from market (clamped to `[minPrice,maxPrice]`, preserving `orderId`/`size`) via `correctOrderPriceOnChain` UPDATEs instead of virtualize→cancel; adds whole-burst swept-band caching and asymmetric multi-sell-sweep buy exclusion for chunked and unified bursts (`modules/order/strategy.ts`, `modules/dexbot_class.ts`, `tests/test_grid_robustness.ts`).
+
+### 2026-09-01
+
+- **Fix(engine)**: revert anchor divergence and boundary-evidence, restore last-fill guard — removes `MarketAnchor`/`BOUNDARY-EVIDENCE`/`BAND-EXCLUSION` paths that drifted from self-trade fills and cancelled stranded orders, restores `deriveTargetBoundary`/`snapRail` grid-dedupe and seeds `LAST-FILL-GUARD` from book at startup/post-fill to block BUY above last filled BUY and SELL below last filled SELL with cross-guard per-type collision checks (`modules/constants.ts`, `modules/order/utils/order.ts`, `modules/order/strategy.ts`, `modules/order/grid_reconcile.ts`, `modules/dexbot_class.ts`, `modules/order/manager.ts`, `modules/dexbot_cow_runtime.ts`).
+- **Fix(grid)**: close duplicate-order incident class from trigger-reset phantom empty read — a trigger reset that observed a single 0-order lagging-node read rebuilt over a live order and queued the wrong duplicate for cancel (books 0.5626 vs chain 0.5626+0.6659). Fix: trigger `GRID-RESYNC` empty reads now require a 2s confirming re-read (`SYNC_EMPTY_READ_CONFIRM_DELAY_MS`), rotation/plan UPDATEs clamp or skip growing PARTIAL slots above booked remaining size, Pass 1 size-consistency tiebreak rebinds a slot to the same-price chain order matching booked size (exact), and `updateOrdersOnChainBatchCOW` drains pending price corrections before planning (`modules/dexbot_maintenance_runtime.ts`, `modules/constants.ts`, `modules/dexbot_cow_runtime.ts`, `modules/order/sync_engine.ts`, `modules/order/manager.ts`).
+- **Fix(g guard)**: last-fill guard pivot ± halfIncrement (BUY < pivot*(1-half), SELL > pivot*(1+half)) — replaces dual-pivot + tolerance with single global pivot (most recent fill) ± half grid increment (e.g. i=0.5% @1000 → BUY<997.5, SELL>1002.5); fixes SELL 1013>1001 after BUY 1001 being wrongly blocked and closes half-step profit hole; spread-correction bypass retained (`modules/order/manager.ts`, `modules/dexbot_cow_runtime.ts`).
+
+### 2026-09-02
+
+- **Feat(genesis)**: implement genesis-frozen price-slot determinism (Phase 1–2, log mode) — `slot-N` becomes the single source of truth (`price = genesis.priceLevels[N]`); adds `GridGenesis`/`hashPriceLevels`/`priceLevelsForGenesis`/`priceForSlot`/`slotIndexForPrice` (binary search, lower-wins tie)/`priceSlotEqual` (int equality)/`buildGenesisFromPriceLevels`/`assertSlotPriceInvariant`, canonical `parseSlotIndex` (`modules/order/utils/slot.ts`), `createOrderGrid` dedup+genesis build, `loadGrid` genesis validation/canonical re-sort/type re-assignment via `parseSlotIndex` with legacy migration, `account_orders`/`working_grid`/`system`/`startup`/`recovery` genesis threading, and `GRID_PRICE_SLOT_DETERMINISM_PLAN.md` (`modules/order/utils/math.ts`, `modules/order/grid.ts`, `modules/account_orders.ts`, `modules/order/working_grid.ts`, `modules/order/utils/system.ts`, `modules/dexbot_startup_runtime.ts`, `modules/dexbot_state_recovery.ts`, `modules/order/grid_reconcile.ts`, `docs/*`, `tests/test_grid_price_slot_invariant.ts`).
+- **Feat(genesis)**: complete genesis-frozen price-slot determinism (phases 3–9) — replaces all tolerance-based price matching with `slotId` equality / `priceSlotEqual`; sync engine Pass 2 adopts by nearest slot via `slotIndexForPrice` with `isSlotInRail` gap check and VIRTUAL/free slot bind; COW guards `hasSlotPriceCollision`/`validateCreateTargetSlots` use `priceSlotEqual`; fill/grid/rail paths (`isSlotInRail` fail-closed, `chainOrderMatchesSlot`, `hasDuplicatePriceLevel`, `grid_reconcile` cleanup) unified on genesis; legacy tolerance retained only for no-genesis migration (`modules/order/sync_engine.ts`, `modules/dexbot_cow_runtime.ts`, `modules/order/utils/validate.ts`, `modules/dexbot_fill_runtime.ts`, `modules/order/*`, `tests/*` 12 suites).
+- **Feat(editor)**: add Range quality legend with tiered coloring — `RANGE_QUALITY` thresholds (`GREEN_MIN 2.0` wide / `YELLOW_MIN 1.55` efficient / `ORANGE_MIN 1.45` tight / `RED_MAX 1.45` suicidal `<1.45x`) drive a pre-entry legend and live `colorRangeValueByQuality` in `askNumberOrMultiplier`/`askMaxPrice` and summary Pair display (cyan) (`modules/constants.ts`, `modules/account_bots.ts`).
+- **Feat(whitelist)**: add scoped `--bot` overwrite with validation and warnings — `dexbot white --bot <botKey>` overwrites only the targeted whitelist key (merge preserves unknown flags like `derivativeSignals`) while additive-only behavior is preserved without `--bot`; `parseOptions` now collects `botKeys` (`--bot`/`--bot-key`/`--botKey`, `=` and comma forms, repeatable) with missing/flag-like validation (throws, main prints usage and exits 1), `buildWhitelist` filters to targeted keys and warns when `--bot` target not found or has non-AMA `gridPrice` (`scripts/generate_market_adapter_whitelist.ts`, `dexbot.ts`, `docs/*`, `tests/test_market_adapter_fixes.ts`).
+- **Fix(editor)**: align Range quality wording — legend `≤1.35x: suizidal` → `<1.45x: suizidal` to match `getRangeQuality` (`<1.45x` red, `1.45x–1.55x` orange) and make `RANGE_QUALITY.RED_MAX` authoritative (`modules/constants.ts`, `modules/account_bots.ts`).
+
 ## [1.4.24] - 2026-08-28 - Native Fill Gap Recovery, Eager Coalesced Retry, LP Collateral Offer-First Pricing
 
 ### 2026-08-28

package/README.md

@@ -178,6 +178,7 @@ Keep the default settings first, and tune these:
    This writes `market_adapter_whitelist.json` in the profiles directory. New AMA bots get AMA
    live writes and range scaling. Use `dexbot white --dynamic-weight` for
    newly generated dynamic-weight entries; existing entries are preserved.
+   To overwrite an existing bot: `dexbot white --dynamic-weight --bot <botKey>`.
 
 6. **Start DEXBot2** with `dexbot start`.
 
@@ -234,12 +235,13 @@ Defaults in [`modules/constants.ts`](modules/constants.ts) are overridable at gl
 
 ## 🎯 Zero-Dependency Process Management
 
-`dexbot start` is the recommended production runtime (global install). Repo-root users can run `./unlock` instead. It runs the selected bot set as one monolithic bot process, with the credential daemon and market adapter in separate helper processes. Monolithic start/stop/restart controls apply to the whole runtime, not to individual bots.
+`dexbot start` is the recommended production runtime (global install). Repo-root users can run `./unlock` instead. It runs the selected bot set as one monolithic bot process, with the credential daemon and market adapter in separate helper processes. Monolithic start/stop/reload/restart controls apply to the whole runtime, not to individual bots.
 
 ```bash
 dexbot start/stop          # Stop/start the monolithic runtime
 dexbot start --dryrun      # Dry-run (no transactions broadcast)
-dexbot restart             # Restart the monolithic runtime
+dexbot reload              # Reload the runtime (leaves credential daemon untouched)
+dexbot restart             # Restart the runtime (re-unlocks credential daemon)
 dexbot delete              # Shut down and clean up
 ```
 
@@ -259,6 +261,8 @@ 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 analysis/charts/
+dexbot tv <bot|pool|A/B>   # TradingView 1h chart with AMA overlay (default: 3 months)
+dexbot credit [<bot>]      # Live summed MPA + borrowed-credit positions per asset per bot
 
 dexbot update              # Update DEXBot2
 dexbot clear               # Clear log files
@@ -271,6 +275,7 @@ PM2 is optional — `dexbot start` is the native solution.
 
 ```bash
 dexbot pm2 [<bot>]                         # Start with PM2
+dexbot pm2 reload {all|<bot>}              # Reload managed apps, dexbot-cred untouched
 dexbot pm2 restart {all|<bot>|dexbot-cred} # Safe restart
 dexbot pm2 stop {all|<bot>}                # Stop (via wrapper)
 dexbot pm2 delete {all|<bot>}              # Delete (via wrapper)

package/analysis/README.md

@@ -21,9 +21,10 @@ Tools that inspect DEXBot trading behavior and the market data it operates on. O
 | Tool | Ask this when… | One-line command |
 |------|----------------|------------------|
 | [`trade_profitability.ts`](#trade-profitability-analyzer-trade_profitabilityts) | "Is my bot making money?" — PnL, R-multiples, drawdown | `npm run analysis:trade-pnl -- <account-id>` |
+| [`grid_correction_check.ts`](#grid-correction-check-grid_correction_checkts) | "Is my grid placing orders monotonically?" — sell/buy price inversion detector | `npm run analysis:grid-check -- --bot-key <bot-key>` |
 | [`analyze_risk_profile.ts`](#risk-profile-analyzer-analyze_risk_profilets) | "How wide should my Safe Range clamps be?" | `node dist/analysis/analyze_risk_profile.js --bot-key <bot-key>` |
 | [`analyze_trade_heatmap.ts`](#trade-heatmap-analyze_trade_heatmapts) | "Where did trade volume cluster vs the AMA?" | `node dist/analysis/analyze_trade_heatmap.js --bot-key <bot-key>` |
-| [`tradingview/analyze_tradingview.ts`](#tradingview-chart-tradingviewanalyze_tradingviewts) | "Just give me a candle chart" | `npm run analysis:tradingview -- --source market_adapter --bot-key <bot-key>` |
+| [`tradingview/analyze_tradingview.ts`](#tradingview-chart-tradingviewanalyze_tradingviewts) | "Just give me a candle chart" | `dexbot tv <bot-key>` |
 | [`analyze_dynamic_weight.ts`](#dynamic-weight-research-analyze_dynamic_weightts) | "Are buy/sell weights tuned for this regime?" | `node dist/analysis/analyze_dynamic_weight.js --bot-key <bot-key>` |
 | [`analyze_volatility.ts`](#volatility-analyze_volatilityts) | "Both weights clipped too hard / not enough?" | `node dist/analysis/analyze_volatility.js --bot-key <bot-key>` |
 | [`analyze_regime.ts`](#supporting-sub-signals) | "Is the trend/chaos gate too aggressive?" | `node dist/analysis/analyze_regime.js --bot-key <bot-key>` |
@@ -137,8 +138,8 @@ Fetches `fill_order` operations for a BitShares account from Kibana within a spe
 # Account by ID, last 7 days (default)
 node dist/analysis/trade_profitability.js 1.2.123456
 
-# Account by name with on-chain resolution
-node dist/analysis/trade_profitability.js "my-account-name" --lookup --hours 720
+# Account by name (auto-resolved in the background)
+node dist/analysis/trade_profitability.js "my-account-name" --hours 720
 
 # Absolute window with asset filter
 node dist/analysis/trade_profitability.js 1.2.123456 \
@@ -161,7 +162,8 @@ node dist/analysis/trade_profitability.js 1.2.123456 \
 | `--end <iso>` | — | End time |
 | `--hours <n>` | `168` (7d) | Lookback hours (alternative to start/end) |
 | `--asset <id>` | all | Filter to one base asset ID |
-| `--lookup` | off | Resolve account name to 1.2.x ID via BitShares node |
+| `--lookup` | off | Legacy (no-op): account names always resolve automatically |
+| `--refresh-account` | off | Force re-resolution and update the stored `accountId` |
 | `--node <url>` | first healthy from built-in pool (10 nodes) | BitShares node for account + asset resolution |
 | `--csv <file>` | — | Export chronologically sorted trade list |
 | `--json <file>` | — | Export full analysis with per-pair PnL data |
@@ -219,6 +221,50 @@ node dist/analysis/trade_profitability.js 1.2.123456 \
 
 </details>
 
+### Grid Correction Check (`grid_correction_check.ts`)
+
+Validates grid discipline from the same Kibana fill pipeline as `trade_profitability.ts`: two consecutive same-direction fills on a pair must be monotonic — sell prices rising, buy prices falling (equal is OK). An inversion means the bot placed an order below its own previous sell (or above its own previous buy), e.g. an orphaned order filling outside grid accounting. Used as the external regression gate for the orphan-fix plans in `docs/CONSOLIDATED_ORPHAN_FIX_SUMMARY.md`.
+
+**Pipeline:** Kibana `fill_order` query (paginated `search_after`) → on-chain asset precision resolution → buy/sell classification → chronological sort → per-order aggregation (multi-fill orders collapsed to weighted-avg price by default) → consecutive same-direction pair comparison → violation report with daily histogram.
+
+```bash
+# Per-order aggregated check (default), last 7 days
+npm run analysis:grid-check -- --bot-key <bot-key> --hours 168
+
+# 30 days, JSON + CSV export of violations
+npm run analysis:grid-check -- --bot-key <bot-key> --hours 720 --json out.json --csv out.csv
+
+# Raw fill granularity instead of per-order aggregation
+npm run analysis:grid-check -- --bot-key <bot-key> --per-fill --hours 168
+
+# Forgive small adverse moves within 0.1%
+npm run analysis:grid-check -- --bot-key <bot-key> --hours 168 --tolerance 0.1
+```
+
+Exit code `0` = pass, `2` = violations found, `1` = fatal error. Bot keys resolve via `profiles/bots.json` (`--list-bots` to enumerate); the account defaults to the bot's stored `accountId` when present (no chain lookup — the ID is auto-saved next to `preferredAccount` after the first successful name resolution, re-verified with `--refresh-account`), otherwise `preferredAccount` is resolved on-chain, and can be overridden with `--account <1.2.x|name>`.
+
+<details><summary>Options (click to expand)</summary>
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--bot-key <key>` | — | Bot key or name from `profiles/bots.json` (required) |
+| `--hours <n>` | `168` | Lookback hours from now |
+| `--start <iso>` / `--end <iso>` | — | Absolute time window |
+| `--account <id>` | bot `preferredAccount` | Override account ID or name |
+| `--lookup` | off | Legacy (no-op): account names always resolve via BitShares node when no stored ID exists |
+| `--refresh-account` | off | Force re-resolution of `preferredAccount` and update the stored `accountId` when it changed |
+| `--node <url>` | first built-in node | Node for account/asset resolution |
+| `--per-fill` | off | Check at fill granularity instead of per-order aggregated |
+| `--include-cross-pair` | off | Also check consecutive fills across different pairs |
+| `--tolerance <pct>` | `0` | Adverse price move (%) forgiven before flagging |
+| `--json <file>` / `--csv <file>` | — | Export violations |
+| `--verbose` | off | Print the full trade sequence |
+| `--list-bots` | — | List available bot keys and exit |
+
+</details>
+
+**Notes:** strict sat-level comparison is the ground truth (`--tolerance` only forgives small inversions); multi-fill orders are collapsed to a weighted-average price for the default per-order mode, so a single order's partial fills at identical prices never count as inversions.
+
 ## Charts & Visualization
 
 ### Trade Heatmap (`analyze_trade_heatmap.ts`)
@@ -265,7 +311,12 @@ node dist/analysis/analyze_trade_heatmap.js \
 Generates a standalone TradingView-style HTML chart with candle OHLC, SMA, AMA, VWMA, and volume panel. See [tradingview/README.md](tradingview/README.md) for full documentation.
 
 ```bash
-# Bot-key (auto-resolves candle file and AMA settings)
+# Recommended one-step: bot, pool, or pair (fetches candles + renders, default 3 months)
+dexbot tv <bot-key>
+dexbot tv 133
+dexbot tv TOKENA/TOKENB
+
+# Manual: bot-key (auto-resolves candle file and AMA settings)
 npm run analysis:tradingview -- --source market_adapter --bot-key <bot-key>
 
 # From an explicit candle file
@@ -445,6 +496,7 @@ These npm scripts wrap common analysis runners:
 |--------|---------|
 | `npm run analysis:tradingview` | `node dist/analysis/tradingview/analyze_tradingview.js` |
 | `npm run analysis:trade-pnl` | `node dist/analysis/trade_profitability.js` |
+| `npm run analysis:grid-check` | `node dist/analysis/grid_correction_check.js` |
 | `npm run analysis:derivatives` | `node dist/analysis/analyze_derivatives.js` (legacy SMA/MACD/RSI layer, reference only) |
 | `npm run ama:chart:lp-local` | `node dist/analysis/ama_fitting/generate_unified_comparison_chart.js` (chart also auto-generated by optimizer) |
 
@@ -457,6 +509,9 @@ npm run analysis:tradingview -- --source market_adapter --bot-key <bot-key>
 # Trade PnL
 npm run analysis:trade-pnl -- 1.2.123456 --hours 720
 
+# Grid correction check (monotonicity regression gate)
+npm run analysis:grid-check -- --bot-key <bot-key> --hours 168
+
 # File-based
 npm run analysis:tradingview -- --file market_adapter/data/market_adapter_<bot-key>_1h.json
 npm run ama:chart:lp-local -- --data market_adapter/data/lp/<pair>/lp_pool_<id>_<interval>.json
@@ -465,4 +520,5 @@ npm run ama:chart:lp-local -- --data market_adapter/data/lp/<pair>/lp_pool_<id>_
 ## Related Docs
 
 - [Market Adapter](../market_adapter/README.md) — live AMA pricing, grid triggers, dynamic weights, and recalc triggers
+- [Consolidated Orphan-Fix Summary](../docs/CONSOLIDATED_ORPHAN_FIX_SUMMARY.md) — orphan/gap-band root-cause plans; `grid_correction_check` is their regression gate
 - [DEXBot2 Tuning Cheat Sheet](../claw/docs/DEXBOT2_TUNING_CHEAT_SHEET.md) — grid tuning reference for live bots

package/analysis/ama_fitting/package.json

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

package/analysis/analyze_derivatives.ts

@@ -14,7 +14,7 @@
  *
  *   node dist/analysis/analyze_derivatives.js \\
  *     --source market_adapter \
- *     --bot-key XRP-BTS
+ *     --bot-key AAA-BBB
  *
  * Output:
  *   analysis/charts/derivative_chart.html

package/analysis/bot_key_utils.ts

@@ -4,7 +4,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { PATHS } from '../modules/paths.js';
 import { getStorage } from '../modules/storage/index.js';
-const { readJSON } = getStorage();
+const { readJSON, writeJSON } = getStorage();
+import { parseJsonWithComments } from '../modules/order/utils/system.js';
 import { MARKET_ADAPTER } from '../modules/constants.js';
 import { loadMarketProfiles } from './tradingview/tradingview_uplot_chart_generator.js';
 import { sanitizeKey } from '../modules/utils/sanitize_key.js';
@@ -22,7 +23,13 @@ function loadBotSettings(filePath = PATHS.PROFILES.BOTS_JSON) {
     try {
         return readJSON(filePath);
     } catch (_) {
-        return null;
+        // The bot editor reads/writes through a comment-tolerant parser, so
+        // operator comments may legally exist — fall back before giving up.
+        try {
+            return parseJsonWithComments(fs.readFileSync(filePath, 'utf8'));
+        } catch (_) {
+            return null;
+        }
     }
 }
 
@@ -70,6 +77,268 @@ function loadBotMeta(botKey: any, filePath = PATHS.PROFILES.BOTS_JSON) {
     return loose || null;
 }
 
+/**
+ * Locate the source span of the entryIndex-th object literal inside the
+ * top-level "bots" array of a (possibly comment-bearing) JSON document.
+ * Strings and // + block comments are skipped while scanning, so braces
+ * inside them never disturb the balance count. Returns null when the
+ * document shape is unexpected — callers fall back to a full rewrite.
+ */
+function findBotsEntrySpan(raw: string, entryIndex: number): { start: number; end: number } | null {
+    const m = /"bots"\s*:\s*\[/.exec(raw);
+    if (!m) return null;
+    let i = m.index + m[0].length; // just past '['
+    const n = raw.length;
+    let count = 0;
+    const skipWsComments = () => {
+        while (i < n) {
+            const c = raw[i];
+            if (c === ' ' || c === '\t' || c === '\n' || c === '\r') { i++; continue; }
+            if (c === '/' && raw[i + 1] === '/') { while (i < n && raw[i] !== '\n') i++; continue; }
+            if (c === '/' && raw[i + 1] === '*') { i += 2; while (i < n && !(raw[i] === '*' && raw[i + 1] === '/')) i++; i += 2; continue; }
+            break;
+        }
+    };
+    const skipString = () => {
+        const q = raw[i];
+        i++;
+        while (i < n) {
+            const c = raw[i];
+            if (c === '\\') { i += 2; continue; }
+            if (c === q) { i++; return; }
+            i++;
+        }
+    };
+    // Skip one JSON value starting at raw[i]; false on malformed input.
+    const skipValue = (): boolean => {
+        skipWsComments();
+        if (i >= n) return false;
+        const c = raw[i];
+        if (c === '"' || c === "'") { skipString(); return true; }
+        if (c === '{' || c === '[') {
+            const open = c;
+            const close = c === '{' ? '}' : ']';
+            i++;
+            let depth = 1;
+            while (i < n && depth > 0) {
+                const d = raw[i];
+                if (d === '"' || d === "'") { skipString(); continue; }
+                if (d === '/' && raw[i + 1] === '/') { while (i < n && raw[i] !== '\n') i++; continue; }
+                if (d === '/' && raw[i + 1] === '*') { i += 2; while (i < n && !(raw[i] === '*' && raw[i + 1] === '/')) i++; i += 2; continue; }
+                if (d === open) depth++;
+                else if (d === close) depth--;
+                i++;
+            }
+            return depth === 0;
+        }
+        while (i < n && raw[i] !== ',' && raw[i] !== ']' && raw[i] !== '}') i++;
+        return true;
+    };
+    for (;;) {
+        skipWsComments();
+        if (i >= n) return null;
+        if (raw[i] === ']') return null; // array ended before entryIndex
+        if (raw[i] === '{') {
+            const start = i;
+            if (!skipValue()) return null;
+            if (count === entryIndex) return { start, end: i };
+            count++;
+        } else if (!skipValue()) {
+            return null;
+        }
+        skipWsComments();
+        if (i < n && raw[i] === ',') { i++; continue; }
+        if (i < n && raw[i] === ']') return null;
+        return null; // malformed separator
+    }
+}
+
+/**
+ * Locate the string value of a top-level key inside one bot-entry source
+ * span. Unlike a regex, this scan skips over // and block comments as well
+ * as string literals, so a key-looking fragment inside a comment (e.g.
+ * `// "accountId": "1.2.9999" (old)`) can never be mistaken for the real
+ * key. Returns the span of the quoted value (including quotes), or null
+ * when the key is absent or its value is not a string.
+ */
+function findEntryKeyValueSpan(entrySrc: string, key: string): { valueStart: number; valueEnd: number } | null {
+    const n = entrySrc.length;
+    const isWs = (c: string) => c === ' ' || c === '\t' || c === '\n' || c === '\r';
+    let i = 0;
+    let depth = 0;
+    while (i < n) {
+        const c = entrySrc[i];
+        if (isWs(c)) { i++; continue; }
+        if (c === '/' && entrySrc[i + 1] === '/') { while (i < n && entrySrc[i] !== '\n') i++; continue; }
+        if (c === '/' && entrySrc[i + 1] === '*') { i += 2; while (i < n && !(entrySrc[i] === '*' && entrySrc[i + 1] === '/')) i++; i += 2; continue; }
+        if (c === '{' || c === '[') { depth++; i++; continue; }
+        if (c === '}' || c === ']') { depth--; i++; continue; }
+        if (c !== '"') { i++; continue; }
+        // String literal: read it (honoring backslash escapes).
+        let j = i + 1;
+        let str = '';
+        while (j < n) {
+            const d = entrySrc[j];
+            if (d === '\\') { str += entrySrc.slice(j, j + 2); j += 2; continue; }
+            if (d === '"') break;
+            str += d; j++;
+        }
+        if (j >= n) return null;
+        const closingQuote = j;
+        if (depth !== 1 || str !== key) { i = closingQuote + 1; continue; }
+        // Candidate key at top level: expect `:` then a quoted value.
+        let k = closingQuote + 1;
+        while (k < n && isWs(entrySrc[k])) k++;
+        if (entrySrc[k] !== ':') { i = closingQuote + 1; continue; }
+        k++;
+        while (k < n && isWs(entrySrc[k])) k++;
+        if (entrySrc[k] !== '"') { i = closingQuote + 1; continue; }
+        let m = k + 1;
+        while (m < n) {
+            const e = entrySrc[m];
+            if (e === '\\') { m += 2; continue; }
+            if (e === '"') return { valueStart: k, valueEnd: m + 1 };
+            m++;
+        }
+        return null;
+    }
+    return null;
+}
+
+/**
+ * Byte-preserving accountId update: replaces the value in place, or inserts
+ * `"accountId"` right after `"preferredAccount"` keeping the line indent, so
+ * comments, key order and formatting elsewhere in the file survive. The
+ * patched document is re-parsed (comments allowed) and the value asserted
+ * before the atomic tmp+rename write. Returns false on any uncertainty —
+ * callers fall back to a full rewrite.
+ */
+function patchAccountIdInRaw(filePath: string, entryIndex: number, accountId: string): boolean {
+    let raw: string;
+    try {
+        raw = fs.readFileSync(filePath, 'utf8');
+    } catch (_) {
+        return false;
+    }
+    const span = findBotsEntrySpan(raw, entryIndex);
+    if (!span) return false;
+    const entrySrc = raw.slice(span.start, span.end);
+    let patchedEntry: string | null = null;
+    const idSpan = findEntryKeyValueSpan(entrySrc, 'accountId');
+    if (idSpan) {
+        patchedEntry = entrySrc.slice(0, idSpan.valueStart)
+            + `"${accountId}"`
+            + entrySrc.slice(idSpan.valueEnd);
+    } else {
+        const prefSpan = findEntryKeyValueSpan(entrySrc, 'preferredAccount');
+        if (!prefSpan) return false;
+        const lineStart = entrySrc.lastIndexOf('\n', prefSpan.valueEnd) + 1;
+        const indentMatch = /^[ \t]*/.exec(entrySrc.slice(lineStart));
+        const indent = indentMatch ? indentMatch[0] : '  ';
+        patchedEntry = entrySrc.slice(0, prefSpan.valueEnd)
+            + `,\n${indent}"accountId": "${accountId}"`
+            + entrySrc.slice(prefSpan.valueEnd);
+    }
+    if (!patchedEntry || patchedEntry === entrySrc) return false;
+    const patched = raw.slice(0, span.start) + patchedEntry + raw.slice(span.end);
+    try {
+        const reparsed = parseJsonWithComments(patched);
+        const checkEntries = Array.isArray(reparsed?.bots) ? reparsed.bots : [];
+        if (checkEntries[entryIndex]?.accountId !== accountId) return false;
+    } catch (_) {
+        return false;
+    }
+    const tmpPath = `${filePath}.tmp-persist-${process.pid}-${Date.now()}`;
+    try {
+        fs.writeFileSync(tmpPath, patched, 'utf8');
+        fs.renameSync(tmpPath, filePath);
+        return true;
+    } catch (_) {
+        try { fs.unlinkSync(tmpPath); } catch (_) { /* best-effort cleanup */ }
+        return false;
+    }
+}
+
+/**
+ * Persist a resolved account name → ID mapping onto the bot entry in
+ * profiles/bots.json (`accountId` next to `preferredAccount`), so analysis
+ * tools can skip the chain lookup on subsequent runs. No-op when the stored
+ * value already matches. Prefers a byte-preserving textual patch (comments,
+ * key order and formatting survive); falls back to a full rewrite using the
+ * same atomic writeJSON serialization the bot editor uses. Returns true when
+ * the file was updated.
+ */
+function persistBotAccountId(botKey: any, accountId: string, filePath = PATHS.PROFILES.BOTS_JSON): boolean {
+    if (!botKey || !/^1\.2\.\d+$/.test(String(accountId))) return false;
+    let settings: any = null;
+    try {
+        settings = loadBotSettings(filePath);
+    } catch (_) {
+        return false;
+    }
+    const entries = Array.isArray(settings?.bots) ? settings.bots : [];
+    const normalizedKey = String(botKey).toLowerCase();
+    const index = entries.findIndex((bot: any, i: number) => computeBotKey(bot, i) === normalizedKey);
+    if (index < 0 || entries[index]?.accountId === accountId) return false;
+    try {
+        if (patchAccountIdInRaw(filePath, index, String(accountId))) return true;
+    } catch (_) {
+        // Fall through to the full rewrite below.
+    }
+    entries[index].accountId = String(accountId);
+    try {
+        writeJSON(filePath, settings);
+        return true;
+    } catch (_) {
+        return false;
+    }
+}
+
+/**
+ * Return the stored chain account ID for a bot key, or null when none is
+ * stamped yet. When expectedRef is given, the stored ID is only returned if
+ * the entry's current preferredAccount still matches it — a rename must
+ * never silently reuse a stale ID.
+ */
+function getStoredBotAccountId(botKey: any, expectedRef?: string | null, filePath = PATHS.PROFILES.BOTS_JSON): string | null {
+    if (!botKey) return null;
+    let meta: any = null;
+    try {
+        meta = loadBotMeta(botKey, filePath);
+    } catch (_) {
+        return null;
+    }
+    const stored = meta && /^1\.2\.\d+$/.test(String(meta.accountId ?? '')) ? String(meta.accountId) : null;
+    if (!stored) return null;
+    if (expectedRef != null && String(meta.preferredAccount ?? '').toLowerCase() !== String(expectedRef).toLowerCase()) return null;
+    return stored;
+}
+
+/**
+ * Find the bot entry whose preferredAccount matches a raw account reference
+ * (case-insensitive). Used by tools that accept a bare account name to locate
+ * the stored accountId and the persist target. Returns null for 1.2.x input
+ * or when no bot claims the name.
+ */
+function findBotKeyByAccountRef(ref: any, filePath = PATHS.PROFILES.BOTS_JSON): { botKey: string; meta: any } | null {
+    if (!ref || /^1\.2\.\d+$/.test(String(ref))) return null;
+    let settings: any = null;
+    try {
+        settings = loadBotSettings(filePath);
+    } catch (_) {
+        return null;
+    }
+    const entries = Array.isArray(settings?.bots) ? settings.bots : [];
+    const want = String(ref).toLowerCase();
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        if (entry && String(entry.preferredAccount ?? '').toLowerCase() === want) {
+            return { botKey: computeBotKey(entry, i), meta: entry };
+        }
+    }
+    return null;
+}
+
 function resolveAmaConfig(botKey: any) {
     const botMeta = loadBotMeta(botKey);
     // Unknown bot key: fall back to the global erSmoothPeriod default (same
@@ -153,5 +422,5 @@ function resolveAmaKey(botKey: any) {
     return 'AMA3';
 }
 
-export { loadBotSettings, sanitizeKey, computeBotKey, resolveBotKey, candleFileForBot, resolveCandleFile, loadBotMeta, resolveAmaConfig, resolveAmaKey }
+export { loadBotSettings, sanitizeKey, computeBotKey, resolveBotKey, candleFileForBot, resolveCandleFile, loadBotMeta, getStoredBotAccountId, findBotKeyByAccountRef, persistBotAccountId, resolveAmaConfig, resolveAmaKey }