dexbot 1.4.25 → 1.5.0

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 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

package/README.md

@@ -235,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
 ```
 
@@ -260,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
@@ -272,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

@@ -24,7 +24,7 @@ Tools that inspect DEXBot trading behavior and the market data it operates on. O
 | [`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>` |
@@ -138,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 \
@@ -162,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 |
@@ -240,7 +241,7 @@ npm run analysis:grid-check -- --bot-key <bot-key> --per-fill --hours 168
 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 `preferredAccount` and can be overridden with `--account <1.2.x|name>`.
+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>
 
@@ -250,7 +251,8 @@ Exit code `0` = pass, `2` = violations found, `1` = fatal error. Bot keys resolv
 | `--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 | Resolve account name to 1.2.x via BitShares node |
+| `--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 |
@@ -309,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

package/analysis/ama_fitting/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ama_fitting",
-  "version": "1.4.25",
+  "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 }
 

package/analysis/bot_usage/discover_bot_accounts.ts

@@ -18,12 +18,16 @@ const { writeJSON } = getStorage();
  *        Q1 — top 100 accounts by limit_order_create count
  *        Q2 — top 100 accounts by limit_order_cancel count
  *        Q3 — top 100 accounts by fill_order count
+ *        Q4 — top 200 accounts by limit_order_update count (op 77, DEXBot2 fingerprint)
  *   2. Merge & pre-filter:
  *        creates ≥ MIN_CREATES  (grid analysis determines DEXBot candidacy)
  *   3. Grid analysis (parallel, batches of 5):
  *        Fetch 200 raw orders per candidate → per-session geometric spacing test
  *   4. BitShares: resolve account IDs → names (batch db.get_objects call)
- *   5. Rank by DEX score and print table
+ *   5. Rank by DEX score and print table.
+ *        HIGH tier (80+) is split by op-77 usage:
+ *          updates ≥ 1 → DEXBot2 (native limit_order_update in-place re-price)
+ *          updates = 0 → DEXBot1-style (cancel-only, cancel + recreate)
  *
  * Usage:
  *   node dist/analysis/bot_usage/discover_bot_accounts.js
@@ -51,6 +55,7 @@ import {
     buildTopSellerAccountsQuery,
     buildTopCancellerAccountsQuery,
     buildTopFilledAccountsQuery,
+    buildTopUpdaterAccountsQuery,
     DEFAULT_CONFIG,
 } from './kibana_bot_queries.js';
 import { NODE_MANAGEMENT } from '../../modules/constants.js';
@@ -61,6 +66,7 @@ interface AccountCounts {
     creates: number;
     cancels: number;
     fills: number;
+    updates: number;
 }
 
 interface CandidateInfo {
@@ -68,6 +74,8 @@ interface CandidateInfo {
     creates: number;
     cancels: number;
     fills: number;
+    updates: number;
+    flavor: 'DEXBot2' | 'DEXBot1' | '';
     cancelRatio: number;
     fillRate: number;
     gridScore: number;
@@ -323,18 +331,21 @@ async function run() {
 
     console.log('Phase 1: Querying Kibana for top active accounts...');
 
-    const [createRes, cancelRes, fillRes]: any[] = await Promise.all([
+    const [createRes, cancelRes, fillRes, updateRes]: any[] = await Promise.all([
         withRetry(() => kibanaSearch(KIBANA_CFG, buildTopSellerAccountsQuery(lookbackH, 200, opts.minCreates)),
             'top-seller query'),
         withRetry(() => kibanaSearch(KIBANA_CFG, buildTopCancellerAccountsQuery(lookbackH, 200, 5)),
             'top-canceller query'),
         withRetry(() => kibanaSearch(KIBANA_CFG, buildTopFilledAccountsQuery(lookbackH, 200, 3)),
             'top-fills query'),
+        withRetry(() => kibanaSearch(KIBANA_CFG, buildTopUpdaterAccountsQuery(lookbackH, 200, 1)),
+            'top-updater query'),
     ]);
 
     const createBuckets = createRes?.aggregations?.by_account?.buckets ?? [];
     const cancelBuckets = cancelRes?.aggregations?.by_account?.buckets ?? [];
     const fillBuckets   = fillRes?.aggregations?.by_account?.buckets   ?? [];
+    const updateBuckets = updateRes?.aggregations?.by_account?.buckets ?? [];
 
     if (opts.verbose) {
         console.log(`  [verbose] createRes keys: ${Object.keys(createRes ?? {}).join(', ')}`);
@@ -344,6 +355,7 @@ async function run() {
     console.log(`  Creates: ${createBuckets.length} accounts with ≥${opts.minCreates} creates`);
     console.log(`  Cancels: ${cancelBuckets.length} accounts with ≥5 cancels`);
     console.log(`  Fills:   ${fillBuckets.length} accounts with ≥3 fills`);
+    console.log(`  Updates: ${updateBuckets.length} accounts with ≥1 limit_order_update (op 77)`);
 
     if (createBuckets.length === 0) {
         console.log('');
@@ -360,17 +372,23 @@ async function run() {
     console.log('\nPhase 2: Merging and filtering candidates...');
 
     const accounts: Record<string, AccountCounts> = {};
-    for (const b of createBuckets) accounts[b.key] = { creates: b.doc_count, cancels: 0, fills: 0 };
+    for (const b of createBuckets) accounts[b.key] = { creates: b.doc_count, cancels: 0, fills: 0, updates: 0 };
     for (const b of cancelBuckets) {
-        if (!accounts[b.key]) accounts[b.key] = { creates: 0, cancels: 0, fills: 0 };
+        if (!accounts[b.key]) accounts[b.key] = { creates: 0, cancels: 0, fills: 0, updates: 0 };
         accounts[b.key].cancels = b.doc_count;
     }
     for (const b of fillBuckets) {
-        if (!accounts[b.key]) accounts[b.key] = { creates: 0, cancels: 0, fills: 0 };
+        if (!accounts[b.key]) accounts[b.key] = { creates: 0, cancels: 0, fills: 0, updates: 0 };
         accounts[b.key].fills = b.doc_count;
     }
+    for (const b of updateBuckets) {
+        if (!accounts[b.key]) accounts[b.key] = { creates: 0, cancels: 0, fills: 0, updates: 0 };
+        accounts[b.key].updates = b.doc_count;
+    }
 
     // Pre-filter: must have creates ≥ minCreates (grid analysis determines DEXBot candidacy)
+    // Flavor: any limit_order_update (op 77) in-window → DEXBot2 (native in-place
+    // re-price); zero updates → DEXBot1-style (cancel-only: cancel + recreate).
     const candidates: CandidateInfo[] = (Object.entries(accounts) as [string, AccountCounts][])
         .filter(([, s]) => s.creates >= opts.minCreates)
         .map(([id, s]) => ({
@@ -378,6 +396,8 @@ async function run() {
             creates: s.creates,
             cancels: s.cancels,
             fills:   s.fills,
+            updates: s.updates,
+            flavor: (s.updates >= 1 ? 'DEXBot2' : 'DEXBot1') as 'DEXBot2' | 'DEXBot1',
             cancelRatio: s.cancels / Math.max(s.creates, 1),
             fillRate:    s.creates > 0 ? (s.fills / s.creates * 100) : 0,
         } as CandidateInfo))
@@ -492,9 +512,41 @@ async function run() {
     console.log('════════════════════════════════════════════════════════════════════════════════════');
     console.log('');
 
-    // Print by DEX score tier
+    // Print by DEX score tier. HIGH tier (80+) splits by update-order usage:
+    //   DEXBot2      — broadcast limit_order_update (op 77) in-window (in-place re-price)
+    //   DEXBot1-style — cancel-only, no op 77 (cancel + recreate)
+    const highV2 = results.filter(r => r.dexScore >= 80 && r.updates >= 1);
+    const highV1 = results.filter(r => r.dexScore >= 80 && r.updates < 1);
+
+    const hdrHigh = ' #   Name                  ID              Creates  Fills  Cancel  Fill%  C/C   MaxBatch  Incr%  Grid  DEX  Updates';
+    function printHighGroup(label: string, rows: CandidateInfo[]) {
+        if (!rows.length) return;
+        console.log(` ── ${label}`);
+        console.log('');
+        console.log(hdrHigh);
+        console.log(' ' + '─'.repeat(hdrHigh.length - 1));
+        for (const r of rows) {
+            const rank    = String(results.indexOf(r) + 1).padStart(2);
+            const name    = r.name.padEnd(22).slice(0, 22);
+            const id      = r.id.padEnd(14);
+            const creates = String(r.creates).padStart(7);
+            const fills   = String(r.fills).padStart(6);
+            const cancels = String(r.cancels).padStart(7);
+            const fr      = (r.fillRate.toFixed(1) + '%').padStart(5);
+            const cr      = r.cancelRatio.toFixed(2).padStart(4);
+            const batch   = String(r.maxBatch || '-').padStart(9);
+            const inc     = (r.impliedInc != null ? r.impliedInc.toFixed(2) + '%' : 'n/a').padStart(6);
+            const grid    = String(r.gridScore).padStart(5);
+            const dex     = String(r.dexScore).padStart(4);
+            const upd     = String(r.updates).padStart(7);
+            console.log(` ${rank}  ${name}  ${id}  ${creates}  ${fills}  ${cancels}  ${fr}  ${cr}  ${batch}  ${inc}  ${grid}  ${dex}  ${upd}`);
+        }
+        console.log('');
+    }
+    printHighGroup('HIGH confidence — DEXBot2 (80+, uses limit_order_update op 77)', highV2);
+    printHighGroup('HIGH confidence — DEXBot1-style (80+, cancel-only, no op 77)', highV1);
+
     const tiers = [
-        { label: 'HIGH confidence (80+) — almost certainly DEXBot/DEXBot2', min: 80, max: 101 },
         { label: 'MEDIUM confidence (50–79) — likely a grid bot',           min: 50, max:  80 },
         { label: 'LOW confidence (25–49) — some automation detected',       min: 25, max:  50 },
         { label: 'WEAK signal (<25) — create/cancel pattern, no grid',     min:  0, max:  25 },
@@ -531,13 +583,13 @@ async function run() {
 
     // ── Summary ───────────────────────────────────────────────────────────────
 
-    const high   = results.filter(r => r.dexScore >= 80).length;
+    const high   = highV2.length + highV1.length;
     const medium = results.filter(r => r.dexScore >= 50 && r.dexScore < 80).length;
     const low    = results.filter(r => r.dexScore >= 25 && r.dexScore < 50).length;
 
     console.log('════════════════════════════════════════════════════════════════════════════════════');
     console.log(` Total candidates scanned:  ${results.length}`);
-    console.log(` HIGH (80+):   ${high}  accounts — almost certainly DEXBot/DEXBot2`);
+    console.log(` HIGH (80+):   ${high}  accounts — DEXBot2: ${highV2.length} (op 77 updates) / DEXBot1-style: ${highV1.length} (cancel-only)`);
     console.log(` MEDIUM (50+): ${medium}  accounts — likely grid bots`);
     console.log(` LOW (25+):    ${low}  accounts — weak signal`);
     console.log('');
@@ -545,6 +597,7 @@ async function run() {
     console.log('   C/C = cancel/create ratio  (grid bots: ~1.0)');
     console.log('   Incr% = implied grid increment from price spacing');
     console.log('   Grid = grid quality 0-100  |  DEX = DEXBot confidence 0-100');
+    console.log('   Updates = limit_order_update (op 77) count — DEXBot2 only; 0 = cancel-only (DEXBot1-style)');
     console.log('');
 
     // ── Export JSON ────────────────────────────────────────────────────────────
@@ -553,9 +606,11 @@ async function run() {
         const exportData = results.map(r => ({
             id:          r.id,
             name:        r.name,
+            flavor:      r.flavor,
             creates:     r.creates,
             fills:       r.fills,
             cancels:     r.cancels,
+            updates:     r.updates,
             fillPct:     r.fillRate,
             cancelRatio: r.cancelRatio,
             maxBatch:    r.maxBatch,