dexbot 1.3.1 → 1.3.3

package/dist/modules/dexbot_class.js

@@ -53,33 +53,26 @@
  *
  * ===============================================================================
  */
-const { path } = require('./path_api');
-const { BitShares, waitForConnected, onReconnect: registerReconnectHook } = require('./bitshares_client');
-const { getStorage } = require('./storage');
-const storage = getStorage();
+const { BitShares } = require('./bitshares_client');
 const chainKeys = require('./chain_keys');
-const { getKeyStore } = require('./key_store');
 const chainOrders = require('./chain_orders');
 const fundRegistry = require('./fund_registry');
-const { BroadcastUncertainError } = require('./dexbot_credential_client');
-const { OrderManager, grid: Grid } = require('./order');
-const { retryPersistenceIfNeeded, initializeFeeCache, } = require('./order/utils/system');
-const { hasExecutableActions, validateCreateTargetSlots } = require('./order/utils/validate');
-const { buildCreateOrderArgs, buildCreateOpFingerprint, virtualizeOrder, correctAllPriceMismatches, convertToSpreadPlaceholder, buildOutsideInPairGroups, extractBatchOperationResults, buildFillKey, formatUnmatchedChainOrder } = require('./order/utils/order');
-const { validateOrderSize } = require('./order/utils/math');
 const { ProcessedFillStore, PROCESSED_FILL_PERSISTENCE_MODES } = require('./order/processed_fill_store');
 const DexbotFillRuntime = require('./dexbot_fill_runtime');
 const DexbotMaintenanceRuntime = require('./dexbot_maintenance_runtime');
+const DexbotStateRecovery = require('./dexbot_state_recovery');
+const DexbotStartupRuntime = require('./dexbot_startup_runtime');
 const CreditRuntime = require('./credit_runtime');
-const { ORDER_STATES, ORDER_TYPES, REBALANCE_STATES, COW_ACTIONS, TIMING, PIPELINE_TIMING, GRID_LIMITS, MAINTENANCE, FILL_PROCESSING, DAEMON_CODES, } = require('./constants');
-const { PATHS, getRecalculateTriggerFile } = require('./paths');
-const { attemptResumePersistedGridByPriceMatch, decideStartupGridAction, reconcileGridOrders } = require('./order/grid_reconcile');
-const { AccountOrders } = require('./account_orders');
-const { parseJsonWithComments } = require('./order/utils/system');
-const { cloneWeightDistribution } = require('./order/utils/math');
-const { normalizeBotEntry } = require('./bot_settings');
+const { TIMING, FILL_PROCESSING, DAEMON_CODES, } = require('./constants');
+const { PATHS } = require('./paths');
 const Format = require('./order/format');
-const { resolveBotRuntimeSettings } = require('./runtime_settings');
+const cowRuntime = require('./dexbot_cow_runtime');
+function waitForConnected(...args) { return require('./bitshares_client').waitForConnected(...args); }
+function getKeyStore(...args) { return require('./key_store').getKeyStore(...args); }
+function hasExecutableActions(...args) { return require('./order/utils/validate').hasExecutableActions(...args); }
+function getRecalculateTriggerFile(...args) { return require('./paths').getRecalculateTriggerFile(...args); }
+function cloneWeightDistribution(...args) { return require('./order/utils/math').cloneWeightDistribution(...args); }
+function resolveBotRuntimeSettings(...args) { return require('./runtime_settings').resolveBotRuntimeSettings(...args); }
 const PROFILES_BOTS_FILE = PATHS.PROFILES.BOTS_JSON;
 const PROFILES_DIR = PATHS.PROFILES_DIR;
 class DEXBot {
@@ -142,6 +135,7 @@ class DEXBot {
     _ghostOrderCancelAttempted;
     _dustHealthCheckTimer;
     _lastBroadcastHeartbeatAt;
+    _lastDeferredDustCount;
     _currentBatchId;
     /**
      * Create a new DEXBot instance
@@ -222,6 +216,7 @@ class DEXBot {
         this._targetedDriftSyncCooldownMs = this.config.timing.TARGETED_DRIFT_SYNC_COOLDOWN_MS;
         this._maintenanceCooldownCycles = 0;
         this._lastGridActivityAt = 0;
+        this._lastDeferredDustCount = 0;
         this._currentCycleId = 0;
         this._autoCancelOrphanCycleMarker = null;
         this._autoCancelOrphanSubCount = 0;
@@ -322,21 +317,7 @@ class DEXBot {
      * @private
      */
     async _persistAndRecoverIfNeeded() {
-        this.manager._recentFillKeysSnapshot = this._getRecentFillKeysSnapshot();
-        const validation = await this.manager.persistGrid();
-        if (!validation.isValid) {
-            this._warn(`Startup validation failed: ${validation.reason}. Triggering immediate recovery...`);
-            // Trigger centralized recovery (Hard Reset)
-            const recoveryValidation = await this.manager.accountant._performStateRecovery(this.manager);
-            if (recoveryValidation.isValid) {
-                this._log(`✓ Startup recovery successful. Persistent state restored.`);
-                this.manager._recentFillKeysSnapshot = this._getRecentFillKeysSnapshot();
-                await this.manager.persistGrid();
-            }
-            else {
-                this._warn(`Startup recovery failed: ${recoveryValidation.reason}. Bot proceeding with caution.`);
-            }
-        }
+        return DexbotStateRecovery.persistAndRecoverIfNeeded(this);
     }
     /**
      * Snapshot the recently queued fill keys as a plain object for crash-durable persistence.
@@ -346,42 +327,14 @@ class DEXBot {
      * @returns {Record<string, number>}
      */
     _getRecentFillKeysSnapshot() {
-        const snapshot = {};
-        const now = Date.now();
-        // 1. Collect live keys from the in-memory map
-        for (const [key, timestamp] of this._recentlyQueuedFills) {
-            if (now - Number(timestamp) < this._fillDedupeWindowMs) {
-                snapshot[key] = Number(timestamp);
-            }
-        }
-        // 2. Merge with the previous snapshot — carry forward any keys that
-        //    were present in a prior persist cycle, are still within the
-        //    dedup window, but have been evicted from _recentlyQueuedFills
-        //    (e.g. by TTL-based pruning between two persistGrid calls).
-        //    This prevents a crash + restart from losing keys that were
-        //    processed but not yet persisted.
-        if (this.manager?._recentFillKeysSnapshot) {
-            for (const [key, timestamp] of Object.entries(this.manager._recentFillKeysSnapshot)) {
-                if (!(key in snapshot) && now - Number(timestamp) < this._fillDedupeWindowMs) {
-                    snapshot[key] = Number(timestamp);
-                }
-            }
-        }
-        return snapshot;
+        return DexbotStateRecovery.getRecentFillKeysSnapshot(this);
     }
     /**
      * Get current pipeline signal state for congestion checks.
      * @returns {{incomingFillQueueLength: number, shadowLocks: number, batchInFlight: boolean, recoveryInFlight: boolean, broadcasting: boolean}}
      */
     _getPipelineSignals() {
-        this.manager?._cleanExpiredLocks?.();
-        return {
-            incomingFillQueueLength: this._incomingFillQueue.length,
-            shadowLocks: this.manager?.shadowOrderIds?.size || 0,
-            batchInFlight: this._batchInFlight,
-            recoveryInFlight: this._recoverySyncInFlight,
-            broadcasting: this.manager?.isBroadcastingActive?.() || false
-        };
+        return DexbotMaintenanceRuntime.getPipelineSignals(this);
     }
     /**
      * Mark that grid activity occurred (updates idle timer).
@@ -389,8 +342,7 @@ class DEXBot {
      * @returns {void}
      */
     _markGridActivity(reason = 'activity') {
-        this._lastGridActivityAt = Date.now();
-        this.manager?.logger?.log?.(`[MAINT-IDLE] Activity observed: ${reason}`, 'debug');
+        return DexbotMaintenanceRuntime.markGridActivity(this, reason);
     }
     /**
      * Trigger a full state recovery sync (fetch chain + sync from open orders + persist).
@@ -398,25 +350,7 @@ class DEXBot {
      * @returns {Promise<void>}
      */
     async _triggerStateRecoverySync(reason = 'state recovery sync') {
-        if (!this.manager)
-            return;
-        if (this._recoverySyncInFlight) {
-            this.manager.logger.log(`[RECOVERY] Skipping duplicate recovery request: ${reason}`, 'warn');
-            return;
-        }
-        this._recoverySyncInFlight = true;
-        try {
-            this.manager.logger.log(`Triggering state recovery sync (${reason})...`, 'info');
-            await this.manager.fetchAccountTotals(this.accountId);
-            const openOrders = await chainOrders.readOpenOrders(this.accountId);
-            await this.manager.syncFromOpenOrders(openOrders, { skipAccounting: true });
-            if (typeof this.manager.persistGrid === 'function') {
-                await this.manager.persistGrid();
-            }
-        }
-        finally {
-            this._recoverySyncInFlight = false;
-        }
+        return DexbotStateRecovery.triggerStateRecoverySync(this, reason);
     }
     /**
      * Abort the current flow if an illegal state signal was raised.
@@ -424,14 +358,7 @@ class DEXBot {
      * @returns {Promise<boolean>} True if flow was aborted
      */
     async _abortFlowIfIllegalState(flowContext) {
-        const illegalSignal = this.manager?.consumeIllegalStateSignal?.();
-        if (!illegalSignal) {
-            return false;
-        }
-        this.manager.logger.log(`[HARD-ABORT] ${flowContext} aborted due to illegal state (${illegalSignal.context}): ${illegalSignal.message}`, 'error');
-        await this._triggerStateRecoverySync(`hard-abort ${flowContext}`);
-        this._maintenanceCooldownCycles = Math.max(this._maintenanceCooldownCycles, 1);
-        return true;
+        return DexbotStateRecovery.abortFlowIfIllegalState(this, flowContext);
     }
     /**
      * Handle a hard abort from batch processing due to illegal state or accounting failure.
@@ -441,24 +368,7 @@ class DEXBot {
      * @returns {Promise<Object>} Abort result object
      */
     async _handleBatchHardAbort(err, phase = 'batch processing', opsCount = 0) {
-        const baseResult = { executed: false, hadRotation: false };
-        const opsInfo = opsCount > 0 ? ` with ${opsCount} ops` : '';
-        if (err?.code === 'ILLEGAL_ORDER_STATE') {
-            const illegalSignal = this.manager.consumeIllegalStateSignal?.();
-            await this._triggerStateRecoverySync(illegalSignal?.message || `illegal order state during ${phase}${opsInfo}`);
-            this._maintenanceCooldownCycles = Math.max(this._maintenanceCooldownCycles, 1);
-            return { ...baseResult, abortedForIllegalState: true };
-        }
-        if (err?.code === 'ACCOUNTING_COMMITMENT_FAILED') {
-            const accountingSignal = this.manager.consumeAccountingFailureSignal?.();
-            const reason = accountingSignal
-                ? `accounting lock failure (${accountingSignal.side} ${Format.formatAmount8(accountingSignal.amount)}) during ${accountingSignal.context}`
-                : `accounting commitment lock failure during ${phase}${opsInfo}`;
-            await this._triggerStateRecoverySync(reason);
-            this._maintenanceCooldownCycles = Math.max(this._maintenanceCooldownCycles, 1);
-            return { ...baseResult, abortedForAccountingFailure: true };
-        }
-        return null;
+        return DexbotStateRecovery.handleBatchHardAbort(this, err, phase, opsCount);
     }
     /**
      * Apply recoverable grid updates (order virtualisation) after a batch failure.
@@ -467,30 +377,7 @@ class DEXBot {
      * @returns {Promise<number>} Number of updates applied
      */
     async _applyRecoverableGridUpdates(updates, context = 'recoverable-grid-update') {
-        if (!this.manager || !Array.isArray(updates) || updates.length === 0) {
-            return 0;
-        }
-        let applied;
-        if (typeof this.manager.applyGridUpdateBatch === 'function') {
-            await this.manager.applyGridUpdateBatch(updates, context);
-            applied = updates.length;
-        }
-        else {
-            applied = 0;
-            for (const update of updates) {
-                if (typeof this.manager._updateOrder !== 'function')
-                    break;
-                await this.manager._updateOrder(update, context);
-                applied++;
-            }
-        }
-        // Persist master grid mutations applied outside COW (stale-order
-        // virtualization, size-drift corrections). These run in the COW catch
-        // handler where the success-path persistGrid is never reached.
-        if (applied > 0 && typeof this.manager.persistGrid === 'function') {
-            await this.manager.persistGrid();
-        }
-        return applied;
+        return DexbotStateRecovery.applyRecoverableGridUpdates(this, updates, context);
     }
     /**
      * Recover from explicit stale order errors by virtualizing affected grid slots.
@@ -499,36 +386,7 @@ class DEXBot {
      * @returns {Promise<{executed: boolean, hadRotation: boolean, stale: boolean, recoveredByVirtualization?: boolean}>}
      */
     async _recoverExplicitStaleOrders(staleOrderIds, reason = 'stale order cleanup') {
-        const staleIds = Array.from(staleOrderIds || []).filter(Boolean);
-        if (staleIds.length === 0) {
-            return { executed: false, hadRotation: false, stale: false };
-        }
-        this.manager.logger.log(`[COW] Stale order(s) detected: ${staleIds.join(', ')}. Applying targeted cleanup.`, 'warn');
-        const updates = [];
-        for (const [, gridOrder] of this.manager.orders.entries()) {
-            if (!gridOrder?.orderId || !staleOrderIds.has(gridOrder.orderId))
-                continue;
-            this._staleCleanedOrderIds.set(gridOrder.orderId, Date.now());
-            updates.push({ ...virtualizeOrder(gridOrder), size: 0 });
-        }
-        // Register any stale IDs that had no matching grid slot
-        for (const orderId of staleIds) {
-            if (!this._staleCleanedOrderIds.has(orderId)) {
-                this._staleCleanedOrderIds.set(orderId, Date.now());
-            }
-        }
-        if (updates.length > 0) {
-            await this._applyRecoverableGridUpdates(updates, reason);
-        }
-        else {
-            this.manager.logger.log(`[COW] No local grid slot matched stale order cleanup request (${staleIds.join(', ')}).`, 'debug');
-        }
-        return {
-            executed: false,
-            hadRotation: false,
-            stale: true,
-            recoveredByVirtualization: updates.length > 0
-        };
+        return DexbotStateRecovery.recoverExplicitStaleOrders(this, staleOrderIds, reason);
     }
     /**
      * Recover from on-chain size drift detected during batch broadcast.
@@ -536,32 +394,7 @@ class DEXBot {
      * @returns {Promise<{executed: boolean, hadRotation: boolean, recoveredBySync: boolean, reason: string}>}
      */
     async _recoverBatchSizeDrift(err, opContexts = []) {
-        // Try a targeted fix first: extract the affected order IDs from the
-        // operation contexts and correct them directly from chain.  This
-        // avoids a full state recovery sync in the common single-order case.
-        const affectedOrderIds = this._extractSizeDriftOrderIds(opContexts);
-        if (affectedOrderIds.length > 0) {
-            this.manager.logger.log(`[COW] Targeted size-drift repair for ${affectedOrderIds.length} order(s): ${affectedOrderIds.join(', ')}`, 'debug');
-            const repaired = await this._targetedOrderRepair(affectedOrderIds);
-            if (repaired) {
-                return {
-                    executed: false,
-                    hadRotation: false,
-                    recoveredBySync: true,
-                    reason: 'ORDER_SIZE_DRIFT_TARGETED'
-                };
-            }
-            this.manager.logger.log('[COW] Targeted repair failed, falling back to full state recovery sync.', 'warn');
-        }
-        const reason = `recoverable size drift during COW batch: ${err.message}`;
-        this.manager.logger.log(`[COW] Recovering from on-chain size drift via recovery sync: ${err.message}`, 'warn');
-        await this._triggerStateRecoverySync(reason);
-        return {
-            executed: false,
-            hadRotation: false,
-            recoveredBySync: true,
-            reason: 'ORDER_SIZE_DRIFT'
-        };
+        return DexbotStateRecovery.recoverBatchSizeDrift(this, err, opContexts);
     }
     /**
      * Extract chain order IDs from opContexts for operations that could
@@ -570,18 +403,7 @@ class DEXBot {
      * @returns {string[]} Unique chain order IDs
      */
     _extractSizeDriftOrderIds(opContexts) {
-        if (!Array.isArray(opContexts))
-            return [];
-        const ids = new Set();
-        for (const ctx of opContexts) {
-            if (ctx?.kind === 'size-update' && ctx?.updateInfo?.partialOrder?.orderId) {
-                ids.add(ctx.updateInfo.partialOrder.orderId);
-            }
-            else if (ctx?.kind === 'rotation' && ctx?.rotation?.oldOrder?.orderId) {
-                ids.add(ctx.rotation.oldOrder.orderId);
-            }
-        }
-        return Array.from(ids);
+        return DexbotStateRecovery.extractSizeDriftOrderIds(opContexts);
     }
     /**
      * Reload the entire grid from the persisted on-disk snapshot and reconcile
@@ -594,83 +416,7 @@ class DEXBot {
      * @returns {Promise<{success: boolean, reason?: string}>}
      */
     async _recoverFromPersistedGrid() {
-        if (!this.accountOrders || !this.manager) {
-            return { success: false, reason: 'accountOrders or manager unavailable' };
-        }
-        const accountRef = this.accountId || this.account?.id || this.account;
-        if (!accountRef) {
-            return { success: false, reason: 'no account reference' };
-        }
-        this.manager.logger.log('[RECOVERY] Attempting full grid reload from persisted snapshot...', 'warn');
-        try {
-            // 1. Force reload from disk
-            const persistedGrid = this.accountOrders.loadGrid(true);
-            if (!persistedGrid || persistedGrid.length === 0) {
-                return { success: false, reason: 'no persisted grid on disk' };
-            }
-            const boundaryIdx = this.accountOrders.loadBoundaryIdx(true);
-            // 2. Load into manager (same path as startup at line 1340)
-            await Grid.loadGrid(this.manager, persistedGrid, boundaryIdx);
-            // Gap 1: Grid snapshot sanity check — shared logic with startup path.
-            if (await this._rejectCorruptedGridSnapshot('recovery')) {
-                return { success: false, reason: 'corrupted grid snapshot rejected (fund drift)' };
-            }
-            // 3. Read current chain state
-            const chainOpenOrders = await chainOrders.readOpenOrders(accountRef);
-            // 4. Reconcile
-            if (chainOpenOrders.length > 0 && this.manager?.syncFromOpenOrders) {
-                await this.manager.syncFromOpenOrders(chainOpenOrders, {
-                    skipAccounting: true,
-                });
-            }
-            // 5. Persist the reconciled state
-            if (typeof this.manager.persistGrid === 'function') {
-                await this.manager.persistGrid();
-            }
-            this.manager.logger.log(`[RECOVERY] Grid reloaded from persisted snapshot: ${this.manager.orders.size} orders, ` +
-                `${chainOpenOrders.length} on-chain orders synced`, 'info');
-            // Gap 2: Check for unmatched chain orders after reload + sync.
-            // If the sync resolved all unmatched entries, _lastUnmatchedChainOrders
-            // was cleared by the sync engine. If any remain, the persisted snapshot
-            // produced an inconsistent grid — reject so the structural resync
-            // falls through to requestGridReset (full rebuild from chain).
-            const remainingUnmatched = Array.isArray(this.manager?._lastUnmatchedChainOrders)
-                ? this.manager._lastUnmatchedChainOrders
-                : [];
-            if (remainingUnmatched.length > 0) {
-                const sample = remainingUnmatched.slice(0, 3)
-                    .map(o => this._formatUnmatchedChainOrderForLog(o))
-                    .join(' | ');
-                this.manager.logger.log(`[RECOVERY] Persisted grid reloaded but ${remainingUnmatched.length} unmatched chain order(s) ` +
-                    `remain${sample ? ` (${sample})` : ''}. Rejecting — full grid reset required.`, 'warn');
-                return { success: false, reason: `grid inconsistent after reload: ${remainingUnmatched.length} unmatched remain` };
-            }
-            // If the reloaded grid is still bloated, reject recovery so the
-            // caller falls through to a full grid reset (requestGridReset).
-            // Without this check, a bloated snapshot gets accepted as "success"
-            // and the structural-resync loop loads the same broken state forever.
-            //
-            // NOTE: loadGrid() already fires requestStructuralGridResync when it
-            // detects bloat internally, so the inner async resync may be in flight
-            // by the time this outer check runs. That's fine — the structural-resync
-            // gate (_structuralGridResyncRunning / _structuralGridResyncTimer) dedup's
-            // concurrent requests. This outer check exists so the synchronous return
-            // value is honest about the state; the inner resync is a safety net.
-            const { isGridBloated } = require('./order/grid');
-            const ordersArr = Array.from(this.manager.orders.values());
-            const bloatPostRecovery = isGridBloated(this.manager, ordersArr);
-            if (bloatPostRecovery.bloated) {
-                const d = bloatPostRecovery.details;
-                this.manager.logger.log(`[RECOVERY] Persisted grid reloaded but still bloated ` +
-                    `(${d.gridSize} slots, max ${d.maxAllowed}). Rejecting — full grid reset required.`, 'warn');
-                return { success: false, reason: 'grid still bloated after reload' };
-            }
-            return { success: true };
-        }
-        catch (err) {
-            this.manager.logger.log(`[RECOVERY] Full grid reload from persisted snapshot failed: ${err.message}`, 'error');
-            return { success: false, reason: err.message };
-        }
+        return DexbotStateRecovery.recoverFromPersistedGrid(this);
     }
     /**
      * Reject a corrupted grid snapshot when catastrophic fund drift is detected.
@@ -681,25 +427,7 @@ class DEXBot {
      * @returns {Promise<boolean>} True if the snapshot was rejected (cleared).
      */
     async _rejectCorruptedGridSnapshot(context) {
-        if (!this.manager?.checkFundDriftAfterFills)
-            return false;
-        const driftCheck = this.manager.checkFundDriftAfterFills();
-        if (driftCheck.isValid)
-            return false;
-        const tag = context === 'recovery' ? '[RECOVERY][SNAPSHOT-REJECT]' : '[SNAPSHOT-REJECT]';
-        this._warn(`${tag} Corrupted grid snapshot detected: ` +
-            `drift sell=${driftCheck.driftSell.toFixed(2)} buy=${driftCheck.driftBuy.toFixed(2)}. ` +
-            `Deleting corrupted snapshot.`);
-        if (this.accountOrders && typeof this.accountOrders.clearGrid === 'function') {
-            try {
-                await this.accountOrders.clearGrid();
-                this._warn(`${tag} Corrupted grid snapshot deleted.`);
-            }
-            catch (clearErr) {
-                this._warn(`${tag} Failed to delete corrupted snapshot: ${clearErr.message}`);
-            }
-        }
-        return true;
+        return DexbotStateRecovery.rejectCorruptedGridSnapshot(this, context);
     }
     /**
      * Attempt to repair size-drift for specific order IDs by reading their
@@ -709,141 +437,16 @@ class DEXBot {
      * @returns {Promise<boolean>} True if all affected orders were repaired
      */
     async _targetedOrderRepair(orderIds) {
-        try {
-            const objects = await BitShares.db.get_objects(orderIds);
-            if (!Array.isArray(objects) || objects.length !== orderIds.length)
-                return false;
-            const updates = [];
-            for (let i = 0; i < orderIds.length; i++) {
-                const chainOrder = objects[i];
-                const gridOrder = Array.from(this.manager.orders.values())
-                    .find((o) => o.orderId === orderIds[i]);
-                if (!gridOrder)
-                    continue;
-                if (!chainOrder || typeof chainOrder.for_sale === 'undefined') {
-                    // Order no longer exists on chain -> fully filled or cancelled.
-                    updates.push({ ...virtualizeOrder(gridOrder), size: 0 });
-                }
-                else {
-                    const chainUnits = Number(chainOrder.for_sale);
-                    if (Number.isFinite(chainUnits)) {
-                        const { blockchainToFloat } = require('./order/utils/math');
-                        const prec = gridOrder.type === ORDER_TYPES.SELL
-                            ? this.manager.assets.assetA.precision
-                            : this.manager.assets.assetB.precision;
-                        const floatSize = blockchainToFloat(chainUnits, prec);
-                        if (floatSize !== gridOrder.size) {
-                            updates.push({
-                                id: gridOrder.id,
-                                size: floatSize,
-                                rawOnChain: chainOrder,
-                            });
-                        }
-                    }
-                }
-            }
-            if (updates.length > 0) {
-                await this._applyRecoverableGridUpdates(updates, 'targeted-size-drift-repair');
-            }
-            return true;
-        }
-        catch (err) {
-            this.manager.logger.log(`[COW] Targeted order repair failed: ${err.message}`, 'debug');
-            return false;
-        }
+        return DexbotStateRecovery.targetedOrderRepair(this, orderIds);
     }
     /**
      * Initialize bot state from storage and blockchain.
      * Consolidates common initialization logic for start() and startWithPrivateKey().
-     * @returns {{persistedGrid: Object, persistedBtsFeesOwed: number, persistedBoundaryIdx: number, persistedBtsBalance: number}}
+     * @returns {{persistedGrid: Object, persistedBtsFeesOwed: number, persistedBoundaryIdx: number, persistedBtsBalance: number, persistedRecentFillKeys: Object}}
      * @private
      */
     async _initializeStartupState() {
-        // Create AccountOrders with bot-specific file (one file per bot)
-        this.accountOrders = new AccountOrders({ botKey: this.config.botKey });
-        this._processedFillStore.configure({
-            accountOrders: this.accountOrders
-        });
-        // Load persisted processed fills to prevent reprocessing after restart
-        const loadedPersistedFills = this._processedFillStore.loadPersisted({
-            minTimestamp: Date.now() - this._fillRecordRetentionMs
-        });
-        if (loadedPersistedFills > 0) {
-            this._log(`Loaded ${loadedPersistedFills} persisted fill records to prevent reprocessing`);
-        }
-        // Ensure bot metadata is properly initialized in storage BEFORE any Grid operations
-        const raw = storage.readFile(PROFILES_BOTS_FILE);
-        const allBotsConfig = parseJsonWithComments(raw).bots || [];
-        const myBotConfig = allBotsConfig
-            .map((b, originalIdx) => b.active !== false ? normalizeBotEntry(b, originalIdx) : null)
-            .find(b => b && b.botKey === this.config.botKey);
-        if (myBotConfig) {
-            await this.accountOrders.syncMeta(myBotConfig);
-        }
-        if (!this.manager) {
-            const mgrLogFile = this.config?.name ? path.join(PATHS.LOGS_DIR, `${this.config.name}.log`) : undefined;
-            this.manager = new OrderManager({ ...this.config, logFile: mgrLogFile });
-            this.manager.account = this.account;
-            this.manager.accountId = this.accountId;
-            this.manager.accountOrders = this.accountOrders;
-        }
-        this._wireStructuralGridResyncRequest();
-        this._wireProcessedFillTracking();
-        this.manager.startBootstrap();
-        try {
-            // Fetch account totals from blockchain at startup to initialize funds
-            try {
-                if (this.accountId && this.config.assetA && this.config.assetB) {
-                    await this.manager._initializeAssets();
-                    await this.manager.fetchAccountTotals(this.accountId);
-                    this._log('Fetched blockchain account balances at startup');
-                }
-            }
-            catch (err) {
-                this._log(`Startup balance fetch FAILED: ${err.message}. Order sizing may be incorrect until next successful sync.`, 'error');
-            }
-            // Ensure fee cache is initialized before any fill processing that calls getAssetFees().
-            try {
-                await initializeFeeCache([this.config || {}], BitShares);
-            }
-            catch (err) {
-                this._log(`Fee cache initialization FAILED: ${err.message}. Fee calculations will use defaults until cache is refreshed.`, 'error');
-            }
-            const persistedGrid = this.accountOrders.loadGrid();
-            // CRITICAL REPAIR: Strip fake orderIds where orderId === id (e.g. "slot-0")
-            let repairedGrid = persistedGrid;
-            if (persistedGrid && persistedGrid.length > 0) {
-                let repairCount = 0;
-                repairedGrid = persistedGrid.map(order => {
-                    if (order && order.orderId && order.orderId === order.id) {
-                        repairCount++;
-                        const repairedOrder = { ...order, orderId: '' };
-                        if (repairedOrder.state === ORDER_STATES.ACTIVE || repairedOrder.state === ORDER_STATES.PARTIAL) {
-                            repairedOrder.state = ORDER_STATES.VIRTUAL;
-                        }
-                        return repairedOrder;
-                    }
-                    return order;
-                });
-                if (repairCount > 0) {
-                    this._log(`[REPAIR] Stripped ${repairCount} fake orderId(s) from persisted grid to restore rebalancing logic.`);
-                }
-            }
-            const persistedBtsFeesOwed = this.accountOrders.loadBtsFeesOwed();
-            const persistedBoundaryIdx = this.accountOrders.loadBoundaryIdx();
-            const persistedBtsBalance = this.accountOrders.loadBtsBalance();
-            const persistedRecentFillKeys = this.accountOrders.loadRecentFillKeys();
-            return {
-                persistedGrid: repairedGrid,
-                persistedBtsFeesOwed,
-                persistedBoundaryIdx,
-                persistedBtsBalance,
-                persistedRecentFillKeys,
-            };
-        }
-        finally {
-            this.manager.finishBootstrap();
-        }
+        return DexbotStartupRuntime.initializeStartupState(this);
     }
     /**
      * Wire processed fill tracking into the manager.
@@ -989,446 +592,7 @@ class DEXBot {
      * @private
      */
     async _finishStartupSequence(startupState) {
-        let { persistedGrid, persistedBtsFeesOwed, persistedBoundaryIdx, persistedBtsBalance, persistedRecentFillKeys, } = startupState;
-        try {
-            // CRITICAL: Activate fill listener EARLY - before ANY operations that place orders
-            // This ensures fills during trigger reset and grid initialization are captured
-            if (typeof this._fillsUnsubscribe === 'function') {
-                await this._fillsUnsubscribe().catch(() => { });
-            }
-            this._fillsUnsubscribe = await chainOrders.listenForFills(this.account || undefined, this._createFillCallback(chainOrders));
-            if (typeof this._fillsUnsubscribe !== 'function') {
-                this._warn('Fill listener did not provide an unsubscribe handler. Shutdown cleanup may be incomplete.');
-                this._fillsUnsubscribe = null;
-            }
-            this._log('Fill listener activated (ready to process fills during startup)');
-            // Register reconnection callback for safety-net sync after websocket reconnect
-            if (!this._reconnectUnregister) {
-                this._reconnectUnregister = registerReconnectHook(() => {
-                    this._log('Blockchain connection re-established; scheduling safety-net sync');
-                    const runSafetyNetSync = async () => {
-                        if (this.manager && this.accountId && !this._shuttingDown && !this.config.dryRun) {
-                            // Cap the entire safety-net sync at TIMING.SAFETY_NET_SYNC_TIMEOUT_MS so it can
-                            // never hold _fillProcessingLock longer than the
-                            // 20s shutdown lock timeout. readOpenOrders +
-                            // synchronizeWithChain + batch + persist can be
-                            // ~45s worst case without a cap, which would
-                            // stall shutdown until the 20s timeout fires.
-                            const safetyNetTimeoutMs = this.config.timing?.SAFETY_NET_SYNC_TIMEOUT_MS;
-                            let safetyNetTimer;
-                            const workPromise = this.manager._fillProcessingLock.acquire(async () => {
-                                if (this._shuttingDown)
-                                    return;
-                                const chainOpenOrders = await chainOrders.readOpenOrders(this.accountId);
-                                if (this._shuttingDown)
-                                    return;
-                                const syncResult = await this.manager.synchronizeWithChain(chainOpenOrders, 'readOpenOrders');
-                                if (this._shuttingDown)
-                                    return;
-                                if (syncResult?.filledOrders?.length > 0) {
-                                    this._refreshDynamicWeightDistribution('post-reconnect sync fill');
-                                    this._log(`Post-reconnect sync: ${syncResult.filledOrders.length} grid order(s) found filled.`, 'info');
-                                    await this._processFillsWithBatching(syncResult.filledOrders, new Set(), 'post-reconnect sync fill');
-                                    if (this._shuttingDown)
-                                        return;
-                                }
-                                this.manager._recentFillKeysSnapshot = this._getRecentFillKeysSnapshot();
-                                await this.manager.persistGrid();
-                                // Cancel any dust created by reconnect fills immediately.
-                                if (!this._shuttingDown) {
-                                    try {
-                                        const reconnectHealth = await this.manager.checkGridHealth(this.updateOrdersOnChainPlan.bind(this));
-                                        await this._cancelDustOrders({
-                                            buy: reconnectHealth.buyDustOrders,
-                                            sell: reconnectHealth.sellDustOrders,
-                                        });
-                                    }
-                                    catch (_dustErr) {
-                                        this._warn(`[RECONNECT] Dust cancel failed: ${_dustErr.message}`);
-                                    }
-                                }
-                            });
-                            try {
-                                await Promise.race([
-                                    workPromise,
-                                    new Promise((_, reject) => {
-                                        safetyNetTimer = setTimeout(() => reject(new Error(`Safety-net sync exceeded ${safetyNetTimeoutMs}ms cap`)), safetyNetTimeoutMs);
-                                    })
-                                ]);
-                            }
-                            catch (capErr) {
-                                const fallback = await Promise.race([
-                                    workPromise.then(() => ({ ok: true })),
-                                    new Promise(resolve => setTimeout(() => resolve({ ok: false }), 0))
-                                ]);
-                                if (fallback.ok) {
-                                    this._log(`Safety-net sync completed despite timeout — ignoring spurious error.`, 'info');
-                                }
-                                else {
-                                    this._warn(`Post-reconnect safety-net sync aborted: ${capErr?.message || capErr}`);
-                                }
-                            }
-                            finally {
-                                if (safetyNetTimer)
-                                    clearTimeout(safetyNetTimer);
-                            }
-                        }
-                    };
-                    // The setImmediate callback returns a Promise; we MUST attach
-                    // a .catch so a rejection here does not propagate to
-                    // process.on('unhandledRejection') and tear down the bot.
-                    setImmediate(() => {
-                        runSafetyNetSync().catch(err => {
-                            try {
-                                this._warn('Post-reconnect safety-net sync failed: ' + (err?.message || err));
-                            }
-                            catch (_warnErr) {
-                                // _warn itself inaccessible — last line of defense.
-                            }
-                        });
-                    });
-                });
-            }
-            // CRITICAL: Handle any pending trigger file reset FIRST before any other startup operations
-            const hadTriggerReset = await this._handlePendingTriggerReset();
-            // CRITICAL: After trigger reset, skip normal startup - grid is already fully initialized
-            // The trigger reset already did: grid init, order placement, sync, and persistence
-            if (hadTriggerReset) {
-                this._log('Trigger reset completed. Skipping normal startup grid initialization.');
-                // Post-bootstrap validation and fill processing
-                await this.manager._fillProcessingLock.acquire(async () => {
-                    // STEP 1: Check for fills that occurred during trigger reset
-                    // These are orders that got filled while Grid.recalculateGrid() was running.
-                    // The filled slots need new orders placed on them.
-                    if (this._incomingFillQueue.length > 0) {
-                        this._log(`[POST-RESET] ${this._incomingFillQueue.length} fill(s) detected during trigger reset. Processing...`);
-                        // Process fills - this will place new orders on the filled slots
-                        // Use normal fill processing since bootstrap is complete
-                        const fills = this._incomingFillQueue.splice(0);
-                        const processedFillKeys = new Set();
-                        let requiresOpenOrdersSync = false;
-                        for (const fill of fills) {
-                            if (!fill || fill.op?.[0] !== 4)
-                                continue;
-                            const fillOp = fill.op[1];
-                            const gridOrder = this.manager.orders.get(fillOp.order_id) ||
-                                Array.from(this.manager.orders.values()).find((o) => o.orderId === fillOp.order_id);
-                            if (!gridOrder) {
-                                // CRITICAL FIX: Even if order not in grid, we must still credit the fill proceeds
-                                // This can happen when fills arrive after an order was marked VIRTUAL during sequential processing
-                                let orphanFillKey = buildFillKey(fill);
-                                if (!orphanFillKey) {
-                                    orphanFillKey = this._buildOrphanFillFallbackKey(fill);
-                                }
-                                if (orphanFillKey && !this._isNewFillKey(orphanFillKey, processedFillKeys, '[POST-RESET]', fillOp.order_id)) {
-                                    continue;
-                                }
-                                this._log(`[POST-RESET] Processing funds for unknown order ${fillOp.order_id} (not in grid but crediting proceeds)`, 'warn');
-                                const accountingResult = await this._applyReplaySafeOrphanFillAccounting(fill, fillOp, {
-                                    context: 'POST-RESET',
-                                    logger: { log: this._log.bind(this) },
-                                    replayMessage: (op) => `[POST-RESET] Replay detected for orphan fill ${op.order_id}; skipping duplicate credit`
-                                });
-                                if (accountingResult.status === 'missing_key') {
-                                    requiresOpenOrdersSync = true;
-                                }
-                                continue;
-                            }
-                            this._log(`[POST-RESET] Processing fill for ${gridOrder.type} order ${gridOrder.id} at price ${gridOrder.price}`);
-                            const trackedFillKey = buildFillKey(fill);
-                            if (trackedFillKey && !this._isNewFillKey(trackedFillKey, processedFillKeys, '[POST-RESET]', fillOp.order_id)) {
-                                continue;
-                            }
-                            this.manager.lockOrders([gridOrder.id]);
-                            try {
-                                const accountingResult = await this._applyReplaySafeTrackedFillAccounting(fill, fillOp, {
-                                    context: 'POST-RESET',
-                                    logger: { log: this._log.bind(this) },
-                                    replayMessage: (op) => `[POST-RESET] Replay detected for ${op.order_id}; skipping duplicate rebalance`
-                                });
-                                if (accountingResult.status === 'missing_key') {
-                                    requiresOpenOrdersSync = true;
-                                    continue;
-                                }
-                                if (accountingResult.status !== 'applied') {
-                                    continue;
-                                }
-                                // Process this fill through the full rebalance pipeline
-                                // This will shift the boundary and place a new order on the filled slot
-                                const result = await this._processFillsWithBatching([gridOrder], new Set(), `[POST-RESET] fill ${gridOrder.id}`);
-                                if (result.aborted) {
-                                    this._warn('[POST-RESET] Aborted batch due to illegal state; skipping grid persistence this cycle');
-                                    continue;
-                                }
-                            }
-                            finally {
-                                this.manager.unlockOrders([gridOrder.id]);
-                            }
-                        }
-                        if (requiresOpenOrdersSync) {
-                            this._log('[POST-RESET] Falling back to open-orders sync for fill(s) missing replay-safe history identifiers', 'warn');
-                            const postResetChainOpenOrders = await chainOrders.readOpenOrders(this.accountId);
-                            const syncResult = await this.manager.syncFromOpenOrders(postResetChainOpenOrders);
-                            if (syncResult.filledOrders?.length > 0) {
-                                await this._processFillsWithBatching(syncResult.filledOrders, new Set(), '[POST-RESET] open-orders fallback');
-                            }
-                        }
-                        await this._flushProcessedFillPersistence('post-reset-batch');
-                        this.manager._recentFillKeysSnapshot = this._getRecentFillKeysSnapshot();
-                        await this.manager.persistGrid();
-                    }
-                    // STEP 2: Refresh chain truth before spread correction. Trigger
-                    // reset can create/cancel orders and fills can arrive while the
-                    // reset is running; spread decisions must not use stale local grid.
-                    const { aborted: postResetAborted, hasUnmatched: postResetUnmatched } = await this._syncOpenOrdersAndProcessFills('[POST-RESET] pre-spread');
-                    if (postResetUnmatched) {
-                        this._warn(`[POST-RESET] Skipping spread correction: ${postResetUnmatched} unmatched chain order(s) require maintenance reconciliation`);
-                    }
-                    // STEP 3: Spread check AFTER fills are processed and chain truth refreshed
-                    await this.manager.recalculateFunds();
-                    if (!postResetAborted && !postResetUnmatched) {
-                        const spreadResult = await this.manager.checkSpreadCondition(BitShares, this.updateOrdersOnChainPlan.bind(this));
-                        if (spreadResult && spreadResult.ordersPlaced > 0) {
-                            this._log(`✓ Spread correction after trigger reset: ${spreadResult.ordersPlaced} order(s) placed`);
-                            await this._persistAndRecoverIfNeeded();
-                        }
-                    }
-                    // Cancel any dust created by post-reset fills immediately.
-                    if (!this._shuttingDown) {
-                        try {
-                            const postResetHealth = await this.manager.checkGridHealth(this.updateOrdersOnChainPlan.bind(this));
-                            await this._cancelDustOrders({
-                                buy: postResetHealth.buyDustOrders,
-                                sell: postResetHealth.sellDustOrders,
-                            });
-                        }
-                        catch (_dustErr) {
-                            this._warn(`[POST-RESET] Dust cancel failed: ${_dustErr.message}`);
-                        }
-                    }
-                    this._log('Bootstrap phase complete - fill processing resumed', 'info');
-                });
-                await this._setupTriggerFileDetection();
-                await this._setupCreditRuntime();
-                await this._refreshAndSyncCreditRuntime();
-                this._setupBlockchainFetchInterval();
-                this._setupCreditWatchdogInterval();
-                this._setupCredentialDaemonWatchdogInterval();
-                this._setupDustHealthCheckInterval();
-                if (this._isOpenOrdersSyncLoopEnabled()) {
-                    this._startOpenOrdersSyncLoop();
-                }
-                else {
-                    this._log('Open-orders sync loop disabled by configuration (TIMING.OPEN_ORDERS_SYNC_LOOP_ENABLED=false)');
-                }
-                this._log(`DEXBot started. OrderManager running (dryRun=${!!this.config.dryRun})`);
-                return; // Skip normal startup path
-            }
-            // Restore persisted BTS fee
-            // SAFE: Done at startup before orders are created, and within fill lock when needed
-            this.manager.resetFunds();
-            // CRITICAL FIX: Restore BTS fees owed from persistence
-            if (persistedBtsFeesOwed && persistedBtsFeesOwed > 0) {
-                this.manager.funds.btsFeesOwed = Number(persistedBtsFeesOwed);
-            }
-            // Restore BTS balance for non-BTS pairs
-            if (this.config.assetA !== 'BTS' && this.config.assetB !== 'BTS') {
-                if (persistedBtsBalance && typeof persistedBtsBalance === 'object') {
-                    this.manager.btsBalance = {
-                        free: persistedBtsBalance.free || 0,
-                        total: persistedBtsBalance.total || 0,
-                        locked: persistedBtsBalance.locked || 0
-                    };
-                }
-            }
-            // Restore recently queued fill keys for crash-durable dedup window.
-            // All persisted keys are restored; the in-memory TTL (_fillDedupeWindowMs)
-            // will naturally evict any that are already expired on the next fill cycle.
-            if (persistedRecentFillKeys && typeof persistedRecentFillKeys === 'object') {
-                for (const [fillKey, timestamp] of Object.entries(persistedRecentFillKeys)) {
-                    this._recentlyQueuedFills.set(fillKey, Number(timestamp));
-                }
-                this._log(`Restored ${Object.keys(persistedRecentFillKeys).length} recently queued fill key(s) from persisted snapshot`, 'debug');
-            }
-            if (!this.config.dryRun && !this.accountId) {
-                throw new Error('Cannot start bot without a resolved account ID');
-            }
-            // Use this.accountId which was set during initialize()
-            const chainOpenOrders = this.config.dryRun ? [] : await chainOrders.readOpenOrders(this.accountId);
-            let shouldRegenerate = false;
-            if (!persistedGrid || persistedGrid.length === 0) {
-                shouldRegenerate = true;
-                this._log('No persisted grid found. Generating new grid.');
-            }
-            else {
-                await this.manager._initializeAssets();
-                const decision = await decideStartupGridAction({
-                    persistedGrid,
-                    chainOpenOrders,
-                    manager: this.manager,
-                    logger: { log: (msg) => this._log(msg) },
-                    storeGrid: async (orders) => {
-                        // Pass the snapshot directly to persistGrid so the live
-                        // `manager.orders` map is not briefly swapped (which would
-                        // leave the _ordersByState/_ordersByType indexes inconsistent
-                        // with the map for the duration of the persist call).
-                        await this.manager.persistGrid(orders);
-                    },
-                    attemptResumeFn: attemptResumePersistedGridByPriceMatch,
-                });
-                shouldRegenerate = decision.shouldRegenerate;
-                if (shouldRegenerate && chainOpenOrders.length === 0) {
-                    this._log('Persisted grid found, but no matching active orders on-chain. Generating new grid.');
-                }
-            }
-            // Restore BTS fees owed ONLY if we're NOT regenerating the grid
-            if (!shouldRegenerate) {
-                // CRITICAL: Restore BTS fees owed from blockchain operations
-                if (persistedBtsFeesOwed > 0) {
-                    this.manager.funds.btsFeesOwed = persistedBtsFeesOwed;
-                    this._log(`✓ Restored BTS fees owed: ${Format.formatAmount8(persistedBtsFeesOwed)} BTS`);
-                }
-            }
-            else {
-                this._log(`ℹ Grid regenerating - resetting BTS fees to clean state`);
-                this.manager.funds.btsFeesOwed = 0;
-            }
-            // CRITICAL: Use fill lock during ENTIRE startup synchronization to prevent races.
-            // This includes grid init, finishBootstrap, and maintenance - all in one atomic block.
-            // Lock order: _fillProcessingLock → _divergenceLock (canonical order, same as _consumeFillQueue)
-            await this.manager._fillProcessingLock.acquire(async () => {
-                try {
-                    this._refreshDynamicWeightDistribution('startup');
-                    if (shouldRegenerate) {
-                        await this.manager._initializeAssets();
-                        if (Array.isArray(chainOpenOrders) && chainOpenOrders.length > 0) {
-                            this._log('Generating new grid and syncing with existing on-chain orders...');
-                            await Grid.initializeGrid(this.manager);
-                            await this.manager.syncFromOpenOrders(chainOpenOrders, { skipAccounting: true });
-                            const rebalanceResult = await reconcileGridOrders({
-                                manager: this.manager,
-                                config: this.config,
-                                account: this.account,
-                                privateKey: this.privateKey,
-                                chainOrders,
-                                chainOpenOrders,
-                            });
-                            await this._executeBatchIfNeeded(rebalanceResult, 'startup reconcile (regenerated grid)');
-                        }
-                        else {
-                            this._log('Generating new grid and placing initial orders on-chain...');
-                            await this.placeInitialOrders();
-                        }
-                        await this._persistAndRecoverIfNeeded();
-                    }
-                    else {
-                        this._log('Found active session. Loading and syncing existing grid.');
-                        await Grid.loadGrid(this.manager, persistedGrid, persistedBoundaryIdx);
-                        let startupChainOpenOrders = chainOpenOrders;
-                        const syncResult = await this.manager.syncFromOpenOrders(startupChainOpenOrders, { skipAccounting: true });
-                        // Process price corrections queued during startup sync.
-                        // These are not picked up by _consumeFillQueue until a fill
-                        // arrives, which may never come for an idle market.
-                        if (syncResult.ordersNeedingCorrection?.length > 0) {
-                            await correctAllPriceMismatches(this.manager, this.account, this.privateKey, chainOrders);
-                        }
-                        if (syncResult.filledOrders && syncResult.filledOrders.length > 0) {
-                            this._log(`Startup sync: ${syncResult.filledOrders.length} grid order(s) found filled. Processing proceeds.`, 'info');
-                            const batchResult = await this._processFillsWithBatching(syncResult.filledOrders, new Set(), 'startup sync fill rebalance', { skipAccountTotalsUpdate: true });
-                            if (!batchResult?.aborted) {
-                                // Refresh open orders so startup reconcile works with post-batch chain reality
-                                // and avoids reconciling against a stale pre-batch snapshot.
-                                startupChainOpenOrders = await chainOrders.readOpenOrders(this.accountId);
-                                await this.manager.synchronizeWithChain(startupChainOpenOrders, 'readOpenOrders');
-                            }
-                        }
-                        const rebalanceResult = await reconcileGridOrders({
-                            manager: this.manager,
-                            config: this.config,
-                            account: this.account,
-                            privateKey: this.privateKey,
-                            chainOrders,
-                            chainOpenOrders: startupChainOpenOrders,
-                        });
-                        await this._executeBatchIfNeeded(rebalanceResult, 'startup reconcile (loaded grid)');
-                        // Dust state is no longer persisted — cancelled immediately on detection.
-                        await this._persistAndRecoverIfNeeded();
-                        // Gap 1: Grid snapshot sanity check — shared logic with recovery path.
-                        await this._rejectCorruptedGridSnapshot('startup');
-                    }
-                    // Drain any fills that arrived during startup while still in bootstrap
-                    // mode. Safe to call directly since we already hold _fillProcessingLock
-                    // and _processFillsWithBootstrapMode does NOT re-acquire it.
-                    if (this._incomingFillQueue.length > 0) {
-                        this._log(`[STARTUP] Processing ${this._incomingFillQueue.length} queued fill(s) before bootstrap ends`);
-                        await this._processFillsWithBootstrapMode(chainOrders);
-                    }
-                    this.manager.finishBootstrap();
-                    // Refresh account totals after bootstrap to eliminate the timing
-                    // gap between the initial balance fetch and grid operations (sync,
-                    // reconcile, fills). Without this, the first maintenance cycle sees
-                    // a fund drift (expected at bootstrap) and triggers an unnecessary
-                    // invariant violation + full recovery cycle.
-                    // Bound by a timeout to avoid blocking _fillProcessingLock on a
-                    // flaky node. If the fetch times out, continue with cached values;
-                    // the next periodic maintenance cycle will retry.
-                    const FETCH_TIMEOUT_MS = 30000;
-                    let _fetchTimeoutHandle;
-                    try {
-                        await Promise.race([
-                            this.manager.fetchAccountTotals(),
-                            new Promise((_, reject) => {
-                                _fetchTimeoutHandle = setTimeout(() => reject(new Error('timeout')), FETCH_TIMEOUT_MS);
-                            })
-                        ]);
-                    }
-                    catch (fetchErr) {
-                        this._log(`[STARTUP] [${this.config?.botKey || 'unknown'}] fetchAccountTotals ${fetchErr.message === 'timeout' ? 'timed out' : 'failed'} (${fetchErr.message}). Continuing with cached account totals.`, 'warn');
-                    }
-                    finally {
-                        clearTimeout(_fetchTimeoutHandle);
-                    }
-                    // Perform initial grid maintenance (thresholds, divergence, spread, health)
-                    // Consolidated into shared logic to ensure consistent behavior at boot and runtime.
-                    // CRITICAL: Pass lockAlreadyHeld since we're inside _fillProcessingLock.acquire()
-                    await this._runGridMaintenance('startup');
-                    // Cancel any dust from a previous bot lifetime immediately.
-                    const startupHealth = await this.manager.checkGridHealth(this.updateOrdersOnChainPlan.bind(this));
-                    await this._cancelDustOrders({
-                        buy: startupHealth.buyDustOrders,
-                        sell: startupHealth.sellDustOrders,
-                    });
-                    this._log('Bootstrap phase complete - fill processing resumed', 'info');
-                }
-                finally {
-                    // CRITICAL: Always clear bootstrap flag, even on error
-                    this.manager.finishBootstrap();
-                }
-            });
-            await this._setupTriggerFileDetection();
-            await this._setupCreditRuntime();
-            await this._refreshAndSyncCreditRuntime();
-            await this._runCreditRuntimeMaintenance('startup');
-            this._setupBlockchainFetchInterval();
-            this._setupCreditWatchdogInterval();
-            this._setupCredentialDaemonWatchdogInterval();
-            // Periodic dust health check — catches partials that fell below threshold
-            // without triggering the post-fill pipeline. Cancels immediately inside the
-            // fill-processing lock to avoid racing with fill batches or sync operations.
-            this._setupDustHealthCheckInterval();
-            if (this._isOpenOrdersSyncLoopEnabled()) {
-                this._startOpenOrdersSyncLoop();
-            }
-            else {
-                this._log('Open-orders sync loop disabled by configuration (TIMING.OPEN_ORDERS_SYNC_LOOP_ENABLED=false)');
-            }
-            this._log(`DEXBot started. OrderManager running (dryRun=${!!this.config.dryRun})`);
-        }
-        catch (err) {
-            this._warn(`Error during grid initialization: ${err.message}`);
-            await this.shutdown();
-            throw err;
-        }
+        return DexbotStartupRuntime.finishStartupSequence(this, startupState);
     }
     /**
      * Create the fill callback for listenForFills.
@@ -1447,35 +611,10 @@ class DEXBot {
      * @returns {Promise<{syncResult: Object|null, aborted: boolean, hasUnmatched: number, openOrders: Array|null}>}
      */
     async _syncOpenOrdersAndProcessFills(tag) {
-        if (!this.accountId || this.config?.dryRun) {
-            return { syncResult: null, aborted: false, hasUnmatched: 0, openOrders: null };
-        }
-        try {
-            let openOrders = await chainOrders.readOpenOrders(this.accountId);
-            const syncResult = await this.manager.synchronizeWithChain(openOrders, 'readOpenOrders');
-            let aborted = false;
-            if (syncResult?.filledOrders?.length > 0) {
-                this._refreshDynamicWeightDistribution(`${tag} sync-fill`);
-                this._log(`[SYNC-CHAIN] ${syncResult.filledOrders.length} filled order(s) found during ${tag}`, 'info');
-                const batchResult = await this._processFillsWithBatching(syncResult.filledOrders, new Set(), `${tag} sync-fill`);
-                if (!batchResult?.aborted) {
-                    openOrders = await chainOrders.readOpenOrders(this.accountId);
-                    await this.manager.synchronizeWithChain(openOrders, 'readOpenOrders');
-                }
-                else {
-                    aborted = true;
-                }
-            }
-            const hasUnmatched = syncResult?.unmatchedChainOrders?.length || 0;
-            return { syncResult, aborted, hasUnmatched, openOrders };
-        }
-        catch (err) {
-            this._warn(`[SYNC-CHAIN] Open-orders sync failed during ${tag}: ${err.message}`);
-            return { syncResult: null, aborted: true, hasUnmatched: -1, openOrders: null };
-        }
+        return DexbotMaintenanceRuntime.syncOpenOrdersAndProcessFills(this, tag);
     }
     _maxConsecutiveFillConsumerFailures() {
-        return this.config.fillProcessing?.MAX_CONSECUTIVE_CONSUMER_FAILURES ?? FILL_PROCESSING.MAX_CONSECUTIVE_CONSUMER_FAILURES;
+        return DexbotFillRuntime.maxConsecutiveFillConsumerFailures(this);
     }
     /**
      * Compute the backoff delay for fill-consumer retries after the failure
@@ -1487,80 +626,10 @@ class DEXBot {
      * @private
      */
     _computeFillConsumerBackoffMs(failures) {
-        const fp = this.config.fillProcessing || FILL_PROCESSING;
-        const initial = fp.CONSUMER_BACKOFF_INITIAL_MS;
-        const max = fp.CONSUMER_BACKOFF_MAX_MS;
-        const stepAfterMax = Math.max(0, failures - this._maxConsecutiveFillConsumerFailures());
-        // 0 -> initial, 1 -> 2*initial, 2 -> 4*initial, ... capped at max.
-        return Math.min(max, initial * Math.pow(2, stepAfterMax));
+        return DexbotFillRuntime.computeFillConsumerBackoffMs(this, failures);
     }
     _scheduleFillConsumerRestart(chainOrders) {
-        const failures = this._consecutiveConsumeFailures;
-        if (failures >= this._maxConsecutiveFillConsumerFailures()) {
-            // Past the failure budget: switch from tight setImmediate loop to
-            // exponential backoff. The consumer continues to retry — a transient
-            // outage (e.g., credential daemon recovery) will resume normal
-            // operation as soon as one cycle succeeds and resets the counter.
-            // A permanent failure mode yields slower-but-still-progressing
-            // retries capped at CONSUMER_BACKOFF_MAX_MS, with no permanent
-            // stop that would require a bot restart.
-            const backoffMs = this._computeFillConsumerBackoffMs(failures);
-            const elapsedSec = this._consumeFailureFirstAt
-                ? Math.round((Date.now() - this._consumeFailureFirstAt) / TIMING.MILLISECONDS_PER_SECOND)
-                : null;
-            const elapsed = elapsedSec !== null ? `${elapsedSec}s` : 'unknown';
-            // Escalate log level on sustained failure so operators monitoring
-            // for error/critical alerts are not blind to a stuck consumer.
-            //   - warn   : within the first escalation window (5-9 failures,
-            //              <5 min) — could be a slow recovery
-            //   - error  : 10+ failures OR 5+ minutes of sustained failure
-            //   - critical: 20+ failures OR 15+ minutes of sustained failure —
-            //              this is the "permanent fault" signal
-            const sustainedLevel = (failures >= 20 || (elapsedSec !== null && elapsedSec >= 900))
-                ? 'critical'
-                : (failures >= 10 || (elapsedSec !== null && elapsedSec >= 300))
-                    ? 'error'
-                    : 'warn';
-            this._log(`[FILL-QUEUE] Fill consumer has failed ${failures} consecutive times over ${elapsed}; ` +
-                `backing off ${Math.round(backoffMs / TIMING.MILLISECONDS_PER_SECOND)}s before retry. ` +
-                `Queue: ${this._incomingFillQueue.length} fills.`, sustainedLevel);
-            setTimeout(() => {
-                if (this._shuttingDown)
-                    return;
-                this._consumeFillQueue(chainOrders).catch(err => {
-                    if (!this._consumeFailureFirstAt) {
-                        this._consumeFailureFirstAt = Date.now();
-                    }
-                    this._consecutiveConsumeFailures++;
-                    const newFailures = this._consecutiveConsumeFailures;
-                    const newElapsedSec = this._consumeFailureFirstAt
-                        ? Math.round((Date.now() - this._consumeFailureFirstAt) / TIMING.MILLISECONDS_PER_SECOND)
-                        : null;
-                    const resumeLevel = (newFailures >= 20 || (newElapsedSec !== null && newElapsedSec >= 900))
-                        ? 'critical'
-                        : (newFailures >= 10 || (newElapsedSec !== null && newElapsedSec >= 300))
-                            ? 'error'
-                            : 'warn';
-                    this._log(`Fill consumer resume after backoff failed ` +
-                        `(${newFailures} total, ` +
-                        `next backoff ${Math.round(this._computeFillConsumerBackoffMs(newFailures) / TIMING.MILLISECONDS_PER_SECOND)}s): ` +
-                        `${err.message}`, resumeLevel);
-                    // Continue the backoff loop. The success path of
-                    // _consumeFillQueue resets the counter, breaking the cycle.
-                    this._scheduleFillConsumerRestart(chainOrders);
-                });
-            }, backoffMs);
-            return;
-        }
-        setImmediate(() => this._consumeFillQueue(chainOrders).catch(err => {
-            if (!this._consumeFailureFirstAt) {
-                this._consumeFailureFirstAt = Date.now();
-            }
-            this._consecutiveConsumeFailures++;
-            const remaining = this._maxConsecutiveFillConsumerFailures() - this._consecutiveConsumeFailures;
-            this._log(`Fill consumer failed (${this._consecutiveConsumeFailures}/${this._maxConsecutiveFillConsumerFailures()}, ` +
-                `${remaining} attempts remaining): ${err.message}`, this._consecutiveConsumeFailures >= 3 ? 'warn' : 'error');
-        }));
+        DexbotFillRuntime.scheduleFillConsumerRestart(this, chainOrders);
     }
     /**
      * Consume queued fills from incomingFillQueue and rebalance.
@@ -1576,564 +645,7 @@ class DEXBot {
      * @private
      */
     async _consumeFillQueue(chainOrders) {
-        // Helper: every early return below is a "deferral", not a failure.
-        // The counter only tracks actual failures, so any healthy deferral
-        // path should also reset the counter. Without this, a sequence of
-        // F-S-F-S-F-S-F-S-F (fail, succeed, fail, succeed, ...) would still
-        // reach the max and trip backoff, OR a failure followed by an empty
-        // queue / shutdown / in-flight batch would leave the counter sticky
-        // and trigger backoff one step sooner on the next real failure.
-        const resetFailureWatchdogIfSet = () => {
-            if (this._consecutiveConsumeFailures > 0 || this._consumeFailureFirstAt > 0) {
-                this._consecutiveConsumeFailures = 0;
-                this._consumeFailureFirstAt = 0;
-            }
-        };
-        // ATOMIC: Only attempt lock acquisition if queue has work
-        // This prevents unnecessary lock contention on empty queues
-        if (this._incomingFillQueue.length === 0) {
-            // Empty queue = consumer is healthy, just idle.
-            resetFailureWatchdogIfSet();
-            return;
-        }
-        // Check shutdown state
-        if (this._shuttingDown) {
-            this._warn('Fill processing skipped: shutdown in progress');
-            resetFailureWatchdogIfSet();
-            return;
-        }
-        if (this._batchInFlight || this._recoverySyncInFlight) {
-            this.manager?.logger?.log?.(`Fill processing deferred: order pipeline active (${this._incomingFillQueue.length} queued)`, 'debug');
-            // A batch is in flight, not a failure. The next iteration will
-            // either succeed (and reset the counter on the success path) or
-            // fail and increment it. Either way, leaving an old failure
-            // count here would double-count.
-            resetFailureWatchdogIfSet();
-            return;
-        }
-        let pendingFillKeysForCurrentCycle = new Set();
-        try {
-            // BOOTSTRAP OPTIMIZATION: During bootstrap, prioritize fill processing over grid-wide checks
-            // Process fills immediately with side-only rebalancing (no expensive full grid recalculations)
-            if (this.manager.isBootstrapping()) {
-                // During bootstrap: skip lock contention checks, process fills directly
-                let bootstrapSkipped = false;
-                await this.manager._fillProcessingLock.acquire(async () => {
-                    if (!this.manager.isBootstrapping()) {
-                        // Bootstrap finished while waiting for the lock — no
-                        // work to do, but the iteration is still healthy.
-                        bootstrapSkipped = true;
-                        return;
-                    }
-                    await this._processFillsWithBootstrapMode(chainOrders);
-                });
-                if (bootstrapSkipped) {
-                    // Bootstrap-mode lock callback returned without doing
-                    // work; the .acquire() success path at line ~1941 that
-                    // would normally reset the counter is not reached in
-                    // this branch. Reset here so a stale counter from a
-                    // prior failure doesn't carry over.
-                    resetFailureWatchdogIfSet();
-                }
-                return;
-            }
-            // NORMAL MODE: Non-blocking check if lock already has waiters
-            // This prevents unbounded queue growth while still ensuring processing
-            // Note: We DO proceed if lock is held but has no waiters - we'll wait our turn
-            if (this.manager._fillProcessingLock.getQueueLength() > 0) {
-                this._metrics.lockContentionEvents++;
-                // Deferral, not a failure. Reset the watchdog so the next
-                // call (which may now find an empty queue, or process
-                // successfully) doesn't inherit a stale counter.
-                resetFailureWatchdogIfSet();
-                return;
-            }
-            await this.manager._fillProcessingLock.acquire(async () => {
-                // Reset orphan-fill credit timestamp at the start of each
-                // fill cycle. It is re-set when orphan fills are credited,
-                // and consumed (set to null) on the next fund-invariant check
-                // in accounting.ts, which widens tolerance by 5x while set.
-                // Written to this.manager (not this) because accounting.ts
-                // reads from the OrderManager reference (mgr).
-                // Also cleared by _performStateRecovery after a fresh chain
-                // fetch. The timestamp value itself is not compared against a
-                // window — it acts as a consume-on-read boolean.
-                this.manager._orphanFillsCreditedAt = null;
-                while (this._incomingFillQueue.length > 0) {
-                    const batchStartTime = Date.now();
-                    // Track max queue depth
-                    this._metrics.maxQueueDepth = Math.max(this._metrics.maxQueueDepth, this._incomingFillQueue.length);
-                    // 1. Take snapshot of current work (ATOMIC: splice removes and returns fills atomically)
-                    const allFills = this._incomingFillQueue.splice(0); // Atomically clear and get all fills
-                    const validFills = [];
-                    const processedFillKeys = new Set();
-                    pendingFillKeysForCurrentCycle = new Set();
-                    let requiresOpenOrdersSync = false;
-                    // 2. Filter and Deduplicate (Standard Logic)
-                    for (const fill of allFills) {
-                        if (fill && fill.op && fill.op[0] === FILL_PROCESSING.OPERATION_TYPE) {
-                            const fillOp = fill.op[1];
-                            // SELF-CANCEL GUARD: only drop malformed, cancel-like
-                            // artifacts for an order the local process just cancelled.
-                            // Real fill_order ops carry economic data and must still be
-                            // accounted even if they arrive shortly after a successful
-                            // cancel broadcast.
-                            const hasFillEconomics = fillOp?.pays?.asset_id && fillOp?.pays?.amount != null
-                                && fillOp?.receives?.asset_id && fillOp?.receives?.amount != null;
-                            if (chainOrders && typeof chainOrders.wasRecentlyOwnCancelled === 'function'
-                                && chainOrders.wasRecentlyOwnCancelled(fillOp.order_id)
-                                && !hasFillEconomics) {
-                                this.manager.logger.log(`[SELF-CANCEL] Skipping non-economic fill artifact for order ${fillOp.order_id} (just cancelled by this bot)`, 'debug');
-                                continue;
-                            }
-                            // ACCOUNT VALIDATION: Verify the filled order belongs to this bot's account/grid
-                            // Only process fills for orders we actually manage
-                            const gridOrder = this.manager.orders.get(fillOp.order_id) ||
-                                Array.from(this.manager.orders.values()).find((o) => o.orderId === fillOp.order_id);
-                            if (!gridOrder) {
-                                // Check if this order was already freed by stale-order batch cleanup.
-                                // When a batch fails due to a stale order reference, the cleanup converts the
-                                // slot to VIRTUAL/SPREAD, releasing committed funds to chainFree. If we also
-                                // credit the fill proceeds here, we double-count the capital.
-                                const staleMarkedAt = this._staleCleanedOrderIds.get(fillOp.order_id);
-                                if (staleMarkedAt != null) {
-                                    const staleAgeMs = Date.now() - staleMarkedAt;
-                                    if (staleAgeMs <= this._staleCleanupRetentionMs) {
-                                        this.manager.logger.log(`[ORPHAN-FILL] Skipping double-credit for stale-cleaned order ${fillOp.order_id} ` +
-                                            `(funds already freed by batch cleanup, age=${staleAgeMs}ms)`, 'warn');
-                                        continue;
-                                    }
-                                    this._staleCleanedOrderIds.delete(fillOp.order_id);
-                                }
-                                // Legitimate orphan fill: order was virtualized during sequential processing
-                                // but a fill arrived afterward. Credit proceeds to maintain fund tracking.
-                                let orphanFillKey = buildFillKey(fill);
-                                if (!orphanFillKey) {
-                                    orphanFillKey = this._buildOrphanFillFallbackKey(fill);
-                                }
-                                if (orphanFillKey && !this._isNewFillKey(orphanFillKey, processedFillKeys, '[ORPHAN-FILL]', fillOp.order_id)) {
-                                    continue;
-                                }
-                                this.manager.logger.log(`[ORPHAN-FILL] Processing funds for unknown order ${fillOp.order_id} (not in grid but crediting proceeds)`, 'warn');
-                                const accountingResult = await this._applyReplaySafeOrphanFillAccounting(fill, fillOp, {
-                                    context: 'ORPHAN-FILL',
-                                    replayMessage: (op) => `[ORPHAN-FILL] Replay detected for ${op.order_id}; skipping duplicate credit`
-                                });
-                                if (accountingResult.status === 'missing_key') {
-                                    requiresOpenOrdersSync = true;
-                                }
-                                // Record orphan fill credit timestamp for fund invariant
-                                // tolerance widening. Written to this.manager because
-                                // accounting.ts reads from the OrderManager (mgr).
-                                this.manager._orphanFillsCreditedAt = Date.now();
-                                // Don't add to validFills - we can't do rebalancing without a grid slot
-                                // But the funds are now credited, preventing fund invariant violation
-                                continue;
-                            }
-                            // Process both maker and taker fills for our grid orders
-                            // Grid validation ensures we only process fills belonging to our account
-                            // Taker fills are included because the bot may execute market orders or act as taker
-                            const roleStr = fillOp.is_maker !== false ? 'maker' : 'taker';
-                            this.manager.logger.log(`Processing ${roleStr} fill for order ${fillOp.order_id}`, 'debug');
-                            const fillKey = buildFillKey(fill);
-                            if (!fillKey) {
-                                this.manager.logger.log(`[FILL] Missing history id for order ${fillOp.order_id} block ${fill.block_num}; deferring to open-orders sync`, 'warn');
-                                requiresOpenOrdersSync = true;
-                                continue;
-                            }
-                            if (!this._isNewFillKey(fillKey, processedFillKeys, '[FILL]', fillOp.order_id)) {
-                                continue;
-                            }
-                            validFills.push(fill);
-                            // Log info
-                            const paysAmount = fillOp.pays ? fillOp.pays.amount : '?';
-                            const receivesAmount = fillOp.receives ? fillOp.receives.amount : '?';
-                            this._log(`\n===== FILL DETECTED =====`);
-                            this._log(`Order ID: ${fillOp.order_id}`);
-                            this._log(`Pays: ${paysAmount}, Receives: ${receivesAmount}`);
-                            this._log(`Block: ${fill.block_num} (History ID: ${fill.id || 'N/A'})`);
-                            this._log(`=========================\n`);
-                        }
-                    }
-                    // Clean up short-lived queue dedupe cache to prevent memory leak.
-                    const cleanupTimestamp = Date.now();
-                    let cleanedCount = 0;
-                    for (const [key, timestamp] of this._recentlyQueuedFills) {
-                        if (cleanupTimestamp - timestamp > this._fillDedupeWindowMs) {
-                            this._recentlyQueuedFills.delete(key);
-                            cleanedCount++;
-                        }
-                    }
-                    if (cleanedCount > 0) {
-                        this.manager.logger.log(`Cleaned ${cleanedCount} old queued fill records. Remaining: ${this._recentlyQueuedFills.size}`, 'debug');
-                    }
-                    if (validFills.length === 0 && !requiresOpenOrdersSync)
-                        continue; // Loop back for more
-                    // 3. Sync and Collect Filled Orders
-                    let allFilledOrders = [];
-                    let ordersNeedingCorrection = [];
-                    const pendingGhostOrders = new Set();
-                    const fillMode = chainOrders.getFillProcessingMode();
-                    const processValidFills = async (fillsToSync) => {
-                        let resolvedOrders = [];
-                        if (fillMode === 'history') {
-                            this.manager.logger.log(`Syncing ${fillsToSync.length} fill(s) (history mode)`, 'info');
-                            // Batch mode for 2+ fills: acquires _gridLock once, batches drift refetch
-                            if (fillsToSync.length >= 2) {
-                                const batchResult = await this.manager.syncFromFillHistoryBatch(fillsToSync, {
-                                    persistenceMode: PROCESSED_FILL_PERSISTENCE_MODES.BATCHED
-                                });
-                                for (const fill of fillsToSync) {
-                                    const fillKey = buildFillKey({
-                                        orderId: fill?.op?.[1]?.order_id,
-                                        blockNum: fill?.block_num,
-                                        historyId: fill?.id
-                                    });
-                                    if (fillKey)
-                                        pendingFillKeysForCurrentCycle.add(fillKey);
-                                }
-                                if (batchResult.filledOrders)
-                                    resolvedOrders.push(...batchResult.filledOrders);
-                                if (batchResult.requiresOpenOrdersSync)
-                                    requiresOpenOrdersSync = true;
-                                if (batchResult.ghostOrderIds?.length > 0) {
-                                    for (const id of batchResult.ghostOrderIds) {
-                                        pendingGhostOrders.add(id);
-                                    }
-                                }
-                            }
-                            else {
-                                // Single fill: use individual per-fill path
-                                for (const fill of fillsToSync) {
-                                    const resultHistory = await this.manager.syncFromFillHistory(fill, {
-                                        persistenceMode: PROCESSED_FILL_PERSISTENCE_MODES.BATCHED
-                                    });
-                                    const fillKey = buildFillKey({
-                                        orderId: fill?.op?.[1]?.order_id,
-                                        blockNum: fill?.block_num,
-                                        historyId: fill?.id
-                                    });
-                                    if (fillKey)
-                                        pendingFillKeysForCurrentCycle.add(fillKey);
-                                    // Dust is handled by post-fill detection below.
-                                    if (resultHistory.filledOrders)
-                                        resolvedOrders.push(...resultHistory.filledOrders);
-                                    if (resultHistory.requiresOpenOrdersSync)
-                                        requiresOpenOrdersSync = true;
-                                    if (resultHistory.ghostOrderId)
-                                        pendingGhostOrders.add(resultHistory.ghostOrderId);
-                                }
-                            }
-                        }
-                        if (fillMode !== 'history' || requiresOpenOrdersSync) {
-                            if (fillMode === 'history' && requiresOpenOrdersSync) {
-                                this.manager.logger.log('Falling back to open-orders sync for fill(s) missing replay-safe history identifiers', 'warn');
-                            }
-                            this.manager.logger.log(`Syncing ${fillsToSync.length} fill(s) (open orders mode)`, 'info');
-                            const chainOpenOrders = await chainOrders.readOpenOrders(this.account);
-                            const resultOpenOrders = await this.manager.syncFromOpenOrders(chainOpenOrders);
-                            // Dust is handled by post-fill detection below.
-                            if (resultOpenOrders.filledOrders)
-                                resolvedOrders.push(...resultOpenOrders.filledOrders);
-                            if (resultOpenOrders.ordersNeedingCorrection)
-                                ordersNeedingCorrection.push(...resultOpenOrders.ordersNeedingCorrection);
-                        }
-                        return resolvedOrders;
-                    };
-                    this.manager.pauseFundRecalc();
-                    try {
-                        // FIX 1: Block-level fill batching — group valid fills by block
-                        // and process each block group as a unit. This prevents slot
-                        // collisions when fills from the same block (original + replacement
-                        // orders both filled) arrive in different sync batches. Processing
-                        // all fills from a block together lets the sync engine see every
-                        // fill for overlapping slots simultaneously.
-                        const fillsByBlock = new Map();
-                        const fillsWithoutBlock = [];
-                        for (const fill of validFills) {
-                            if (fill.block_num != null) {
-                                const list = fillsByBlock.get(fill.block_num);
-                                if (list)
-                                    list.push(fill);
-                                else
-                                    fillsByBlock.set(fill.block_num, [fill]);
-                            }
-                            else {
-                                fillsWithoutBlock.push(fill);
-                            }
-                        }
-                        // Process block groups in ascending block order so the sync
-                        // engine sees a deterministic, chronological fill sequence.
-                        const sortedBlocks = [...fillsByBlock.keys()].sort((a, b) => a - b);
-                        const accumulatedOrders = [];
-                        let anyRequiresSync = false;
-                        // Capture whether any fill was skipped during validation
-                        // (e.g. missing history ID) and set the sync flag. The
-                        // per-block reset below would lose this state since those
-                        // fills were filtered out of validFills and never enter
-                        // any block group.
-                        const initialRequiresSync = requiresOpenOrdersSync;
-                        for (const blockNum of sortedBlocks) {
-                            // Reset requiresOpenOrdersSync per block group so one
-                            // block's history-id gap doesn't force the next block
-                            // into an unnecessary open-orders snapshot re-fetch.
-                            requiresOpenOrdersSync = false;
-                            this.manager.logger.log(`[FILL-BLOCK] Processing ${fillsByBlock.get(blockNum).length} fill(s) from block ${blockNum}`, 'debug');
-                            const blockResult = await processValidFills(fillsByBlock.get(blockNum));
-                            accumulatedOrders.push(...blockResult);
-                            if (requiresOpenOrdersSync)
-                                anyRequiresSync = true;
-                        }
-                        // Preserve both per-block sync flags and the initial flag
-                        // from filtered-out fills (missing history ID).
-                        requiresOpenOrdersSync = anyRequiresSync || initialRequiresSync;
-                        if (fillsWithoutBlock.length > 0) {
-                            this.manager.logger.log(`[FILL-BLOCK] Processing ${fillsWithoutBlock.length} fill(s) without block info`, 'debug');
-                            const noBlockResult = await processValidFills(fillsWithoutBlock);
-                            accumulatedOrders.push(...noBlockResult);
-                            if (requiresOpenOrdersSync)
-                                anyRequiresSync = true;
-                        }
-                        // If a fill was filtered out during validation (e.g. missing
-                        // history ID) and no block group triggered the open-orders
-                        // sync, run it now so the grid state is reconciled.
-                        if (requiresOpenOrdersSync && !anyRequiresSync) {
-                            this.manager.logger.log('[FILL-BLOCK] Running open-orders sync for fills with missing history identifiers', 'warn');
-                            const fallbackOrders = await processValidFills([]);
-                            accumulatedOrders.push(...fallbackOrders);
-                            // Flag consumed — variable goes out of scope on
-                            // next while iteration.
-                        }
-                        allFilledOrders = accumulatedOrders;
-                        // 4. Handle Price Corrections
-                        if (ordersNeedingCorrection.length > 0) {
-                            const correctionResult = await correctAllPriceMismatches(this.manager, this.account, this.privateKey, chainOrders);
-                            if (correctionResult.failed > 0)
-                                this.manager.logger.log(`${correctionResult.failed} corrections failed`, 'error');
-                        }
-                    }
-                    finally {
-                        // 4b. Cancel orphaned chain orders detected by other-side rounding.
-                        //     These orders have a tiny residual that the bot treated as fully
-                        //     filled, but the blockchain did not close the order. We send a
-                        //     cancel tx to clean up the zombie order on chain.
-                        //     Runs in the finally so it still fires even if processValidFills
-                        //     throws after collecting ghost IDs into pendingGhostOrders.
-                        //
-                        //     OPTIMIZATION: Batch all new ghost cancels into one executeBatch
-                        //     call with multiple cancelOrder ops, reducing per-order tx fees
-                        //     and broadcast overhead. Falls back to individual cancels on
-                        //     batch failure.
-                        if (pendingGhostOrders.size > 0) {
-                            if (!this._ghostOrderCancelAttempted)
-                                this._ghostOrderCancelAttempted = new Set();
-                            const newGhostIds = [...pendingGhostOrders].filter(id => !this._ghostOrderCancelAttempted.has(id));
-                            if (newGhostIds.length > 0) {
-                                const MAX_OPS_PER_TX = 200;
-                                let batchFailed = false;
-                                // Build cancel ops with per-ID error tolerance.
-                                // Index correlates 1:1 with newGhostIds (allSettled preserves order).
-                                const buildResults = await Promise.allSettled(newGhostIds.map(id => chainOrders.buildCancelOrderOp(this.account, id)));
-                                const cancelOps = [];
-                                for (let i = 0; i < buildResults.length; i++) {
-                                    const result = buildResults[i];
-                                    const id = newGhostIds[i];
-                                    if (result.status === 'fulfilled') {
-                                        cancelOps.push(result.value);
-                                    }
-                                    else {
-                                        this.manager.logger.log(`[SYNC] Failed to build cancel op for ghost order ${id}: ${result.reason?.message || result.reason}`, 'warn');
-                                    }
-                                }
-                                // Chunk into batches respecting MAX_OPS_PER_TX
-                                for (let i = 0; i < cancelOps.length; i += MAX_OPS_PER_TX) {
-                                    const chunk = cancelOps.slice(i, i + MAX_OPS_PER_TX);
-                                    const batchIds = newGhostIds.slice(i, i + MAX_OPS_PER_TX);
-                                    try {
-                                        this.manager.logger.log(`[SYNC] Batch-cancelling ${chunk.length} orphaned chain order(s) ` +
-                                            `(batch ${Math.floor(i / MAX_OPS_PER_TX) + 1}/${Math.ceil(cancelOps.length / MAX_OPS_PER_TX)})`, 'info');
-                                        await chainOrders.executeBatch(this.account, this.privateKey, chunk);
-                                        // Mark successfully cancelled IDs immediately
-                                        for (const id of batchIds) {
-                                            this._ghostOrderCancelAttempted.add(id);
-                                        }
-                                    }
-                                    catch (batchErr) {
-                                        batchFailed = true;
-                                        this.manager.logger.log(`[SYNC] Batch ghost cancel failed for chunk ${Math.floor(i / MAX_OPS_PER_TX) + 1} ` +
-                                            `(${chunk.length} orders): ${batchErr?.message || batchErr}`, 'warn');
-                                    }
-                                }
-                                // Log overall success if all chunks and all builds succeeded
-                                if (!batchFailed && cancelOps.length === newGhostIds.length) {
-                                    this.manager.logger.log(`[SYNC] Successfully batch-cancelled ${newGhostIds.length} orphaned chain order(s)`, 'info');
-                                }
-                                // Fallback: individual cancels for IDs that were not marked successful
-                                for (const ghostOrderId of newGhostIds) {
-                                    if (this._ghostOrderCancelAttempted.has(ghostOrderId))
-                                        continue;
-                                    try {
-                                        this.manager.logger.log(`[SYNC] Cancelling orphaned chain order ${ghostOrderId} (other-side full-fill residual)`, 'info');
-                                        await chainOrders.cancelOrder(this.account, this.privateKey, ghostOrderId);
-                                        this._ghostOrderCancelAttempted.add(ghostOrderId);
-                                    }
-                                    catch (err) {
-                                        this.manager.logger.log(`[SYNC] Failed to cancel orphaned order ${ghostOrderId}: ${err?.message || err}`, 'warn');
-                                    }
-                                }
-                            }
-                        }
-                        await this.manager.resumeFundRecalc();
-                    }
-                    // Refresh dynamic weight distribution before processing fills
-                    // so the rebalance uses the latest market adapter weights, not
-                    // stale values from the last periodic refresh cycle.
-                    // Lightweight: reads local JSON snapshot file.
-                    this._refreshDynamicWeightDistribution('fill queue');
-                    // 5. Fixed-Cap Fill Rebalance
-                    // - 1..MAX_FILL_BATCH_SIZE fills: unified full-set planning
-                    // - larger bursts: fixed-size chunking at MAX_FILL_BATCH_SIZE
-                    if (allFilledOrders.length > 0) {
-                        const result = await this._processFillsWithBatching(allFilledOrders, null, 'fill set');
-                        let abortedFillCycle = result.aborted;
-                        if (!abortedFillCycle) {
-                            const batchFillKeys = new Set(allFilledOrders.map(filledOrder => buildFillKey({
-                                orderId: filledOrder?.orderId,
-                                blockNum: filledOrder?.blockNum,
-                                historyId: filledOrder?.historyId
-                            })).filter(Boolean));
-                            await this._flushProcessedFillPersistenceForKeys(batchFillKeys, 'fill-batch-committed');
-                        }
-                        else {
-                            this.manager.logger.log('[FILL-DEDUP] Fill cycle aborted; fill key persistence guarded under abort path.', 'warn');
-                        }
-                        // 6. Rebalance Recovery Loop (Sequential Extensions)
-                        // DISABLED FOR SEQUENTIAL: Each sequential fill already triggers a full rebalance with proper
-                        // boundary shift. An additional recovery loop with EMPTY fills causes the boundary to remain
-                        // at the last fill's position, leading to wrong operation types (updates instead of rotations)
-                        // and operations on the wrong side.
-                        //
-                        // In the future, recovery loop can be re-enabled for single fills if needed, but ONLY
-                        // if it passes the actual fills to processFilledOrders so the boundary shifts correctly.
-                        // For now: Each fill = full rebalance with boundary shift = complete correction in one pass.
-                        // CRITICAL: Do NOT run spread correction here during sequential fill processing.
-                        // The rebalance from each fill should maintain spread naturally. Running spread correction
-                        // immediately after creates new orders that may get filled by market before next cycle,
-                        // causing cascading fills and potentially SPREAD slots becoming PARTIAL (error condition).
-                        // Spread correction runs in the main loop instead.
-                        const fullFillCount = allFilledOrders.filter(o => o && o.isPartial !== true).length;
-                        const hasAnyFills = allFilledOrders.some(o => o);
-                        const shouldRunPostFillChecks = !abortedFillCycle && fullFillCount > 0;
-                        const shouldRunDustDetection = !abortedFillCycle && hasAnyFills;
-                        if (shouldRunDustDetection) {
-                            const healthResult = await this.manager.checkGridHealth(this.updateOrdersOnChainPlan.bind(this));
-                            const allDust = [
-                                ...(healthResult.buyDustOrders || []),
-                                ...(healthResult.sellDustOrders || []),
-                            ];
-                            if (allDust.length > 0) {
-                                const dustCancelResult = await this._cancelDustOrders({
-                                    buy: healthResult.buyDustOrders,
-                                    sell: healthResult.sellDustOrders,
-                                });
-                                if (dustCancelResult?.batchResult?.aborted) {
-                                    abortedFillCycle = true;
-                                }
-                            }
-                        }
-                        // Run grid maintenance after fills to rebuild degraded grid.
-                        // CRITICAL FIX (commit a946c33): Replaced inline divergence checks with centralized
-                        // _runGridMaintenance call to ensure pipeline protection applies consistently.
-                        // Before: Divergence checks ran immediately after fills, causing race-to-resize
-                        // After: Grid maintenance waits for isPipelineEmpty() before structural changes
-                        // Run only when the cycle contains at least one full fill.
-                        if (shouldRunPostFillChecks && !abortedFillCycle) {
-                            await this._runGridMaintenance('post-fill');
-                        }
-                    }
-                    else if (pendingFillKeysForCurrentCycle.size > 0) {
-                        await this._flushProcessedFillPersistenceForKeys(pendingFillKeysForCurrentCycle, 'fill-batch-no-rotations');
-                    }
-                    this.manager._recentFillKeysSnapshot = this._getRecentFillKeysSnapshot();
-                    await retryPersistenceIfNeeded(this.manager);
-                    // Periodically clean up old fill records after processing N fills.
-                    // Counter is protected by _fillProcessingLock during fill consumption.
-                    this._fillCleanupCounter += validFills.length;
-                    const cleanupThreshold = MAINTENANCE.CLEANUP_PROBABILITY > 0 && MAINTENANCE.CLEANUP_PROBABILITY < 1
-                        ? Math.floor(1 / MAINTENANCE.CLEANUP_PROBABILITY)
-                        : 100; // Default: every 100 fills
-                    if (this._fillCleanupCounter >= cleanupThreshold) {
-                        try {
-                            await this.accountOrders.cleanOldProcessedFills(TIMING.FILL_RECORD_RETENTION_MS);
-                            this._fillCleanupCounter = 0; // Reset counter after cleanup (success or retry on next batch if failed)
-                        }
-                        catch (err) {
-                            this.manager?.logger?.log(`Warning: Fill cleanup failed (will retry): ${err.message}`, 'warn');
-                        }
-                    }
-                    // Update metrics
-                    this._metrics.fillsProcessed += validFills.length;
-                    this._metrics.fillProcessingTimeMs += Date.now() - batchStartTime;
-                    // Prune expired stale-cleaned order IDs after each processing cycle.
-                    if (this._staleCleanedOrderIds.size > 0) {
-                        const now = Date.now();
-                        let prunedCount = 0;
-                        for (const [orderId, markedAt] of this._staleCleanedOrderIds) {
-                            if (now - markedAt > this._staleCleanupRetentionMs) {
-                                this._staleCleanedOrderIds.delete(orderId);
-                                prunedCount++;
-                            }
-                        }
-                        if (prunedCount > 0) {
-                            this.manager.logger.log(`[STALE-CLEANUP] Pruned ${prunedCount} expired stale-cleaned order IDs ` +
-                                `(retention=${this._staleCleanupRetentionMs}ms, remaining=${this._staleCleanedOrderIds.size})`, 'debug');
-                        }
-                    }
-                } // End while(_incomingFillQueue)
-                this._markGridActivity('fill processing end');
-                // Reset the fill-consumer watchdog on the success path. The
-                // counter is only incremented by _scheduleFillConsumerRestart's
-                // catch handler; without this reset, a fill pattern of
-                // F-S-F-S-F-S-F-S-F would still reach the max and the consumer
-                // would stop being re-scheduled.
-                this._consecutiveConsumeFailures = 0;
-                this._consumeFailureFirstAt = 0;
-            });
-        }
-        catch (err) {
-            const isCredentialOutage = this._isCredentialDaemonError(err);
-            if (pendingFillKeysForCurrentCycle.size > 0) {
-                const flushReason = isCredentialOutage
-                    ? 'credential-outage-verified-fills'
-                    : 'fill-cycle-error-verified-fills';
-                if (isCredentialOutage) {
-                    this._credentialRecoveryNeeded = true;
-                    this._suspendGridPersistenceForCredentialOutage(`credential outage during fill processing: ${err.message}`);
-                }
-                try {
-                    await this._flushProcessedFillPersistenceForKeys(pendingFillKeysForCurrentCycle, flushReason, { throwOnError: true });
-                    const credentialSuffix = isCredentialOutage
-                        ? '; grid persistence is suspended until recovery'
-                        : '';
-                    this.manager?.logger?.log?.(`[FILL-DEDUP] Persisted ${pendingFillKeysForCurrentCycle.size} verified processed-fill write(s) after fill cycle error${credentialSuffix}.`, isCredentialOutage ? 'warn' : 'info');
-                }
-                catch (flushErr) {
-                    this.manager?.logger?.log?.(`[FILL-DEDUP] Failed to persist verified fill keys during fill error handling: ${flushErr.message}`, 'warn');
-                }
-            }
-            if (isCredentialOutage && pendingFillKeysForCurrentCycle.size === 0) {
-                this._credentialRecoveryNeeded = true;
-                this._suspendGridPersistenceForCredentialOutage(`credential outage during fill processing: ${err.message}`);
-            }
-            this._log(`Error processing fills: ${err.message}`, 'error');
-            if (err.stack)
-                this._log(err.stack, 'error');
-        }
-        // Post-processing: If new fills arrived while processing, schedule another cycle
-        // SAFE: Done outside lock context, no async work in finally block
-        if (!this._shuttingDown && this._incomingFillQueue.length > 0) {
-            this._scheduleFillConsumerRestart(chainOrders);
-        }
+        return DexbotFillRuntime.consumeFillQueue(this, chainOrders);
     }
     /**
      * Process fills during bootstrap phase using the standard fill pipeline.
@@ -2153,98 +665,7 @@ class DEXBot {
      * @returns {Promise<void>}
      */
     async _processFillsWithBootstrapMode(chainOrders) {
-        if (this._incomingFillQueue.length === 0)
-            return;
-        const startTime = Date.now();
-        const fills = this._incomingFillQueue.splice(0);
-        const validFills = [];
-        const processedFillKeys = new Set();
-        let requiresOpenOrdersSync = false;
-        // 1. Validate and deduplicate fills
-        for (const fill of fills) {
-            if (!fill || fill.op?.[0] !== 4)
-                continue;
-            const fillOp = fill.op[1];
-            const gridOrder = this.manager.orders.get(fillOp.order_id) ||
-                Array.from(this.manager.orders.values()).find((o) => o.orderId === fillOp.order_id);
-            if (!gridOrder) {
-                // CRITICAL FIX: Even if order not in grid, we must still credit the fill proceeds
-                // This can happen when fills arrive after an order was marked VIRTUAL during sequential processing
-                let orphanFillKey = buildFillKey(fill);
-                if (!orphanFillKey) {
-                    orphanFillKey = this._buildOrphanFillFallbackKey(fill);
-                }
-                if (orphanFillKey && !this._isNewFillKey(orphanFillKey, processedFillKeys, '[BOOTSTRAP]', fillOp.order_id)) {
-                    continue;
-                }
-                this.manager.logger.log(`[BOOTSTRAP] Processing funds for unknown order ${fillOp.order_id} (not in grid but crediting proceeds)`, 'warn');
-                const accountingResult = await this._applyReplaySafeOrphanFillAccounting(fill, fillOp, {
-                    context: 'BOOTSTRAP'
-                });
-                if (accountingResult.status === 'missing_key') {
-                    requiresOpenOrdersSync = true;
-                }
-                continue;
-            }
-            const trackedFillKey = buildFillKey(fill);
-            if (trackedFillKey && !this._isNewFillKey(trackedFillKey, processedFillKeys, '[BOOTSTRAP]', fillOp.order_id)) {
-                continue;
-            }
-            this.manager.lockOrders([gridOrder.id]);
-            try {
-                const accountingResult = await this._applyReplaySafeTrackedFillAccounting(fill, fillOp, {
-                    context: 'BOOTSTRAP',
-                    replayMessage: (op) => `[BOOTSTRAP] Replay detected for ${op.order_id}; skipping duplicate bootstrap rebalance`
-                });
-                if (accountingResult.status === 'missing_key') {
-                    requiresOpenOrdersSync = true;
-                    continue;
-                }
-                if (accountingResult.status !== 'applied') {
-                    continue;
-                }
-                validFills.push({ ...fill, gridOrder });
-                const fillType = gridOrder.type === ORDER_TYPES.BUY ? 'BUY' : 'SELL';
-                this._log(`[BOOTSTRAP] Fill detected: ${fillType} order (${fillOp.is_maker !== false ? 'maker' : 'taker'})`);
-            }
-            finally {
-                this.manager.unlockOrders([gridOrder.id]);
-            }
-        }
-        if (requiresOpenOrdersSync) {
-            this._log('[BOOTSTRAP] Falling back to open-orders sync for fill(s) missing replay-safe history identifiers', 'warn');
-            const bootstrapChainOpenOrders = await chainOrders.readOpenOrders(this.accountId);
-            const syncResult = await this.manager.syncFromOpenOrders(bootstrapChainOpenOrders);
-            if (syncResult.filledOrders?.length > 0) {
-                const queuedOrderIds = new Set(validFills.map(fill => fill?.gridOrder?.orderId).filter(Boolean));
-                for (const filledOrder of syncResult.filledOrders) {
-                    if (!filledOrder?.orderId || queuedOrderIds.has(filledOrder.orderId))
-                        continue;
-                    validFills.push({ gridOrder: filledOrder });
-                    queuedOrderIds.add(filledOrder.orderId);
-                }
-            }
-        }
-        await this._flushProcessedFillPersistence('bootstrap-batch');
-        if (validFills.length === 0)
-            return;
-        // 2. Process fills through the standard fill pipeline.
-        // This handles same-side replacement, symmetric rebalance, and dust cleanup
-        // via the same path used by the post-reset flow.
-        try {
-            this._log(`[BOOTSTRAP] Processing ${validFills.length} fill(s) through standard pipeline`, 'info');
-            const filledOrders = validFills.map(f => f.gridOrder);
-            const result = await this._processFillsWithBatching(filledOrders, new Set(), '[BOOTSTRAP] fill processing');
-            if (result.aborted) {
-                this._warn('[BOOTSTRAP] Aborted batch due to illegal state; skipping grid persistence this cycle');
-            }
-            this._metrics.fillsProcessed += validFills.length;
-            this._metrics.fillProcessingTimeMs += Date.now() - startTime;
-        }
-        catch (err) {
-            this._warn(`[BOOTSTRAP] Error processing fills: ${err.message}`);
-            this.manager.logger.log(`[BOOTSTRAP] Fill error: ${err.message}`, 'error');
-        }
+        return DexbotFillRuntime.processFillsWithBootstrapMode(this, chainOrders);
     }
     /**
      * Set up account identifier and configure global context.
@@ -2314,43 +735,7 @@ class DEXBot {
      * @returns {Promise<void>}
      */
     async placeInitialOrders() {
-        if (!this.manager) {
-            const mgrLogFile = this.config?.name ? path.join(PATHS.LOGS_DIR, `${this.config.name}.log`) : undefined;
-            this.manager = new OrderManager({ ...this.config, logFile: mgrLogFile });
-            this.manager.accountOrders = this.accountOrders;
-        }
-        this._wireStructuralGridResyncRequest();
-        this.manager.startBootstrap();
-        try {
-            try {
-                const botFunds = this.config && this.config.botFunds ? this.config.botFunds : {};
-                const needsPercent = (v) => typeof v === 'string' && v.includes('%');
-                if ((needsPercent(botFunds.buy) || needsPercent(botFunds.sell)) && (this.accountId || this.account)) {
-                    if (typeof this.manager._fetchAccountBalancesAndSetTotals === 'function') {
-                        await this.manager._fetchAccountBalancesAndSetTotals();
-                    }
-                }
-            }
-            catch (errFetch) {
-                this._warn(`Could not fetch account totals before initializing grid: ${errFetch && errFetch.message ? errFetch.message : errFetch}`);
-            }
-            await Grid.initializeGrid(this.manager);
-            if (this.config.dryRun) {
-                this.manager.logger.log('Dry run enabled, skipping on-chain order placement.', 'info');
-                await this.manager.persistGrid();
-                return;
-            }
-            this.manager.logger.log('Placing initial orders on-chain...', 'info');
-            const ordersToActivate = this.manager.getInitialOrdersToActivate();
-            const orderGroups = this._buildOutsideInPairGroupsForOrders(ordersToActivate);
-            for (const group of orderGroups) {
-                await this.updateOrdersOnChainPlan({ ordersToPlace: group });
-            }
-            await this.manager.persistGrid();
-        }
-        finally {
-            this.manager.finishBootstrap();
-        }
+        return DexbotStartupRuntime.placeInitialOrdersImpl(this);
     }
     /**
      * Build outside-in pair groups for initial order placement.
@@ -2358,11 +743,7 @@ class DEXBot {
      * @returns {Array<Array<Object>>} Grouped order arrays
      */
     _buildOutsideInPairGroupsForOrders(orders) {
-        return buildOutsideInPairGroups(orders, {
-            isValid: Boolean,
-            getType: o => o.type,
-            getPrice: o => o.price,
-        });
+        return cowRuntime.buildOutsideInPairGroupsForOrders(orders);
     }
     /**
      * Build outside-in pair groups for create entry contexts.
@@ -2370,11 +751,7 @@ class DEXBot {
      * @returns {Array<Array<Object>>} Grouped entry arrays
      */
     _buildOutsideInPairGroupsForCreateEntries(createEntries) {
-        return buildOutsideInPairGroups(createEntries, {
-            isValid: e => Boolean(e?.context?.order),
-            getType: e => e.context.order.type,
-            getPrice: e => e.context.order.price,
-        });
+        return cowRuntime.buildOutsideInPairGroupsForCreateEntries(createEntries);
     }
     /**
      * Resolve the centralized fill batch cap.
@@ -2390,19 +767,7 @@ class DEXBot {
      * @returns {Array} Array of operation result entries
      */
     _extractOperationResults(result, warnContext = '') {
-        const extracted = extractBatchOperationResults(result);
-        if (Array.isArray(extracted))
-            return extracted;
-        if (result) {
-            const resultType = Array.isArray(result) ? 'array' : typeof result;
-            const keySummary = (resultType === 'object' && !Array.isArray(result))
-                ? Object.keys(result).slice(0, 8).join(',')
-                : '';
-            const contextSuffix = warnContext ? ` (${warnContext})` : '';
-            const keysSuffix = keySummary ? `; keys=[${keySummary}]` : '';
-            this.manager?.logger?.log(`[COW] Unrecognized operation_results shape${contextSuffix}; defaulting to empty results. resultType=${resultType}${keysSuffix}`, 'warn');
-        }
-        return [];
+        return cowRuntime.extractOperationResults(result, warnContext, this.manager?.logger?.log?.bind(this.manager?.logger));
     }
     /**
      * Find CREATE operation contexts whose broadcast result did not include a chain order id.
@@ -2412,19 +777,7 @@ class DEXBot {
      * @returns {Array<{index:number, ctx:Object}>} Missing create result contexts.
      */
     _findMissingCreateResultContexts(operationResults, opContexts) {
-        const missing = [];
-        if (!Array.isArray(opContexts))
-            return missing;
-        for (let i = 0; i < opContexts.length; i++) {
-            const ctx = opContexts[i];
-            if (ctx?.kind !== 'create')
-                continue;
-            const chainOrderId = operationResults?.[i]?.[1];
-            if (!chainOrderId || !/^1\.7\.\d+$/.test(String(chainOrderId))) {
-                missing.push({ index: i, ctx });
-            }
-        }
-        return missing;
+        return cowRuntime.findMissingCreateResultContexts(operationResults, opContexts);
     }
     /**
      * Run an immediate chain sync after a successful CREATE broadcast returned incomplete ids.
@@ -2438,42 +791,7 @@ class DEXBot {
      * @returns {Promise<void>}
      */
     async _recoverAfterMissingCreateResults(reason = 'missing create operation results') {
-        try {
-            const accountRef = this.accountId || this.account?.id || this.account;
-            if (!accountRef || !this.manager || !chainOrders?.readOpenOrders) {
-                this.manager?.logger?.log?.(`[COW] Recovery sync unavailable after ${reason}`, 'warn');
-                return;
-            }
-            const preRecoveryMissingCreateBlockers = Array.isArray(this.manager._lastUnmatchedChainOrders)
-                ? this.manager._lastUnmatchedChainOrders
-                    .filter(order => order?.reason === 'missing-create-result')
-                    .map(order => ({ ...order }))
-                : [];
-            const openOrders = await chainOrders.readOpenOrders(accountRef);
-            const recoveryResult = await this.manager.syncFromOpenOrders(openOrders, {
-                skipAccounting: false,
-            });
-            this._preserveMissingCreateBlockersAfterRecovery(preRecoveryMissingCreateBlockers, recoveryResult);
-            // Persist any master grid mutations from the recovery sync. The
-            // caller returned from the COW catch handler before reaching the
-            // success-path persistGrid.
-            if (typeof this.manager.persistGrid === 'function') {
-                await this.manager.persistGrid();
-            }
-        }
-        catch (err) {
-            this.manager?.logger?.log?.(`[COW] CRITICAL: Recovery sync failed after ${reason}: ${err.message}`, 'error');
-            if (typeof this.manager?.requestStructuralGridResync === 'function') {
-                try {
-                    await this.manager.requestStructuralGridResync(`recovery sync failed after ${reason}`, {
-                        error: err.message
-                    });
-                }
-                catch (scheduleErr) {
-                    this.manager?.logger?.log?.(`[COW] CRITICAL: Failed to schedule structural resync after recovery failure: ${scheduleErr.message}`, 'error');
-                }
-            }
-        }
+        return cowRuntime.recoverAfterMissingCreateResults(this, reason);
     }
     /**
      * Restore unresolved missing-create blockers after recovery if sync did not adopt them.
@@ -2483,30 +801,7 @@ class DEXBot {
      * @returns {void}
      */
     _preserveMissingCreateBlockersAfterRecovery(blockers, recoveryResult) {
-        if (!Array.isArray(blockers) || blockers.length === 0 || !this.manager)
-            return;
-        const adoptedSlotIds = new Set((Array.isArray(recoveryResult?.updatedOrders) ? recoveryResult.updatedOrders : [])
-            .filter(order => order?.id && order?.orderId)
-            .map(order => order.id));
-        const unresolvedBlockers = blockers.filter(blocker => !blocker.slotId || !adoptedSlotIds.has(blocker.slotId));
-        if (unresolvedBlockers.length === 0)
-            return;
-        const currentUnmatched = Array.isArray(this.manager._lastUnmatchedChainOrders)
-            ? this.manager._lastUnmatchedChainOrders
-            : [];
-        const currentKeys = new Set(currentUnmatched.map(order => `${order.reason || ''}:${order.slotId || ''}:${order.operationIndex ?? ''}`));
-        const restored = [...currentUnmatched];
-        for (const blocker of unresolvedBlockers) {
-            const key = `${blocker.reason || ''}:${blocker.slotId || ''}:${blocker.operationIndex ?? ''}`;
-            if (!currentKeys.has(key))
-                restored.push({ ...blocker });
-        }
-        if (restored.length !== currentUnmatched.length) {
-            this.manager._lastUnmatchedChainOrders = restored;
-            this.manager._lastUnmatchedChainOrdersAt = Date.now();
-            this.manager.logger?.log?.(`[COW] Preserving ${restored.length - currentUnmatched.length} missing-create blocker(s) after recovery sync; ` +
-                `chain snapshot did not account for the affected slot(s).`, 'warn');
-        }
+        return cowRuntime.preserveMissingCreateBlockersAfterRecovery(this, blockers, recoveryResult);
     }
     /**
      * Merge missing CREATE result contexts into manager._lastUnmatchedChainOrders.
@@ -2520,42 +815,7 @@ class DEXBot {
      * @returns {void}
      */
     _markMissingCreateResultsAsStructuralBlocker(missingCreateResults) {
-        const blockers = Array.isArray(missingCreateResults)
-            ? missingCreateResults.map(item => {
-                const order = item.ctx?.order || {};
-                const fingerprint = [
-                    `type=${order.type || 'unknown'}`,
-                    `price=${Format.formatPrice6(order.price)}`,
-                    `size=${Format.formatAmount(order.size)}`
-                ].join(',');
-                return {
-                    chainOrderId: 'unknown',
-                    type: order.type || null,
-                    price: order.price,
-                    size: order.size,
-                    slotId: order.id || item.ctx?.id || null,
-                    reason: 'missing-create-result',
-                    operationIndex: item.index,
-                    fingerprint,
-                };
-            })
-            : [];
-        if (this.manager && blockers.length > 0) {
-            const existing = Array.isArray(this.manager._lastUnmatchedChainOrders)
-                ? this.manager._lastUnmatchedChainOrders
-                : [];
-            const keys = new Set(existing.map(order => `${order.reason || ''}:${order.slotId || ''}:${order.operationIndex ?? ''}`));
-            const merged = [...existing];
-            for (const blocker of blockers) {
-                const key = `${blocker.reason || ''}:${blocker.slotId || ''}:${blocker.operationIndex ?? ''}`;
-                if (!keys.has(key)) {
-                    merged.push(blocker);
-                    keys.add(key);
-                }
-            }
-            this.manager._lastUnmatchedChainOrders = merged;
-            this.manager._lastUnmatchedChainOrdersAt = Date.now();
-        }
+        return cowRuntime.markMissingCreateResultsAsStructuralBlocker(this, missingCreateResults);
     }
     /**
      * Format an unmatched chain order/blocker for COW logs.
@@ -2564,7 +824,7 @@ class DEXBot {
      * @returns {string} Compact human-readable diagnostic.
      */
     _formatUnmatchedChainOrderForLog(order) {
-        return formatUnmatchedChainOrder(order);
+        return cowRuntime.formatUnmatchedChainOrderForLog(order);
     }
     /**
      * Record a pending CREATE broadcast on the manager.
@@ -2587,35 +847,7 @@ class DEXBot {
      * @returns {void}
      */
     _recordPendingBroadcast(entry) {
-        if (!this.manager || !entry || !entry.order)
-            return;
-        if (!this.manager._pendingBroadcasts || !(this.manager._pendingBroadcasts instanceof Map)) {
-            this.manager._pendingBroadcasts = new Map();
-        }
-        const fingerprint = buildCreateOpFingerprint({
-            side: entry.order.type,
-            assetA: this.manager?.assets?.assetA?.id,
-            assetB: this.manager?.assets?.assetB?.id,
-            sellInt: entry.finalInts?.sell,
-            receiveInt: entry.finalInts?.receive,
-            slotId: entry.order.id
-        });
-        if (!fingerprint) {
-            this.manager.logger.log?.(`[COW] Skipped pending-broadcast record: could not build fingerprint for ${entry.order?.id || 'unknown'}`, 'warn');
-            return;
-        }
-        this.manager._pendingBroadcasts.set(fingerprint, {
-            fingerprint,
-            opIndex: entry.opIndex,
-            ctxIndex: entry.ctxIndex,
-            slotId: entry.order.id,
-            orderId: entry.order.id,
-            orderType: entry.order.type,
-            order: entry.order,
-            finalInts: entry.finalInts,
-            batchId: this._currentBatchId || null,
-            recordedAt: Date.now()
-        });
+        return cowRuntime.recordPendingBroadcast(this, entry);
     }
     /**
      * Clear the pending-broadcast cache.
@@ -2626,9 +858,7 @@ class DEXBot {
      * _reconcileAfterUncertainBroadcast before calling this).
      */
     _clearPendingBroadcasts() {
-        if (this.manager && this.manager._pendingBroadcasts instanceof Map) {
-            this.manager._pendingBroadcasts.clear();
-        }
+        return cowRuntime.clearPendingBroadcasts(this.manager?._pendingBroadcasts);
     }
     /**
      * Build a fingerprint for an on-chain order so it can be matched against
@@ -2639,19 +869,7 @@ class DEXBot {
      * @returns {string|null} Fingerprint or null on bad input
      */
     _buildChainOrderFingerprint(chainOrder, slotId) {
-        if (!chainOrder || !slotId)
-            return null;
-        const normalized = this._normalizeChainOrderForPendingMatch(chainOrder);
-        if (!normalized)
-            return null;
-        return buildCreateOpFingerprint({
-            side: normalized.side,
-            assetA: normalized.assetA,
-            assetB: normalized.assetB,
-            sellInt: normalized.sellInt,
-            receiveInt: normalized.receiveInt,
-            slotId
-        });
+        return cowRuntime.buildChainOrderFingerprint(this, chainOrder, slotId);
     }
     /**
      * Normalize raw BitShares limit_order_object data into the integer tuple
@@ -2665,41 +883,7 @@ class DEXBot {
      * @returns {{side: string, assetA: string, assetB: string, sellInt: number, receiveInt: number}|null}
      */
     _normalizeChainOrderForPendingMatch(chainOrder) {
-        if (!chainOrder)
-            return null;
-        const assetA = this.manager?.assets?.assetA?.id;
-        const assetB = this.manager?.assets?.assetB?.id;
-        if (!assetA || !assetB)
-            return null;
-        const explicitSide = (chainOrder.type === 'buy' || chainOrder.type === 'sell')
-            ? chainOrder.type
-            : null;
-        const explicitSell = chainOrder.sellInt ?? chainOrder.sell;
-        const explicitReceive = chainOrder.receiveInt ?? chainOrder.receive;
-        if (explicitSide && Number.isFinite(Number(explicitSell)) && Number.isFinite(Number(explicitReceive))) {
-            return {
-                side: explicitSide,
-                assetA,
-                assetB,
-                sellInt: Number(explicitSell),
-                receiveInt: Number(explicitReceive)
-            };
-        }
-        const base = chainOrder.sell_price?.base;
-        const quote = chainOrder.sell_price?.quote;
-        if (!base || !quote || !base.asset_id || !quote.asset_id)
-            return null;
-        const baseAmount = Number(base.amount);
-        const quoteAmount = Number(quote.amount);
-        if (!Number.isFinite(baseAmount) || !Number.isFinite(quoteAmount))
-            return null;
-        if (base.asset_id === assetA && quote.asset_id === assetB) {
-            return { side: 'sell', assetA, assetB, sellInt: baseAmount, receiveInt: quoteAmount };
-        }
-        if (base.asset_id === assetB && quote.asset_id === assetA) {
-            return { side: 'buy', assetA, assetB, sellInt: baseAmount, receiveInt: quoteAmount };
-        }
-        return null;
+        return cowRuntime.normalizeChainOrderForPendingMatch(this, chainOrder);
     }
     /**
      * Find a chain order that matches a planned slot using price+size proximity.
@@ -2717,56 +901,7 @@ class DEXBot {
      * @returns {Object|null} Matching chain order, or null
      */
     _findChainOrderForSlot(chainOrders, slotId, planned) {
-        if (!Array.isArray(chainOrders) || !slotId)
-            return null;
-        const assetA = this.manager?.assets?.assetA?.id;
-        const assetB = this.manager?.assets?.assetB?.id;
-        if (!assetA || !assetB)
-            return null;
-        // 1. Exact fingerprint match.
-        for (const o of chainOrders) {
-            const fp = this._buildChainOrderFingerprint(o, slotId);
-            if (fp && this.manager._pendingBroadcasts?.has(fp)) {
-                return o;
-            }
-        }
-        if (!planned || !Number.isFinite(Number(planned.sell)) || !Number.isFinite(Number(planned.receive))) {
-            return null;
-        }
-        // 2. Near match: same side, sell int within 1, receive int within 1% or 2 units.
-        const targetSell = Number(planned.sell);
-        const targetReceive = Number(planned.receive);
-        const plannedSide = planned.orderType ||
-            planned.side ||
-            this.manager._pendingBroadcasts?.get?.(planned.fingerprint)?.orderType ||
-            this.manager.orders.get(slotId)?.type;
-        if (plannedSide !== 'buy' && plannedSide !== 'sell') {
-            return null;
-        }
-        let best = null;
-        let bestDistance = Infinity;
-        for (const o of chainOrders) {
-            const normalized = this._normalizeChainOrderForPendingMatch(o);
-            if (!normalized)
-                continue;
-            if (normalized.side !== plannedSide)
-                continue;
-            const sell = Number(normalized.sellInt);
-            const receive = Number(normalized.receiveInt);
-            if (!Number.isFinite(sell) || !Number.isFinite(receive))
-                continue;
-            const sellDelta = Math.abs(sell - targetSell);
-            const receiveDelta = Math.abs(receive - targetReceive);
-            const receiveTol = Math.max(2, Math.floor(targetReceive * 0.01));
-            if (sellDelta > 1 || receiveDelta > receiveTol)
-                continue;
-            const distance = sellDelta * 1000 + receiveDelta;
-            if (distance < bestDistance) {
-                best = o;
-                bestDistance = distance;
-            }
-        }
-        return best;
+        return cowRuntime.findChainOrderForSlot(this, chainOrders, slotId, planned);
     }
     /**
      * Reconcile a broadcast whose chain state is unknown.
@@ -2778,290 +913,27 @@ class DEXBot {
      *
      * Algorithm:
      *   1. Read the account's current open orders from the chain.
-     *   2. For each pending-broadcast entry (fingerprinted CREATE op), look
-     *      for a matching chain order. If found: adopt it (set the opContext's
-     *      chainOrderId and continue with the existing planned slot).
-     *   3. For pending entries with no chain match: virtualize (mark the
-     *      opContext as discarded; the planned slot stays empty until the
-     *      next planning cycle).
-     *   4. Persist + log a structured [COW][UNCERTAIN] summary.
-     *
-     * After this method returns, the bot has either adopted the on-chain
-     * result (good case — chain accepted but we didn't see the reply) or
-     * accepted the discard (chain rejected or never received the op).
-     *
-     * @param {BroadcastUncertainError} err - The thrown error
-     * @param {Array<Object>} opContexts - Original opContexts from the failed batch
-     * @returns {Promise<Object>} Result object compatible with batch return shape
-     */
-    async _reconcileAfterUncertainBroadcast(err, opContexts, options = {}) {
-        if (this.manager?._fillProcessingLock &&
-            typeof this.manager._fillProcessingLock.acquire === 'function' &&
-            !this.manager._fillProcessingLock.isReentrant()) {
-            return this.manager._fillProcessingLock.acquire(() => this._reconcileAfterUncertainBroadcast(err, opContexts, options));
-        }
-        return this._reconcileAfterUncertainBroadcastImpl(err, opContexts, options);
-    }
-    async _reconcileAfterUncertainBroadcastImpl(err, opContexts, options) {
-        const startedAt = Date.now();
-        const pending = (this.manager && this.manager._pendingBroadcasts instanceof Map)
-            ? Array.from(this.manager._pendingBroadcasts.values())
-            : [];
-        const createContextCount = opContexts.filter(c => c && c.kind === 'create').length;
-        const nonCreateContextCount = opContexts.length - createContextCount;
-        this.manager.logger.log(`[COW][UNCERTAIN] batchId=${err?.batchId || 'n/a'} ops=${opContexts.length} ` +
-            `creates=${createContextCount} nonCreates=${nonCreateContextCount} ` +
-            `staleSinceMs=${err?.timeoutMs || 'n/a'}. Entering reconcile-then-decide.`, 'warn');
-        if (!chainOrders?.readOpenOrders) {
-            this.manager.logger.log('[COW][UNCERTAIN] readOpenOrders unavailable; falling back to structural resync only.', 'error');
-            if (typeof this.manager.requestStructuralGridResync === 'function') {
-                await this.manager.requestStructuralGridResync('broadcast uncertain — readOpenOrders unavailable', { batchId: err?.batchId || null });
-            }
-            this._clearPendingBroadcasts();
-            return { executed: false, hadRotation: false, uncertain: true };
-        }
-        // 1. Read the chain
-        const accountRef = this.accountId || this.account?.id || this.account;
-        let chainSnapshot = [];
-        try {
-            chainSnapshot = await chainOrders.readOpenOrders(accountRef);
-        }
-        catch (readErr) {
-            this.manager.logger.log(`[COW][UNCERTAIN] readOpenOrders failed: ${readErr?.message || readErr}. ` +
-                `Falling back to structural resync.`, 'error');
-            if (typeof this.manager.requestStructuralGridResync === 'function') {
-                await this.manager.requestStructuralGridResync('broadcast uncertain — readOpenOrders failed', { batchId: err?.batchId || null, error: readErr?.message || String(readErr) });
-            }
-            this._clearPendingBroadcasts();
-            return { executed: false, hadRotation: false, uncertain: true };
-        }
-        const adopted = [];
-        let discarded = [];
-        // 2. For each pending broadcast, look for a chain match.
-        for (const entry of pending) {
-            const match = this._findChainOrderForSlot(chainSnapshot, entry.slotId, {
-                sell: entry.finalInts?.sell,
-                receive: entry.finalInts?.receive,
-                orderType: entry.orderType || entry.order?.type,
-                fingerprint: entry.fingerprint
-            });
-            if (match) {
-                adopted.push({
-                    slotId: entry.slotId,
-                    chainOrderId: match.id,
-                    orderType: entry.orderType || entry.order?.type,
-                });
-                this.manager._pendingBroadcasts.delete(entry.fingerprint);
-            }
-            else {
-                // Preserve full entry context so the recheck below can use
-                // both the fingerprint match path (against _pendingBroadcasts)
-                // and the near-match path (via finalInts/orderType), not just
-                // slotId alone.
-                discarded.push(entry);
-            }
-        }
-        // ---- RACE MITIGATION: block-delay recheck before discarding creates ----
-        // BROADCAST_DEADLINE fires while the transaction may still be valid
-        // and land in the next block. Wait for up to 3 blocks (~1 BitShares
-        // block interval each) and re-check before permanently discarding.
-        const UNCERTAIN_RECHECK_MAX_ATTEMPTS = this.config.pipelineTiming?.RETRY_MAX_ATTEMPTS ?? PIPELINE_TIMING.RETRY_MAX_ATTEMPTS; // 3
-        const UNCERTAIN_RECHECK_INTERVAL_MS = TIMING.MILLISECONDS_PER_SECOND * 3; // 3s
-        let recheckRound = 0;
-        while (discarded.length > 0 && recheckRound < UNCERTAIN_RECHECK_MAX_ATTEMPTS) {
-            recheckRound++;
-            await new Promise(r => setTimeout(r, UNCERTAIN_RECHECK_INTERVAL_MS));
-            let freshSnapshot;
-            try {
-                freshSnapshot = await chainOrders.readOpenOrders(accountRef);
-            }
-            catch {
-                break;
-            }
-            const stillDiscarded = [];
-            for (const entry of discarded) {
-                const match = this._findChainOrderForSlot(freshSnapshot, entry.slotId, {
-                    sell: entry.finalInts?.sell,
-                    receive: entry.finalInts?.receive,
-                    orderType: entry.orderType || entry.order?.type,
-                    fingerprint: entry.fingerprint
-                });
-                if (match) {
-                    adopted.push({
-                        slotId: entry.slotId,
-                        chainOrderId: match.id,
-                        orderType: entry.orderType || entry.order?.type,
-                    });
-                    this.manager.logger.log(`[COW][UNCERTAIN] CREATE re-adopted after ${recheckRound} block(s): ` +
-                        `${entry.slotId}->${match.id}`, 'info');
-                }
-                else {
-                    stillDiscarded.push(entry);
-                }
-            }
-            discarded = stillDiscarded;
-        }
-        // 3. Re-read chain with latest state. The initial snapshot may be
-        // stale for non-CREATE ops (updates/cancels) not tracked in
-        // _pendingBroadcasts — the seed cause of the slot-115 cascade.
-        let latestSnapshot;
-        try {
-            latestSnapshot = await chainOrders.readOpenOrders(accountRef);
-        }
-        catch {
-            latestSnapshot = chainSnapshot;
-        }
-        // Always sync to link adopted chain orders into grid slots.
-        // Otherwise an adopted slot stays VIRTUAL and the next COW cycle
-        // places a duplicate order at the same price.
-        let hadRotation = false;
-        if (latestSnapshot && latestSnapshot.length > 0 && this.manager?.syncFromOpenOrders) {
-            try {
-                await this.manager.syncFromOpenOrders(latestSnapshot, {
-                    skipAccounting: true,
-                });
-                hadRotation = true;
-            }
-            catch (syncErr) {
-                this.manager.logger.log(`[COW][UNCERTAIN] syncFromOpenOrders failed during recovery: ${syncErr?.message || syncErr}`, 'error');
-                // Fallback: reload from persisted snapshot + re-sync.
-                this.manager.logger.log('[COW][UNCERTAIN] syncFromOpenOrders failed; falling back to full grid reload from persisted snapshot', 'warn');
-                const fallbackResult = await this._recoverFromPersistedGrid();
-                if (fallbackResult.success) {
-                    hadRotation = true;
-                }
-                else {
-                    this.manager.logger.log(`[COW][UNCERTAIN] Persisted grid reload failed: ${fallbackResult.reason}. ` +
-                        `Escalating to structural resync.`, 'warn');
-                    if (typeof this.manager.requestStructuralGridResync === 'function') {
-                        this.manager.requestStructuralGridResync('cow-uncertain-recovery-failed', { reason: fallbackResult.reason }).catch((escalateErr) => {
-                            this.manager.logger.log(`[COW][UNCERTAIN] Escalation to structural resync failed: ${escalateErr.message}`, 'error');
-                        });
-                    }
-                }
-            }
-        }
-        // 4. Log structured summary.
-        const elapsedMs = Date.now() - startedAt;
-        const heartbeatAgeMs = this._lastBroadcastHeartbeatAt
-            ? Date.now() - this._lastBroadcastHeartbeatAt
-            : null;
-        this.manager.logger.log(`[COW][UNCERTAIN] batchId=${err?.batchId || 'n/a'} ops=${opContexts.length} ` +
-            `staleSinceMs=${err?.timeoutMs || 'n/a'} heartbeatAgeMs=${heartbeatAgeMs ?? 'n/a'} ` +
-            `adopted=${adopted.length} discarded=${discarded.length} recheckRounds=${recheckRound} elapsedMs=${elapsedMs}`, adopted.length > 0 ? 'info' : 'warn');
-        if (adopted.length > 0) {
-            this.manager.logger.log(`[COW][UNCERTAIN] Adopted chain orders: ${adopted
-                .map(a => `${a.slotId}->${a.chainOrderId}`)
-                .join(', ')}`, 'info');
-        }
-        if (discarded.length > 0) {
-            this.manager.logger.log(`[COW][UNCERTAIN] Discarded planned CREATEs (no chain match after ${recheckRound} recheck(s)): ${discarded
-                .map(d => d.slotId)
-                .join(', ')}`, 'warn');
-            // Restore target grid sizes for discarded CREATEs so the slots are
-            // not left as virtual/0 after recovery. Without this, the slot stays
-            // at size 0 (set by the fill handler) and is never reactivated until
-            // a fresh fill cycle triggers another rebalance that happens to succeed.
-            // entry.order is the pending-broadcast target order (captured at broadcast
-            // time); its .id matches entry.slotId — the lookup below keys on slotId.
-            for (const entry of discarded) {
-                if (entry.order && entry.slotId) {
-                    const current = this.manager.orders.get(entry.slotId);
-                    if (current && current.state === ORDER_STATES.VIRTUAL && !current.orderId) {
-                        try {
-                            await this.manager._applyOrderUpdate({ ...entry.order, state: ORDER_STATES.VIRTUAL, orderId: null }, 'uncertain-recovery-restore-size', { skipAccounting: true, fee: 0 });
-                            this.manager.logger.log(`[COW][UNCERTAIN] Restored target size for discarded CREATE slot ${entry.slotId} (size: ${entry.order.size})`, 'info');
-                        }
-                        catch (restoreErr) {
-                            this.manager.logger.log(`[COW][UNCERTAIN] Failed to restore size for slot ${entry.slotId}: ${restoreErr?.message || restoreErr}`, 'warn');
-                        }
-                    }
-                }
-            }
-        }
-        // ---- Structural resync safeguard after skipAccounting restore ----
-        // The discarded CREATE restore above used skipAccounting: true to avoid
-        // double-counting when the structural resync recalculates accounting
-        // from scratch. Ensure one is scheduled — if already in-flight (timer
-        // or running), the existing resync will handle the accounting fix.
-        if (discarded.length > 0 && typeof this.manager?.requestStructuralGridResync === 'function') {
-            const alreadyScheduled = this._structuralGridResyncRunning || this._structuralGridResyncTimer;
-            if (!alreadyScheduled) {
-                this.manager.logger.log(`[COW][UNCERTAIN] Scheduling structural resync after discarded CREATE restore ` +
-                    `(skipAccounting used — resync needed for fund recalculation)`, 'info');
-                this.manager.requestStructuralGridResync('cow-uncertain-accounting-repair', { discardedCount: discarded.length }).catch((err) => {
-                    this.manager.logger.log(`[COW][UNCERTAIN] Failed to schedule accounting repair resync: ${err.message}`, 'error');
-                });
-            }
-            else {
-                this.manager.logger.log(`[COW][UNCERTAIN] Structural resync already ${this._structuralGridResyncRunning ? 'running' : 'scheduled'}; ` +
-                    `it will repair accounting after discarded CREATE restore`, 'debug');
-            }
-        }
-        this._clearPendingBroadcasts();
-        // Post-recovery safety net: if there are still unmatched chain
-        // orders after reconcile-then-decide, cancel ONE per cycle. The cap
-        // is enforced inside the helper via _autoCancelOrphanCycleMarker.
-        try {
-            const autoCancelResult = await this._autoCancelOneUnmatchedOrphan();
-            if (autoCancelResult.cancelled) {
-                this.manager.logger.log(`[COW][UNCERTAIN] Auto-cancelled orphan ${autoCancelResult.orderId} ` +
-                    `after recovery (cap=1/cycle).`, 'info');
-            }
-        }
-        catch (orphanErr) {
-            this.manager.logger.log(`[COW][UNCERTAIN] Auto-cancel pass failed: ${orphanErr?.message || orphanErr}`, 'warn');
-        }
-        // Boundary shift recovery: the COW batch that should have committed the
-        // boundary shift from this fill cycle failed before commit. Only COUNT
-        // ADOPTED CREATEs — orders that actually landed on-chain. Discarded
-        // CREATEs represent orders that never existed, so the grid must NOT
-        // shift the boundary for them. The next fill cycle's
-        // calculateTargetGrid → deriveTargetBoundary will recompute the correct
-        // boundary from scratch for any discarded slots.
-        //
-        // NOTE: Direct mutation of manager.boundaryIdx outside a COW commit
-        // violates the invariant stated in grid.ts:1217-1220 (boundary must only
-        // be updated atomically inside _commitWorkingGrid). This is intentional
-        // here because the COW commit already failed — the invariant was already
-        // broken by the broadcast uncertainty, and the adjustment only restores
-        // the state to what the successful commit would have produced for
-        // orders that are confirmed on-chain.
-        if (hadRotation && this.manager && adopted.length > 0) {
-            let boundaryShift = 0;
-            for (const entry of adopted) {
-                if (entry.orderType === ORDER_TYPES.SELL) {
-                    boundaryShift--; // SELL CREATE → fill was BUY → boundary LEFT
-                }
-                else if (entry.orderType === ORDER_TYPES.BUY) {
-                    boundaryShift++; // BUY CREATE → fill was SELL → boundary RIGHT
-                }
-            }
-            if (boundaryShift !== 0) {
-                const oldIdx = this.manager.boundaryIdx;
-                if (typeof oldIdx === 'number') {
-                    const maxIdx = Math.max(0, (this.manager.orders?.size || 1) - 1);
-                    const newIdx = Math.max(0, Math.min(maxIdx, oldIdx + boundaryShift));
-                    if (newIdx !== oldIdx) {
-                        this.manager.boundaryIdx = newIdx;
-                        this.manager.logger.log(`[COW][UNCERTAIN] Boundary adjusted by ${boundaryShift} ` +
-                            `(${adopted.length} adopted CREATE(s), ${discarded.length} discarded): ` +
-                            `${oldIdx} → ${newIdx}. Next COW cycle will generate replacement opposite-side orders.`, 'warn');
-                        if (typeof this.manager._markGridDirty === 'function') {
-                            this.manager._markGridDirty();
-                        }
-                    }
-                }
-            }
-        }
-        // Persist master grid mutations from the reconciliation sync and any
-        // orphan auto-cancellation that ran above. These apply outside the COW
-        // broadcast path and would otherwise be in-memory only. The boundary
-        // adjustment above is also persisted here.
-        if (typeof this.manager?.persistGrid === 'function') {
-            await this.manager.persistGrid();
-        }
-        return { executed: false, hadRotation, uncertain: true, adopted, discarded };
+     *   2. For each pending-broadcast entry (fingerprinted CREATE op), look
+     *      for a matching chain order. If found: adopt it (set the opContext's
+     *      chainOrderId and continue with the existing planned slot).
+     *   3. For pending entries with no chain match: virtualize (mark the
+     *      opContext as discarded; the planned slot stays empty until the
+     *      next planning cycle).
+     *   4. Persist + log a structured [COW][UNCERTAIN] summary.
+     *
+     * After this method returns, the bot has either adopted the on-chain
+     * result (good case — chain accepted but we didn't see the reply) or
+     * accepted the discard (chain rejected or never received the op).
+     *
+     * @param {BroadcastUncertainError} err - The thrown error
+     * @param {Array<Object>} opContexts - Original opContexts from the failed batch
+     * @returns {Promise<Object>} Result object compatible with batch return shape
+     */
+    async _reconcileAfterUncertainBroadcast(err, opContexts, options = {}) {
+        return cowRuntime.reconcileAfterUncertainBroadcast(this, err, opContexts, options);
+    }
+    async _reconcileAfterUncertainBroadcastImpl(err, opContexts, options) {
+        return cowRuntime.reconcileAfterUncertainBroadcastImpl(this, err, opContexts, options);
     }
     /**
      * Auto-cancel a price-drift orphan from the unmatched-order snapshot.
@@ -3089,72 +961,7 @@ class DEXBot {
      * @returns {Promise<{cancelled: boolean, orderId?: string, reason?: string}>}
      */
     async _autoCancelOneUnmatchedOrphan() {
-        const cycleId = this._currentCycleId || 0;
-        // FIX 4: Higher cap during recovery mode so orphan backlog clears faster.
-        const recoveryActive = this.manager?._recoveryState?.structuralResyncRequested === true;
-        const cycleCap = recoveryActive ? 5 : 1;
-        if (this._autoCancelOrphanCycleMarker === cycleId) {
-            if (this._autoCancelOrphanSubCount >= cycleCap) {
-                return { cancelled: false, reason: 'cap-reached-this-cycle', subCount: this._autoCancelOrphanSubCount };
-            }
-        }
-        else {
-            // Reset sub-count on first call this cycle
-            this._autoCancelOrphanCycleMarker = cycleId;
-            this._autoCancelOrphanSubCount = 0;
-        }
-        const pending = (this.manager && this.manager._pendingBroadcasts instanceof Map)
-            ? this.manager._pendingBroadcasts.size
-            : 0;
-        if (pending > 0) {
-            return { cancelled: false, reason: 'pending-broadcasts-active' };
-        }
-        const unmatched = Array.isArray(this.manager?._lastUnmatchedChainOrders)
-            ? this.manager._lastUnmatchedChainOrders
-            : [];
-        if (unmatched.length === 0) {
-            return { cancelled: false, reason: 'no-unmatched' };
-        }
-        // Check for fingerprinted entries first — these came from a pending
-        // broadcast (missing-create-result) and must be handled by the recovery
-        // path, not by auto-cancel. The first fingerprinted entry is checked
-        // regardless of its reason field.
-        const fingerprinted = unmatched.find(u => u && u.fingerprint);
-        if (fingerprinted) {
-            return { cancelled: false, reason: 'fingerprinted-handle-via-recovery' };
-        }
-        // Only cancel price-drift orphans — these are surplus orders that
-        // drifted away from their assigned slot price and have no adoptable
-        // grid slot. All other unmatched orders (duplicate-price-level,
-        // already-matched-slot, etc.) are adoptable positions that the structural
-        // resync will integrate into the grid — cancelling them destroys capital.
-        const target = unmatched.find(u => u && u.reason === 'price-drift-orphan');
-        if (!target) {
-            return { cancelled: false, reason: 'no-price-drift-orphan', message: 'no price-drift orphan to cancel; other unmatched orders are adoptable' };
-        }
-        const orderId = target.id || target.orderId || target.chainOrderId;
-        if (!orderId) {
-            return { cancelled: false, reason: 'no-orderId' };
-        }
-        if (!chainOrders?.cancelOrder) {
-            return { cancelled: false, reason: 'cancelOrder-unavailable' };
-        }
-        try {
-            await chainOrders.cancelOrder(this.account, this.privateKey, orderId);
-            if (typeof chainOrders.recordOwnCancel === 'function') {
-                chainOrders.recordOwnCancel(orderId);
-            }
-            // Increment sub-count only after a confirmed successful cancel.
-            // Failed cancels do not consume the per-cycle cap budget.
-            this._autoCancelOrphanSubCount++;
-            this.manager.logger.log(`[COW] Auto-cancelled ${this._autoCancelOrphanSubCount}/${unmatched.length} unmatched chain order ` +
-                `(${this._formatUnmatchedChainOrderForLog(target)}) — per-cycle cap=${cycleCap}.`, 'warn');
-            return { cancelled: true, orderId };
-        }
-        catch (err) {
-            this.manager.logger.log(`[COW] Auto-cancel of unmatched chain order ${orderId} failed: ${err?.message || err}`, 'error');
-            return { cancelled: false, reason: 'cancel-failed', error: err?.message || String(err) };
-        }
+        return cowRuntime.autoCancelOneUnmatchedOrphan(this);
     }
     // Pair mode applies only when create contexts include both BUY and SELL.
     // Single-side create batches intentionally remain a single executeBatch.
@@ -3164,21 +971,7 @@ class DEXBot {
      * @returns {boolean} True if pair mode should be used
      */
     _shouldExecuteCreatePairMode(opContexts) {
-        if (!Array.isArray(opContexts) || opContexts.length < 2)
-            return false;
-        if (!opContexts.every(ctx => ctx?.kind === 'create' && ctx?.order))
-            return false;
-        let hasBuy = false;
-        let hasSell = false;
-        for (const ctx of opContexts) {
-            if (ctx.order.type === ORDER_TYPES.BUY)
-                hasBuy = true;
-            if (ctx.order.type === ORDER_TYPES.SELL)
-                hasSell = true;
-            if (hasBuy && hasSell)
-                return true;
-        }
-        return false;
+        return cowRuntime.shouldExecuteCreatePairMode(this, opContexts);
     }
     /**
      * Execute operations with retry on BroadcastUncertainError.
@@ -3190,36 +983,7 @@ class DEXBot {
      * the full operations array would duplicate those creates on chain.
      */
     async _executeWithRetryOnUncertain(operations, opContexts) {
-        const MAX_RETRIES = 1;
-        for (let attempt = 1;; attempt++) {
-            try {
-                return await this._executeOperationsWithStrategy(operations, opContexts);
-            }
-            catch (err) {
-                const isRetriable = err instanceof BroadcastUncertainError
-                    && !err.partialOnChainState
-                    && attempt <= MAX_RETRIES;
-                if (isRetriable) {
-                    this.manager.logger.log(`[COW] Broadcast uncertain (attempt ${attempt}/${MAX_RETRIES + 1}), retrying...`, 'warn');
-                    await this._ensureCredentialDaemonWritable('COW batch retry');
-                    // Reconcile before retry — stale ops would fail "not found".
-                    try {
-                        const accountRef = this.accountId || this.account?.id || this.account;
-                        const freshChain = await chainOrders.readOpenOrders(accountRef);
-                        if (freshChain.length > 0 && this.manager?.syncFromOpenOrders) {
-                            await this.manager.syncFromOpenOrders(freshChain, {
-                                skipAccounting: true,
-                            });
-                        }
-                    }
-                    catch (syncErr) {
-                        this.manager.logger.log(`[COW] Pre-retry sync failed (non-fatal): ${syncErr?.message || syncErr}`, 'warn');
-                    }
-                    continue;
-                }
-                throw err;
-            }
-        }
+        return cowRuntime.executeWithRetryOnUncertain(this, operations, opContexts);
     }
     /**
      * Execute blockchain operations with appropriate strategy (single batch or pair mode).
@@ -3228,63 +992,7 @@ class DEXBot {
      * @returns {Promise<{result: Object, opContexts: Array}>} Execution result with contexts
      */
     async _executeOperationsWithStrategy(operations, opContexts) {
-        if (!this._shouldExecuteCreatePairMode(opContexts)) {
-            const result = await chainOrders.executeBatch(this.account, this.privateKey, operations);
-            return { result, opContexts };
-        }
-        const createEntries = [];
-        for (let i = 0; i < operations.length; i++) {
-            createEntries.push({
-                operation: operations[i],
-                context: opContexts[i],
-            });
-        }
-        const groups = this._buildOutsideInPairGroupsForCreateEntries(createEntries);
-        const mergedOperationResults = [];
-        const mergedRawResults = [];
-        const mergedContexts = [];
-        // Grouped execution is fail-fast, but NOT atomic across groups.
-        // Each group is a separate on-chain transaction; if a later group fails,
-        // earlier groups may already be confirmed on-chain.
-        for (let idx = 0; idx < groups.length; idx++) {
-            const group = groups[idx];
-            const groupOps = group.map(e => e.operation);
-            const groupContexts = group.map(e => e.context);
-            this.manager.logger.log(`[COW] Broadcasting create pair group ${idx + 1}/${groups.length} (${groupOps.length} op${groupOps.length > 1 ? 's' : ''}, outside->center)`, 'info');
-            let groupResult;
-            try {
-                groupResult = await chainOrders.executeBatch(this.account, this.privateKey, groupOps);
-            }
-            catch (err) {
-                const groupsBroadcast = idx;
-                const groupsTotal = groups.length;
-                const broadcastedOperationCount = mergedContexts.length;
-                this.manager.logger.log(`[COW] Grouped create execution failed at group ${idx + 1}/${groupsTotal}; ${groupsBroadcast} group(s) already broadcast (${broadcastedOperationCount} op context(s)). Partial on-chain state is possible.`, 'error');
-                err.partialOnChainState = groupsBroadcast > 0;
-                err.groupsBroadcast = groupsBroadcast;
-                err.groupsTotal = groupsTotal;
-                err.broadcastedOperationCount = broadcastedOperationCount;
-                throw err;
-            }
-            const groupOpResults = this._extractOperationResults(groupResult);
-            mergedOperationResults.push(...groupOpResults);
-            mergedRawResults.push(groupResult?.raw || null);
-            mergedContexts.push(...groupContexts);
-        }
-        return {
-            result: {
-                success: true,
-                raw: {
-                    grouped: true,
-                    groupsExecuted: groups.length,
-                    groupResults: mergedRawResults,
-                },
-                operation_results: mergedOperationResults,
-                grouped: true,
-                groupsExecuted: groups.length
-            },
-            opContexts: mergedContexts
-        };
+        return cowRuntime.executeOperationsWithStrategy(this, operations, opContexts);
     }
     /**
      * Validate that operations can be executed with available funds before broadcasting.
@@ -3296,94 +1004,7 @@ class DEXBot {
      * @private
      */
     _validateOperationFunds(operations, assetA, assetB) {
-        if (!operations || operations.length === 0) {
-            return { isValid: true, summary: 'No operations to validate' };
-        }
-        const { blockchainToFloat, floatToBlockchainInt, quantizeFloat } = require('./order/utils/math');
-        const snap = this.manager.getChainFundsSnapshot();
-        const netRequiredFunds = { [assetA.id]: 0, [assetB.id]: 0 };
-        const runningRequiredFunds = { [assetA.id]: 0, [assetB.id]: 0 };
-        const peakRequiredFunds = { [assetA.id]: 0, [assetB.id]: 0 };
-        // Sum amounts and check individual order sizes
-        for (const op of operations) {
-            if (!op?.op_data)
-                continue;
-            let sellAssetId = null;
-            let sellAmountInt = 0;
-            if (op.op_name === 'limit_order_create') {
-                sellAssetId = op.op_data.amount_to_sell?.asset_id;
-                sellAmountInt = op.op_data.amount_to_sell?.amount;
-            }
-            else if (op.op_name === 'limit_order_update') {
-                // In limit_order_update, new_price.base is the amount to sell
-                sellAssetId = op.op_data.new_price?.base?.asset_id;
-                sellAmountInt = op.op_data.new_price?.base?.amount;
-            }
-            if (sellAssetId && (sellAmountInt !== undefined && sellAmountInt !== null)) {
-                const precision = (sellAssetId === assetA.id) ? assetA.precision : assetB.precision;
-                const assetSymbol = (sellAssetId === assetA.id) ? assetA.symbol : assetB.symbol;
-                // CRITICAL SAFETY CHECK: Ensure amount is greater than zero
-                if (Number(sellAmountInt) <= 0) {
-                    return {
-                        isValid: false,
-                        summary: `[VALIDATION] CRITICAL: Zero amount order detected for ${assetSymbol} (assetId=${sellAssetId})`,
-                        violations: [{ asset: assetSymbol, sizeInt: sellAmountInt, reason: 'Zero amount' }]
-                    };
-                }
-                // Track signed per-op deltas in operation order.
-                // CREATE consumes full amount; UPDATE consumes/releases delta.
-                let signedDelta = 0;
-                if (op.op_name === 'limit_order_update') {
-                    const deltaAssetId = op.op_data.delta_amount_to_sell?.asset_id;
-                    const deltaSellInt = op.op_data.delta_amount_to_sell?.amount;
-                    if (deltaAssetId === sellAssetId && Number.isFinite(Number(deltaSellInt))) {
-                        signedDelta = blockchainToFloat(deltaSellInt, precision);
-                    }
-                }
-                else {
-                    signedDelta = blockchainToFloat(sellAmountInt, precision);
-                }
-                netRequiredFunds[sellAssetId] = quantizeFloat((netRequiredFunds[sellAssetId] || 0) + signedDelta, precision);
-                runningRequiredFunds[sellAssetId] = quantizeFloat((runningRequiredFunds[sellAssetId] || 0) + signedDelta, precision);
-                const nextPeak = Math.max(Number(peakRequiredFunds[sellAssetId] || 0), Number(runningRequiredFunds[sellAssetId] || 0));
-                peakRequiredFunds[sellAssetId] = quantizeFloat(nextPeak, precision);
-            }
-        }
-        // Calculate available funds - CRITICAL FIX: Check against FREE balance, not free+required
-        // Bug: Previous logic added requiredFunds to available, making validation meaningless
-        // Correct logic: available = chainFree (current free balance)
-        // If required > available, batch will fail on execution
-        const availableFunds = {
-            [assetA.id]: quantizeFloat(snap.chainFreeSell || 0, assetA.precision),
-            [assetB.id]: quantizeFloat(snap.chainFreeBuy || 0, assetB.precision)
-        };
-        // Check for fund violations using quantized comparison
-        const fundViolations = [];
-        for (const assetId in peakRequiredFunds) {
-            const required = peakRequiredFunds[assetId];
-            const netRequired = netRequiredFunds[assetId] || 0;
-            const available = availableFunds[assetId] || 0;
-            // Use precision-aware comparison
-            const prec = (assetId === assetA.id) ? assetA.precision : assetB.precision;
-            if (floatToBlockchainInt(required, prec) > floatToBlockchainInt(available, prec)) {
-                fundViolations.push({
-                    asset: assetId === assetA.id ? assetA.symbol : assetB.symbol,
-                    required,
-                    netRequired,
-                    available,
-                    deficit: quantizeFloat(required - available, prec)
-                });
-            }
-        }
-        if (fundViolations.length > 0) {
-            let summary = `[VALIDATION] Fund validation FAILED:\n`;
-            for (const v of fundViolations) {
-                summary += `  ${v.asset}: peakRequired=${Format.formatAmount8(v.required)}, netRequired=${Format.formatAmount8(v.netRequired)}, available=${Format.formatAmount8(v.available)}, deficit=${Format.formatAmount8(v.deficit)}\n`;
-            }
-            return { isValid: false, summary: summary.trim(), violations: fundViolations };
-        }
-        const summary = `[VALIDATION] PASSED: ${operations.length} operations`;
-        return { isValid: true, summary };
+        return cowRuntime.validateOperationFunds(this, operations, assetA, assetB);
     }
     /**
      * Resolve the ideal size from an order-like object with fallback.
@@ -3392,20 +1013,7 @@ class DEXBot {
      * @returns {number|null} Resolved size or null
      */
     _resolveIdealSizeForValidation(orderLike, fallbackSize = null) {
-        const candidates = [
-            orderLike?.idealSize,
-            orderLike?.order?.idealSize,
-            orderLike?.size,
-            orderLike?.order?.size,
-            fallbackSize
-        ];
-        for (const candidate of candidates) {
-            const numeric = Number(candidate);
-            if (Number.isFinite(numeric) && numeric > 0) {
-                return numeric;
-            }
-        }
-        return null;
+        return cowRuntime.resolveIdealSizeForValidation(this, orderLike, fallbackSize);
     }
     /**
      * Validate that an order size is safe to execute (above minimum dust thresholds).
@@ -3416,7 +1024,7 @@ class DEXBot {
      * @returns {import('./types').OrderValidationResult}
      */
     _validateOrderSizeForExecution(size, type, orderLike = null, fallbackSize = null) {
-        return validateOrderSize(size, type, this.manager.assets, this.config.gridLimits?.MIN_ORDER_SIZE_FACTOR, this._resolveIdealSizeForValidation(orderLike, fallbackSize), this.config.gridLimits?.PARTIAL_DUST_THRESHOLD_PERCENTAGE);
+        return cowRuntime.validateOrderSizeForExecution(this, size, type, orderLike, fallbackSize);
     }
     /**
      * Execute a batch of order operations if the rebalance result has executable actions.
@@ -3756,77 +1364,7 @@ class DEXBot {
      * @returns {Array<{type: string, id: string, order?: Object, orderId?: string, newSize?: number, newPrice?: number, newGridId?: string}>}
      */
     _buildActionsFromPlan(plan) {
-        const normalizedPlan = Array.isArray(plan)
-            ? { ordersToPlace: plan }
-            : (plan || {});
-        const { ordersToPlace = [], ordersToRotate = [], ordersToUpdate = [], ordersToCancel = [] } = normalizedPlan;
-        const actions = [];
-        for (const o of ordersToCancel) {
-            if (o?.orderId) {
-                actions.push({ type: COW_ACTIONS.CANCEL, id: o.id, orderId: o.orderId });
-            }
-        }
-        for (const r of ordersToRotate) {
-            const oldOrder = r?.oldOrder || r;
-            const id = oldOrder?.id || r?.id;
-            const orderId = oldOrder?.orderId || r?.orderId;
-            const newGridId = r?.newGridId || id;
-            const newSize = Number.isFinite(Number(r?.newSize))
-                ? Number(r.newSize)
-                : Number(r?.size || oldOrder?.size || 0);
-            const newPrice = Number.isFinite(Number(r?.newPrice))
-                ? Number(r.newPrice)
-                : Number(r?.price || oldOrder?.price);
-            const orderType = r?.type || oldOrder?.type;
-            if (!id || !orderId || !newGridId || !orderType || !Number.isFinite(newPrice) || !(newSize > 0))
-                continue;
-            actions.push({
-                type: COW_ACTIONS.UPDATE,
-                id,
-                orderId,
-                newGridId,
-                newSize,
-                newPrice,
-                order: {
-                    id: newGridId,
-                    type: orderType,
-                    price: newPrice,
-                    size: newSize
-                }
-            });
-        }
-        for (const o of ordersToUpdate) {
-            const partialOrder = o?.partialOrder || o;
-            const id = o?.id || partialOrder?.id;
-            const orderId = o?.orderId || partialOrder?.orderId;
-            const orderType = o?.type || partialOrder?.type;
-            const newSize = Number.isFinite(Number(o?.newSize))
-                ? Number(o.newSize)
-                : Number(partialOrder?.size || 0);
-            if (!id || !orderId)
-                continue;
-            actions.push({
-                type: COW_ACTIONS.UPDATE,
-                id,
-                orderId,
-                newSize,
-                order: {
-                    ...(partialOrder || {}),
-                    id,
-                    orderId,
-                    type: orderType,
-                    size: newSize
-                }
-            });
-        }
-        // Run CREATE actions after UPDATE actions so same-batch downsizes can
-        // release balance before placements consume it.
-        for (const o of ordersToPlace) {
-            if (!o?.id)
-                continue;
-            actions.push({ type: COW_ACTIONS.CREATE, id: o.id, order: o });
-        }
-        return actions;
+        return cowRuntime.buildActionsFromPlan(this, plan);
     }
     /**
      * Build a COW result object (workingGrid + actions) from a simple plan.
@@ -3834,78 +1372,7 @@ class DEXBot {
      * @returns {{workingGrid: import('./types').WorkingGrid, workingIndexes: Object, workingBoundary: number, actions: Array}}
      */
     _buildCowResultFromPlan(plan) {
-        const { WorkingGrid } = require('./order/working_grid');
-        const workingGrid = new WorkingGrid(this.manager.orders, {
-            baseVersion: Number.isFinite(Number(this.manager._gridVersion)) ? this.manager._gridVersion : 0
-        });
-        const workingBoundary = this.manager.boundaryIdx;
-        const actions = this._buildActionsFromPlan(plan);
-        // Project planned actions into working grid so COW commit carries intended transitions.
-        for (const action of actions) {
-            if (action.type === COW_ACTIONS.CANCEL) {
-                const current = workingGrid.get(action.id);
-                if (!current)
-                    continue;
-                workingGrid.set(action.id, convertToSpreadPlaceholder(current));
-            }
-            else if (action.type === COW_ACTIONS.CREATE) {
-                if (!action.id || !action.order)
-                    continue;
-                const current = workingGrid.get(action.id) || { id: action.id };
-                workingGrid.set(action.id, {
-                    ...current,
-                    ...action.order,
-                    id: action.id,
-                    state: ORDER_STATES.VIRTUAL,
-                    orderId: null
-                });
-            }
-            else if (action.type === COW_ACTIONS.UPDATE) {
-                if (action.newGridId && action.newGridId !== action.id) {
-                    const current = workingGrid.get(action.id);
-                    if (current) {
-                        workingGrid.set(action.id, convertToSpreadPlaceholder(current));
-                    }
-                    const targetId = action.newGridId;
-                    const targetCurrent = workingGrid.get(targetId) || { id: targetId };
-                    const rotatedSize = Number.isFinite(Number(action.newSize))
-                        ? Number(action.newSize)
-                        : Number(targetCurrent.size || 0);
-                    const rotatedPrice = Number.isFinite(Number(action.newPrice))
-                        ? Number(action.newPrice)
-                        : Number(action.order?.price ?? targetCurrent.price);
-                    workingGrid.set(targetId, {
-                        ...targetCurrent,
-                        ...(action.order || {}),
-                        id: targetId,
-                        size: rotatedSize,
-                        price: rotatedPrice,
-                        state: ORDER_STATES.VIRTUAL,
-                        orderId: null
-                    });
-                    continue;
-                }
-                const current = workingGrid.get(action.id);
-                if (!current)
-                    continue;
-                const newSize = Number.isFinite(Number(action.newSize))
-                    ? Number(action.newSize)
-                    : Number(current.size || 0);
-                workingGrid.set(action.id, {
-                    ...current,
-                    ...(action.order || {}),
-                    id: action.id,
-                    orderId: action.orderId || current.orderId,
-                    size: newSize
-                });
-            }
-        }
-        return {
-            workingGrid,
-            workingIndexes: workingGrid.getIndexes(),
-            workingBoundary,
-            actions
-        };
+        return cowRuntime.buildCowResultFromPlan(this, plan);
     }
     /**
      * Restore skipped update slots in the working grid to master state.
@@ -3915,16 +1382,7 @@ class DEXBot {
      * @returns {void}
      */
     _restoreSkippedUpdateSlotsInWorkingGrid(workingGrid, skippedSlotIds, skippedCount = 0) {
-        if (!workingGrid || !skippedSlotIds || skippedSlotIds.size === 0) {
-            return;
-        }
-        const masterVersion = Number.isFinite(Number(this.manager?._gridVersion))
-            ? Number(this.manager._gridVersion)
-            : undefined;
-        for (const slotId of skippedSlotIds) {
-            workingGrid.syncFromMaster(this.manager.orders, slotId, masterVersion);
-        }
-        this.manager.logger.log(`[COW] Restored ${skippedSlotIds.size} slot(s) after ${skippedCount} skipped update action(s).`, 'debug');
+        return cowRuntime.restoreSkippedUpdateSlotsInWorkingGrid(this, workingGrid, skippedSlotIds, skippedCount);
     }
     /**
      * COW broadcast: Execute blockchain operations and commit working grid on success.
@@ -3934,751 +1392,10 @@ class DEXBot {
      * @private
      */
     async _updateOrdersOnChainBatchCOW(cowResult) {
-        this._currentCycleId = (Number.isFinite(Number(this._currentCycleId)) ? Number(this._currentCycleId) : 0) + 1;
-        const { workingGrid, workingIndexes, workingBoundary, actions } = cowResult;
-        if (this.config.dryRun) {
-            const cancelCount = actions.filter(a => a.type === COW_ACTIONS.CANCEL).length;
-            const createCount = actions.filter(a => a.type === COW_ACTIONS.CREATE).length;
-            const updateCount = actions.filter(a => a.type === COW_ACTIONS.UPDATE).length;
-            if (cancelCount > 0)
-                this.manager.logger.log(`Dry run: would cancel ${cancelCount} orders`, 'info');
-            if (createCount > 0)
-                this.manager.logger.log(`Dry run: would place ${createCount} new orders`, 'info');
-            if (updateCount > 0)
-                this.manager.logger.log(`Dry run: would update ${updateCount} orders`, 'info');
-            return { executed: true, hadRotation: false };
-        }
-        const createSlotValidation = validateCreateTargetSlots(actions, this.manager?.orders);
-        if (!createSlotValidation.isValid) {
-            for (const violation of createSlotValidation.violations) {
-                this.manager.logger.log(`[COW] Rejecting CREATE for occupied slot ${violation.targetId}: ` +
-                    `existing orderId=${violation.currentOrderId}, type=${violation.currentType}, state=${violation.currentState}`, 'error');
-            }
-            return {
-                executed: false,
-                aborted: true,
-                reason: 'CREATE_SLOT_OCCUPIED',
-                violations: createSlotValidation.violations,
-                hadRotation: false
-            };
-        }
-        const hasCreateActions = actions.some(action => action.type === COW_ACTIONS.CREATE);
-        // Gap 5: Recovery exhausted — block all CREATES. The bot has exhausted
-        // its recovery attempt budget and needs a fill or sync cycle to reset.
-        // Existing orders remain active and are monitored, but no new orders
-        // are placed until recovery resets.
-        if (hasCreateActions && this.manager?._recoveryExhaustedAt) {
-            const exhaustedAge = Date.now() - this.manager._recoveryExhaustedAt;
-            this.manager.logger.log?.(`[RECOVERY-EXHAUSTED] Blocking ${actions.filter(a => a.type === COW_ACTIONS.CREATE).length} CREATE(s) ` +
-                `(exhausted ${(exhaustedAge / 1000).toFixed(0)}s ago). ` +
-                `Waiting for next fill or sync cycle to reset recovery state.`, 'warn');
-            return {
-                executed: false,
-                aborted: true,
-                reason: 'RECOVERY_EXHAUSTED',
-                hadRotation: false
-            };
-        }
-        const unmatchedChainOrders = Array.isArray(this.manager?._lastUnmatchedChainOrders)
-            ? this.manager._lastUnmatchedChainOrders
-            : [];
-        // PENDING_BROADCASTS: an earlier batch timed out at the credential
-        // daemon and the chain status of its CREATEs is still unknown. The
-        // recovery path (_reconcileAfterUncertainBroadcast) is responsible
-        // for resolving it. We refuse to publish a fresh CREATE batch until
-        // recovery runs, otherwise we risk double-publishing or stacking
-        // orphan orders on top of potentially-orphaned ones.
-        const pendingBroadcasts = (this.manager && this.manager._pendingBroadcasts instanceof Map)
-            ? Array.from(this.manager._pendingBroadcasts.values())
-            : [];
-        if (hasCreateActions && (unmatchedChainOrders.length > 0 || pendingBroadcasts.length > 0)) {
-            // ---- Handle pending broadcasts first ----
-            if (pendingBroadcasts.length > 0) {
-                this.manager.logger.log(`[COW] Rejecting CREATE batch: ${pendingBroadcasts.length} pending broadcast(s) from a prior uncertain ` +
-                    `broadcast. Running recovery before placing replacement orders.`, 'error');
-                if (typeof this.manager.requestStructuralGridResync === 'function') {
-                    if (this.manager._recoveryState)
-                        this.manager._recoveryState = { ...this.manager._recoveryState, structuralResyncRequested: true };
-                    await this.manager.requestStructuralGridResync('pending broadcasts before COW create', { pendingBroadcasts: pendingBroadcasts.map(p => p.slotId) });
-                }
-                try {
-                    await this._reconcileAfterUncertainBroadcast(new BroadcastUncertainError('rejected CREATE batch had pending broadcasts', {
-                        operations: pendingBroadcasts.map(p => p.order),
-                        accountName: this.account,
-                        batchId: this._currentBatchId || null,
-                        payload: null,
-                        timeoutMs: null
-                    }), []);
-                }
-                catch (recoverErr) {
-                    this.manager.logger.log(`[COW] Recovery from pending broadcasts failed: ${recoverErr?.message || recoverErr}`, 'error');
-                }
-                return {
-                    executed: false,
-                    aborted: true,
-                    reason: 'PENDING_BROADCASTS',
-                    hadRotation: false
-                };
-            }
-            // ---- Unmatched orders: adopt instead of cancel ----
-            // Unmatched orders are legitimate on-chain positions the grid
-            // hasn't adopted yet. Cancelling them destroys capital and
-            // creates gaps in the order book. Instead, re-sync to adopt
-            // them into the grid, then reject (the sync invalidated the
-            // working grid, so the existing COW plan is stale).
-            // NOTE: syncFromOpenOrders may be a partial no-op under certain
-            // lock conditions (e.g. _fillProcessingLock + !isReentrant).
-            // Structural resync scheduled below handles adoption regardless.
-            const unmatchedSample = unmatchedChainOrders
-                .slice(0, 3)
-                .map(o => this._formatUnmatchedChainOrderForLog(o))
-                .join(' | ');
-            this.manager.logger.log(`[COW] ${unmatchedChainOrders.length} unmatched chain order(s) blocking CREATES ` +
-                (unmatchedSample ? `(${unmatchedSample})` : '') +
-                ` — adopting via sync instead of cancelling`, 'info');
-            try {
-                const accountRef = this.account;
-                const freshSnapshot = await chainOrders.readOpenOrders(accountRef);
-                if (freshSnapshot && freshSnapshot.length > 0) {
-                    const syncResult = await this.manager.syncFromOpenOrders(freshSnapshot, {
-                        skipAccounting: true,
-                    });
-                    // Only overwrite _lastUnmatchedChainOrders when sync actually
-                    // processed orders (filled + updated + corrected > 0).
-                    // Force-release and lock-contention early-exit paths return
-                    // empty arrays without touching _lastUnmatchedChainOrders —
-                    // overwriting with [] would drop stale unmatched entries.
-                    if (syncResult && Array.isArray(syncResult.unmatchedChainOrders)) {
-                        const processed = (syncResult.filledOrders?.length || 0) +
-                            (syncResult.updatedOrders?.length || 0) +
-                            (syncResult.ordersNeedingCorrection?.length || 0);
-                        if (processed > 0) {
-                            this.manager._lastUnmatchedChainOrders = syncResult.unmatchedChainOrders;
-                            this.manager.logger.log(`[COW] Adopted chain order(s) via sync: ${processed} processed, ` +
-                                `${syncResult.unmatchedChainOrders.length} still unmatched`, 'info');
-                        }
-                        else {
-                            // processed === 0 with unmatched still present means the
-                            // sync could not adopt the unmatched chain orders. This is
-                            // normal when called re-entrantly (inside _fillProcessingLock):
-                            // the sync engine runs inline and either timed out (unlikely
-                            // for a re-entrant call) or all chain orders were already
-                            // matched — leaving only stale unmatched entries.
-                            const syncUnmatchedCount = syncResult.unmatchedChainOrders.length;
-                            this.manager.logger.log(`[COW] Sync returned without processing (processed=0, ` +
-                                `unmatched=${syncUnmatchedCount} in result, ` +
-                                `_lastUnmatchedChainOrders=${unmatchedChainOrders.length}). ` +
-                                `Structural resync will handle adoption.`, syncUnmatchedCount > 0 ? 'warn' : 'debug');
-                            // If the sync result itself has unmatched entries that
-                            // differ from _lastUnmatchedChainOrders, adopt them now
-                            // so the stale tracker is more accurate for the resync.
-                            if (syncUnmatchedCount > 0 && syncUnmatchedCount !== unmatchedChainOrders.length) {
-                                this.manager._lastUnmatchedChainOrders = syncResult.unmatchedChainOrders.map((o) => ({ ...o }));
-                                this.manager.logger.log(`[COW] Updated _lastUnmatchedChainOrders from sync result: ` +
-                                    `${unmatchedChainOrders.length} → ${syncUnmatchedCount}`, 'debug');
-                            }
-                        }
-                    }
-                }
-            }
-            catch (syncErr) {
-                this.manager.logger.log(`[COW] Failed to sync/unmatched orders: ${syncErr?.message || syncErr}`, 'warn');
-            }
-            // Working grid is stale after master grid mutation from sync.
-            // Request structural resync to rebuild the grid on the next cycle.
-            if (typeof this.manager.requestStructuralGridResync === 'function') {
-                if (this.manager._recoveryState)
-                    this.manager._recoveryState = { ...this.manager._recoveryState, structuralResyncRequested: true };
-                await this.manager.requestStructuralGridResync('unmatched chain orders before COW create', { unmatchedChainOrders: unmatchedChainOrders });
-            }
-            this.manager.logger.log(`[COW] Rejecting CREATE batch after sync: working grid invalidated by master mutation`, 'info');
-            return {
-                executed: false,
-                aborted: true,
-                reason: 'UNMATCHED_CHAIN_ORDERS',
-                hadRotation: false
-            };
-        }
-        const { assetA, assetB } = this.manager.assets;
-        const operations = [];
-        const opContexts = [];
-        const skippedUpdateSlotIds = new Set();
-        let skippedUpdateCount = 0;
-        // Collect IDs to lock from actions
-        const idsToLock = new Set();
-        for (const action of actions) {
-            if (action.type === COW_ACTIONS.CANCEL && action.orderId) {
-                idsToLock.add(action.orderId);
-                if (action.id)
-                    idsToLock.add(action.id);
-            }
-            else if (action.type === COW_ACTIONS.CREATE && action.id) {
-                idsToLock.add(action.id);
-            }
-            else if (action.type === COW_ACTIONS.UPDATE && action.orderId) {
-                idsToLock.add(action.orderId);
-                if (action.id)
-                    idsToLock.add(action.id);
-            }
-        }
-        // Apply shadow locks
-        this.manager.lockOrders(idsToLock);
-        try {
-            this._batchInFlight = true;
-            this._markGridActivity('batch start');
-            this.manager._setRebalanceState(REBALANCE_STATES.BROADCASTING);
-            this.manager.startBroadcasting();
-            // Build operations from actions
-            for (const action of actions) {
-                if (action.type === COW_ACTIONS.CANCEL) {
-                    try {
-                        const op = await chainOrders.buildCancelOrderOp(this.account, action.orderId);
-                        operations.push(op);
-                        const order = this.manager.orders.get(action.id) || { id: action.id, orderId: action.orderId };
-                        opContexts.push({ kind: 'cancel', order });
-                    }
-                    catch (err) {
-                        const orderNotFound = /\bnot found\b/i.test(err.message) || /\bdoes not exist\b/i.test(err.message);
-                        if (orderNotFound) {
-                            this.manager.logger.log(`[COW] Cancel skipped for ${action.id} (${action.orderId}): order already removed from chain`, 'debug');
-                        }
-                        else {
-                            this.manager.logger.log(`Failed to prepare cancel op for ${action.id}: ${err.message}`, 'error');
-                        }
-                    }
-                }
-                else if (action.type === COW_ACTIONS.CREATE) {
-                    try {
-                        const order = action.order;
-                        const sizeValidation = this._validateOrderSizeForExecution(order.size, order.type, order, order.size);
-                        if (!sizeValidation.isValid) {
-                            this.manager.logger.log(`Skipping create op for ${action.id}: ${sizeValidation.reason}`, 'warn');
-                            continue;
-                        }
-                        const liveSlot = this.manager.orders.get(order.id);
-                        const plannedPrice = Number(order.price);
-                        const livePrice = liveSlot ? Number(liveSlot.price) : NaN;
-                        const priceDrift = Number.isFinite(plannedPrice) && Number.isFinite(livePrice)
-                            ? Math.abs(livePrice - plannedPrice)
-                            : 0;
-                        const effectiveOrder = (priceDrift > 0)
-                            ? { ...order, price: livePrice, size: order.size, type: order.type }
-                            : order;
-                        if (priceDrift > 0) {
-                            this.manager.logger.log(`[COW] Pre-broadcast price freshness: slot ${order.id} ` +
-                                `drifted from planned=${plannedPrice} to live=${livePrice} ` +
-                                `(diff=${priceDrift}); rebuilding CREATE op with live price.`, 'debug');
-                        }
-                        const args = buildCreateOrderArgs(effectiveOrder, assetA, assetB);
-                        const buildResult = await chainOrders.buildCreateOrderOp(this.account, args.amountToSell, args.sellAssetId, args.minToReceive, args.receiveAssetId, null);
-                        if (!buildResult) {
-                            this.manager.logger.log(`Skipping create op for ${action.id}: amounts would round to 0 on blockchain`, 'warn');
-                            continue;
-                        }
-                        operations.push(buildResult.op);
-                        opContexts.push({ kind: 'create', id: order.id, order: effectiveOrder, args, finalInts: buildResult.finalInts });
-                        this._recordPendingBroadcast({
-                            opIndex: operations.length - 1,
-                            ctxIndex: opContexts.length - 1,
-                            order: effectiveOrder,
-                            finalInts: buildResult.finalInts
-                        });
-                    }
-                    catch (err) {
-                        this.manager.logger.log(`Failed to prepare create op for ${action.id}: ${err.message}`, 'error');
-                    }
-                }
-                else if (action.type === COW_ACTIONS.UPDATE) {
-                    try {
-                        // Rotation update: move existing on-chain order to a new slot/price.
-                        if (action.newGridId && action.newGridId !== action.id) {
-                            const masterOrder = this.manager.orders.get(action.id);
-                            const orderType = action.order?.type || masterOrder?.type;
-                            const newPrice = Number.isFinite(Number(action.newPrice))
-                                ? Number(action.newPrice)
-                                : Number(action.order?.price);
-                            const newSize = Number.isFinite(Number(action.newSize))
-                                ? Number(action.newSize)
-                                : Number(action.order?.size || 0);
-                            if (!masterOrder || !action.orderId || !orderType || !Number.isFinite(newPrice) || newSize <= 0) {
-                                continue;
-                            }
-                            const rotationSizeValidation = this._validateOrderSizeForExecution(newSize, orderType, action.order, newSize);
-                            if (!rotationSizeValidation.isValid) {
-                                this.manager.logger.log(`Skipping rotation update ${action.id} -> ${action.newGridId}: ${rotationSizeValidation.reason}`, 'warn');
-                                continue;
-                            }
-                            const { amountToSell, minToReceive } = buildCreateOrderArgs({ type: orderType, size: newSize, price: newPrice }, assetA, assetB);
-                            const buildResult = await chainOrders.buildUpdateOrderOp(this.account, action.orderId, { amountToSell, minToReceive, newPrice, orderType }, masterOrder.rawOnChain || null);
-                            if (!buildResult) {
-                                skippedUpdateCount++;
-                                if (action.id)
-                                    skippedUpdateSlotIds.add(action.id);
-                                if (action.newGridId)
-                                    skippedUpdateSlotIds.add(action.newGridId);
-                                this.manager.logger.log(`[COW] Skipping rotation update ${action.id} -> ${action.newGridId}: no blockchain delta`, 'debug');
-                                continue;
-                            }
-                            operations.push(buildResult.op);
-                            opContexts.push({
-                                kind: 'rotation',
-                                rotation: {
-                                    oldOrder: { ...masterOrder },
-                                    newGridId: action.newGridId,
-                                    newPrice,
-                                    newSize,
-                                    type: orderType
-                                },
-                                finalInts: buildResult.finalInts
-                            });
-                            continue;
-                        }
-                        const newSize = Number.isFinite(Number(action.newSize))
-                            ? Number(action.newSize)
-                            : Number(action.order?.size || 0);
-                        const masterOrder = this.manager.orders.get(action.id);
-                        const orderType = action.order?.type || masterOrder?.type;
-                        const cachedRawOnChain = masterOrder?.rawOnChain || action.order?.rawOnChain || null;
-                        const op = await chainOrders.buildUpdateOrderOp(this.account, action.orderId, { amountToSell: newSize, orderType }, cachedRawOnChain);
-                        if (!op) {
-                            skippedUpdateCount++;
-                            if (action.id)
-                                skippedUpdateSlotIds.add(action.id);
-                            if (action.newGridId)
-                                skippedUpdateSlotIds.add(action.newGridId);
-                            this.manager.logger.log(`[COW] Skipping size update ${action.id} (${action.orderId}): no blockchain delta`, 'debug');
-                            continue;
-                        }
-                        operations.push(op.op);
-                        const partialOrder = masterOrder || {
-                            id: action.id,
-                            orderId: action.orderId,
-                            type: orderType
-                        };
-                        opContexts.push({ kind: 'size-update', updateInfo: { partialOrder, newSize }, finalInts: op.finalInts });
-                        // Catch for both rotation-update and size-update branches.
-                    }
-                    catch (err) {
-                        const orderNotFound = /\bnot found\b/i.test(err.message) || /\bdoes not exist\b/i.test(err.message);
-                        if (orderNotFound) {
-                            try {
-                                const fbOrder = action.order || this.manager.orders.get(action.id);
-                                const fbType = fbOrder?.type;
-                                const fbSize = action.newSize || fbOrder?.size || 0;
-                                // Live price from TARGET slot (same pattern as CREATE path).
-                                const targetSlotId = action.newGridId || action.id;
-                                const plannedPrice = action.newPrice || action.order?.price || 0;
-                                const liveSlotForPrice = this.manager.orders.get(targetSlotId);
-                                const livePrice = liveSlotForPrice ? Number(liveSlotForPrice.price) : NaN;
-                                const priceDrift = Number.isFinite(plannedPrice) && Number.isFinite(livePrice)
-                                    ? Math.abs(livePrice - plannedPrice)
-                                    : 0;
-                                const fbPrice = (priceDrift > 0) ? livePrice : plannedPrice;
-                                if (priceDrift > 0) {
-                                    this.manager.logger.log(`[COW] CREATE fallback price drift for ${action.id} -> ${targetSlotId}: ` +
-                                        `planned=${plannedPrice} live=${livePrice} (diff=${priceDrift})`, 'debug');
-                                }
-                                // Same size gate as regular CREATE path.
-                                const sizeCheck = this._validateOrderSizeForExecution(fbSize, fbType, fbOrder, fbSize);
-                                if (!sizeCheck.isValid) {
-                                    this.manager.logger.log(`[COW] CREATE fallback for ${action.id} rejected by size validation: ${sizeCheck.reason}`, 'warn');
-                                }
-                                else if (fbType && fbSize > 0 && fbPrice > 0) {
-                                    const fbArgs = buildCreateOrderArgs({ type: fbType, size: fbSize, price: fbPrice }, assetA, assetB);
-                                    const fbResult = await chainOrders.buildCreateOrderOp(this.account, fbArgs.amountToSell, fbArgs.sellAssetId, fbArgs.minToReceive, fbArgs.receiveAssetId, null);
-                                    if (fbResult) {
-                                        operations.push(fbResult.op);
-                                        opContexts.push({
-                                            kind: 'create',
-                                            id: targetSlotId,
-                                            order: { id: targetSlotId, type: fbType, price: fbPrice, size: fbSize },
-                                            args: { amountToSell: fbArgs.amountToSell, minToReceive: fbArgs.minToReceive },
-                                            finalInts: fbResult.finalInts
-                                        });
-                                        this._recordPendingBroadcast({
-                                            opIndex: operations.length - 1,
-                                            ctxIndex: opContexts.length - 1,
-                                            order: { id: targetSlotId, type: fbType, price: fbPrice, size: fbSize },
-                                            finalInts: fbResult.finalInts
-                                        });
-                                        this.manager.logger.log(`[COW] Recovered "not found" for ${action.id}: converted UPDATE to CREATE for slot ${targetSlotId}`, 'warn');
-                                        continue;
-                                    }
-                                }
-                            }
-                            catch (fbErr) {
-                                this.manager.logger.log(`[COW] CREATE fallback also failed for ${action.id}: ${fbErr.message}`, 'warn');
-                            }
-                        }
-                        this.manager.logger.log(`Failed to prepare update op for ${action.id}: ${err.message}`, 'error');
-                    }
-                }
-            }
-            if (skippedUpdateCount > 0) {
-                this._restoreSkippedUpdateSlotsInWorkingGrid(workingGrid, skippedUpdateSlotIds, skippedUpdateCount);
-            }
-            if (operations.length === 0) {
-                this.manager._setRebalanceState(REBALANCE_STATES.NORMAL);
-                return { executed: false, hadRotation: false };
-            }
-            // Validate funds before broadcasting
-            const validation = this._validateOperationFunds(operations, assetA, assetB);
-            this.manager.logger.log(validation.summary, validation.isValid ? 'info' : 'warn');
-            if (!validation.isValid) {
-                this.manager.logger.log(`Skipping batch broadcast: ${validation.violations.length} fund violation(s) detected`, 'warn');
-                this.manager._setRebalanceState(REBALANCE_STATES.NORMAL);
-                return { executed: false, hadRotation: false };
-            }
-            await this._ensureCredentialDaemonWritable('COW batch broadcast');
-            // Execute batch
-            this.manager.logger.log(`[COW] Broadcasting batch with ${operations.length} operations...`, 'info');
-            this._lastBroadcastHeartbeatAt = Date.now();
-            const execution = await this._executeWithRetryOnUncertain(operations, opContexts);
-            const result = execution.result;
-            const executedContexts = execution.opContexts;
-            // Process results and commit on success
-            this.manager.pauseFundRecalc();
-            try {
-                this.manager._throwOnIllegalState = true;
-                if (result.success) {
-                    // Pre-commit integrity: only CREATE ops require returned chainOrderIds.
-                    // Cancel/update operation results may be empty depending on the broadcaster.
-                    const preCommitResults = this._extractOperationResults(result, 'pre-commit-integrity');
-                    const missingCreateResults = this._findMissingCreateResultContexts(preCommitResults, executedContexts);
-                    if (missingCreateResults.length > 0) {
-                        const missingSlots = missingCreateResults
-                            .map(item => item.ctx?.order?.id || item.ctx?.id || `op-${item.index}`)
-                            .join(', ');
-                        this.manager.logger.log(`[COW] Refusing to commit working grid: ${missingCreateResults.length} CREATE op(s) ` +
-                            `returned no chainOrderId (${missingSlots}). Discarding working grid and syncing from chain.`, 'error');
-                        this.manager._clearWorkingGridRef();
-                        this.manager._setRebalanceState(REBALANCE_STATES.NORMAL);
-                        this._markMissingCreateResultsAsStructuralBlocker(missingCreateResults);
-                        await this._recoverAfterMissingCreateResults('missing create operation results');
-                        return {
-                            executed: false,
-                            hadRotation: false,
-                            missingCreateResults: missingCreateResults.map(item => ({
-                                index: item.index,
-                                slotId: item.ctx?.order?.id || item.ctx?.id || null
-                            }))
-                        };
-                    }
-                    // SUCCESS: Commit working grid to master (atomic swap)
-                    this.manager.logger.log('[COW] Blockchain success - committing working grid to master', 'info');
-                    // RC-FIX: skipRecalc prevents invariant violation before optimistic accounting
-                    await this.manager._commitWorkingGrid(workingGrid, workingIndexes, workingBoundary, { skipRecalc: true });
-                    // Commitment accounting is handled in real-time by
-                    // updateOptimisticFreeBalance when capital is committed to orders.
-                    // The old post-batch deduction path was removed to avoid double-counting.
-                    // Process batch results for logging/metrics
-                    const batchResult = await this._processBatchResults(result, executedContexts);
-                    // Persist to disk. CRITICAL: working grid was already committed
-                    // to master above; if persistence is skipped or validation fails
-                    // here, the on-disk snapshot will be older than the in-memory
-                    // master. Retry once and surface the failure explicitly so the
-                    // next cycle / shutdown can recover.
-                    const persistResult = await this.manager.persistGrid();
-                    if (persistResult && (persistResult.skipped || persistResult.isValid === false)) {
-                        this.manager.logger.log(`[COW][PERSIST-GUARD] First persist attempt was ` +
-                            `${persistResult.skipped ? 'skipped' : 'invalid'} ` +
-                            `(${persistResult.reason || 'no reason'}); retrying once before ` +
-                            `clearing working grid reference.`, 'warn');
-                        this.manager._persistenceWarning = persistResult;
-                        const retryResult = await this.manager.persistGrid();
-                        if (retryResult && (retryResult.skipped || retryResult.isValid === false)) {
-                            this.manager.logger.log(`[COW][PERSIST-GUARD] Retry also skipped/invalid ` +
-                                `(${retryResult.reason || 'no reason'}). Master grid in memory ` +
-                                `is ahead of disk snapshot; structural resync requested.`, 'error');
-                            if (typeof this.manager.requestStructuralGridResync === 'function') {
-                                this.manager._recoveryState = { ...this.manager._recoveryState, structuralResyncRequested: true };
-                                await this.manager.requestStructuralGridResync('persistence guard triggered after COW batch', { persistReason: retryResult.reason || 'unknown' });
-                            }
-                        }
-                        else {
-                            delete this.manager._persistenceWarning;
-                        }
-                    }
-                    else if (this.manager._persistenceWarning) {
-                        delete this.manager._persistenceWarning;
-                    }
-                    this._metrics.batchesExecuted++;
-                    this.manager._clearWorkingGridRef();
-                    this._clearPendingBroadcasts();
-                    return { executed: true, hadRotation: true, ...batchResult };
-                }
-                else {
-                    // FAILURE: Working grid discarded, master unchanged
-                    this.manager.logger.log('[COW] Blockchain failed - working grid discarded, master unchanged', 'warn');
-                    this.manager._clearWorkingGridRef();
-                    this._clearPendingBroadcasts();
-                    return { executed: false, hadRotation: false, ...result };
-                }
-            }
-            finally {
-                this.manager._throwOnIllegalState = false;
-                // Keep broadcasting true during resumeFundRecalc to skip invariant checks
-                // that would fail due to stale accountTotals (not yet refreshed from blockchain)
-                await this.manager.resumeFundRecalc();
-                this.manager.stopBroadcasting();
-                const createCount = actions.filter(a => a.type === COW_ACTIONS.CREATE).length;
-                const cancelCount = actions.filter(a => a.type === COW_ACTIONS.CANCEL).length;
-                this.manager.logger.logFundsStatus(this.manager, `AFTER COW batch (created=${createCount}, cancelled=${cancelCount})`);
-            }
-        }
-        catch (err) {
-            this.manager.logger.log(`[COW] Batch transaction failed: ${err.message}`, 'error');
-            if (err?.partialOnChainState) {
-                this.manager.logger.log(`[COW] Non-atomic grouped execution detected (${err.groupsBroadcast}/${err.groupsTotal} groups broadcast). Local rollback cannot undo confirmed on-chain operations; next sync/reconcile will converge state.`, 'warn');
-            }
-            this.manager.stopBroadcasting();
-            this.manager._clearWorkingGridRef();
-            // BROADCAST_UNCERTAIN: the credential daemon timed out (or hit its
-            // inner deadline) and the chain status of the planned CREATEs is
-            // unknown. Run the reconcile-then-decide recovery path: read the
-            // chain, match each pending broadcast by fingerprint, adopt any
-            // chain-side matches, and discard the rest. We MUST NOT throw —
-            // throwing would re-enter the catch loop on the next attempt and
-            // potentially double-publish.
-            if (err instanceof BroadcastUncertainError) {
-                return await this._reconcileAfterUncertainBroadcast(err, opContexts);
-            }
-            // Handle hard abort
-            const hardAbortResult = await this._handleBatchHardAbort(err, 'COW batch processing', operations.length);
-            if (hardAbortResult)
-                return hardAbortResult;
-            // Check for stale orders — filled in the ~1.5s broadcast window after our plan was built.
-            const staleOrderIds = new Set();
-            const patterns = [
-                /Limit order (1\.7\.\d+) does not exist/g,
-                /Unable to find Object (1\.7\.\d+)/g,
-                /object (1\.7\.\d+) (?:does not exist|not found)/gi
-            ];
-            for (const pattern of patterns) {
-                let m;
-                while ((m = pattern.exec(err.message)) !== null) {
-                    staleOrderIds.add(m[1]);
-                }
-            }
-            // "Cannot deduct all or more from order than order contains" means the order still
-            // exists, but its on-chain size shrank during the broadcast window. That is not an
-            // explicit stale/missing-order signal, so reconcile from chain instead of virtualizing.
-            if (/Cannot deduct all or more from order than order contains/.test(err.message)) {
-                return await this._recoverBatchSizeDrift(err, opContexts);
-            }
-            if (staleOrderIds.size > 0) {
-                // Recover explicit missing-order failures without aborting the entire fill cycle.
-                // Use the manager update path so indexes, working-grid sync, accounting, and
-                // persistence stay coherent.
-                return await this._recoverExplicitStaleOrders(staleOrderIds, 'cow-stale-order-cleanup');
-            }
-            throw err;
-        }
-        finally {
-            this._batchInFlight = false;
-            this._markGridActivity('batch end');
-            this.manager.unlockOrders(idsToLock);
-            if (!this._shuttingDown && this._incomingFillQueue.length > 0) {
-                this._scheduleFillConsumerRestart(chainOrders);
-            }
-        }
+        return cowRuntime.updateOrdersOnChainBatchCOW(this, cowResult);
     }
-    /**
-     * Process results from batch transaction execution.
-     * Updates order state, synchronizes with chain, and deducts BTS fees.
-     * @param {Object} result - Transaction result from executeBatch
-     * @param {Array} opContexts - Operation context array with operation metadata (must be 1:1 with result.operation_results)
-     * @returns {Object} Result with { executed: boolean, hadRotation: boolean }
-     * @private
-     */
     async _processBatchResults(result, opContexts) {
-        const results = this._extractOperationResults(result, '_processBatchResults');
-        const { getAssetFees } = require('./order/utils/math');
-        // IMPORTANT: Call without amount to get fee schedule fields
-        // ({ createFee, updateFee, ... }), not proceeds projection fields.
-        const btsFeeData = getAssetFees('BTS');
-        let hadRotation = false;
-        let updateOperationCount = 0;
-        const updatesToApply = [];
-        for (let i = 0; i < opContexts.length; i++) {
-            const ctx = opContexts[i];
-            const res = results[i];
-            if (ctx.kind === 'cancel') {
-                this.manager.logger.log(`Cancelled surplus order ${ctx.order.id} (${ctx.order.orderId})`, 'info');
-                const oldOrder = ctx.order;
-                const committedOrder = oldOrder?.id ? this.manager.orders.get(oldOrder.id) : null;
-                // The COW commit already updated manager.orders. Apply ONLY the optimistic
-                // accounting transition using pre-commit -> committed order states.
-                if (oldOrder && committedOrder && this.manager.accountant) {
-                    await this.manager.accountant.updateOptimisticFreeBalance(oldOrder, committedOrder, 'fill-cancel', btsFeeData?.cancelFee || 0, false);
-                }
-            }
-            else if (ctx.kind === 'size-update') {
-                const oldOrder = ctx.updateInfo.partialOrder;
-                const ord = this.manager.orders.get(oldOrder.id);
-                // Apply optimistic accounting from pre-commit -> committed state,
-                // including blockchain update fee deduction.
-                if (oldOrder && ord && this.manager.accountant) {
-                    await this.manager.accountant.updateOptimisticFreeBalance(oldOrder, ord, 'order-update', btsFeeData.updateFee, false);
-                }
-                if (ord) {
-                    const updatedSlot = { ...ord, size: ctx.updateInfo.newSize };
-                    // Update rawOnChain cache with new integers
-                    if (ctx.finalInts) {
-                        updatedSlot.rawOnChain = {
-                            id: ord.orderId,
-                            for_sale: String(ctx.finalInts.sell),
-                            sell_price: {
-                                base: { amount: String(ctx.finalInts.sell), asset_id: ctx.finalInts.sellAssetId },
-                                quote: { amount: String(ctx.finalInts.receive), asset_id: ctx.finalInts.receiveAssetId }
-                            }
-                        };
-                    }
-                    updatesToApply.push({ order: updatedSlot, context: 'post-update-metadata' });
-                }
-                this.manager.logger.log(`Size update complete: ${ctx.updateInfo.partialOrder.orderId}`, 'info');
-                updateOperationCount++;
-            }
-            else if (ctx.kind === 'create') {
-                const chainOrderId = res && res[1];
-                if (chainOrderId) {
-                    // synchronizeWithChain handles the full VIRTUAL -> ACTIVE transition
-                    // including orderId assignment and fee deduction.
-                    await this.manager.synchronizeWithChain({
-                        gridOrderId: ctx.order.id, chainOrderId, expectedType: ctx.order.type, fee: btsFeeData.createFee
-                    }, 'createOrder');
-                    // After sync, apply rawOnChain metadata if available
-                    if (ctx.finalInts) {
-                        const syncedOrder = this.manager.orders.get(ctx.order.id);
-                        if (syncedOrder) {
-                            updatesToApply.push({
-                                order: {
-                                    ...syncedOrder,
-                                    rawOnChain: {
-                                        id: chainOrderId,
-                                        for_sale: String(ctx.finalInts.sell),
-                                        sell_price: {
-                                            base: { amount: String(ctx.finalInts.sell), asset_id: ctx.finalInts.sellAssetId },
-                                            quote: { amount: String(ctx.finalInts.receive), asset_id: ctx.finalInts.receiveAssetId }
-                                        }
-                                    }
-                                },
-                                context: 'post-placement-metadata'
-                            });
-                        }
-                    }
-                    this.manager.logger.log(`Placed ${ctx.order.type} order ${ctx.order.id} -> ${chainOrderId}`, 'info');
-                }
-                else {
-                    const fingerprint = [
-                        `type=${ctx.order.type || 'unknown'}`,
-                        `price=${Format.formatPrice6(ctx.order.price)}`,
-                        `size=${Format.formatAmount(ctx.order.size)}`
-                    ].join(',');
-                    this.manager.logger.log(`[COW] CRITICAL: Create op for slot ${ctx.order.id} (type=${ctx.order.type}) ` +
-                        `returned no chainOrderId. Identify any orphaned on-chain order by local fingerprint ` +
-                        `${fingerprint} before cancelling.`, 'error');
-                }
-            }
-            else if (ctx.kind === 'rotation') {
-                hadRotation = true;
-                const { rotation } = ctx;
-                const { oldOrder, newPrice, newGridId, newSize, type } = rotation;
-                if (!newGridId) {
-                    // Size correction only
-                    const ord = this.manager.orders.get(oldOrder.id || rotation.id);
-                    // Apply optimistic accounting from pre-commit -> committed state,
-                    // including blockchain update fee deduction.
-                    if (oldOrder && ord && this.manager.accountant) {
-                        await this.manager.accountant.updateOptimisticFreeBalance(oldOrder, ord, 'order-update', btsFeeData.updateFee, false);
-                    }
-                    if (ord) {
-                        const updatedSlot = { ...ord, size: newSize };
-                        // Update rawOnChain cache with new integers
-                        if (ctx.finalInts) {
-                            updatedSlot.rawOnChain = {
-                                id: ord.orderId,
-                                for_sale: String(ctx.finalInts.sell),
-                                sell_price: {
-                                    base: { amount: String(ctx.finalInts.sell), asset_id: ctx.finalInts.sellAssetId },
-                                    quote: { amount: String(ctx.finalInts.receive), asset_id: ctx.finalInts.receiveAssetId }
-                                }
-                            };
-                        }
-                        updatesToApply.push({ order: updatedSlot, context: 'post-update-metadata' });
-                    }
-                    updateOperationCount++;
-                    continue;
-                }
-                // Full rotation: old slot was virtualized in the committed working grid.
-                // Activate the destination slot with the existing on-chain orderId.
-                const slot = this.manager.orders.get(newGridId);
-                if (!slot) {
-                    this.manager.logger.log(`[ROTATION] Destination slot ${newGridId} missing from master grid after COW commit - skipping activation, sync will reconcile`, 'error');
-                    // Still clear source orderId to prevent a stale chain reference persisting
-                    if (oldOrder?.id && oldOrder.id !== newGridId) {
-                        const staleSource = this.manager.orders.get(oldOrder.id);
-                        if (staleSource?.orderId) {
-                            updatesToApply.push({
-                                order: { ...staleSource, state: ORDER_STATES.VIRTUAL, orderId: null, rawOnChain: null },
-                                context: 'post-rotation-source-clear'
-                            });
-                        }
-                    }
-                    continue;
-                }
-                const updatedSlot = {
-                    ...slot,
-                    id: newGridId,
-                    type,
-                    size: newSize,
-                    price: newPrice,
-                    state: ORDER_STATES.ACTIVE,
-                    orderId: oldOrder?.orderId || slot.orderId || null
-                };
-                if (ctx.finalInts) {
-                    updatedSlot.rawOnChain = {
-                        id: updatedSlot.orderId,
-                        for_sale: String(ctx.finalInts.sell),
-                        sell_price: {
-                            base: { amount: String(ctx.finalInts.sell), asset_id: ctx.finalInts.sellAssetId },
-                            quote: { amount: String(ctx.finalInts.receive), asset_id: ctx.finalInts.receiveAssetId }
-                        }
-                    };
-                }
-                if (oldOrder && updatedSlot && this.manager.accountant) {
-                    await this.manager.accountant.updateOptimisticFreeBalance(oldOrder, updatedSlot, 'order-update', btsFeeData.updateFee, false);
-                }
-                // Ensure rotation source slot is cleared in master state.
-                // COW projection may keep source slots ACTIVE when target keeps a non-zero
-                // virtual size, but after a successful on-chain rotation the source orderId
-                // must no longer remain attached to the old slot.
-                if (oldOrder?.id && oldOrder.id !== newGridId) {
-                    const currentSource = this.manager.orders.get(oldOrder.id);
-                    if (currentSource && currentSource.orderId) {
-                        updatesToApply.push({
-                            order: {
-                                ...currentSource,
-                                state: ORDER_STATES.VIRTUAL,
-                                orderId: null,
-                                rawOnChain: null
-                            },
-                            context: 'post-rotation-source-clear'
-                        });
-                    }
-                }
-                updatesToApply.push({ order: updatedSlot, context: 'post-rotation-metadata' });
-            }
-        }
-        // Apply all collected updates in a single batch
-        if (updatesToApply.length > 0) {
-            await this.manager.applyGridUpdateBatch(updatesToApply.map(u => u.order), 'batch-results-process', { skipAccounting: true });
-        }
-        return {
-            executed: true,
-            hadRotation,
-            updateOperationCount
-        };
+        return cowRuntime.processBatchResults(this, result, opContexts);
     }
     /**
      * Perform grid recalculation triggered by trigger file.
@@ -4919,89 +1636,17 @@ class DEXBot {
         }
     }
     async requestGridReset(reason = 'structural change', options = {}) {
-        if (!this.manager || typeof this._performGridResync !== 'function') {
-            return { skipped: true, reason: 'grid resync unavailable' };
-        }
-        const message = reason ? `[CR-RESET] ${reason}` : '[CR-RESET] grid reset requested';
-        this._log(`${message}; rebuilding grid from fresh on-chain state`, 'info');
-        const resetOptions = {
-            ...options,
-            refreshCenterPrice: options.refreshCenterPrice !== false,
-        };
-        // Skip acquire if no lock exists (no fill processing to serialize against)
-        // or if the caller already holds the lock (re-entrant). In the latter case
-        // the lock's isReentrant() check prevents queueing and runs inline.
-        // Otherwise, wait on the queue — this is the intended path for callers
-        // outside the fill-processing context that need exclusive access.
-        if (!this.manager._fillProcessingLock || this.manager._fillProcessingLock.isReentrant()) {
-            return this._performGridResync(resetOptions);
-        }
-        return this.manager._fillProcessingLock.acquire(async () => this._performGridResync(resetOptions));
+        return DexbotMaintenanceRuntime.requestGridReset(this, reason, options);
     }
     _wireStructuralGridResyncRequest() {
-        if (!this.manager || this.manager.requestStructuralGridResync)
-            return;
-        this.manager.requestStructuralGridResync = async (reason = 'structural recovery', details = {}) => {
-            if (this._shuttingDown) {
-                return { skipped: true, reason: 'shutting down' };
-            }
-            if (this._structuralGridResyncRunning || this._structuralGridResyncTimer) {
-                return { skipped: true, reason: 'structural grid resync already scheduled' };
-            }
-            const unmatchedCount = Array.isArray(details?.unmatchedChainOrders)
-                ? details.unmatchedChainOrders.length
-                : 0;
-            this._structuralGridResyncTimer = setTimeout(async () => {
-                this._structuralGridResyncTimer = null;
-                if (this._shuttingDown)
-                    return;
-                this._structuralGridResyncRunning = true;
-                try {
-                    // Try the lighter persisted-grid reload before full reset.
-                    const persistedResult = await this._recoverFromPersistedGrid();
-                    if (persistedResult.success) {
-                        if (this.manager?._recoveryState) {
-                            this.manager._recoveryState = { ...this.manager._recoveryState, attemptCount: 0, lastAttemptAt: 0, lastFailureAt: 0 };
-                        }
-                        return;
-                    }
-                    const suffix = unmatchedCount > 0 ? ` (${unmatchedCount} unmatched chain order(s))` : '';
-                    this._warn(`[RECOVERY] Running structural full grid resync for ${reason}${suffix}`);
-                    const resetResult = await this.requestGridReset('rms_structural_grid_resync', {
-                        refreshCenterPrice: true,
-                    });
-                    if (resetResult && this.manager?._recoveryState) {
-                        this.manager._recoveryState = { ...this.manager._recoveryState, attemptCount: 0, lastAttemptAt: 0, lastFailureAt: 0 };
-                    }
-                }
-                catch (err) {
-                    this._warn(`[RECOVERY] Structural full grid resync failed: ${err.message}`);
-                }
-                finally {
-                    this._structuralGridResyncRunning = false;
-                    if (this.manager?._recoveryState) {
-                        this.manager._recoveryState = { ...this.manager._recoveryState, structuralResyncRequested: false };
-                    }
-                }
-            }, 0);
-            return { scheduled: true };
-        };
+        return DexbotMaintenanceRuntime.wireStructuralGridResyncRequest(this);
     }
     /**
      * Get current metrics for monitoring and debugging.
      * @returns {Object} Metrics snapshot
      */
     getMetrics() {
-        this.manager?._cleanExpiredLocks?.();
-        return {
-            ...this._metrics,
-            queueDepth: this._incomingFillQueue.length,
-            fillProcessingLockActive: this.manager?._fillProcessingLock?.isLocked() || false,
-            divergenceLockActive: this.manager?._divergenceLock?.isLocked() || false,
-            shadowLocksActive: this.manager?.shadowOrderIds?.size || 0,
-            recoveryExhaustedAt: this.manager?._recoveryExhaustedAt || null,
-            recentFillsTracked: this._recentlyProcessedFills.size
-        };
+        return DexbotMaintenanceRuntime.getMetrics(this);
     }
     /**
      * Execute grid maintenance checks in strict order with pipeline consensus.
@@ -5048,40 +1693,25 @@ class DEXBot {
     async _cancelDustOrders({ buy: buyDust = [], sell: sellDust = [] } = {}) {
         return DexbotMaintenanceRuntime.cancelDustOrders(this, { buy: buyDust, sell: sellDust });
     }
+    /**
+     * Run a single dust health check cycle: inspect grid for partials below the
+     * configured dust threshold and cancel them immediately inside the fill-
+     * processing lock (with timeout).  Safe to call from the periodic timer or
+     * once at startup.
+     * @private
+     */
+    async _runDustHealthCheck() {
+        return DexbotMaintenanceRuntime.runDustHealthCheck(this);
+    }
     /**
      * Set up the periodic dust health check interval.
      * Catches partials below the dust threshold that were missed by the post-fill
      * pipeline (e.g. from a prior bot lifetime after crash/restart).
-     * Cancels dust immediately inside the fill-processing lock.
+     * Calls _runDustHealthCheck on each tick.
      * @private
      */
     _setupDustHealthCheckInterval() {
-        const DUST_HEALTH_CHECK_INTERVAL_MS = 5 * 60 * 1000;
-        this._dustHealthCheckTimer = setInterval(async () => {
-            if (this._shuttingDown || !this.manager)
-                return;
-            try {
-                const health = await this.manager.checkGridHealth(this.updateOrdersOnChainPlan?.bind(this));
-                const allDust = [
-                    ...(health.buyDustOrders || []),
-                    ...(health.sellDustOrders || []),
-                ];
-                if (allDust.length > 0) {
-                    await this.manager._fillProcessingLock.acquire(async () => {
-                        await this._cancelDustOrders({
-                            buy: health.buyDustOrders,
-                            sell: health.sellDustOrders,
-                        });
-                    });
-                }
-            }
-            catch {
-                // Silently retry next interval
-            }
-        }, DUST_HEALTH_CHECK_INTERVAL_MS);
-        if (typeof this._dustHealthCheckTimer?.unref === 'function') {
-            this._dustHealthCheckTimer.unref();
-        }
+        return DexbotMaintenanceRuntime.setupDustHealthCheckInterval(this);
     }
     /**
      * Perform grid maintenance: fund thresholds, spread condition, grid health, divergence.