dexbot 1.4.24 → 1.5.0

package/dist/modules/order/grid.js

@@ -110,7 +110,7 @@ function _snapshotFundState(manager) {
         sellLocked: Number(manager.accountTotals?.sellLocked || 0),
     };
 }
-import { floatToBlockchainInt, getPrecisionByOrderType, getPrecisionsForManager, calculateOrderCreationFees, calculateOrderSizes, calculateRotationOrderSizes, calculateAvailableFundsValue, calculateGridSideDivergenceMetric, getPrecisionSlack, getMinOrderSize, getSingleDustThreshold, getGridBestPrices, calculateSpreadFromOrders, allocateFundsByWeights, calculateGapSlots as _mathGapSlots, findPriceCollision, getBtsSide, getSellStartIdx, resolveGapBand, countGapBandSpread, validatePersistedBoundary, adjustBudgetForBtsFees, clamp, } from './utils/math.js';
+import { floatToBlockchainInt, getPrecisionByOrderType, getPrecisionsForManager, calculateOrderCreationFees, calculateOrderSizes, calculateRotationOrderSizes, calculateAvailableFundsValue, calculateGridSideDivergenceMetric, getPrecisionSlack, getMinOrderSize, getSingleDustThreshold, getGridBestPrices, calculateSpreadFromOrders, allocateFundsByWeights, calculateGapSlots as _mathGapSlots, priceSlotEqual, getBtsSide, getSellStartIdx, resolveGapBand, countGapBandSpread, validatePersistedBoundary, adjustBudgetForBtsFees, clamp, buildGenesisFromPriceLevels, assertSlotPriceInvariant, hashPriceLevels, } from './utils/math.js';
 import { filterOrdersByType, checkSizesBeforeMinimum, checkSizeThreshold, resolveConfiguredPriceBound, shouldFlagOutOfSpread, isOrderHealthy, isPhantomOrder, isSlotAvailable, isOrderOnChain, isOrderPlaced, hasOnChainId, isEmptyGridSlot, parseSlotIndex, calculateIdealBoundary, assignGridRoles, resolveOnChainRetypeType } from './utils/order.js';
 import { loadAmaCenterPrice, loadAmaCenterSnapshot, withBlockchainRetry } from './utils/system.js';
 import * as MathUtils from './utils/math.js';
@@ -361,6 +361,21 @@ export function createOrderGrid(config) {
     }
     // Sort all levels from lowest to highest (Master Rail order)
     priceLevels.sort((a, b) => a - b);
+    // Dedupe geometric levels that collide at float precision (tiny increments);
+    // keeps slot-N ↔ index mapping stable vs migration dedupe (grid.ts:652)
+    {
+        const seen = new Set();
+        const deduped = [];
+        for (const p of priceLevels) {
+            const key = Number(p).toFixed(12);
+            if (!seen.has(key)) {
+                seen.add(key);
+                deduped.push(p);
+            }
+        }
+        priceLevels.length = 0;
+        priceLevels.push(...deduped);
+    }
     if (priceLevels.length === 0) {
         throw new Error(`Grid generation produced no price levels for startPrice=${startPrice}, ` +
             `bounds=[${minPrice}, ${maxPrice}], incrementPercent=${incrementPercent}. ` +
@@ -402,7 +417,8 @@ export function createOrderGrid(config) {
         buy: Math.floor(gapSlots / 2),
         sell: gapSlots - Math.floor(gapSlots / 2)
     };
-    return { orders: updatedOrders, boundaryIdx, initialSpreadCount, gapSlots };
+    const genesis = buildGenesisFromPriceLevels(startPrice, incrementPercent, gapSlots, priceLevels);
+    return { orders: updatedOrders, boundaryIdx, initialSpreadCount, gapSlots, priceLevels, genesis };
 }
 /**
  * Internal utility to clear all order-related manager caches.
@@ -442,10 +458,165 @@ function _clearOrderCachesLogic(manager) {
  * @param {number|null} [boundaryIdx=null] - The master boundary index.
  * @returns {Promise<void>}
  */
-export async function loadGrid(manager, grid, boundaryIdx = null) {
+export async function loadGrid(manager, grid, boundaryIdx = null, genesisInput = null) {
     if (!Array.isArray(grid))
         return;
     return await manager._gridLock.acquire(async () => {
+        // Genesis determinism: if snapshot provided genesis, validate slots
+        // against it; if legacy snapshot has no genesis, migrate by building
+        // genesis from live config and re-sorting to canonical price order.
+        let genesis = genesisInput || manager._genesis || null;
+        // Validate genesis hash if present (wired for stale-pair detection #3)
+        // On mismatch we only warn — genesis is still used for validation (log mode) / virtualization (enforce mode);
+        // a stale persisted snapshot vs fresh manager._genesis scenario is covered by the log/enforce gate above
+        if (genesis && Array.isArray(genesis.priceLevels) && typeof genesis.priceLevelsHash === 'string') {
+            try {
+                const recomputed = hashPriceLevels(genesis.priceLevels);
+                if (recomputed !== genesis.priceLevelsHash) {
+                    manager.logger?.log?.(`[GENESIS] hash mismatch persisted=${genesis.priceLevelsHash} recomputed=${recomputed} — persisted genesis hash does not match recomputed hash; continuing with persisted genesis`, 'warn');
+                }
+            }
+            catch { }
+        }
+        const validationMode = (() => {
+            try {
+                const raw = (typeof process !== 'undefined' && process.env?.GRID_PRICE_SLOT_VALIDATION) || 'log';
+                return String(raw).toLowerCase() === 'enforce' ? 'enforce' : 'log';
+            }
+            catch {
+                return 'log';
+            }
+        })();
+        if (genesis && Array.isArray(genesis.priceLevels)) {
+            // Validate each slot's price against genesis; virtualize only in enforce mode (plan §13)
+            const newGrid = [];
+            for (const slot of grid) {
+                try {
+                    assertSlotPriceInvariant(slot, genesis);
+                    newGrid.push(slot);
+                }
+                catch (e) {
+                    const msg = `[GENESIS] Slot ${slot?.id} price mismatch vs genesis → ${validationMode === 'enforce' ? 'virtualize' : 'log-only'}: ${getErrorMessage(e)}`;
+                    manager.logger?.log?.(msg, 'warn');
+                    if (validationMode === 'enforce') {
+                        newGrid.push({ ...slot, state: ORDER_STATES.VIRTUAL, size: 0, orderId: '' });
+                    }
+                    else {
+                        newGrid.push(slot);
+                    }
+                }
+            }
+            grid = newGrid;
+            // Ensure canonical price-sorted order matches slot-N order
+            // Quirk fix: previously `isPriceSorted && parsed!==i` gated re-sort, so a shuffled
+            // array with misaligned ids but unsorted prices incorrectly skipped re-sort.
+            // Now: re-sort if any parseable id != index (price order is authoritative via slot-N).
+            const idxOrderMatchesPriceOrder = (() => {
+                for (let i = 0; i < grid.length; i++) {
+                    const parsed = parseSlotIndex(grid[i]?.id);
+                    if (parsed === null)
+                        return false;
+                    if (parsed !== i)
+                        return false;
+                }
+                return true;
+            })();
+            if (!idxOrderMatchesPriceOrder) {
+                const sorted = [...grid].sort((a, b) => {
+                    const pa = parseSlotIndex(a?.id);
+                    const pb = parseSlotIndex(b?.id);
+                    if (pa !== null && pb !== null)
+                        return pa - pb;
+                    return Number(a.price) - Number(b.price);
+                });
+                // Detect if re-sort actually changes order
+                let changed = false;
+                for (let i = 0; i < grid.length; i++)
+                    if (grid[i].id !== sorted[i].id) {
+                        changed = true;
+                        break;
+                    }
+                if (changed) {
+                    manager.logger?.log?.(`[GENESIS] Re-sorted persisted grid to canonical slot-N order`, 'warn');
+                    grid = sorted;
+                }
+            }
+            // Guard: explicit persistedGenesis should not blindly overwrite a fresher in-memory _genesis
+            // from an in-process rebuild (currently unreachable but latent hazard if flows change)
+            if (manager._genesis && manager._genesis.priceLevelsHash && genesis.priceLevelsHash && manager._genesis.priceLevelsHash !== genesis.priceLevelsHash) {
+                manager.logger?.log?.(`[GENESIS] persisted genesis hash ${genesis.priceLevelsHash} differs from in-memory ${manager._genesis.priceLevelsHash} — keeping in-memory genesis`, 'warn');
+            }
+            else {
+                manager._genesis = genesis;
+            }
+        }
+        else if (grid.length > 0) {
+            // Migration: build genesis from live geometric rail (plan §4.1/§10)
+            // Do NOT derive priceLevels from persisted slot prices — a truncated
+            // persisted array would permanently shrink genesis. Recompute from
+            // startPrice/min/max/increment per createOrderGrid §2.1.
+            const startPrice = Number(manager.config?.startPrice);
+            const minPrice = Number(manager.config?.minPrice);
+            const maxPrice = Number(manager.config?.maxPrice);
+            const incPct = Number(manager.config?.incrementPercent);
+            if (Number.isFinite(startPrice) && Number.isFinite(minPrice) && Number.isFinite(maxPrice) && Number.isFinite(incPct)) {
+                try {
+                    const stepUp = 1 + (incPct / 100);
+                    const stepDown = 1 - (incPct / 100);
+                    const priceLevels = [];
+                    let upPrice = startPrice * Math.sqrt(stepUp);
+                    while (upPrice <= maxPrice) {
+                        priceLevels.push(upPrice);
+                        upPrice *= stepUp;
+                    }
+                    let downPrice = startPrice * Math.sqrt(stepDown);
+                    while (downPrice >= minPrice) {
+                        priceLevels.push(downPrice);
+                        downPrice *= stepDown;
+                    }
+                    priceLevels.sort((a, b) => a - b);
+                    // Dedupe (floatToBlockchainInt equality via fixed 12-decimals)
+                    const uniq = [];
+                    const seen = new Set();
+                    for (const p of priceLevels) {
+                        const key = Number(p).toFixed(12);
+                        if (!seen.has(key)) {
+                            seen.add(key);
+                            uniq.push(p);
+                        }
+                    }
+                    const gapSlotsForGenesis = calculateGapSlots(incPct, manager.config?.targetSpreadPercent, manager.config?.gridLimits);
+                    const built = buildGenesisFromPriceLevels(startPrice, incPct, gapSlotsForGenesis, uniq);
+                    // Cross-check: if user edited startPrice/min/max/increment across restarts on a legacy snapshot,
+                    // the new-config rail will mismatch most persisted slot prices → noisy log / mass-virtualize
+                    // in enforce mode and the mismatched genesis would be persisted. Count failures first.
+                    let mismatchCount = 0;
+                    for (const slot of grid) {
+                        try {
+                            assertSlotPriceInvariant(slot, built);
+                        }
+                        catch {
+                            mismatchCount++;
+                        }
+                    }
+                    const mismatchRatio = grid.length > 0 ? mismatchCount / grid.length : 0;
+                    if (mismatchRatio > 0.5) {
+                        manager.logger?.log?.(`[GENESIS] Migration: ${mismatchCount}/${grid.length} slots mismatch new-config rail (ratio ${mismatchRatio.toFixed(2)}) — config may have changed since snapshot; NOT adopting migration genesis (validation would ${validationMode === 'enforce' ? 'mass-virtualize' : 'be noisy'}). Persisted grid will be kept as-is until a clean rebuild`, 'warn');
+                    }
+                    else {
+                        if (mismatchCount > 0) {
+                            manager.logger?.log?.(`[GENESIS] Migration: ${mismatchCount}/${grid.length} slots mismatch new-config rail — will be logged${validationMode === 'enforce' ? '/virtualized' : ''} on next load`, 'warn');
+                        }
+                        manager._genesis = built;
+                        genesis = built;
+                        manager.logger?.log?.(`[GENESIS] Migrated legacy grid: built genesis with ${uniq.length} levels (hash ${built.priceLevelsHash})`, 'info');
+                    }
+                }
+                catch (e) {
+                    manager.logger?.log?.(`[GENESIS] Migration failed: ${getErrorMessage(e)}`, 'warn');
+                }
+            }
+        }
         try {
             await withBlockchainRetry(() => manager._initializeAssets(), 'initializeAssets', { logger: manager.logger });
         }
@@ -517,11 +688,10 @@ export async function loadGrid(manager, grid, boundaryIdx = null) {
             manager.logger?.log?.(`Restored boundary index: ${restoredBoundary}`, 'info');
         }
         // Reassign slot types based on current boundary.
-        // Every slot's type must match its position in the price-sorted rail
-        // relative to the boundary + gapSlots.  Stale persisted types cause
-        // split spread zones and ILLEGAL_SPREAD_STATE errors.  The subsequent
-        // sync will detect type mismatches with chain orders (e.g. a BUY-zone
-        // slot holding a SELL chain order) and auto-cancel + recreate them.
+        // Every slot's type must match its price-slot index (parseSlotIndex)
+        // relative to the boundary + gapSlots, not array position.  After
+        // genesis freeze the persisted array may have been re-sorted, but
+        // slot-N is the canonical identity.
         if (restoredBoundary !== null) {
             const gapSlots = loadGapSlots;
             manager._gapSlots = gapSlots;
@@ -529,9 +699,22 @@ export async function loadGrid(manager, grid, boundaryIdx = null) {
             const sellStartIdx = getSellStartIdx(restoredBoundary, gapSlots);
             let reassignCount = 0;
             grid = grid.map((slot, i) => {
-                const correctType = (i <= buyEndIdx)
+                const parsedIdx = parseSlotIndex(slot?.id);
+                // Plan §4.3: unparseable ids are invalid per decision #3 — enforce virtualizes,
+                // log mode keeps index fallback (legacy grids with ids like 'b1'/'planned' need type via position)
+                if (parsedIdx === null) {
+                    if (validationMode === 'enforce') {
+                        manager.logger?.log?.(`[GENESIS] unparseable slot id ${slot?.id} at index ${i} → virtualize (SPREAD)`, 'warn');
+                        reassignCount++;
+                        return { ...slot, state: ORDER_STATES.VIRTUAL, size: 0, orderId: '', type: ORDER_TYPES.SPREAD };
+                    }
+                    manager.logger?.log?.(`[GENESIS] unparseable slot id ${slot?.id} at index ${i} → log-only, using index fallback ${i} for type`, 'warn');
+                    // fall through with idx = i so legacy sized VIRTUAL rail slots (e.g. 'planned') keep their size/type
+                }
+                const idx = parsedIdx !== null ? parsedIdx : i;
+                const correctType = (idx <= buyEndIdx)
                     ? ORDER_TYPES.BUY
-                    : (i >= sellStartIdx)
+                    : (idx >= sellStartIdx)
                         ? ORDER_TYPES.SELL
                         : ORDER_TYPES.SPREAD;
                 // DEFENSIVE BACKSTOP: a VIRTUAL slot with no orderId and
@@ -570,7 +753,7 @@ export async function loadGrid(manager, grid, boundaryIdx = null) {
                     // comparison false and wrongly resolves below-center
                     // slots to SELL.
                     if (newType === ORDER_TYPES.SPREAD && isOrderOnChain(slot)) {
-                        newType = resolveOnChainRetypeType(slot, i, buyEndIdx, ORDER_TYPES);
+                        newType = resolveOnChainRetypeType(slot, idx, buyEndIdx, ORDER_TYPES);
                     }
                     reassignCount++;
                     return { ...slot, type: newType };
@@ -605,6 +788,7 @@ export async function loadGrid(manager, grid, boundaryIdx = null) {
         }
         manager.pauseRecalcLogging();
         manager.pauseFundRecalc();
+        let sanitizedSizedVirtual = [];
         try {
             // RC-2: Use applyOrderUpdate (PRIVATE/UNLOCKED)
             for (const order of grid) {
@@ -613,8 +797,31 @@ export async function loadGrid(manager, grid, boundaryIdx = null) {
                     manager.logger?.log?.(`Sanitizing corrupted order ${order.id}: ACTIVE/PARTIAL without orderId -> VIRTUAL`, 'warn');
                     currentOrder = { ...order, state: ORDER_STATES.VIRTUAL };
                 }
+                // Sized VIRTUAL slot with no on-chain id AND durable orphan
+                // evidence (createUncertain: set only where a CREATE
+                // broadcast result was lost — COW uncertain-restore and
+                // startup uncertain-create handlers). Unflagged sized
+                // VIRTUAL slots are the NORMAL planned-but-unplaced grid
+                // state (budgeted sizes cover the whole rail and persist
+                // by design), so their sizes must survive reload; only
+                // flagged orphans get zeroed so re-derivation or spread
+                // correction re-places them next cycle. One aggregate
+                // warn instead of per-slot spam.
+                if (currentOrder.state === ORDER_STATES.VIRTUAL
+                    && !hasOnChainId(currentOrder)
+                    && Number(currentOrder.size || 0) > 0
+                    && currentOrder.createUncertain === true) {
+                    sanitizedSizedVirtual.push(currentOrder.id);
+                    currentOrder = { ...currentOrder, size: 0, createUncertain: false };
+                }
                 await manager._applyOrderUpdate(currentOrder, 'grid-load', { skipAccounting: true });
             }
+            if (sanitizedSizedVirtual.length > 0) {
+                const preview = sanitizedSizedVirtual.slice(0, 10).join(', ');
+                manager.logger?.log?.(`Sanitized ${sanitizedSizedVirtual.length} creation-uncertain sized slot(s) on load ` +
+                    `(VIRTUAL with size but no orderId -> size dropped): ${preview}` +
+                    (sanitizedSizedVirtual.length > 10 ? ' …' : ''), 'warn');
+            }
             // Gap-band occupancy for the spread metric.  Empty slots are
             // normalized to SPREAD (side-neutral) above, so a raw
             // `type === SPREAD` count would include every empty slot on both
@@ -901,13 +1108,15 @@ export async function initializeGrid(manager) {
         // Continuing would create grid with 0 fund allocation, rendering it non-functional
         throw new Error(`Cannot initialize grid without account totals: ${getErrorMessage(e)}`);
     }
-    const { orders, boundaryIdx, initialSpreadCount, gapSlots } = createOrderGrid({
+    const { orders, boundaryIdx, initialSpreadCount, gapSlots, genesis } = createOrderGrid({
         ...manager.config,
         startPrice: gridStartPrice,
         minPrice: resolvedMinP,
         maxPrice: resolvedMaxP,
     });
     manager._gapSlots = gapSlots;
+    if (genesis)
+        manager._genesis = genesis;
     // RC-8: Update boundary with notification to dependent systems
     // Persist master boundary for StrategyEngine
     if (manager.boundaryIdx !== boundaryIdx) {
@@ -1063,6 +1272,18 @@ export async function recalculateGrid(manager, opts) {
                 manager.logger?.log?.(`Error during startup order reconciliation: ${getErrorMessage(err)}`, 'error');
                 throw new Error(`Grid recalculation failed during order reconciliation: ${getErrorMessage(err)}`);
             }
+            // Fix #5 (Mode D): the P3 boundary-evidence gate above may have
+            // re-derived the boundary via manager._restoreBoundary. recalculateGrid's
+            // earlier persistGrid (before initializeGrid) captured the stale value, so
+            // without this flush the corrected boundary never reaches disk and the
+            // [BOUNDARY-EVIDENCE] contradiction re-fires on every resync. Persist the
+            // reconciled grid (corrected boundary included) now.
+            try {
+                await manager.persistGrid(undefined);
+            }
+            catch (persistErr) {
+                manager.logger?.log?.(`Error persisting boundary-corrected grid after reconcile: ${getErrorMessage(persistErr)}`, 'warn');
+            }
             if (_resyncAborted)
                 return;
             manager.logger?.log?.('Full resync complete.', 'info');
@@ -1674,6 +1895,15 @@ export async function checkSpreadCondition(manager, _BitShares, updateOrdersOnCh
         // Limit spread = nominal + half increment tolerance (0.5 steps).
         const limitSpread = nominalSpread + (manager.config.incrementPercent * toleranceSteps);
         manager.logger?.log?.(`Spread too wide (${Format.formatPercent(currentSpread)} > ${Format.formatPercent(limitSpread)}), correcting with ${manager.outOfSpread} extra slot(s)...`, 'warn');
+        // Refresh funds before the side decision below: the top-of-tick recalc may
+        // predate fills processed since, and determineOrderSideByFunds reads
+        // manager.funds/accountTotals directly (not via _getSizingContext). No-op
+        // while a fill cycle holds the recalc pause; funds that move after this
+        // point are covered by the TOCTOU re-plan before broadcast.
+        try {
+            await manager.recalculateFunds();
+        }
+        catch { /* best-effort */ }
         const decision = determineOrderSideByFunds(manager, lastPrice);
         if (!decision.side)
             return false;
@@ -1838,13 +2068,25 @@ export async function checkWindowDust(manager) {
     const topSellOrder = allOrders
         .filter((o) => o.type === ORDER_TYPES.SELL && isLiveOrder(o))
         .sort((a, b) => a.price - b.price)[0];
-    // Check if an order has a duplicate price level — an active sibling at the
-    // same price within tolerance. If so, cancelling won't create a grid gap.
-    // Only checks ACTIVE siblings. If two PARTIALs share a price with no active
-    // sibling, neither qualifies and the gap is left to the rebalancer.
-    // Uses the LARGER size of the two orders for tolerance calculation to prevent
-    // a tiny dust order from inflating the tolerance window.
-    const hasDuplicatePriceLevel = (order, assets) => findPriceCollision(allOrders, order.id, order.price, order.size, order.type, assets, (o) => o.type === order.type && o.state === ORDER_STATES.ACTIVE && !!o.orderId && o.price != null) != null;
+    // Check if an order has a duplicate slot — an active sibling with same price via integer round-trip.
+    const hasDuplicatePriceLevel = (order, assets) => {
+        const precision = order.type === ORDER_TYPES.SELL ? assets.assetA.precision : assets.assetB.precision;
+        for (const o of allOrders) {
+            if (o.id === order.id)
+                continue;
+            if (o.type !== order.type || o.state !== ORDER_STATES.ACTIVE || !o.orderId || o.price == null)
+                continue;
+            try {
+                if (priceSlotEqual(o.price, order.price, precision))
+                    return true;
+            }
+            catch {
+                if (o.price === order.price)
+                    return true;
+            }
+        }
+        return false;
+    };
     const assets = manager.assets;
     const allPartials = allOrders.filter((o) => isLiveOrder(o) && o.state === ORDER_STATES.PARTIAL);
     const isTopBuy = (o) => topBuyOrder && o.id === topBuyOrder.id;
@@ -1998,15 +2240,26 @@ export function determineOrderSideByFunds(manager, currentMarketPrice) {
     const buyViable = buyAvailable > buyMinUnit;
     const sellViable = sellAvailable > sellMinUnit;
     let side = null;
+    let skipReason = null;
     if (buyViable && sellViable) {
         // Normalize sell (assetA) to assetB units using market price so both sides
         // are comparable. Without this, a raw number comparison (e.g. 2192 BTS vs
         // 0.12 XRP) always picks BUY even when the sell side is larger in value.
+        // When the market price is unavailable (non-finite, e.g. empty book after
+        // a crash wiped one side), raw-unit comparison across assets is meaningless
+        // and can arm the wrong side in exactly the scenario where price may be
+        // missing. Skip the correction and let the next cycle decide with a real
+        // price rather than guess.
         const marketPrice = Number(currentMarketPrice);
-        const sellInBuyUnits = (Number.isFinite(marketPrice) && marketPrice > 0)
-            ? sellAvailable * marketPrice
-            : sellAvailable;
-        side = buyAvailable >= sellInBuyUnits ? ORDER_TYPES.BUY : ORDER_TYPES.SELL;
+        if (!Number.isFinite(marketPrice) || marketPrice <= 0) {
+            skipReason =
+                `market price unavailable (${String(currentMarketPrice)}) with funds on both sides ` +
+                    `(buy=${Format.formatAmount8(buyAvailable)}, sell=${Format.formatAmount8(sellAvailable)})`;
+        }
+        else {
+            const sellInBuyUnits = sellAvailable * marketPrice;
+            side = buyAvailable >= sellInBuyUnits ? ORDER_TYPES.BUY : ORDER_TYPES.SELL;
+        }
     }
     else if (buyViable) {
         side = ORDER_TYPES.BUY;
@@ -2014,6 +2267,10 @@ export function determineOrderSideByFunds(manager, currentMarketPrice) {
     else if (sellViable) {
         side = ORDER_TYPES.SELL;
     }
+    if (skipReason) {
+        manager.logger?.log?.(`Spread correction skipped: ${skipReason}; refusing to compare raw cross-asset units`, 'warn');
+        return { side: null, reason: skipReason };
+    }
     if (!side) {
         const committedBuy = Math.max(0, Number(manager.funds?.committed?.chain?.buy || 0));
         const committedSell = Math.max(0, Number(manager.funds?.committed?.chain?.sell || 0));
@@ -2032,19 +2289,30 @@ export function determineOrderSideByFunds(manager, currentMarketPrice) {
                 side = ORDER_TYPES.SELL;
             }
             else {
-                // Deterministic fallback when both sides hold inventory but market valuation is unavailable.
-                side = ORDER_TYPES.BUY;
+                // Both sides hold committed inventory but market valuation is
+                // unavailable — leave side null (skip) rather than default to
+                // BUY. A deterministic cross-asset guess is exactly the
+                // wrong-side risk above; the next cycle with a real price
+                // decides. Carry the reason so the bottom skip log does not
+                // misreport this branch as "no committed inventory".
+                skipReason =
+                    `market price unavailable (${String(currentMarketPrice)}) with committed inventory on both sides ` +
+                        `(committed buy=${Format.formatAmount8(committedBuy)}, committed sell=${Format.formatAmount8(committedSell)})`;
+            }
+            if (side) {
+                manager.logger?.log?.(`Spread correction using redistribution fallback on ${side} ` +
+                    `(free buy=${Format.formatAmount8(buyAvailable)}, free sell=${Format.formatAmount8(sellAvailable)}, ` +
+                    `price=${hasValidPrice ? Format.formatAmount8(marketPrice) : 'unavailable'})`, 'info');
             }
-            manager.logger?.log?.(`Spread correction using redistribution fallback on ${side} ` +
-                `(free buy=${Format.formatAmount8(buyAvailable)}, free sell=${Format.formatAmount8(sellAvailable)}, ` +
-                `price=${hasValidPrice ? Format.formatAmount8(marketPrice) : 'unavailable'})`, 'info');
         }
     }
     if (!side) {
-        manager.logger?.log?.(`Spread correction skipped: insufficient free funds and no committed inventory to redistribute ` +
-            `(buy=${Format.formatAmount8(buyAvailable)}, sell=${Format.formatAmount8(sellAvailable)})`, 'warn');
+        manager.logger?.log?.(skipReason
+            ? `Spread correction skipped: ${skipReason}`
+            : `Spread correction skipped: insufficient free funds and no committed inventory to redistribute ` +
+                `(buy=${Format.formatAmount8(buyAvailable)}, sell=${Format.formatAmount8(sellAvailable)})`, 'warn');
     }
-    return { side, reason: side ? `Choosing ${side}` : 'Insufficient funds or committed inventory' };
+    return { side, reason: side ? `Choosing ${side}` : (skipReason || 'Insufficient funds or committed inventory') };
 }
 /**
  * Resolve the MIN_SPREAD_ORDERS gap reserve used by boundary promotion.
@@ -2184,9 +2452,10 @@ export async function prepareSpreadCorrectionOrders(manager, preferredSide, outO
         .sort((a, b) => railType === ORDER_TYPES.BUY ? a.price - b.price : b.price - a.price)
         .slice(0, missingSlots);
     // Secondary candidates: orphaned virtual slots that have lost their
-    // order (e.g. stale-cleaned after a race condition during a crash).
-    // These sit inside the active window and are invisible to the
-    // gap-band SPREAD filter above.
+    // order (e.g. stale-cleaned after a race condition during a crash, or a
+    // lowest-sell slot dust-cancelled and then left unplaced after a
+    // boundary shift). These sit inside the active window and are invisible
+    // to the gap-band SPREAD filter above.
     //
     // Empty slots are stored SPREAD (side-neutral) after normalization, so
     // the stored type can be railType OR SPREAD — what matters is that the
@@ -2195,11 +2464,22 @@ export async function prepareSpreadCorrectionOrders(manager, preferredSide, outO
     // whose boundary position has moved into the spread or opposite zone are
     // NOT re-activated on the stale side — doing so would compound inventory
     // at prices where the bot already traded.
+    //
+    // NOTE: we deliberately accept BOTH zero-size and sized virtual slots
+    // here. A sized sell/buy slot that lost its orderId (the classic
+    // boundary-oscillation orphan) has size > 0 but no on-chain order — the
+    // old `size === 0` guard excluded it, so spread correction silently
+    // planned 0 orders and the gap never closed. Dropping the guard is safe:
+    // create targets are rebuilt from `current: 0` + the fresh ideal from
+    // allocateFundsByWeights (grid.ts:2790-2800, 2861-2870), so a sized
+    // orphan's stale stored size never leaks into a placement; getMinOrderSize
+    // is only a collision-tolerance fallback (grid.ts:2712), not the primary
+    // sizer. Orphans are excluded from the sideSlots sizing denominator too,
+    // so this also removes the prior dilution of every other order.
     const orphanedVirtualCandidates = allOrders
         .filter((o) => (o.type === railType || o.type === ORDER_TYPES.SPREAD)
         && o.state === ORDER_STATES.VIRTUAL
         && !o.orderId
-        && Number(o.size || 0) === 0
         && getSlotCorrectType(o) === railType)
         .sort((a, b) => railType === ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price)
         .slice(0, missingSlots);
@@ -2281,10 +2561,22 @@ export async function prepareSpreadCorrectionOrders(manager, preferredSide, outO
         spreadCandidates = spreadCandidates.filter((c) => {
             if (c.price == null)
                 return false;
-            // Resolve candidate size: if zero/missing, use minimum so tolerance
-            // doesn't collapse to zero (calculatePriceTolerance returns null for size <= 0).
-            const cs = (c.size && c.size > 0) ? c.size : getMinOrderSize(railType, manager.assets);
-            return !findPriceCollision(allOrders, c.id, c.price, cs, railType, manager.assets, (o) => isOrderPlaced(o) && o.price != null);
+            const precision = railType === ORDER_TYPES.SELL ? manager.assets.assetA.precision : manager.assets.assetB.precision;
+            for (const o of allOrders) {
+                if (!isOrderPlaced(o) || o.price == null)
+                    continue;
+                if (o.id === c.id)
+                    continue;
+                try {
+                    if (priceSlotEqual(o.price, c.price, precision))
+                        return false;
+                }
+                catch {
+                    if (o.price === c.price)
+                        return false;
+                }
+            }
+            return true;
         });
         const filteredCount = preFilter - spreadCandidates.length;
         if (filteredCount > 0) {
@@ -2296,7 +2588,7 @@ export async function prepareSpreadCorrectionOrders(manager, preferredSide, outO
     }
     if (!edgePartial && spreadCandidates.length === 0) {
         manager.logger?.log?.(`[SPREAD-CORRECTION] No suitable partials, orphaned virtual slots, or spread slots found. Skipping.`, 'warn');
-        return { ordersToPlace: [], ordersToUpdate: [] };
+        return { ordersToPlace: [], ordersToUpdate: [], origin: 'spread-correction' };
     }
     const orphanedIds = new Set(orphanedVirtualCandidates.map((o) => o.id));
     const sideSlots = allOrders
@@ -2308,7 +2600,7 @@ export async function prepareSpreadCorrectionOrders(manager, preferredSide, outO
     ].sort((a, b) => a.price - b.price);
     const ctx = await _getSizingContext(manager, sideName);
     if (!ctx || ctx.budget <= 0 || syntheticSideSlots.length === 0) {
-        return { ordersToPlace: [], ordersToUpdate: [] };
+        return { ordersToPlace: [], ordersToUpdate: [], origin: 'spread-correction' };
     }
     const precisionEpsilon = getPrecisionSlack(ctx.precision, 1);
     const idealSizes = allocateFundsByWeights(ctx.budget, syntheticSideSlots.length, manager.config.weightDistribution[sideName], manager.config.incrementPercent / 100, railType === ORDER_TYPES.BUY, 0, ctx.precision);
@@ -2345,7 +2637,7 @@ export async function prepareSpreadCorrectionOrders(manager, preferredSide, outO
         }
     }
     if (prioritizedTargets.length === 0) {
-        return { ordersToPlace: [], ordersToUpdate: [] };
+        return { ordersToPlace: [], ordersToUpdate: [], origin: 'spread-correction' };
     }
     const totalNeeded = prioritizedTargets.reduce((sum, t) => sum + Math.max(0, Number(t.needed || 0)), 0);
     let recoveredBudget = 0;
@@ -2479,6 +2771,6 @@ export async function prepareSpreadCorrectionOrders(manager, preferredSide, outO
     if (combinedUpdates.length > 0 || ordersToPlace.length > 0) {
         manager.logger?.log?.(`[SPREAD-CORRECTION] Prepared updates=${combinedUpdates.length}, creates=${ordersToPlace.length}, remainingBudget=${Format.formatSizeByOrderType(Math.max(0, remainingBudget), railType, manager.assets)}`, 'debug');
     }
-    return { ordersToPlace, ordersToUpdate: combinedUpdates, ...(boundaryIdx === undefined ? {} : { boundaryIdx }) };
+    return { ordersToPlace, ordersToUpdate: combinedUpdates, ...(boundaryIdx === undefined ? {} : { boundaryIdx }), origin: 'spread-correction' };
 }
 //# sourceMappingURL=grid.js.map