dexbot 1.4.25 → 1.5.0

package/analysis/bot_usage/kibana_bot_queries.ts

@@ -32,6 +32,10 @@
  *   limit_order_cancel:
  *     op_object.fee_paying_account        — account that cancelled
  *     op_object.order                     — the order ID cancelled
+ *
+ *   limit_order_update (op 77, DEXBot2-only — native in-place re-price):
+ *     op_object.seller                    — account that updated the order
+ *     op_object.order                     — the limit order ID updated
  */
 
 
@@ -42,6 +46,11 @@ import { kibanaSearch, DEFAULT_CONFIG as BASE_CONFIG } from '../../market_adapte
 const OP_LIMIT_ORDER_CREATE = 1;
 const OP_LIMIT_ORDER_CANCEL = 2;
 const OP_FILL_ORDER         = 4;
+// Native in-place order re-price. Only DEXBot2 broadcasts this (COW UPDATE
+// actions via buildUpdateOrderOp); DEXBot1 (Python staggered_orders) predates
+// it and can only cancel + recreate. Presence of op 77 on an account is the
+// DEXBot2 fingerprint; absence means cancel-only (DEXBot1-style).
+const OP_LIMIT_ORDER_UPDATE = 77;
 
 const DEFAULT_CONFIG = {
     ...BASE_CONFIG,
@@ -166,7 +175,37 @@ function buildTopFilledAccountsQuery(lookbackHours: number, topN: number = 100,
     };
 }
 
+/**
+ * Top N accounts by limit_order_update count (seller field, op 77).
+ * DEXBot2 fingerprint: only DEXBot2 broadcasts native in-place re-prices
+ * (COW UPDATE actions). DEXBot1-style bots never emit op 77 — they cancel
+ * (op 2) and recreate (op 1) instead.
+ */
+function buildTopUpdaterAccountsQuery(lookbackHours: number, topN: number = 200, minUpdates: number = 1) {
+    return {
+        size: 0,
+        query: {
+            bool: {
+                filter: [
+                    { term:  { operation_type: OP_LIMIT_ORDER_UPDATE } },
+                    { range: { 'block_data.block_time': { gte: `now-${lookbackHours}h`, lte: 'now' } } },
+                ],
+            },
+        },
+        aggs: {
+            by_account: {
+                terms: {
+                    field:         'operation_history.op_object.seller.keyword',
+                    size:          topN,
+                    min_doc_count: minUpdates,
+                    order:         { _count: 'desc' },
+                },
+            },
+        },
+    };
+}
+
 // ─── Exports ──────────────────────────────────────────────────────────────────
 
-export { DEFAULT_CONFIG, kibanaSearch, buildOrderPriceQuery, buildTopSellerAccountsQuery, buildTopCancellerAccountsQuery, buildTopFilledAccountsQuery }
+export { DEFAULT_CONFIG, kibanaSearch, buildOrderPriceQuery, buildTopSellerAccountsQuery, buildTopCancellerAccountsQuery, buildTopFilledAccountsQuery, buildTopUpdaterAccountsQuery, OP_LIMIT_ORDER_UPDATE }
 

package/analysis/chart_utils.ts

@@ -54,8 +54,11 @@ function toEpochSeconds(ts: any, fallbackIdx: any) {
     return fallbackIdx * 3600;
 }
 
-function writeChartFile(filePath: any, html: any) {
-    const chartDir = path.dirname(filePath);
+function toFileUrl(filePath: any): string {
+    return `file://${path.resolve(String(filePath))}`;
+}
+
+function writeChartFile(filePath: any, html: any) {    const chartDir = path.dirname(filePath);
     if (!fs.existsSync(chartDir)) ensureDir(chartDir);
     ensureSiblingUplotAssets(chartDir);
     // Atomic write (tmp + rename, matching the production storage adapter
@@ -190,5 +193,5 @@ function bindPan(chart) {
 }
 `;
 
-export { escapeHtml, serializeJsonForScript, toEpochSeconds, writeChartFile, embedFunctionSources, UPLOT_SHARED_SCRIPT }
+export { escapeHtml, serializeJsonForScript, toEpochSeconds, writeChartFile, toFileUrl, embedFunctionSources, UPLOT_SHARED_SCRIPT }
 

package/analysis/grid_correction_check.ts

@@ -37,7 +37,7 @@ import fs from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import * as KC from '../market_adapter/core/kibana_client.js';
 import * as C from '../modules/constants.js';
-import { loadBotMeta, loadBotSettings, computeBotKey } from './bot_key_utils.js';
+import { loadBotMeta, loadBotSettings, computeBotKey, persistBotAccountId } from './bot_key_utils.js';
 
 const { kibanaSearch, DEFAULT_CONFIG: BASE_CONFIG } = KC;
 
@@ -221,8 +221,11 @@ Time range (one of):
 
 Options:
   --account <id>         Override account ID (default: from bot preferredAccount)
-  --lookup               Resolve account name to ID via BitShares node
-  --node <url>           BitShares node URL for --lookup / precision resolution
+  --lookup               Legacy: account names always resolve via BitShares node
+  --refresh-account      Force re-resolution of preferredAccount and update the
+                         stored accountId when it changed (default: reuse the
+                         stored accountId with no chain lookup)
+  --node <url>           BitShares node URL for account / precision resolution
   --increment <pct>      Grid increment percent (default: from bot config or ${Number((C as any)?.DEFAULT_CONFIG?.incrementPercent ?? 0.5)})
   --tolerance <pct>      Deprecated alias for --increment (kept for compat, prefer --increment)
   --per-fill             Check at fill granularity (default: per-order aggregated)
@@ -262,6 +265,7 @@ function parseArgs() {
         end: null,
         account: null,
         lookup: false,
+        refreshAccount: false,
         node: C.NODE_MANAGEMENT.DEFAULT_NODES[0],
         perFill: false,
         includeCrossPair: false,
@@ -279,6 +283,7 @@ function parseArgs() {
             case '--end': opts.end = args[++i]; break;
             case '--account': opts.account = args[++i]; break;
             case '--lookup': opts.lookup = true; break;
+            case '--refresh-account': opts.refreshAccount = true; break;
             case '--node': opts.node = args[++i]; break;
             case '--per-fill': opts.perFill = true; break;
             case '--include-cross-pair': opts.includeCrossPair = true; break;
@@ -356,32 +361,63 @@ async function resolveAccountId(name: string, nodeUrl: string): Promise<string |
     }
 }
 
-async function resolveAccountForBot(botKey: string, overrideAccount: string | null, nodeUrl: string, doLookup: boolean): Promise<{ accountId: string; botMeta: any }> {
+async function resolveAccountForBot(botKey: string, overrideAccount: string | null, nodeUrl: string, doRefresh: boolean): Promise<{ accountId: string; botMeta: any }> {
     const botMeta = loadBotMeta(botKey);
     if (!botMeta && !overrideAccount) {
         console.error(`Error: bot key '${botKey}' not found in profiles/bots.json and no --account provided.`);
         console.error(`Use --list-bots to see available keys, or pass --account <1.2.x> explicitly.`);
         process.exit(1);
     }
-    let accountId = overrideAccount ?? botMeta?.preferredAccount ?? null;
-    if (!accountId) {
+    // An explicit --account always wins and is never persisted.
+    if (overrideAccount) {
+        if (/^1\.2\.\d+$/.test(String(overrideAccount))) {
+            return { accountId: String(overrideAccount), botMeta };
+        }
+        console.log(`  Resolving account name '${overrideAccount}'...`);
+        const resolvedOverride = await resolveAccountId(String(overrideAccount), nodeUrl);
+        if (!resolvedOverride) {
+            console.error(`Error: failed to resolve --account '${overrideAccount}' to 1.2.x`);
+            process.exit(1);
+        }
+        console.log(`  → ${resolvedOverride}`);
+        return { accountId: String(resolvedOverride), botMeta };
+    }
+    const prefRaw = botMeta?.preferredAccount != null ? String(botMeta.preferredAccount) : null;
+    const prefIsId = !!prefRaw && /^1\.2\.\d+$/.test(prefRaw);
+    const storedId = /^1\.2\.\d+$/.test(String(botMeta?.accountId ?? '')) ? String(botMeta.accountId) : null;
+    // An explicit 1.2.x preferredAccount is authoritative: the stored accountId
+    // is a derived cache and must never override it. Self-heal the cache.
+    if (prefIsId) {
+        if (storedId && storedId !== prefRaw && persistBotAccountId(botKey, prefRaw as string)) {
+            console.log(`  Updated stale stored accountId ${storedId} → ${prefRaw} from preferredAccount`);
+        }
+        return { accountId: prefRaw as string, botMeta };
+    }
+    if (!prefRaw) {
         console.error(`Error: bot '${botKey}' has no preferredAccount and no --account provided.`);
         process.exit(1);
     }
-    // If account looks like a name, resolve it
-    if (!/^1\.2\.\d+$/.test(String(accountId))) {
-        if (doLookup || !String(accountId).startsWith('1.2.')) {
-            console.log(`  Resolving account name '${accountId}'...`);
-            const resolved = await resolveAccountId(String(accountId), nodeUrl);
-            if (!resolved) {
-                console.error(`Error: failed to resolve account name '${accountId}' to 1.2.x`);
-                process.exit(1);
-            }
-            console.log(`  → ${resolved}`);
-            accountId = resolved;
-        }
+    // Name + fresh-enough cache + no refresh requested: offline-friendly fast path.
+    if (storedId && !doRefresh) {
+        console.log(`  Using stored accountId ${storedId} from profiles/bots.json (no lookup needed; pass --refresh-account to re-verify)`);
+        return { accountId: storedId, botMeta };
+    }
+    // No cache, or --refresh-account: resolve the name on-chain.
+    console.log(`  Resolving account name '${prefRaw}'...`);
+    const resolved = await resolveAccountId(prefRaw, nodeUrl);
+    if (!resolved) {
+        console.error(`Error: failed to resolve account name '${prefRaw}' to 1.2.x`);
+        process.exit(1);
+    }
+    console.log(`  → ${resolved}`);
+    if (!storedId && persistBotAccountId(botKey, resolved)) {
+        console.log(`  Stored accountId ${resolved} in profiles/bots.json for '${botKey}'`);
+    } else if (storedId && storedId !== resolved && persistBotAccountId(botKey, resolved)) {
+        console.log(`  Updated stored accountId ${storedId} → ${resolved} in profiles/bots.json for '${botKey}'`);
+    } else if (storedId === resolved) {
+        console.log(`  Stored accountId ${resolved} confirmed up to date`);
     }
-    return { accountId: String(accountId), botMeta };
+    return { accountId: String(resolved), botMeta };
 }
 
 // ─── Asset precision resolution ───────────────────────────────────────────────
@@ -829,7 +865,7 @@ async function main() {
     console.log(`\nGrid correction check — bot-key: ${opts.botKey}`);
     console.log(`Range: ${label}`);
 
-    const { accountId, botMeta } = await resolveAccountForBot(opts.botKey, opts.account, opts.node, opts.lookup);
+    const { accountId, botMeta } = await resolveAccountForBot(opts.botKey, opts.account, opts.node, opts.refreshAccount);
     console.log(`Account: ${accountId}${botMeta ? `  (${botMeta.assetA}/${botMeta.assetB})` : ''}`);
     const incrementPercent = resolveIncrementPercent(botMeta, opts.incrementPercent);
     console.log(`Increment: ${incrementPercent}% (halfInc ${incrementPercent/2}%)${opts.incrementPercent == null && botMeta?.incrementPercent != null ? ' — from bot config' : opts.incrementPercent != null ? ' — from --increment' : ' — default'}`);

package/analysis/resolve_bot_accounts.ts

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * BOT ACCOUNT-ID BACKFILL
+ *
+ * Resolves every bot's preferredAccount name to its chain account ID and
+ * stamps `accountId` next to `preferredAccount` in profiles/bots.json, so
+ * analysis tools and scripts can skip the chain lookup on later runs.
+ * Nothing is ever written by hand — all IDs in the file come from this
+ * script, the bot editor, or the analysis tools themselves.
+ *
+ * Usage:
+ *   node dist/analysis/resolve_bot_accounts.js [--bot-key <key>] [--refresh]
+ *       [--timeout-ms <n>] [--dry-run] [--json]
+ *
+ * Exit code 0 = all bot accounts resolved (or nothing to do),
+ *           1 = one or more resolutions failed.
+ *
+ * Short-lived batch tool: suppresses chain INFO logging and disconnects the
+ * shared client on exit. Run standalone only — never import/call from a
+ * long-running process holding a live connection.
+ */
+
+import { loadBotSettings, computeBotKey, persistBotAccountId } from './bot_key_utils.js';
+import { setGlobalConsoleLevel, getGlobalConsoleLevel } from '../modules/order/logger.js';
+import { sleep } from '../modules/order/utils/system.js';
+import { getErrorMessage } from '../modules/utils/errors.js';
+
+const DEFAULT_TIMEOUT_MS = 20000;
+
+function printHelp() {
+    console.log(`\
+Usage: node dist/analysis/resolve_bot_accounts.js [options]
+
+Resolve bot preferredAccount names to chain IDs and store them as accountId
+in profiles/bots.json (byte-preserving; comments and formatting survive).
+
+Options:
+  --bot-key <key>    Only process this bot key or bot name (default: all bots)
+  --refresh          Re-resolve even when a stored accountId exists
+  --timeout-ms <n>   Per-account chain lookup timeout (default: ${DEFAULT_TIMEOUT_MS})
+  --dry-run          Report what would change without writing anything
+  --json             Append a machine-readable summary
+  --help, -h         Show this help
+`);
+}
+
+function parseArgs() {
+    const args = process.argv.slice(2);
+    if (args.includes('--help') || args.includes('-h')) { printHelp(); process.exit(0); }
+    const opts: any = {
+        botKey: null,
+        refresh: false,
+        timeoutMs: DEFAULT_TIMEOUT_MS,
+        dryRun: false,
+        json: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        switch (args[i]) {
+            case '--bot-key': opts.botKey = args[++i]; break;
+            case '--refresh': opts.refresh = true; break;
+            case '--timeout-ms': opts.timeoutMs = parseInt(args[++i], 10); break;
+            case '--dry-run': opts.dryRun = true; break;
+            case '--json': opts.json = true; break;
+            default:
+                console.error(`Unknown option: ${args[i]}`);
+                process.exit(1);
+        }
+    }
+    if (!Number.isFinite(opts.timeoutMs) || opts.timeoutMs <= 0) {
+        console.error('Error: --timeout-ms must be a positive number.');
+        process.exit(1);
+    }
+    return opts;
+}
+
+async function resolveWithTimeout(chainOrders: any, ref: string, timeoutMs: number): Promise<{ id: string | null; reason: string }> {
+    const timeoutErr: any = new Error(`lookup timed out after ${timeoutMs}ms`);
+    timeoutErr.code = 'ACCOUNT_LOOKUP_TIMEOUT';
+    try {
+        const id = await Promise.race([
+            chainOrders.resolveAccountId(ref),
+            sleep(timeoutMs).then(() => { throw timeoutErr; }),
+        ]);
+        if (id && /^1\.2\.\d+$/.test(String(id))) return { id: String(id), reason: 'resolved' };
+        return { id: null, reason: 'not-found' };
+    } catch (err: any) {
+        return { id: null, reason: err && err.code === 'ACCOUNT_LOOKUP_TIMEOUT' ? 'timeout' : 'error' };
+    }
+}
+
+async function main() {
+    const opts = parseArgs();
+    const settings = loadBotSettings();
+    const entries = Array.isArray(settings?.bots) ? settings.bots : [];
+    if (!entries.length) {
+        console.log('No bots in profiles/bots.json — nothing to do.');
+        process.exit(0);
+    }
+
+    let targets = entries.map((bot: any, index: number) => ({ bot, index, key: computeBotKey(bot, index) }));
+    if (opts.botKey) {
+        const want = String(opts.botKey).toLowerCase();
+        targets = targets.filter((t: any) => t.key === want || String(t.bot?.name ?? '').toLowerCase() === want);
+        if (!targets.length) {
+            console.error(`Error: bot '${opts.botKey}' not found in profiles/bots.json.`);
+            process.exit(1);
+        }
+    }
+
+    // Suppress chain INFO spam for the whole batch; restored in finally.
+    // (setSuppressConnectionLog is read lazily so this file never drags the
+    // chain stack in when it cannot be loaded.)
+    let chainClient: any = null;
+    let prevSuppress = false;
+    let prevGlobalLevel: string | null = null;
+    let suppressionArmed = false;
+    let chainOrders: any = null;
+    try {
+        chainClient = await import('../modules/bitshares_client.js');
+        prevSuppress = chainClient.isSuppressConnectionLog();
+        prevGlobalLevel = getGlobalConsoleLevel();
+        suppressionArmed = true;
+        chainClient.setSuppressConnectionLog(true);
+        setGlobalConsoleLevel('warn');
+        chainOrders = await import('../modules/chain_orders.js');
+    } catch (err: any) {
+        console.error(`Error: could not load the chain stack (${getErrorMessage(err)}).`);
+        process.exit(1);
+    }
+
+    const results: any[] = [];
+    try {
+        for (const t of targets) {
+            const name = t.bot?.name ?? t.key;
+            const prefRaw = t.bot?.preferredAccount != null ? String(t.bot.preferredAccount) : '';
+            const stored = /^1\.2\.\d+$/.test(String(t.bot?.accountId ?? '')) ? String(t.bot.accountId) : null;
+            if (!prefRaw) {
+                results.push({ key: t.key, name, status: 'skipped', detail: 'no preferredAccount' });
+                console.log(`- ${t.key}: skipped (no preferredAccount)`);
+                continue;
+            }
+            if (/^1\.2\.\d+$/.test(prefRaw)) {
+                if (stored !== prefRaw) {
+                    const wrote = opts.dryRun ? true : persistBotAccountId(t.key, prefRaw);
+                    const status = !wrote ? 'failed' : (opts.dryRun ? 'would-update' : 'updated');
+                    results.push({ key: t.key, name, status, detail: wrote ? `preferredAccount is authoritative (${prefRaw})` : 'could not write profiles/bots.json' });
+                    console.log(`- ${t.key}: ${!wrote ? 'FAILED to write' : (opts.dryRun ? 'would update' : 'updated')} stored accountId → ${prefRaw} (preferredAccount is authoritative)`);
+                } else {
+                    results.push({ key: t.key, name, status: 'cached', detail: prefRaw });
+                    console.log(`- ${t.key}: cached (${prefRaw})`);
+                }
+                continue;
+            }
+            if (stored && !opts.refresh) {
+                results.push({ key: t.key, name, status: 'cached', detail: stored });
+                console.log(`- ${t.key}: cached (${stored})`);
+                continue;
+            }
+            const r = await resolveWithTimeout(chainOrders, prefRaw, opts.timeoutMs);
+            if (r.id) {
+                const changed = stored !== r.id;
+                const wrote = !changed || opts.dryRun ? true : persistBotAccountId(t.key, r.id);
+                const status = !wrote ? 'failed' : (opts.dryRun ? (changed ? 'would-update' : 'unchanged') : (changed ? (stored ? 'updated' : 'stored') : 'unchanged'));
+                results.push({ key: t.key, name, status, detail: wrote ? r.id : 'could not write profiles/bots.json' });
+                console.log(`- ${t.key}: '${prefRaw}' → ${r.id}${!wrote ? ' (FAILED to store)' : (changed ? (opts.dryRun ? ' (would store)' : (stored ? ' (updated)' : ' (stored)')) : ' (unchanged)')}`);
+            } else {
+                const why = r.reason === 'timeout' ? `nodes unreachable (timed out after ${opts.timeoutMs}ms)` : 'not found on the blockchain';
+                results.push({ key: t.key, name, status: 'failed', detail: why });
+                console.log(`- ${t.key}: FAILED to resolve '${prefRaw}' (${why})`);
+            }
+        }
+    } finally {
+        if (chainClient) {
+            try { await chainClient.disconnectClient(); } catch (_) { /* best-effort cleanup */ }
+            if (suppressionArmed) {
+                try { chainClient.setSuppressConnectionLog(prevSuppress); } catch (_) { /* restore-only */ }
+            }
+        }
+        if (suppressionArmed) {
+            try { setGlobalConsoleLevel(prevGlobalLevel); } catch (_) { /* restore-only */ }
+        }
+    }
+
+    const failed = results.filter((r: any) => r.status === 'failed');
+    const skipped = results.filter((r: any) => r.status === 'skipped').length;
+    const ok = results.length - failed.length - skipped;
+    console.log(`\nDone: ${ok} resolved, ${skipped} skipped, ${failed.length} failed${opts.dryRun ? ' (dry run, nothing written)' : ''}.`);
+    if (opts.json) {
+        console.log(JSON.stringify({ dryRun: opts.dryRun, results }, null, 2));
+    }
+    process.exit(failed.length ? 1 : 0);
+}
+
+main().catch((err: any) => {
+    console.error('Fatal:', getErrorMessage(err));
+    process.exit(1);
+});

package/analysis/trade_profitability.ts

@@ -5,6 +5,7 @@ import fs from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import * as KC from '../market_adapter/core/kibana_client.js';
 import * as C from '../modules/constants.js';
+import { findBotKeyByAccountRef, getStoredBotAccountId, persistBotAccountId } from './bot_key_utils.js';
 
 const { kibanaSearch, DEFAULT_CONFIG: BASE_CONFIG } = KC;
 
@@ -194,14 +195,15 @@ Analyzes filled orders for a BitShares account, computing realized PnL
 via FIFO or sequential (LIFO) inventory tracking.
 
 Arguments:
-  accountId              BitShares account ID (1.2.x) or name (with --lookup)
+  accountId              BitShares account ID (1.2.x) or name (auto-resolved in the background)
 
 Options:
   --start <iso>          Start time (ISO 8601, e.g. 2025-01-01 or 2025-01-01T00:00:00Z)
   --end <iso>            End time (ISO 8601)
   --hours <n>            Lookback hours from now (alternative to --start/--end)
   --asset <assetId>      Filter to one base asset (e.g. 1.3.113 for bitUSD)
-  --lookup               Resolve account name to ID via BitShares node
+  --lookup               Legacy (no-op): account names always resolve automatically
+  --refresh-account      Force re-resolution and update the stored accountId
   --node <url>           BitShares node URL (default: first healthy from built-in pool)
   --csv <file>           Export trade list as CSV
   --json <file>          Export full analysis as JSON
@@ -233,6 +235,7 @@ function parseArgs() {
         end: null,
         asset: null,
         lookup: false,
+        refreshAccount: false,
         node: C.NODE_MANAGEMENT.DEFAULT_NODES[0],
         csv: null,
         json: null,
@@ -249,6 +252,7 @@ function parseArgs() {
             case '--end':          opts.end      = args[++i]; break;
             case '--asset':        opts.asset    = args[++i]; break;
             case '--lookup':       opts.lookup   = true; break;
+            case '--refresh-account': opts.refreshAccount = true; break;
             case '--node':         opts.node     = args[++i]; break;
             case '--csv':          opts.csv      = args[++i]; break;
             case '--json':         opts.json     = args[++i]; break;
@@ -1329,13 +1333,37 @@ async function run() {
     const opts = parseArgs();
     let accountId = opts.accountId;
 
-    if (opts.lookup) {
-        const resolved = await resolveAccountId(accountId, opts.node);
-        if (!resolved) {
-            console.error(`  Could not resolve "${accountId}" to an account ID`);
-            process.exit(1);
+    if (!/^1\.2\.\d+$/.test(String(accountId))) {
+        // Background resolution: the Kibana query below filters on the 1.2.x
+        // account_id field, so a name must always resolve first (a raw name
+        // would silently return zero fills).
+        // Stored ID first: when the name belongs to a bot in profiles/bots.json
+        // and its stamped accountId still matches, no chain lookup is needed.
+        let matchedKey: string | null = null;
+        let stored: string | null = null;
+        try {
+            const match = findBotKeyByAccountRef(accountId);
+            if (match) {
+                matchedKey = match.botKey;
+                stored = getStoredBotAccountId(match.botKey, accountId);
+            }
+        } catch (_) {
+            // bots.json issues must never break resolution; fall through to chain.
+        }
+        if (stored && !opts.refreshAccount) {
+            console.log(`  Using stored accountId ${stored} from profiles/bots.json (no lookup needed; pass --refresh-account to re-verify)`);
+            accountId = stored;
+        } else {
+            const resolved = await resolveAccountId(accountId, opts.node);
+            if (!resolved) {
+                console.error(`  Could not resolve "${accountId}" to an account ID`);
+                process.exit(1);
+            }
+            accountId = resolved;
+            if (matchedKey && persistBotAccountId(matchedKey, resolved)) {
+                console.log(`  Stored accountId ${resolved} in profiles/bots.json`);
+            }
         }
-        accountId = resolved;
     }
 
     // Build time range

package/analysis/tradingview/README.md

@@ -2,6 +2,31 @@
 
 This exporter generates a standalone HTML chart in the `analysis/charts/` folder using the local `uPlot`-based TradingView-style renderer.
 
+## Recommended: `dexbot tv` (One Step)
+
+`dexbot tv` fetches the candles itself (chunked Kibana scans for pools, order-book fallback for pairs) and then renders through this exporter — no manual fetch/export steps needed:
+
+```bash
+# Bot chart with AMA overlay (bot key from profiles/bots.json, default: 3 months)
+dexbot tv <bot>
+
+# Any pool by bare or full ID
+dexbot tv 133
+dexbot tv 1.19.133
+
+# Any pair (pool-first, order-book fallback)
+dexbot tv TOKENA/TOKENB
+
+# Options
+dexbot tv <bot> --month 6              # months of 1h candles (default: 3)
+dexbot tv <bot> --chart analysis/charts/custom.html
+dexbot tv <bot> --scale linear         # log (default) or linear
+```
+
+Output: `analysis/charts/tv_<bot|pool_<id>|<a>_<b>>_1h_<N>m.html`, with a clickable `file://` link printed on completion. Unknown targets fail fast with the list of known bot keys.
+
+The sections below cover manual usage (explicit candle files, direct runner flags).
+
 ## What It Produces
 
 - Log-scale price chart

package/analysis/tradingview/analyze_tradingview.ts

@@ -11,7 +11,7 @@ import { getErrorMessage } from '../../modules/utils/errors.js';
 import { toIntervalLabel } from '../../market_adapter/interval_utils.js';
 import { loadBotMeta } from '../bot_key_utils.js';
 import { resolveSource, listAvailableBots } from '../resolve_source.js';
-import { writeChartFile } from '../chart_utils.js';
+import { writeChartFile, toFileUrl } from '../chart_utils.js';
 import { PATHS } from '../../modules/paths.js';
 
 
@@ -148,7 +148,7 @@ async function main() {
 
         writeChartFile(config.chartFile, html);
 
-        if (!config.quiet) console.log(`[TradingView] ✓ Chart saved to ${config.chartFile}`);
+        if (!config.quiet) console.log(`\n[TradingView] ✓ Chart saved. Open chart: (${toFileUrl(config.chartFile)})`);
     } catch (err: any) {
         console.error(`[TradingView] Error: ${getErrorMessage(err)}`);
         process.exit(1);

package/analysis/trend_detection/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trend-detection",
-  "version": "1.4.25",
+  "version": "1.5.0",
   "description": "Kalman filter trend detection with tactical/modal state tracking",
   "main": "../../dist/analysis/trend_detection/kalman_trend_analyzer.js",
   "scripts": {

package/claw/modules/claw_launcher.ts

@@ -9,6 +9,7 @@ import { loadSettingsFile, resolveRawBotEntries, saveSettingsFile, normalizeBotE
 import { normalizeMode, detectMode, setPreferredMode, describeModeChoice } from './launcher_mode_detector.js';
 import { normalizeRoot, resolveRuntimeScript, normalizeProfileDir } from './launcher_paths.js';
 import { getErrorMessage } from '../../modules/utils/errors.js';
+import { isSameBotName } from '../../modules/utils/sanitize_key.js';
 
 const storage = getStorage();
 
@@ -174,7 +175,7 @@ async function launcherReset(botName: string | null, options: Record<string, any
   const { config } = loadSettingsFile(PROFILES_BOTS_FILE);
   const entries = normalizeBotEntries(resolveRawBotEntries(config));
 
-  const targets = botName ? entries.filter((b: any) => b.name === botName) : entries.filter((b: any) => b.active !== false);
+  const targets = botName ? entries.filter((b: any) => isSameBotName(b.name, botName)) : entries.filter((b: any) => b.active !== false);
 
   if (botName && targets.length === 0) {
     throw new Error(`Bot '${botName}' not found in ${PROFILES_BOTS_FILE}`);
@@ -235,7 +236,7 @@ async function launcherDisable(botName: string | null, options: Record<string, a
     };
   }
 
-  const match = entries.find((b: any) => b.name === botName);
+  const match = entries.find((b: any) => isSameBotName(b.name, botName));
   if (!match) {
     throw new Error(`Bot '${botName}' not found in ${PROFILES_BOTS_FILE}`);
   }
@@ -268,7 +269,7 @@ async function launcherPm2Start(botName: string | null, options: Record<string,
   const { config } = loadSettingsFile(PROFILES_BOTS_FILE);
   const entries = normalizeBotEntries(resolveRawBotEntries(config));
 
-  const targets = botName ? entries.filter((b: any) => b.name === botName) : entries.filter((b: any) => b.active !== false);
+  const targets = botName ? entries.filter((b: any) => isSameBotName(b.name, botName)) : entries.filter((b: any) => b.active !== false);
 
   if (botName && targets.length === 0) {
     throw new Error(`Bot '${botName}' not found or not active in ${PROFILES_BOTS_FILE}`);
@@ -287,7 +288,7 @@ async function launcherPm2Start(botName: string | null, options: Record<string,
   // Filter apps if specific bot requested
   let appsToStart = apps;
   if (botName) {
-    appsToStart = apps.filter((app: any) => app.name === botName);
+    appsToStart = apps.filter((app: any) => isSameBotName(app.name, botName));
     if (appsToStart.length === 0) {
       throw new Error(`No PM2 app found for bot '${botName}'`);
     }

package/claw/modules/credit_runtime_adapter.ts

@@ -3,6 +3,7 @@
 import { PATHS } from '../../modules/paths.js';
 import CreditRuntime from '../../modules/credit_runtime.js';
 import { getErrorMessage } from '../../modules/utils/errors.js';
+import { isSameBotName } from '../../modules/utils/sanitize_key.js';
 
 
 function createCreditRuntimeAdapter(infra: any, options: Record<string, any> = {}) {
@@ -55,7 +56,7 @@ function createCreditRuntimeAdapter(infra: any, options: Record<string, any> = {
     try {
       const bundle = await infra.profiles.loadBundle();
       const match = bundle.bots.find(
-        (b: Record<string, any>) => b.botKey === botRef || b.name === botRef,
+        (b: Record<string, any>) => isSameBotName(b.botKey, botRef) || isSameBotName(b.name, botRef),
       );
       return match || null;
     } catch {

package/claw/modules/dexbot_profiles.ts

@@ -10,6 +10,7 @@ import { acquireFileLock } from '../../market_adapter/utils/file_lock.js';
 import { assertNoDuplicateBotKeys } from '../../modules/bot_settings.js';
 import { clone } from './utils.js';
 import { createBotKey, sanitizeKey } from '../../modules/account_orders.js';
+import { isSameBotName } from '../../modules/utils/sanitize_key.js';
 const storage = getStorage();
 
 import type { BotSettings, ProfileOptions, ClawProfileBundle } from './types.js';
@@ -815,10 +816,10 @@ function matchBotIdentifier(bot: any, identifier: any) {
   }
 
   if (typeof identifier === 'object') {
-    if (identifier.botKey && bot.botKey === identifier.botKey) {
+    if (identifier.botKey && (bot.botKey === identifier.botKey || isSameBotName(bot.botKey, identifier.botKey))) {
       return true;
     }
-    if (identifier.name && bot.name === identifier.name) {
+    if (identifier.name && isSameBotName(bot.name, identifier.name)) {
       return true;
     }
     if (identifier.assetA && identifier.assetB && bot.assetA === identifier.assetA && bot.assetB === identifier.assetB) {
@@ -839,7 +840,7 @@ function matchBotIdentifier(bot: any, identifier: any) {
     return false;
   }
 
-  if (bot.botKey === value || bot.name === value) {
+  if (bot.botKey === value || isSameBotName(bot.botKey, value) || isSameBotName(bot.name, value)) {
     return true;
   }
 

package/claw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dexbot2-claw",
-  "version": "1.4.25",
+  "version": "1.5.0",
   "private": true,
   "description": "Claw bridge and runtime integration layer for BitShares and DEXBot2.",
   "type": "module",