dexbot 1.1.14 → 1.2.1

package/dist/modules/order/manager.js

@@ -11,8 +11,7 @@
  *
  * SECTION 1: EXTERNAL DEPENDENCIES
  * SECTION 2: COW REBALANCE ENGINE
- * SECTION 3: STATE MANAGER
- * SECTION 4: ORDER MANAGER CLASS
+ * SECTION 3: ORDER MANAGER CLASS
  * ===============================================================================
  */
 // ===============================================================================
@@ -29,7 +28,7 @@ const AsyncLock = require('./async_lock');
 const Accountant = require('./accounting');
 const StrategyEngine = require('./strategy');
 const SyncEngine = require('./sync_engine');
-const Grid = require('./grid');
+const { calculateCurrentSpread, checkSpreadCondition, checkGridHealth } = require('./grid');
 const Format = require('./format');
 const { toFiniteNumber, isValidNumber } = Format;
 // ===============================================================================
@@ -57,7 +56,7 @@ const { toFiniteNumber, isValidNumber } = Format;
 // 1. Master grid NEVER modified during planning (immutable during rebalance)
 // 2. Fills that arrive during rebalance are QUEUED, not lost
 // 3. Working grid is DISPOSABLE - if rebalance fails, discard it
-// 4. Only ONE rebalance plan active at a time (StateManager.rebalance)
+// 4. Only ONE rebalance plan active at a time (_rebalanceState)
 // 5. Staleness detection aborts if master changes (fills, manual commands)
 //
 // FILL HANDLING DURING REBALANCE:
@@ -138,186 +137,7 @@ class COWRebalanceEngine {
     }
 }
 // ===============================================================================
-// SECTION 3: STATE MANAGER
-// ===============================================================================
-class StateManager {
-    logger;
-    rebalance;
-    recovery;
-    gridRegen;
-    bootstrap;
-    broadcast;
-    signals;
-    pipeline;
-    constructor(options = {}) {
-        this.logger = options.logger || null;
-        this.reset();
-    }
-    reset() {
-        this.rebalance = {
-            state: REBALANCE_STATES.NORMAL,
-            currentWorkingGrid: null
-        };
-        this.recovery = {
-            attemptCount: 0,
-            lastAttemptAt: 0,
-            inFlight: false,
-            lastFailureAt: 0
-        };
-        this.gridRegen = {
-            buy: { armed: true, lastTriggeredAt: 0 },
-            sell: { armed: true, lastTriggeredAt: 0 }
-        };
-        this.bootstrap = {
-            isBootstrapping: false
-        };
-        this.broadcast = {
-            isBroadcasting: false,
-            startedAt: 0,
-        };
-        this.signals = {
-            lastIllegalState: null,
-            lastAccountingFailure: null
-        };
-        this.pipeline = {
-            blockedSince: null,
-            recoveryAttempted: false
-        };
-    }
-    getRebalanceState() {
-        return this.rebalance.state;
-    }
-    setRebalanceState(state) {
-        this.rebalance.state = state;
-        this.logger?.log(`[COW] Rebalance state: ${state}`, 'debug');
-    }
-    isRebalancing() {
-        return this.rebalance.state === REBALANCE_STATES.REBALANCING;
-    }
-    isBroadcasting() {
-        return this.rebalance.state === REBALANCE_STATES.BROADCASTING;
-    }
-    setWorkingGrid(workingGrid) {
-        this.rebalance.currentWorkingGrid = workingGrid;
-    }
-    getWorkingGrid() {
-        return this.rebalance.currentWorkingGrid;
-    }
-    clearWorkingGrid() {
-        this.rebalance.currentWorkingGrid = null;
-    }
-    recordRecoveryAttempt() {
-        this.recovery.attemptCount++;
-        this.recovery.lastAttemptAt = Date.now();
-        this.recovery.inFlight = true;
-    }
-    completeRecovery(success) {
-        this.recovery.inFlight = false;
-        if (!success) {
-            this.recovery.lastFailureAt = Date.now();
-        }
-    }
-    isRecoveryInFlight() {
-        return this.recovery.inFlight;
-    }
-    getRecoveryStats() {
-        return { ...this.recovery };
-    }
-    isSideArmed(side) {
-        return this.gridRegen[side]?.armed ?? false;
-    }
-    disarmSide(side) {
-        if (this.gridRegen[side]) {
-            this.gridRegen[side].armed = false;
-            this.gridRegen[side].lastTriggeredAt = Date.now();
-        }
-    }
-    armSide(side) {
-        if (this.gridRegen[side]) {
-            this.gridRegen[side].armed = true;
-        }
-    }
-    startBootstrap() {
-        this.bootstrap.isBootstrapping = true;
-        this.logger?.log('[BOOTSTRAP] Started', 'debug');
-    }
-    finishBootstrap() {
-        this.bootstrap.isBootstrapping = false;
-        this.logger?.log('[BOOTSTRAP] Finished', 'debug');
-    }
-    isBootstrapping() {
-        return this.bootstrap.isBootstrapping;
-    }
-    startBroadcasting() {
-        this.broadcast.isBroadcasting = true;
-        this.broadcast.startedAt = Date.now();
-        this.logger?.log?.('[BROADCAST] Flag set — fill processing will be deferred until stopBroadcasting()', 'debug');
-    }
-    stopBroadcasting() {
-        this.broadcast.isBroadcasting = false;
-        this.broadcast.startedAt = 0;
-    }
-    isBroadcastingActive() {
-        if (this.broadcast.isBroadcasting && this.broadcast.startedAt > 0) {
-            const elapsed = Date.now() - this.broadcast.startedAt;
-            if (elapsed > 120000) {
-                this.logger?.log?.('[BROADCAST] Auto-clearing stale broadcast flag after 120s', 'warn');
-                this.broadcast.isBroadcasting = false;
-                this.broadcast.startedAt = 0;
-            }
-        }
-        return this.broadcast.isBroadcasting;
-    }
-    setIllegalStateSignal(signal) {
-        this.signals.lastIllegalState = {
-            ...signal,
-            at: Date.now()
-        };
-    }
-    consumeIllegalStateSignal() {
-        const signal = this.signals.lastIllegalState;
-        this.signals.lastIllegalState = null;
-        return signal;
-    }
-    setAccountingFailureSignal(signal) {
-        this.signals.lastAccountingFailure = {
-            ...signal,
-            at: Date.now()
-        };
-    }
-    consumeAccountingFailureSignal() {
-        const signal = this.signals.lastAccountingFailure;
-        this.signals.lastAccountingFailure = null;
-        return signal;
-    }
-    markPipelineBlocked() {
-        if (!this.pipeline.blockedSince) {
-            this.pipeline.blockedSince = Date.now();
-        }
-    }
-    markPipelineClear() {
-        this.pipeline.blockedSince = null;
-        this.pipeline.recoveryAttempted = false;
-    }
-    getPipelineBlockedDuration() {
-        return this.pipeline.blockedSince ? Date.now() - this.pipeline.blockedSince : 0;
-    }
-    isPipelineBlocked() {
-        return this.pipeline.blockedSince !== null;
-    }
-    getState() {
-        return {
-            rebalance: { ...this.rebalance, currentWorkingGrid: null },
-            recovery: { ...this.recovery },
-            gridRegen: { ...this.gridRegen },
-            bootstrap: { ...this.bootstrap },
-            broadcast: { ...this.broadcast },
-            pipeline: { ...this.pipeline }
-        };
-    }
-}
-// ===============================================================================
-// SECTION 4: ORDER MANAGER CLASS
+// SECTION 3: ORDER MANAGER CLASS
 // ===============================================================================
 class OrderManager {
     config;
@@ -329,7 +149,14 @@ class OrderManager {
     accountant;
     strategy;
     sync;
-    _state;
+    _rebalanceState;
+    _bootstrapping;
+    _broadcastingFlag;
+    _broadcastingStartedAt;
+    _illegalStateSignal;
+    _accountingFailureSignal;
+    _recoveryStateValue;
+    _gridRegenStateValue;
     _ordersByState;
     _ordersByType;
     targetSpreadCount;
@@ -354,15 +181,19 @@ class OrderManager {
     _recentlyRotatedOrderIds;
     _gridSidesUpdated;
     _pauseFundRecalc;
+    _pauseFundRecalcWatchdog;
     _pauseRecalcLogging;
+    _pauseRecalcLoggingWatchdog;
     _throwOnIllegalState;
     _pipelineBlockedSince;
     _recoveryAttempted;
+    _syncGeneration;
     _gridVersion;
     _gridPersistenceSuspendedReason;
     _pendingBroadcasts;
     _committedOrderIds;
     _gridDirtyAt;
+    _pendingRecovery;
     _metrics;
     _currentWorkingGrid;
     _cowEngine;
@@ -388,7 +219,23 @@ class OrderManager {
         this.accountant = new Accountant(this);
         this.strategy = new StrategyEngine(this);
         this.sync = new SyncEngine(this);
-        this._state = new StateManager({ logger: this.logger });
+        this._rebalanceState = REBALANCE_STATES.NORMAL;
+        this._bootstrapping = false;
+        this._broadcastingFlag = false;
+        this._broadcastingStartedAt = 0;
+        this._illegalStateSignal = null;
+        this._accountingFailureSignal = null;
+        this._recoveryStateValue = {
+            phase: 'idle',
+            attemptCount: 0,
+            lastAttemptAt: 0,
+            inFlight: false,
+            lastFailureAt: 0
+        };
+        this._gridRegenStateValue = {
+            buy: { armed: true, lastTriggeredAt: 0 },
+            sell: { armed: true, lastTriggeredAt: 0 }
+        };
         // Index Sets use mutable mutation patterns controlled via _applyOrderUpdate
         // These are private implementation details and must NOT be mutated directly
         // All external code must go through the COW pipeline
@@ -423,7 +270,7 @@ class OrderManager {
         //   Level 2: _gridLock         (grid mutations)
         //   Level 3: _syncLock         (sync operations)
         //   Level 4: _fundLock         (fund operations — innermost)
-        // WARNING: AsyncLock is NOT reentrant.
+        // Note: AsyncLock IS re-entrant (acquire detects nested calls via _holding).
         this._divergenceLock = new AsyncLock({ level: 0 });
         this._fillProcessingLock = new AsyncLock({ level: 1 });
         this._gridLock = new AsyncLock({ level: 2 });
@@ -432,15 +279,19 @@ class OrderManager {
         this._recentlyRotatedOrderIds = new Set();
         this._gridSidesUpdated = new Set();
         this._pauseFundRecalc = 0;
+        this._pauseFundRecalcWatchdog = null;
         this._pauseRecalcLogging = false;
+        this._pauseRecalcLoggingWatchdog = null;
         this._throwOnIllegalState = false;
         this._pipelineBlockedSince = null;
         this._recoveryAttempted = false;
+        this._syncGeneration = 0;
         this._gridVersion = 0;
         this._gridPersistenceSuspendedReason = null;
         this._pendingBroadcasts = new Map();
         this._committedOrderIds = new Set();
         this._gridDirtyAt = null;
+        this._pendingRecovery = null;
         this._metrics = {
             fundRecalcCount: 0,
             invariantViolations: { buy: 0, sell: 0 },
@@ -450,7 +301,8 @@ class OrderManager {
             lastSyncDurationMs: 0,
             metricsStartTime: Date.now()
         };
-        this._state.startBootstrap();
+        this._bootstrapping = true;
+        this.logger?.log('[BOOTSTRAP] Started', 'debug');
         this._currentWorkingGrid = null;
         this._cowEngine = null;
         this._cleanExpiredLocks();
@@ -468,43 +320,77 @@ class OrderManager {
     }
     _clearWorkingGridRef() {
         this._currentWorkingGrid = null;
-        this._state.clearWorkingGrid();
-        this._state.setRebalanceState(REBALANCE_STATES.NORMAL);
+        this._rebalanceState = REBALANCE_STATES.NORMAL;
     }
     _setRebalanceState(state) {
-        this._state.setRebalanceState(state);
+        this._rebalanceState = state;
+        this.logger?.log(`[COW] Rebalance state: ${state}`, 'debug');
     }
     /**
      * @returns {boolean}
      */
     isRebalancing() {
-        return this._state.isRebalancing();
+        return this._rebalanceState === REBALANCE_STATES.REBALANCING;
     }
     /**
      * @returns {boolean}
      */
     isBroadcasting() {
-        return this._state.isBroadcasting();
+        return this._rebalanceState === REBALANCE_STATES.BROADCASTING;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isBootstrapping() {
+        return this._bootstrapping;
     }
     /**
+     * Whether a broadcast is currently active (no side-effects).
+     * @returns {boolean}
+     */
+    isBroadcastingActive() {
+        return this._broadcastingFlag;
+    }
+    /**
+     * Auto-clears a stale broadcast flag after 120s so a hung
+     * broadcast cannot permanently block rebalancing.
+     * Separated from isBroadcastingActive() so the side-effect only
+     * runs from one well-defined location (maintenance logic) instead
+     * of from every read call-site.
+     * @returns {void}
+     */
+    _clearStaleBroadcastFlag() {
+        if (this._broadcastingFlag && this._broadcastingStartedAt > 0) {
+            const elapsed = Date.now() - this._broadcastingStartedAt;
+            if (elapsed > 120000) {
+                this.logger?.log?.('[BROADCAST] Auto-clearing stale broadcast flag after 120s', 'warn');
+                this._broadcastingFlag = false;
+                this._broadcastingStartedAt = 0;
+            }
+        }
+    }
+    /**
+     * Whether the manager is in the middle of a rebalance plan or broadcast.
      * @returns {boolean}
      */
     isPlanningActive() {
-        return this.isRebalancing() || this.isBroadcasting();
+        return this.isRebalancing() || this.isBroadcastingActive();
     }
     /**
      * @returns {void}
      */
     startBootstrap() {
-        this._state.startBootstrap();
+        this._bootstrapping = true;
+        this.logger?.log('[BOOTSTRAP] Started', 'debug');
     }
     /**
      * @returns {import('./types').BootstrapResult}
      */
     finishBootstrap() {
         const result = { hadDrift: false, driftInfo: null };
-        if (this._state.isBootstrapping()) {
-            this._state.finishBootstrap();
+        if (this._bootstrapping) {
+            this._bootstrapping = false;
+            this.logger?.log('[BOOTSTRAP] Finished', 'debug');
             // Validate fund state at bootstrap completion - if drift exists here,
             // it's not transient (grid is now stable) and indicates a potential bug
             const driftCheck = this.checkFundDriftAfterFills();
@@ -522,13 +408,16 @@ class OrderManager {
      * @returns {void}
      */
     startBroadcasting() {
-        this._state.startBroadcasting();
+        this._broadcastingFlag = true;
+        this._broadcastingStartedAt = Date.now();
+        this.logger?.log?.('[BROADCAST] Flag set — fill processing will be deferred until stopBroadcasting()', 'debug');
     }
     /**
      * @returns {void}
      */
     stopBroadcasting() {
-        this._state.stopBroadcasting();
+        this._broadcastingFlag = false;
+        this._broadcastingStartedAt = 0;
     }
     /**
      * @returns {void}
@@ -613,7 +502,7 @@ class OrderManager {
         });
     }
     async _setAccountTotals(totals) {
-        this.accountTotals = { ...(this.accountTotals || {}), ...totals };
+        this.accountTotals = { ...(this.accountTotals || {}), ...totals, _lastFetchedAt: Date.now() };
         if (!this.funds)
             this.resetFunds();
         await this._recalculateFunds();
@@ -678,31 +567,96 @@ class OrderManager {
         await this.accountant.recalculateFunds();
     }
     /**
+     * Suppress fund recalculation during batch mutations.
+     *
+     * Use when multiple _applyOrderUpdate calls would each trigger redundant
+     * recalculateFunds (e.g. grid load, grid init, fill batch). Must be paired
+     * with resumeFundRecalc() in a try/finally block.
+     *
+     * Supports nesting via depth counter — only the outermost resume triggers
+     * the single consolidated recalculation.
+     *
+     * For bulk mutation sites that also need to suppress debug RECALC logging
+     * during the loop, pair this with pauseRecalcLogging()/resumeRecalcLogging().
+     *
+     * Use independently of pauseRecalcLogging when you need recalc to still run
+     * per-operation but want to batch the trigger (e.g. _updateOrdersForSide
+     * needs per-call chain-free tracking but suppresses log spam).
+     *
      * @returns {void}
      */
     pauseFundRecalc() {
         this._pauseFundRecalc++;
+        // Safety watchdog: if pauseFundRecalc is not resumed within the timeout,
+        // force-reset the counter to prevent permanent suppression from a missed
+        // finally block. Only set when depth goes from 0 → 1 so only the outermost
+        // pause has a watchdog.
+        if (this._pauseFundRecalc === 1) {
+            if (this._pauseFundRecalcWatchdog) {
+                clearTimeout(this._pauseFundRecalcWatchdog);
+            }
+            this._pauseFundRecalcWatchdog = setTimeout(() => {
+                if (this._pauseFundRecalc > 0) {
+                    this.logger?.log?.(`[MANAGER] pauseFundRecalc safety watchdog: resetting depth from ${this._pauseFundRecalc} to 0`, 'warn');
+                    this._pauseFundRecalc = 0;
+                    this._pauseFundRecalcWatchdog = null;
+                    this._recalculateFunds().catch((err) => {
+                        this.logger?.log?.(`[MANAGER] Watchdog recalc failed: ${err.message}`, 'error');
+                    });
+                }
+            }, TIMING.SAFETY_PAUSE_TIMEOUT_MS);
+        }
     }
     /**
+     * Resume fund recalculation and trigger one consolidated recalculateFunds()
+     * when the outermost resume completes.
      * @returns {Promise<void>}
      */
     async resumeFundRecalc() {
         this._pauseFundRecalc = Math.max(0, this._pauseFundRecalc - 1);
         if (this._pauseFundRecalc === 0) {
+            if (this._pauseFundRecalcWatchdog) {
+                clearTimeout(this._pauseFundRecalcWatchdog);
+                this._pauseFundRecalcWatchdog = null;
+            }
             await this.recalculateFunds();
         }
     }
     /**
+     * Suppress only the debug-level [RECALC] log lines inside recalculateFunds().
+     *
+     * Lighter than pauseFundRecalc — recalculation still runs, only log output
+     * is suppressed. Use when individual _updateOrder calls must update chain-free
+     * balances but the iterative debug logging would flood output
+     * (e.g. _updateOrdersForSide grid resize loop).
+     *
+     * When paired with pauseFundRecalc/resumeFundRecalc (grid load/init),
+     * both calcs and logging are suppressed during the batch. When used alone
+     * (_updateOrdersForSide), recalc runs per-call but logs are suppressed.
+     *
      * @returns {void}
      */
     pauseRecalcLogging() {
         this._pauseRecalcLogging = true;
+        if (this._pauseRecalcLoggingWatchdog) {
+            clearTimeout(this._pauseRecalcLoggingWatchdog);
+        }
+        this._pauseRecalcLoggingWatchdog = setTimeout(() => {
+            this.logger?.log?.(`[MANAGER] pauseRecalcLogging safety watchdog: forcing resume after ${TIMING.SAFETY_PAUSE_TIMEOUT_MS}ms`, 'warn');
+            this._pauseRecalcLogging = false;
+            this._pauseRecalcLoggingWatchdog = null;
+        }, TIMING.SAFETY_PAUSE_TIMEOUT_MS);
     }
     /**
+     * Resume recalc debug logging.
      * @returns {void}
      */
     resumeRecalcLogging() {
         this._pauseRecalcLogging = false;
+        if (this._pauseRecalcLoggingWatchdog) {
+            clearTimeout(this._pauseRecalcLoggingWatchdog);
+            this._pauseRecalcLoggingWatchdog = null;
+        }
     }
     /**
      * @param {Array<import('./types').Order>} orders
@@ -817,11 +771,12 @@ class OrderManager {
             const fatalError = validation.errors.find(e => e.isFatal || e.code === 'ILLEGAL_SPREAD_STATE');
             if (fatalError) {
                 this.logger.log(fatalError.message, 'error');
-                this._state.setIllegalStateSignal({
+                this._illegalStateSignal = {
                     id: order.id,
                     context,
-                    message: fatalError.message
-                });
+                    message: fatalError.message,
+                    at: Date.now()
+                };
                 if (this._throwOnIllegalState) {
                     const err = new Error(fatalError.message);
                     err.code = fatalError.code;
@@ -860,7 +815,7 @@ class OrderManager {
         if (this._pauseFundRecalc === 0) {
             await this.recalculateFunds();
         }
-        this._markGridDirty(context, id);
+        this._markGridDirty();
         return true;
     }
     _syncWorkingGridFromMasterMutation(orderId, context) {
@@ -868,7 +823,7 @@ class OrderManager {
             return;
         }
         try {
-            this._currentWorkingGrid.markStale(`master mutation during ${this._rebalanceState.toLowerCase()} (${context})`);
+            this._currentWorkingGrid.markStale(`master mutation during ${(this._rebalanceState || '').toLowerCase()} (${context})`);
             this._currentWorkingGrid.syncFromMaster(this.orders, orderId, this._gridVersion);
         }
         catch (syncErr) {
@@ -898,11 +853,9 @@ class OrderManager {
      * other paths (e.g. raw `this.orders.set(...)` from a refactor) should
      * invoke this explicitly so the dirty-flag invariant still holds.
      *
-     * @param {string} [reason='unknown'] - Context label for diagnostics
-     * @param {string} [orderId=null] - Order that triggered the mutation
      * @returns {void}
      */
-    _markGridDirty(reason = 'unknown', orderId = null) {
+    _markGridDirty() {
         if (this._gridDirtyAt == null) {
             this._gridDirtyAt = Date.now();
         }
@@ -974,7 +927,6 @@ class OrderManager {
             const rebalanceResult = await this.performSafeRebalance(orders, excl);
             return rebalanceResult;
         }
-        const { WorkingGrid } = require('./working_grid');
         const workingGrid = new WorkingGrid(this.orders, { baseVersion: this._gridVersion });
         return {
             actions: [],
@@ -1142,13 +1094,17 @@ class OrderManager {
      * @returns {Object|null} The consumed signal or null
      */
     consumeIllegalStateSignal() {
-        return this._state.consumeIllegalStateSignal();
+        const signal = this._illegalStateSignal;
+        this._illegalStateSignal = null;
+        return signal;
     }
     /**
      * @returns {Object|null} The consumed signal or null
      */
     consumeAccountingFailureSignal() {
-        return this._state.consumeAccountingFailureSignal();
+        const signal = this._accountingFailureSignal;
+        this._accountingFailureSignal = null;
+        return signal;
     }
     /**
      * @param {Object} BitShares - BitShares API instance
@@ -1156,20 +1112,20 @@ class OrderManager {
      * @returns {Promise<Object>}
      */
     async checkSpreadCondition(BitShares, batchCb) {
-        return await Grid.checkSpreadCondition(this, BitShares, batchCb);
+        return await checkSpreadCondition(this, BitShares, batchCb);
     }
     /**
      * @param {Function} batchCb - Batch callback
      * @returns {Promise<Object>}
      */
     async checkGridHealth(batchCb) {
-        return await Grid.checkGridHealth(this, batchCb);
+        return await checkGridHealth(this, batchCb);
     }
     /**
      * @returns {Object} Current spread calculation
      */
     calculateCurrentSpread() {
-        return Grid.calculateCurrentSpread(this);
+        return calculateCurrentSpread(this);
     }
     /**
      * @returns {import('./types').DriftCheckResult}
@@ -1214,16 +1170,14 @@ class OrderManager {
         if (recoveryInFlight) {
             reasons.push('recovery sync in-flight');
         }
-        if (broadcasting || this._state.isBroadcastingActive()) {
+        if (broadcasting || this.isBroadcastingActive()) {
             reasons.push('broadcasting active orders');
         }
         if (reasons.length > 0 && !this._pipelineBlockedSince) {
             this._pipelineBlockedSince = Date.now();
-            this._state.markPipelineBlocked();
         }
         else if (reasons.length === 0) {
             this._pipelineBlockedSince = null;
-            this._state.markPipelineClear();
         }
         return {
             isEmpty: reasons.length === 0,
@@ -1241,7 +1195,6 @@ class OrderManager {
             return false;
         this.ordersNeedingPriceCorrection = [];
         this._pipelineBlockedSince = null;
-        this._state.markPipelineClear();
         return true;
     }
     /**
@@ -1435,6 +1388,13 @@ class OrderManager {
         }
         try {
             if (!skipRecalc) {
+                // If the last accounting failure was due to stale accountTotals,
+                // the commit proceeded without locking funds. Refresh accountTotals
+                // before recalculateFunds() to avoid a false-positive drift recovery.
+                if (this._lastAccountingFailure?.reason === 'stale') {
+                    this.logger.log('[COW] Stale accountTotals during commit; refreshing before recalculateFunds to avoid false recovery', 'warn');
+                    await this.fetchAccountTotals(this.accountId);
+                }
                 await this.recalculateFunds();
             }
             const duration = Date.now() - startTime;
@@ -1445,8 +1405,10 @@ class OrderManager {
         }
         catch (recalcErr) {
             this.logger.log(`[COW] Fund recalculation failed post-commit: ${recalcErr.message}`, 'error');
-            this._recoveryState = this._recoveryState || {};
-            this._recoveryState.lastFailureAt = Date.now();
+            if (!this._recoveryStateValue) {
+                this._recoveryStateValue = { phase: 'idle', attemptCount: 0, lastAttemptAt: 0, inFlight: false, lastFailureAt: 0 };
+            }
+            this._recoveryStateValue.lastFailureAt = Date.now();
         }
         finally {
             this._clearWorkingGridRef();
@@ -1461,7 +1423,7 @@ class OrderManager {
     validateGridStateForPersistence(options = {}) {
         const result = validateGridForPersistence(this.orders, this.accountTotals);
         const allowBootstrapTransient = options.allowBootstrapTransient !== false;
-        if (!result.isValid && allowBootstrapTransient && this._state.isBootstrapping()) {
+        if (!result.isValid && allowBootstrapTransient && this._bootstrapping) {
             this.logger.log(`[BOOTSTRAP] Transient state (expected): ${result.reason}`, 'debug');
             return { isValid: true, reason: null };
         }
@@ -1521,7 +1483,14 @@ class OrderManager {
     getMetrics() {
         return {
             ...this._metrics,
-            state: this._state.getState(),
+            state: {
+                rebalance: { state: this._rebalanceState, currentWorkingGrid: null },
+                recovery: { ...this._recoveryStateValue },
+                gridRegen: { ...this._gridRegenStateValue },
+                bootstrap: { isBootstrapping: this._bootstrapping },
+                broadcast: { isBroadcasting: this._broadcastingFlag, startedAt: this._broadcastingStartedAt },
+                pipeline: { blockedSince: this._pipelineBlockedSince, recoveryAttempted: this._recoveryAttempted }
+            },
             currentTime: Date.now()
         };
     }
@@ -1550,52 +1519,53 @@ class OrderManager {
             comparePrecisions
         });
     }
-    get _rebalanceState() {
-        return this._state.getRebalanceState();
-    }
-    set _rebalanceState(value) {
-        this._state.setRebalanceState(value);
-    }
     get _lastIllegalState() {
-        return this._state.signals?.lastIllegalState || null;
+        return this._illegalStateSignal || null;
     }
     set _lastIllegalState(value) {
         if (value) {
-            this._state.setIllegalStateSignal(value);
+            this._illegalStateSignal = {
+                ...value,
+                at: Date.now()
+            };
         }
     }
     get _lastAccountingFailure() {
-        return this._state.signals?.lastAccountingFailure || null;
+        return this._accountingFailureSignal || null;
     }
     set _lastAccountingFailure(value) {
         if (value) {
-            this._state.setAccountingFailureSignal(value);
+            this._accountingFailureSignal = {
+                ...value,
+                at: Date.now()
+            };
         }
     }
     get _recoveryState() {
-        return this._state.recovery;
+        return this._recoveryStateValue;
     }
     set _recoveryState(value) {
         const fallback = {
+            phase: 'idle',
             attemptCount: 0,
             lastAttemptAt: 0,
             inFlight: false,
             lastFailureAt: 0,
             structuralResyncRequested: false
         };
-        this._state.recovery = {
+        this._recoveryStateValue = {
             ...fallback,
             ...(value && typeof value === 'object' ? value : {})
         };
     }
     get _gridRegenState() {
-        return this._state.gridRegen;
+        return this._gridRegenStateValue;
     }
     set _gridRegenState(value) {
         if (!value || typeof value !== 'object')
             return;
         const defaultSide = { armed: true, lastTriggeredAt: 0 };
-        this._state.gridRegen = {
+        this._gridRegenStateValue = {
             buy: { ...defaultSide, ...(value.buy || {}) },
             sell: { ...defaultSide, ...(value.sell || {}) }
         };