dexbot 1.4.23 → 1.4.25

package/dist/modules/order/grid_reconcile.js

@@ -3,11 +3,10 @@ const require = createRequire(import.meta.url);
 import { _countActiveOnGrid, _cancelChainOrder, _recoverStartupSyncFailure, _refreshStartupUpdatePlans, _executeStartupUpdateBatch, _executeStartupSequentialUpdateFallback, _executePlannedStartupCreates, _reconcileStartupSide, } from './grid_reconcile_internal.js';
 import { ORDER_TYPES, ORDER_STATES, TIMING } from '../constants.js';
 import { readOpenOrdersGuarded } from '../chain_orders.js';
-import { calculatePriceTolerance, getAssetFeesSafe } from './utils/math.js';
+import { getAssetFeesSafe, priceSlotEqual } from './utils/math.js';
 import { isOrderPlaced, parseChainOrder, isOrderOnChain, chainOrderMatchesSlot, duplicateOrphanLogInfo, } from './utils/order.js';
 import * as Format from './format.js';
 import { getErrorMessage } from '../utils/errors.js';
-const SUSPECTED_DUPLICATE_TOLERANCE_MULTIPLIER = 5;
 /**
  * Returns { resumed: boolean, matchedCount: number }.
  * @param {Object} params - Destructured parameters
@@ -18,7 +17,7 @@ const SUSPECTED_DUPLICATE_TOLERANCE_MULTIPLIER = 5;
  * @param {Function} params.storeGrid - Grid persistence callback
  * @returns {Promise<{resumed: boolean, matchedCount: number}>}
  */
-export async function attemptResumePersistedGridByPriceMatch({ manager, persistedGrid, chainOpenOrders, logger, storeGrid, boundaryIdx = null, }) {
+export async function attemptResumePersistedGridByPriceMatch({ manager, persistedGrid, chainOpenOrders, logger, storeGrid, boundaryIdx = null, genesis = null, }) {
     if (!Array.isArray(persistedGrid) || persistedGrid.length === 0)
         return { resumed: false, matchedCount: 0 };
     if (!Array.isArray(chainOpenOrders) || chainOpenOrders.length === 0)
@@ -28,7 +27,9 @@ export async function attemptResumePersistedGridByPriceMatch({ manager, persiste
     try {
         logger && logger.log && logger.log('No matching active order IDs found. Attempting to match by price...', 'info');
         const { loadGrid } = require('./grid');
-        await loadGrid(manager, persistedGrid, boundaryIdx);
+        // Prefer explicit genesis if caller wired it, else fall back to manager._genesis
+        const genesisArg = genesis ?? manager?._genesis ?? null;
+        await loadGrid(manager, persistedGrid, boundaryIdx, genesisArg);
         await manager.synchronizeWithChain(chainOpenOrders, 'readOpenOrders');
         const matchedOrderIds = new Set(Array.from(manager.orders.values())
             .filter((o) => o && isOrderOnChain(o))
@@ -66,7 +67,7 @@ export async function attemptResumePersistedGridByPriceMatch({ manager, persiste
  * @param {Function} [params.attemptResumeFn=attemptResumePersistedGridByPriceMatch] - Resume function
  * @returns {Promise<Object>} { shouldRegenerate, hasActiveMatch, resumedByPrice, matchedCount }
  */
-export async function decideStartupGridAction({ persistedGrid, chainOpenOrders, manager, logger, storeGrid, boundaryIdx = null, attemptResumeFn = attemptResumePersistedGridByPriceMatch, }) {
+export async function decideStartupGridAction({ persistedGrid, chainOpenOrders, manager, logger, storeGrid, boundaryIdx = null, genesis = null, attemptResumeFn = attemptResumePersistedGridByPriceMatch, }) {
     const persisted = Array.isArray(persistedGrid) ? persistedGrid : [];
     const chain = Array.isArray(chainOpenOrders) ? chainOpenOrders : [];
     if (persisted.length === 0) {
@@ -78,7 +79,7 @@ export async function decideStartupGridAction({ persistedGrid, chainOpenOrders,
         return { shouldRegenerate: false, hasActiveMatch: true, resumedByPrice: false, matchedCount: 0 };
     }
     if (chain.length > 0) {
-        const resume = await attemptResumeFn({ manager, persistedGrid: persisted, chainOpenOrders: chain, logger, storeGrid, boundaryIdx });
+        const resume = await attemptResumeFn({ manager, persistedGrid: persisted, chainOpenOrders: chain, logger, storeGrid, boundaryIdx, genesis });
         return { shouldRegenerate: !resume.resumed, hasActiveMatch: false, resumedByPrice: !!resume.resumed, matchedCount: resume.matchedCount || 0 };
     }
     return { shouldRegenerate: true, hasActiveMatch: false, resumedByPrice: false, matchedCount: 0 };
@@ -185,6 +186,12 @@ export async function reconcileGridOrders({ manager, config, account, privateKey
         const plannedCancels = [];
         const cancelledDuplicateIds = new Set();
         const activeGridOrders = Array.from(manager.orders.values()).filter((o) => o && o.orderId && isOrderPlaced(o));
+        // Update-first policy: unmatched chain orders are NEVER cancelled here.
+        // They flow into _reconcileStartupSide below, which price-updates them onto
+        // rail slots in a single batch (plannedUpdates), creates missing orders, and
+        // cancels only true surplus (chainCount > targetCount). Pre-emptive
+        // cancellation would turn one batched update into per-order cancel+create
+        // churn and strip the bot's own live orders during a reset.
         for (const u of unmatchedParsed) {
             const p = u.parsed;
             const desc = `Unmatched chain order: ${p.orderId} (${p.type === ORDER_TYPES.BUY ? 'BUY' : 'SELL'}), price=${Format.formatPrice6(p.price)}, size=${Format.formatSizeByOrderType(p.size ?? 0, p.type, manager.assets)}`;
@@ -192,18 +199,14 @@ export async function reconcileGridOrders({ manager, config, account, privateKey
             for (const gridOrder of activeGridOrders) {
                 if (gridOrder.type !== p.type)
                     continue;
+                const precision = p.type === ORDER_TYPES.SELL ? manager.assets.assetA.precision : manager.assets.assetB.precision;
+                const isEqual = priceSlotEqual(p.price, gridOrder.price, precision);
                 const priceDiff = Math.abs(p.price - gridOrder.price);
-                const tolerance = calculatePriceTolerance(gridOrder.price, gridOrder.size, gridOrder.type, manager.assets) || 0;
-                const candidate = {
-                    gridOrder,
-                    priceDiff,
-                    tolerance,
-                    looseTolerance: tolerance * SUSPECTED_DUPLICATE_TOLERANCE_MULTIPLIER,
-                };
+                const candidate = { gridOrder, priceDiff, isEqual };
                 if (!nearest || priceDiff < nearest.priceDiff)
                     nearest = candidate;
             }
-            if (nearest && nearest.priceDiff <= nearest.looseTolerance) {
+            if (nearest && nearest.isEqual) {
                 // The sync layer already owns this duplicate: PASS 2 queues a
                 // cancel-only correction, and startup runs it (correctAllPriceMismatches)
                 // before reconcile — leaving a stale snapshot where the order is already
@@ -226,8 +229,7 @@ export async function reconcileGridOrders({ manager, config, account, privateKey
                 const { level, suffix } = duplicateOrphanLogInfo(p.orderId);
                 logger?.log?.(`SUSPECTED DUPLICATE: ${desc} - nearest active grid ${nearest.gridOrder.id} ` +
                     `(orderId=${nearest.gridOrder.orderId}, price=${Format.formatPrice6(nearest.gridOrder.price)}, ` +
-                    `diff=${Format.formatPrice6(nearest.priceDiff)}, tolerance=${Format.formatPrice6(nearest.tolerance)}, ` +
-                    `looseTolerance=${Format.formatPrice6(nearest.looseTolerance)})${suffix}`, level);
+                    `diff=${Format.formatPrice6(nearest.priceDiff)}, slotEqual=${nearest.isEqual})${suffix}`, level);
                 // Queue duplicate for Phase 2 cancellation instead of executing under lock
                 cancelledDuplicateIds.add(p.orderId);
                 plannedCancels.push({
@@ -239,8 +241,7 @@ export async function reconcileGridOrders({ manager, config, account, privateKey
             else if (nearest) {
                 logger?.log?.(`${desc}; nearest active same-side grid ${nearest.gridOrder.id} ` +
                     `(orderId=${nearest.gridOrder.orderId}, price=${Format.formatPrice6(nearest.gridOrder.price)}, ` +
-                    `diff=${Format.formatPrice6(nearest.priceDiff)}, tolerance=${Format.formatPrice6(nearest.tolerance)}, ` +
-                    `looseTolerance=${Format.formatPrice6(nearest.looseTolerance)})`, 'warn');
+                    `diff=${Format.formatPrice6(nearest.priceDiff)}, slotEqual=${nearest.isEqual})`, 'warn');
             }
             else {
                 logger?.log?.(`${desc}; no active same-side grid order exists`, 'warn');
@@ -290,240 +291,259 @@ export async function reconcileGridOrders({ manager, config, account, privateKey
     // These are the heavy operations that would block all other grid operations
     // if held under _gridLock. All lock acquisitions here follow the canonical
     // hierarchy (fillProcessingLock → syncLock → gridLock → fundLock).
-    const { plannedCreates, plannedUpdates, plannedCancels, chainSellCount, chainBuyCount } = phase1Result;
-    // Execute planned cancellations (duplicates, edge, excess) outside lock.
-    // Each _cancelChainOrder call acquires _gridLock internally via synchronizeWithChain.
-    if (!dryRun && plannedCancels.length > 0) {
-        logger?.log?.(`Startup: Executing ${plannedCancels.length} queued cancellations (Phase 2)`, 'info');
-        for (const cancelPlan of plannedCancels) {
-            try {
-                await _cancelChainOrder({
-                    chainOrders,
-                    account,
-                    privateKey,
-                    manager,
-                    chainOrderId: cancelPlan.chainOrderId,
-                    dryRun,
-                    chainOrderObj: cancelPlan.chainOrderObj,
-                    releaseUntrackedFunds: cancelPlan.releaseUntrackedFunds,
-                });
-                logger?.log?.(`Startup: Cancelled queued order ${cancelPlan.chainOrderId} (Phase 2)`, 'info');
-            }
-            catch (cancelErr) {
-                logger?.log?.(`Startup: Failed to cancel queued order ${cancelPlan.chainOrderId}: ${getErrorMessage(cancelErr)}`, 'error');
-            }
-        }
-    }
-    if (!dryRun && plannedUpdates.length > 0) {
-        let updatePlans = plannedUpdates;
-        const maxBatchAttempts = 3;
-        let batchCompleted = false;
-        if (supportsBatchUpdate) {
-            for (let attempt = 1; attempt <= maxBatchAttempts; attempt++) {
+    // P0 placement mutex: the whole of Phase 2 is broadcast I/O plus master-grid
+    // mutations, and it is NOT under _gridLock. Without the broadcasting gate a
+    // fill-driven COW rebalance can plan and broadcast the SAME slots in parallel
+    // with this loop: the commit is then refused ("master mutation during
+    // broadcasting"), both order generations land on chain, and the loser becomes
+    // a duplicate-price orphan backlog that blocks placements until drained.
+    // startBroadcasting() defers that rebalance —
+    // manager.performSafeRebalance waits on the flag and the fill consumer gates
+    // on it. The flag is refcounted and has a 120s stale-clear watchdog.
+    if (typeof manager.startBroadcasting === 'function')
+        manager.startBroadcasting();
+    try {
+        const { plannedCreates, plannedUpdates, plannedCancels, chainSellCount, chainBuyCount } = phase1Result;
+        // Execute planned cancellations (duplicates, edge, excess) outside lock.
+        // Each _cancelChainOrder call acquires _gridLock internally via synchronizeWithChain.
+        if (!dryRun && plannedCancels.length > 0) {
+            logger?.log?.(`Startup: Executing ${plannedCancels.length} queued cancellations (Phase 2)`, 'info');
+            for (const cancelPlan of plannedCancels) {
                 try {
-                    const batchResult = await _executeStartupUpdateBatch({
-                        updatePlans,
+                    await _cancelChainOrder({
                         chainOrders,
                         account,
                         privateKey,
                         manager,
+                        chainOrderId: cancelPlan.chainOrderId,
                         dryRun,
+                        chainOrderObj: cancelPlan.chainOrderObj,
+                        releaseUntrackedFunds: cancelPlan.releaseUntrackedFunds,
                     });
-                    if (batchResult.executed) {
-                        logger?.log?.(`Startup: Update batch complete (${batchResult.prepared} updated)`, 'info');
+                    logger?.log?.(`Startup: Cancelled queued order ${cancelPlan.chainOrderId} (Phase 2)`, 'info');
+                }
+                catch (cancelErr) {
+                    logger?.log?.(`Startup: Failed to cancel queued order ${cancelPlan.chainOrderId}: ${getErrorMessage(cancelErr)}. ` +
+                        `The order stays live: the relocation/create phases will skip any placement ` +
+                        `that would cross it (STARTUP-CROSS-GUARD) and re-align on the next cycle.`, 'error');
+                }
+            }
+        }
+        if (!dryRun && plannedUpdates.length > 0) {
+            let updatePlans = plannedUpdates;
+            const maxBatchAttempts = 3;
+            let batchCompleted = false;
+            if (supportsBatchUpdate) {
+                for (let attempt = 1; attempt <= maxBatchAttempts; attempt++) {
+                    try {
+                        const batchResult = await _executeStartupUpdateBatch({
+                            updatePlans,
+                            chainOrders,
+                            account,
+                            privateKey,
+                            manager,
+                            dryRun,
+                        });
+                        if (batchResult.executed) {
+                            logger?.log?.(`Startup: Update batch complete (${batchResult.prepared} updated)`, 'info');
+                        }
+                        batchCompleted = true;
+                        break;
+                    }
+                    catch (err) {
+                        logger?.log?.(`Startup: Update batch attempt ${attempt}/${maxBatchAttempts} failed: ${getErrorMessage(err)}`, 'error');
+                        const refreshedChainOrders = await _recoverStartupSyncFailure({
+                            chainOrders,
+                            manager,
+                            account,
+                            logger,
+                            triggerMessage: `Startup: Triggering recovery sync after update batch failure (attempt ${attempt}/${maxBatchAttempts})`,
+                            source: 'startupReconcileUpdateBatchFailure',
+                        });
+                        updatePlans = _refreshStartupUpdatePlans(updatePlans, refreshedChainOrders);
+                        if (updatePlans.length === 0) {
+                            logger?.log?.('Startup: No update plans remain after recovery sync; skipping further update attempts', 'warn');
+                            batchCompleted = true;
+                            break;
+                        }
+                        if (attempt >= maxBatchAttempts) {
+                            logger?.log?.('Startup: Update batch retries exhausted; switching to sequential fallback', 'warn');
+                            break;
+                        }
                     }
-                    batchCompleted = true;
-                    break;
                 }
-                catch (err) {
-                    logger?.log?.(`Startup: Update batch attempt ${attempt}/${maxBatchAttempts} failed: ${getErrorMessage(err)}`, 'error');
-                    const refreshedChainOrders = await _recoverStartupSyncFailure({
+            }
+            else {
+                logger?.log?.('Startup: Batch update helpers unavailable; using sequential fallback updates', 'warn');
+            }
+            if (!batchCompleted && updatePlans.length > 0) {
+                try {
+                    const fallbackResult = await _executeStartupSequentialUpdateFallback({
+                        updatePlans,
                         chainOrders,
-                        manager,
                         account,
-                        logger,
-                        triggerMessage: `Startup: Triggering recovery sync after update batch failure (attempt ${attempt}/${maxBatchAttempts})`,
-                        source: 'startupReconcileUpdateBatchFailure',
+                        privateKey,
+                        manager,
+                        dryRun,
                     });
-                    updatePlans = _refreshStartupUpdatePlans(updatePlans, refreshedChainOrders);
-                    if (updatePlans.length === 0) {
-                        logger?.log?.('Startup: No update plans remain after recovery sync; skipping further update attempts', 'warn');
-                        batchCompleted = true;
-                        break;
-                    }
-                    if (attempt >= maxBatchAttempts) {
-                        logger?.log?.('Startup: Update batch retries exhausted; switching to sequential fallback', 'warn');
-                        break;
+                    if (fallbackResult.executed > 0 || fallbackResult.skipped > 0 || fallbackResult.failed > 0) {
+                        logger?.log?.(`Startup: Sequential fallback complete (updated=${fallbackResult.executed}, skipped=${fallbackResult.skipped}, failed=${fallbackResult.failed})`, fallbackResult.failed > 0 ? 'warn' : 'info');
                     }
                 }
+                catch (err) {
+                    logger?.log?.(`Startup: Sequential fallback failed unexpectedly: ${getErrorMessage(err)}`, 'error');
+                }
             }
         }
-        else {
-            logger?.log?.('Startup: Batch update helpers unavailable; using sequential fallback updates', 'warn');
+        const phase2CreatedOrderIds = new Set();
+        if (!dryRun && plannedCreates.length > 0) {
+            const createdIds = await _executePlannedStartupCreates({
+                createPlans: plannedCreates,
+                chainOrders,
+                account,
+                privateKey,
+                manager,
+                dryRun,
+            });
+            for (const id of createdIds) {
+                phase2CreatedOrderIds.add(id);
+            }
         }
-        if (!batchCompleted && updatePlans.length > 0) {
+        let finalChainSellCount = chainSellCount;
+        let finalChainBuyCount = chainBuyCount;
+        if (!dryRun) {
             try {
-                const fallbackResult = await _executeStartupSequentialUpdateFallback({
-                    updatePlans,
-                    chainOrders,
-                    account,
-                    privateKey,
-                    manager,
-                    dryRun,
+                // Truncated-read guard: get_full_accounts caps the limit_orders
+                // window and fresh orders (exactly the Phase-2 creates) sort last
+                // and are the first entries omitted. The adoption loop and the
+                // surplus-cancel counts would silently operate on a partial
+                // snapshot — defer to the sync loop's targeted drift detection and
+                // keep the pre-Phase-2 counts for the summary log.
+                const freshOpenOrders = await readOpenOrdersGuarded(chainOrders, account, {
+                    log: (message, level) => logger?.log?.(message, level),
+                    label: 'STARTUP',
+                    detail: 'Post-Phase-2 chain read',
                 });
-                if (fallbackResult.executed > 0 || fallbackResult.skipped > 0 || fallbackResult.failed > 0) {
-                    logger?.log?.(`Startup: Sequential fallback complete (updated=${fallbackResult.executed}, skipped=${fallbackResult.skipped}, failed=${fallbackResult.failed})`, fallbackResult.failed > 0 ? 'warn' : 'info');
-                }
-            }
-            catch (err) {
-                logger?.log?.(`Startup: Sequential fallback failed unexpectedly: ${getErrorMessage(err)}`, 'error');
-            }
-        }
-    }
-    const phase2CreatedOrderIds = new Set();
-    if (!dryRun && plannedCreates.length > 0) {
-        const createdIds = await _executePlannedStartupCreates({
-            createPlans: plannedCreates,
-            chainOrders,
-            account,
-            privateKey,
-            manager,
-            dryRun,
-        });
-        for (const id of createdIds) {
-            phase2CreatedOrderIds.add(id);
-        }
-    }
-    let finalChainSellCount = chainSellCount;
-    let finalChainBuyCount = chainBuyCount;
-    if (!dryRun) {
-        try {
-            // Truncated-read guard: get_full_accounts caps the limit_orders
-            // window and fresh orders (exactly the Phase-2 creates) sort last
-            // and are the first entries omitted. The adoption loop and the
-            // surplus-cancel counts would silently operate on a partial
-            // snapshot — defer to the sync loop's targeted drift detection and
-            // keep the pre-Phase-2 counts for the summary log.
-            const freshOpenOrders = await readOpenOrdersGuarded(chainOrders, account, {
-                log: (message, level) => logger?.log?.(message, level),
-                label: 'STARTUP',
-                detail: 'Post-Phase-2 chain read',
-            });
-            if (freshOpenOrders !== null) {
-                const freshParsed = (Array.isArray(freshOpenOrders) ? freshOpenOrders : [])
-                    .map((co) => ({ chain: co, parsed: parseChainOrder(co, manager.assets) }))
-                    .filter((x) => x.parsed);
-                const gridOrderIds = new Set();
-                for (const order of manager.orders.values()) {
-                    if (order && order.orderId)
-                        gridOrderIds.add(order.orderId);
-                }
-                // Merge any chain order IDs Phase 2 successfully created on-chain
-                // (even if _applySync failed to register them in manager.orders).
-                // This prevents Phase 3 from cancelling legitimately created orders.
-                for (const id of phase2CreatedOrderIds) {
-                    gridOrderIds.add(id);
-                }
-                // Adopt any Phase-2 uncertain-landed chain orders that never made
-                // it into grid slots (the group adoption sync only runs when the
-                // post-uncertain read returned orders). Targeted slot adoption
-                // only: match VIRTUAL/SPREAD slots without an orderId by
-                // type+price+size (within tolerance). Full syncFromOpenOrders is
-                // deliberately NOT used here — its pass-1 virtualizes ACTIVE slots
-                // missing from the snapshot, and a lagging read right after the
-                // Phase-2 broadcast would destroy the confirmed grid.
-                const btsFeeData = getAssetFeesSafe('BTS');
-                for (const entry of freshParsed) {
-                    const co = entry.chain;
-                    const parsed = entry.parsed;
-                    if (!co?.id || !parsed)
-                        continue;
-                    if (gridOrderIds.has(co.id))
-                        continue;
-                    const candidate = Array.from(manager.orders.values()).find((o) => {
-                        if (!o || o.orderId || o.state !== ORDER_STATES.VIRTUAL)
-                            return false;
-                        return chainOrderMatchesSlot(parsed, o, manager.assets);
-                    });
-                    if (!candidate)
-                        continue;
-                    try {
-                        await manager._applySync({
-                            gridOrderId: candidate.id,
-                            chainOrderId: co.id,
-                            isPartialPlacement: false,
-                            expectedType: parsed.type,
-                            fee: btsFeeData?.createFee || 0,
-                        }, 'createOrder');
-                        gridOrderIds.add(co.id);
-                        phase2CreatedOrderIds.add(co.id);
-                        logger?.log?.(`Startup: Adopted uncertain-landed chain order ${co.id} into slot ${candidate.id} (${parsed.type}, price=${parsed.price})`, 'warn');
+                if (freshOpenOrders !== null) {
+                    const freshParsed = (Array.isArray(freshOpenOrders) ? freshOpenOrders : [])
+                        .map((co) => ({ chain: co, parsed: parseChainOrder(co, manager.assets) }))
+                        .filter((x) => x.parsed);
+                    const gridOrderIds = new Set();
+                    for (const order of manager.orders.values()) {
+                        if (order && order.orderId)
+                            gridOrderIds.add(order.orderId);
                     }
-                    catch (adoptErr) {
-                        logger?.log?.(`Startup: Failed to adopt landed order ${co.id} into slot ${candidate?.id}: ${getErrorMessage(adoptErr)}`, 'warn');
-                        // The order IS on chain (Phase-2 uncertain-landed). Even
-                        // though the slot registration failed, the ID must still
-                        // be protected from the same pass's surplus-cancel —
-                        // mirror the capturedId protection of _createOrderFromGrid.
-                        // The next sync loop's orphan adoption registers it.
-                        gridOrderIds.add(co.id);
+                    // Merge any chain order IDs Phase 2 successfully created on-chain
+                    // (even if _applySync failed to register them in manager.orders).
+                    // This prevents Phase 3 from cancelling legitimately created orders.
+                    for (const id of phase2CreatedOrderIds) {
+                        gridOrderIds.add(id);
                     }
-                }
-                const staleSurplusCancels = [];
-                for (const side of [ORDER_TYPES.SELL, ORDER_TYPES.BUY]) {
-                    const targetCount = side === ORDER_TYPES.SELL ? targetSell : targetBuy;
-                    let sideOrders = freshParsed.filter((x) => x.parsed.type === side);
-                    const sideLabel = side === ORDER_TYPES.SELL ? 'SELL' : 'BUY';
-                    if (sideOrders.length > targetCount) {
-                        // Sort by chain ID for deterministic cancellation order.
-                        sideOrders = sideOrders.sort((a, b) => (a.chain.id || '').localeCompare(b.chain.id || ''));
-                        let cancelLimit = sideOrders.length - targetCount;
-                        for (const so of sideOrders) {
-                            if (cancelLimit <= 0)
-                                break;
-                            if (!gridOrderIds.has(so.chain.id)) {
-                                staleSurplusCancels.push({ chainOrderObj: so.chain, sideLabel });
-                                cancelLimit--;
-                            }
+                    // Adopt any Phase-2 uncertain-landed chain orders that never made
+                    // it into grid slots (the group adoption sync only runs when the
+                    // post-uncertain read returned orders). Targeted slot adoption
+                    // only: match VIRTUAL/SPREAD slots without an orderId by
+                    // type+price+size (within tolerance). Full syncFromOpenOrders is
+                    // deliberately NOT used here — its pass-1 virtualizes ACTIVE slots
+                    // missing from the snapshot, and a lagging read right after the
+                    // Phase-2 broadcast would destroy the confirmed grid.
+                    const btsFeeData = getAssetFeesSafe('BTS');
+                    for (const entry of freshParsed) {
+                        const co = entry.chain;
+                        const parsed = entry.parsed;
+                        if (!co?.id || !parsed)
+                            continue;
+                        if (gridOrderIds.has(co.id))
+                            continue;
+                        const candidate = Array.from(manager.orders.values()).find((o) => {
+                            if (!o || o.orderId || o.state !== ORDER_STATES.VIRTUAL)
+                                return false;
+                            return chainOrderMatchesSlot(parsed, o, manager.assets);
+                        });
+                        if (!candidate)
+                            continue;
+                        try {
+                            await manager._applySync({
+                                gridOrderId: candidate.id,
+                                chainOrderId: co.id,
+                                isPartialPlacement: false,
+                                expectedType: parsed.type,
+                                fee: btsFeeData?.createFee || 0,
+                            }, 'createOrder');
+                            gridOrderIds.add(co.id);
+                            phase2CreatedOrderIds.add(co.id);
+                            logger?.log?.(`Startup: Adopted uncertain-landed chain order ${co.id} into slot ${candidate.id} (${parsed.type}, price=${parsed.price})`, 'warn');
+                        }
+                        catch (adoptErr) {
+                            logger?.log?.(`Startup: Failed to adopt landed order ${co.id} into slot ${candidate?.id}: ${getErrorMessage(adoptErr)}`, 'warn');
+                            // The order IS on chain (Phase-2 uncertain-landed). Even
+                            // though the slot registration failed, the ID must still
+                            // be protected from the same pass's surplus-cancel —
+                            // mirror the capturedId protection of _createOrderFromGrid.
+                            // The next sync loop's orphan adoption registers it.
+                            gridOrderIds.add(co.id);
                         }
                     }
-                }
-                let cancelledSellCount = 0;
-                let cancelledBuyCount = 0;
-                if (staleSurplusCancels.length > 0) {
-                    for (const sc of staleSurplusCancels) {
-                        try {
-                            await _cancelChainOrder({
-                                chainOrders,
-                                account,
-                                privateKey,
-                                manager,
-                                chainOrderId: sc.chainOrderObj.id,
-                                dryRun,
-                                chainOrderObj: sc.chainOrderObj,
-                                releaseUntrackedFunds: true,
-                            });
-                            if (sc.sideLabel === 'SELL')
-                                cancelledSellCount++;
-                            else
-                                cancelledBuyCount++;
-                            logger?.log?.(`Startup: Cancelled stale surplus ${sc.sideLabel} order ${sc.chainOrderObj.id}`, 'info');
+                    const staleSurplusCancels = [];
+                    for (const side of [ORDER_TYPES.SELL, ORDER_TYPES.BUY]) {
+                        const targetCount = side === ORDER_TYPES.SELL ? targetSell : targetBuy;
+                        let sideOrders = freshParsed.filter((x) => x.parsed.type === side);
+                        const sideLabel = side === ORDER_TYPES.SELL ? 'SELL' : 'BUY';
+                        if (sideOrders.length > targetCount) {
+                            // Sort by chain ID for deterministic cancellation order.
+                            sideOrders = sideOrders.sort((a, b) => (a.chain.id || '').localeCompare(b.chain.id || ''));
+                            let cancelLimit = sideOrders.length - targetCount;
+                            for (const so of sideOrders) {
+                                if (cancelLimit <= 0)
+                                    break;
+                                if (!gridOrderIds.has(so.chain.id)) {
+                                    staleSurplusCancels.push({ chainOrderObj: so.chain, sideLabel });
+                                    cancelLimit--;
+                                }
+                            }
                         }
-                        catch (e) {
-                            logger?.log?.(`Startup: Failed to cancel surplus ${sc.sideLabel} ${sc.chainOrderObj.id}: ${getErrorMessage(e)}`, 'warn');
+                    }
+                    let cancelledSellCount = 0;
+                    let cancelledBuyCount = 0;
+                    if (staleSurplusCancels.length > 0) {
+                        for (const sc of staleSurplusCancels) {
+                            try {
+                                await _cancelChainOrder({
+                                    chainOrders,
+                                    account,
+                                    privateKey,
+                                    manager,
+                                    chainOrderId: sc.chainOrderObj.id,
+                                    dryRun,
+                                    chainOrderObj: sc.chainOrderObj,
+                                    releaseUntrackedFunds: true,
+                                });
+                                if (sc.sideLabel === 'SELL')
+                                    cancelledSellCount++;
+                                else
+                                    cancelledBuyCount++;
+                                logger?.log?.(`Startup: Cancelled stale surplus ${sc.sideLabel} order ${sc.chainOrderObj.id}`, 'info');
+                            }
+                            catch (e) {
+                                logger?.log?.(`Startup: Failed to cancel surplus ${sc.sideLabel} ${sc.chainOrderObj.id}: ${getErrorMessage(e)}`, 'warn');
+                            }
                         }
                     }
+                    finalChainSellCount = freshParsed.filter((x) => x.parsed.type === ORDER_TYPES.SELL).length - cancelledSellCount;
+                    finalChainBuyCount = freshParsed.filter((x) => x.parsed.type === ORDER_TYPES.BUY).length - cancelledBuyCount;
                 }
-                finalChainSellCount = freshParsed.filter((x) => x.parsed.type === ORDER_TYPES.SELL).length - cancelledSellCount;
-                finalChainBuyCount = freshParsed.filter((x) => x.parsed.type === ORDER_TYPES.BUY).length - cancelledBuyCount;
+            }
+            catch (err) {
+                logger?.log?.(`Startup: Failed to refresh final chain counts: ${getErrorMessage(err)}`, 'warn');
             }
         }
-        catch (err) {
-            logger?.log?.(`Startup: Failed to refresh final chain counts: ${getErrorMessage(err)}`, 'warn');
-        }
+        logger && logger.log && logger.log(`Startup reconcile complete: target(sell=${targetSell}, buy=${targetBuy}), chain(sell=${finalChainSellCount}, buy=${finalChainBuyCount}), ` +
+            `gridActive(sell=${_countActiveOnGrid(manager, ORDER_TYPES.SELL)}, buy=${_countActiveOnGrid(manager, ORDER_TYPES.BUY)})`, 'info');
+    }
+    finally {
+        if (typeof manager.stopBroadcasting === 'function')
+            manager.stopBroadcasting();
     }
-    logger && logger.log && logger.log(`Startup reconcile complete: target(sell=${targetSell}, buy=${targetBuy}), chain(sell=${finalChainSellCount}, buy=${finalChainBuyCount}), ` +
-        `gridActive(sell=${_countActiveOnGrid(manager, ORDER_TYPES.SELL)}, buy=${_countActiveOnGrid(manager, ORDER_TYPES.BUY)})`, 'info');
     return null;
 }
 //# sourceMappingURL=grid_reconcile.js.map