dexbot 1.6.0 → 1.6.2

package/dist/modules/dexbot_fill_runtime.d.ts

@@ -236,6 +236,33 @@ declare function shouldDeferFillForBroadcast(bot: any, nowMs?: number): {
  * @param {Object} chainOrders - Chain orders module
  */
 declare function scheduleFillConsumerRestart(bot: any, chainOrders: any): void;
+/**
+ * Level-triggered retry for fills parked by consumeFillQueue's pre-lock
+ * gates (order-pipeline or broadcast deferral).
+ *
+ * Incident (2026-09-13, H-BTS slot-86): a lone fill deferred by an active
+ * broadcast never drained — the defer branches returned without
+ * rescheduling, and none of the edge-triggered wake-ups came: the flag was
+ * leaked (no region end would ever fire), no second fill arrived to trip
+ * the 60s edge-triggered bound, and the non-empty queue held the
+ * maintenance idle gate shut (so the maintenance watchdog never ran).
+ *
+ * This arms a single deduped timer at defer time; on fire it refreshes the
+ * stale-broadcast watchdog (outside maintenance) and re-invokes the
+ * consumer. While still gated the consumer re-arms, so the loop is
+ * self-sustaining until the stuck-fallback bound trips and the queue
+ * drains; once drained the timer settles. At most one retry is pending per
+ * bot. The timer is unref'd so a parked queue never holds the process open
+ * (and fakes that never clear the gate cannot hang the test runner).
+ * @param {any} bot
+ * @param {Object} chainOrders - Chain orders module for blockchain operations
+ * @param {string} reason - Gate label for logging
+ * @param {Object} [options]
+ * @param {number} [options.retryDelayMs] - Override the derived backoff (tests)
+ */
+declare function scheduleDeferredFillRetry(bot: any, chainOrders: any, reason: string, options?: {
+    retryDelayMs?: number;
+}): void;
 /**
  * Process fills during bootstrap phase using the standard fill pipeline.
  * Delegates to the same fill pipeline as the post-reset path.
@@ -244,6 +271,31 @@ declare function scheduleFillConsumerRestart(bot: any, chainOrders: any): void;
  * @returns {Promise<void>}
  */
 declare function processFillsWithBootstrapMode(bot: any, chainOrders: any): Promise<void>;
+/**
+ * Park fills deferred on a stale accountTotals refresh for a bounded retry.
+ *
+ * Background: syncFromFillHistory(Batch) returns { deferred: true } when the
+ * accountTotals refresh fails — accounting is NOT applied. The old code
+ * dropped those fills (already spliced from the queue) while their dedupe
+ * keys stayed marked processed: silent fund loss with a "retrying next
+ * cycle" comment, but the next cycle only exists with backlog.
+ *
+ * Parked fills are held OUTSIDE the live queue (so the maintenance idle gate
+ * keeps working) and re-queued on a backoff timer (FILL_TOTALS_RETRY_BASE_MS,
+ * doubling, capped at FILL_TOTALS_RETRY_MAX_MS). The retry re-runs the same
+ * idempotent sync — safe because nothing was applied and the keys were
+ * released. Retries never stop (attempt counter resets on the first cycle
+ * with no deferrals); the parked array is capped at MAX_INCOMING_FILL_QUEUE
+ * with a critical log as a catastrophic backstop.
+ * @param {any} bot
+ * @param {Object} chainOrders - Chain orders module for blockchain operations
+ * @param {any[]} fills - Raw fill events to park
+ * @param {Object} [options]
+ * @param {number} [options.retryDelayMs] - Override the computed backoff (tests)
+ */
+export declare function parkFillsForTotalsRetry(bot: any, chainOrders: any, fills: any[], options?: {
+    retryDelayMs?: number;
+}): void;
 /**
  * Consume queued fills from incomingFillQueue and rebalance.
  * Deduplicates fills against already-processed set (replay-safe), syncs filled
@@ -254,5 +306,5 @@ declare function processFillsWithBootstrapMode(bot: any, chainOrders: any): Prom
  * @param {Object} chainOrders - Chain orders module for blockchain operations
  */
 declare function consumeFillQueue(bot: any, chainOrders: any): Promise<void>;
-export { wireProcessedFillTracking, flushProcessedFillPersistence, flushProcessedFillPersistenceForKeys, buildOrphanFillFallbackKey, applyReplaySafeFillAccounting, applyReplaySafeTrackedFillAccounting, applyReplaySafeOrphanFillAccounting, processSweepOrphanFill, createFillCallback, maxConsecutiveFillConsumerFailures, computeFillConsumerBackoffMs, scheduleFillConsumerRestart, shouldDeferFillForBroadcast, consumeFillQueue, processFillsWithBootstrapMode };
+export { wireProcessedFillTracking, flushProcessedFillPersistence, flushProcessedFillPersistenceForKeys, buildOrphanFillFallbackKey, applyReplaySafeFillAccounting, applyReplaySafeTrackedFillAccounting, applyReplaySafeOrphanFillAccounting, processSweepOrphanFill, createFillCallback, maxConsecutiveFillConsumerFailures, computeFillConsumerBackoffMs, scheduleFillConsumerRestart, scheduleDeferredFillRetry, shouldDeferFillForBroadcast, consumeFillQueue, processFillsWithBootstrapMode };
 //# sourceMappingURL=dexbot_fill_runtime.d.ts.map

package/dist/modules/dexbot_fill_runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dexbot_fill_runtime.d.ts","sourceRoot":"","sources":["../../modules/dexbot_fill_runtime.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"dexbot_fill_runtime.d.ts","sourceRoot":"","sources":["../../modules/dexbot_fill_runtime.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAkBrF,UAAU,sBAAsB;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,aAAa,CAAC,EAAE,GAAG,CAAC;CACvB;AA8ED;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAe,sBAAsB,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,iBAAiB,EAAE,GAAG,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC,CAiCnJ;AAED,iBAAS,yBAAyB,CAAC,GAAG,EAAE,GAAG,QAW1C;AAsCD;;;;;;GAMG;AACH,iBAAe,6BAA6B,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,GAAE,GAAc,EAAE,OAAO,GAAE,GAAQ,iBAG/F;AAED;;;;;;;GAOG;AACH,iBAAe,oCAAoC,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAE,GAAuB,EAAE,OAAO,GAAE,GAAQ,iBAG9H;AAED;;;;;;GAMG;AACH,iBAAS,0BAA0B,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,iBAsBtD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,iBAAe,6BAA6B,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,EAC3E,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,YAAY,EACZ,MAA4B,EAC5B,eAAwB,EACxB,gBAAyB,EACzB,WAAqB,EACrB,eAA4D,EAC5D,sBAA8B,EACjC,GAAE;IACC,iBAAiB,CAAC,EAAE,GAAG,CAAC;IACxB,kBAAkB,CAAC,EAAE,GAAG,CAAC;IACzB,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,YAAY,CAAC,EAAE,GAAG,CAAC;IACnB,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,GAAG,CAAC;IACtB,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAC/B;;;;;;;;;;;;;;;GAoCL;AAED;;;;;;;;;;;;GAYG;AACH,iBAAe,oCAAoC,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,EAClF,OAAO,EACP,MAA4B,EAC5B,aAAa,EACb,eAA0D,EAC7D,GAAE;IACC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,eAAe,CAAC,EAAE,GAAG,CAAC;CACpB;;;;;;;;;;;;;;;GAQL;AAED;;;;;;;;;;;;GAYG;AACH,iBAAe,mCAAmC,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,EACjF,OAAO,EACP,MAA4B,EAC5B,aAAa,EACb,eAA0D,EAC7D,GAAE;IACC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,eAAe,CAAC,EAAE,GAAG,CAAC;CACpB;;;;;;;;;;;;;;;GAUL;AAED;;;;;;GAMG;AACH,iBAAS,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,IACpC,OAAO,GAAG,mBAmB3B;AAED;;;;GAIG;AACH,iBAAS,kCAAkC,CAAC,GAAG,EAAE,GAAG,OAEnD;AAED;;;;;;;;GAQG;AACH,iBAAS,4BAA4B,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,UAM5D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAO5D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,iBAAS,2BAA2B,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAA;CAAE,CAoBzG;AAED;;;;;;GAMG;AACH,iBAAS,2BAA2B,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,QA4D9D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iBAAS,yBAAyB,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,QAiDrH;AAED;;;;;;GAMG;AACH,iBAAe,6BAA6B,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,iBA0GtE;AAwBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,QA+FxH;AAED;;;;;;;;GAQG;AACH,iBAAe,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,iBA8jBzD;AAED,OAAO,EAAE,yBAAyB,EAAE,6BAA6B,EAAE,oCAAoC,EAAE,0BAA0B,EAAE,6BAA6B,EAAE,oCAAoC,EAAE,mCAAmC,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,kCAAkC,EAAE,4BAA4B,EAAE,2BAA2B,EAAE,yBAAyB,EAAE,2BAA2B,EAAE,gBAAgB,EAAE,6BAA6B,EAAE,CAAA"}

package/dist/modules/dexbot_fill_runtime.js

@@ -4,7 +4,7 @@ const require = createRequire(import.meta.url);
 import * as chainOrders from './chain_orders.js';
 import { PROCESSED_FILL_PERSISTENCE_MODES } from './order/processed_fill_store.js';
 import { NATIVE_CLIENT, FILL_PROCESSING, TIMING, MAINTENANCE, ORDER_TYPES } from './constants.js';
-import { getErrorMessage } from './utils/errors.js';
+import { getErrorMessage, resolveSeamMsOrNull } from './utils/errors.js';
 import { isOrderDoesNotExistError } from './dexbot_maintenance_runtime.js';
 import { slotIndexForPrice, isChainPriceOutOfGrid, isSlotInRail } from './order/utils/math.js';
 import { ORDER_STATES } from './constants.js';
@@ -517,6 +517,85 @@ function scheduleFillConsumerRestart(bot, chainOrders) {
             `${remaining} attempts remaining): ${getErrorMessage(err)}`, bot._consecutiveConsumeFailures >= 3 ? 'warn' : 'error');
     }));
 }
+/**
+ * Level-triggered retry for fills parked by consumeFillQueue's pre-lock
+ * gates (order-pipeline or broadcast deferral).
+ *
+ * Incident (2026-09-13, H-BTS slot-86): a lone fill deferred by an active
+ * broadcast never drained — the defer branches returned without
+ * rescheduling, and none of the edge-triggered wake-ups came: the flag was
+ * leaked (no region end would ever fire), no second fill arrived to trip
+ * the 60s edge-triggered bound, and the non-empty queue held the
+ * maintenance idle gate shut (so the maintenance watchdog never ran).
+ *
+ * This arms a single deduped timer at defer time; on fire it refreshes the
+ * stale-broadcast watchdog (outside maintenance) and re-invokes the
+ * consumer. While still gated the consumer re-arms, so the loop is
+ * self-sustaining until the stuck-fallback bound trips and the queue
+ * drains; once drained the timer settles. At most one retry is pending per
+ * bot. The timer is unref'd so a parked queue never holds the process open
+ * (and fakes that never clear the gate cannot hang the test runner).
+ * @param {any} bot
+ * @param {Object} chainOrders - Chain orders module for blockchain operations
+ * @param {string} reason - Gate label for logging
+ * @param {Object} [options]
+ * @param {number} [options.retryDelayMs] - Override the derived backoff (tests)
+ */
+function scheduleDeferredFillRetry(bot, chainOrders, reason, options = {}) {
+    if (!bot || bot._shuttingDown)
+        return;
+    if (bot._deferredFillRetryTimer)
+        return;
+    if (!Array.isArray(bot._incomingFillQueue) || bot._incomingFillQueue.length === 0)
+        return;
+    const seamRetryMs = resolveSeamMsOrNull(options?.retryDelayMs);
+    const retryMs = seamRetryMs ?? (() => {
+        const deferMaxMs = Number(TIMING?.FILL_BROADCAST_DEFER_MAX_MS) > 0
+            ? Number(TIMING.FILL_BROADCAST_DEFER_MAX_MS)
+            : 60000;
+        return Math.min(5000, Math.max(250, Math.floor(deferMaxMs / 12)));
+    })();
+    // Expose the resolved delay so tests can assert the seam resolution itself
+    // (a `||`-vs-`??` regression here is otherwise invisible: the only
+    // observable effect is a slower retry timer, which nothing measures).
+    // Only written when resolution is reached — the early guards above
+    // (_shuttingDown, timer already armed, empty queue) return before this.
+    bot._deferredFillRetryDelayMs = retryMs;
+    bot._deferredFillRetryWaits = (Number(bot._deferredFillRetryWaits) || 0) + 1;
+    const waits = bot._deferredFillRetryWaits;
+    if (waits === 1 || waits % 12 === 0) {
+        bot.manager?.logger?.log?.(`[FILL-QUEUE] Fill consumer deferred (${reason}, ${bot._incomingFillQueue.length} queued); ` +
+            `retry ${waits} in ${Math.round(retryMs / TIMING.MILLISECONDS_PER_SECOND)}s`, waits === 1 ? 'debug' : 'warn');
+    }
+    bot._deferredFillRetryTimer = setTimeout(() => {
+        bot._deferredFillRetryTimer = null;
+        if (bot._shuttingDown)
+            return;
+        if (!Array.isArray(bot._incomingFillQueue) || bot._incomingFillQueue.length === 0) {
+            bot._deferredFillRetryWaits = 0;
+            return;
+        }
+        // Refresh the stale-broadcast watchdog on the retry path, not just
+        // in maintenance — a parked queue holds the maintenance idle gate
+        // shut, so maintenance can never clear a leaked flag.
+        try {
+            if (typeof bot.manager?._clearStaleBroadcastFlag === 'function') {
+                bot.manager._clearStaleBroadcastFlag();
+            }
+        }
+        catch { /* watchdog must never break the retry */ }
+        const consume = typeof bot._consumeFillQueue === 'function'
+            ? () => bot._consumeFillQueue(chainOrders)
+            : () => consumeFillQueue(bot, chainOrders);
+        consume().catch((err) => {
+            bot._warn?.(`Deferred fill retry failed: ${getErrorMessage(err)}`);
+        });
+    }, retryMs);
+    try {
+        bot._deferredFillRetryTimer?.unref?.();
+    }
+    catch { /* browser-safe: no unref */ }
+}
 /**
  * Process fills during bootstrap phase using the standard fill pipeline.
  * Delegates to the same fill pipeline as the post-reset path.
@@ -618,6 +697,141 @@ async function processFillsWithBootstrapMode(bot, chainOrders) {
         bot.manager.logger.log(`[BOOTSTRAP] Fill error: ${getErrorMessage(err)}`, 'error');
     }
 }
+/**
+ * Release replay-safety dedupe keys consumed by _isNewFillKey for fills that
+ * are NOT being processed after all (stale-totals deferral). Without this, a
+ * re-queued fill is skipped as a duplicate within _fillDedupeWindowMs — the
+ * deferral would credit nothing AND poison the retry. Mirrors the
+ * orphan-adoption release in processSweepOrphanFill.
+ * @param {any} bot
+ * @param {Set<any>} processedFillKeys - Per-cycle key set to release from
+ * @param {any[]} fills - Raw fill events whose keys were consumed
+ */
+function releaseFillDedupeKeys(bot, processedFillKeys, fills) {
+    if (!bot || !processedFillKeys || !Array.isArray(fills))
+        return;
+    for (const fill of fills) {
+        try {
+            const key = buildFillKey(fill);
+            if (!key)
+                continue;
+            processedFillKeys.delete(key);
+            bot._recentlyQueuedFills?.delete?.(key);
+        }
+        catch { /* best-effort */ }
+    }
+}
+/**
+ * Park fills deferred on a stale accountTotals refresh for a bounded retry.
+ *
+ * Background: syncFromFillHistory(Batch) returns { deferred: true } when the
+ * accountTotals refresh fails — accounting is NOT applied. The old code
+ * dropped those fills (already spliced from the queue) while their dedupe
+ * keys stayed marked processed: silent fund loss with a "retrying next
+ * cycle" comment, but the next cycle only exists with backlog.
+ *
+ * Parked fills are held OUTSIDE the live queue (so the maintenance idle gate
+ * keeps working) and re-queued on a backoff timer (FILL_TOTALS_RETRY_BASE_MS,
+ * doubling, capped at FILL_TOTALS_RETRY_MAX_MS). The retry re-runs the same
+ * idempotent sync — safe because nothing was applied and the keys were
+ * released. Retries never stop (attempt counter resets on the first cycle
+ * with no deferrals); the parked array is capped at MAX_INCOMING_FILL_QUEUE
+ * with a critical log as a catastrophic backstop.
+ * @param {any} bot
+ * @param {Object} chainOrders - Chain orders module for blockchain operations
+ * @param {any[]} fills - Raw fill events to park
+ * @param {Object} [options]
+ * @param {number} [options.retryDelayMs] - Override the computed backoff (tests)
+ */
+export function parkFillsForTotalsRetry(bot, chainOrders, fills, options = {}) {
+    if (!bot || !Array.isArray(fills) || fills.length === 0)
+        return;
+    if (!Array.isArray(bot._fillTotalsParkedFills))
+        bot._fillTotalsParkedFills = [];
+    const parked = bot._fillTotalsParkedFills;
+    const maxParked = Number(NATIVE_CLIENT?.SUBSCRIPTIONS?.MAX_INCOMING_FILL_QUEUE) > 0
+        ? Number(NATIVE_CLIENT.SUBSCRIPTIONS.MAX_INCOMING_FILL_QUEUE)
+        : 1000;
+    if (parked.length + fills.length > maxParked) {
+        // Cap overflow: drop OLDEST first (parked front, then incoming front)
+        // so the surviving set reflects the most current chain state. Either
+        // direction is fund-loss without the fund-drift backstop; newest-wins
+        // is the safer choice because stale fills are the most likely to have
+        // been superseded on-chain.
+        const overflow = parked.length + fills.length - maxParked;
+        const dropped = [];
+        let remaining = overflow;
+        if (parked.length > 0 && remaining > 0) {
+            const take = Math.min(parked.length, remaining);
+            dropped.push(...parked.splice(0, take));
+            remaining -= take;
+        }
+        if (remaining > 0) {
+            dropped.push(...fills.splice(0, remaining));
+        }
+        bot.manager?.logger?.log?.(`[FILL] Totals-refresh retry park overflow (cap ${maxParked}): dropping ${dropped.length} oldest fill(s) ` +
+            `(${dropped.map((f) => f?.op?.[1]?.order_id ?? '?').join(',')}); fund-drift detection is the backstop`, 'error');
+        if (fills.length === 0)
+            return;
+    }
+    parked.push(...fills);
+    // A retry is already scheduled — it picks these up; one timer at a time.
+    if (bot._fillTotalsRetryTimer)
+        return;
+    const attempt = Number(bot._fillTotalsRetryAttempt) || 0;
+    const baseMs = Number(TIMING?.FILL_TOTALS_RETRY_BASE_MS) > 0
+        ? Number(TIMING.FILL_TOTALS_RETRY_BASE_MS)
+        : 10000;
+    const maxMs = Number(TIMING?.FILL_TOTALS_RETRY_MAX_MS) > 0
+        ? Number(TIMING.FILL_TOTALS_RETRY_MAX_MS)
+        : 60000;
+    const delayMs = resolveSeamMsOrNull(options?.retryDelayMs)
+        ?? Math.min(baseMs * Math.pow(2, Math.min(attempt, 3)), maxMs);
+    // Expose the resolved delay so tests can assert the seam resolution itself
+    // (a `||`-vs-`??` regression here is otherwise invisible: the only
+    // observable effect is a slower retry timer, which nothing measures).
+    // Only written when resolution is reached — the early guards above (empty
+    // fills, already-armed timer) return before this point.
+    bot._fillTotalsRetryDelayMs = delayMs;
+    bot.manager?.logger?.log?.(`[FILL] Parked ${fills.length} fill(s) on totals-refresh failure ` +
+        `(parked=${parked.length}, attempt=${attempt + 1}, retry in ${Math.round(delayMs / 1000)}s); accounting not yet applied`, 'warn');
+    bot._fillTotalsRetryTimer = setTimeout(() => {
+        bot._fillTotalsRetryTimer = null;
+        if (bot._shuttingDown) {
+            bot.manager?.logger?.log?.(`[FILL] Shutdown with ${bot._fillTotalsParkedFills?.length || 0} totals-parked fill(s) unprocessed; grid persistence snapshot is the backstop`, 'error');
+            return;
+        }
+        // Re-read the attempt counter fresh at fire time (do NOT reuse the
+        // `attempt` captured at park time): a clean cycle may have reset
+        // _fillTotalsRetryAttempt to 0 while this timer was pending, and
+        // writing back the stale captured value would spuriously inflate the
+        // backoff chain. Fresh-read self-corrects; the next park recomputes
+        // the delay from the current counter.
+        const freshAttempt = Number(bot._fillTotalsRetryAttempt) || 0;
+        bot._fillTotalsRetryAttempt = freshAttempt + 1;
+        const due = Array.isArray(bot._fillTotalsParkedFills)
+            ? bot._fillTotalsParkedFills.splice(0)
+            : [];
+        if (due.length === 0)
+            return;
+        // NOTE: this unshift runs BEFORE _consumeFillQueue acquires
+        // _fillProcessingLock. Interleaving with an in-flight cycle is benign
+        // by design: the in-flight run already snapshotted its batch, so the
+        // re-queued fills are simply picked up one cycle later (worst case),
+        // and _deferredFillsPending widens the invariant tolerance for that
+        // drain. Do not move the unshift inside the lock without re-checking
+        // the single-flight / bootstrap branches in consumeFillQueue.
+        bot._incomingFillQueue.unshift(...due);
+        bot._deferredFillsPending = true;
+        bot.manager?.logger?.log?.(`[FILL] Retrying ${due.length} totals-parked fill(s) (attempt ${freshAttempt + 1})`, 'warn');
+        const consume = typeof bot._consumeFillQueue === 'function'
+            ? () => bot._consumeFillQueue(chainOrders)
+            : () => consumeFillQueue(bot, chainOrders);
+        consume().catch((err) => {
+            bot._warn?.(`Totals-parked fill retry failed: ${getErrorMessage(err)}`);
+        });
+    }, delayMs);
+}
 /**
  * Consume queued fills from incomingFillQueue and rebalance.
  * Deduplicates fills against already-processed set (replay-safe), syncs filled
@@ -642,6 +856,9 @@ async function consumeFillQueue(bot, chainOrders) {
     // drain itself must not trip the fund invariant.
     const markDeferredDrain = () => { bot._deferredFillsPending = true; };
     if (bot._incomingFillQueue.length === 0) {
+        // Settled: retire the deferred-retry counter so the deferral log
+        // cadence cannot stay elevated after the queue drained elsewhere.
+        bot._deferredFillRetryWaits = 0;
         resetFailureWatchdogIfSet();
         return;
     }
@@ -650,10 +867,24 @@ async function consumeFillQueue(bot, chainOrders) {
         resetFailureWatchdogIfSet();
         return;
     }
+    // Refresh the stale-broadcast watchdog on every consume attempt, not
+    // just in maintenance — a leaked flag with a parked queue holds the
+    // maintenance idle gate shut, so maintenance would never run to clear
+    // it. Guarded: fakes without a manager must still defer cleanly.
+    try {
+        if (typeof bot.manager?._clearStaleBroadcastFlag === 'function') {
+            bot.manager._clearStaleBroadcastFlag();
+        }
+    }
+    catch { /* watchdog must never break fill consumption */ }
     if (bot._batchInFlight || bot._recoverySyncInFlight) {
         bot.manager?.logger?.log?.(`Fill processing deferred: order pipeline active (${bot._incomingFillQueue.length} queued)`, 'debug');
         markDeferredDrain();
         resetFailureWatchdogIfSet();
+        // Level-triggered retry: without this, a lone fill parked here
+        // waits for a region end / second fill / maintenance tick that may
+        // never come (2026-09-13 H-BTS slot-86).
+        scheduleDeferredFillRetry(bot, chainOrders, 'order pipeline active');
         return;
     }
     // Broadcast pre-check (lock-timeout robustness — see
@@ -666,12 +897,19 @@ async function consumeFillQueue(bot, chainOrders) {
         bot.manager?.logger?.log?.(`Fill processing deferred: broadcast active (${bot._incomingFillQueue.length} queued)`, 'debug');
         markDeferredDrain();
         resetFailureWatchdogIfSet();
+        // Level-triggered retry: without this, a lone fill parked here
+        // waits for a region end / second fill / maintenance tick that may
+        // never come (2026-09-13 H-BTS slot-86).
+        scheduleDeferredFillRetry(bot, chainOrders, 'broadcast active');
         return;
     }
     if (broadcastDefer.stuckFallback) {
         bot.manager?.logger?.log?.('Fill processing proceeding despite stuck broadcast flag (deferral bound exceeded; in-lock wait still applies)', 'warn');
     }
     let pendingFillKeysForCurrentCycle = new Set();
+    // Set when this run parked totals-deferred fills: the retry-attempt
+    // backoff counter only resets on runs with no deferrals.
+    let parkedTotalsRetryThisRun = false;
     try {
         if (bot.manager.isBootstrapping()) {
             let bootstrapSkipped = false;
@@ -795,6 +1033,10 @@ async function consumeFillQueue(bot, chainOrders) {
                 let allFilledOrders = [];
                 let ordersNeedingCorrection = [];
                 const residualCancels = [];
+                // Fills deferred on a stale accountTotals refresh: accounting
+                // NOT applied. Collected here, keys released, parked for a
+                // bounded retry after the block loop (never dropped).
+                const deferredRefills = [];
                 const processValidFills = async (fillsToSync) => {
                     let resolvedOrders = [];
                     {
@@ -804,10 +1046,15 @@ async function consumeFillQueue(bot, chainOrders) {
                                 persistenceMode: PROCESSED_FILL_PERSISTENCE_MODES.BATCHED
                             });
                             if (batchResult.deferred) {
-                                // Deferred: stale accountTotals refresh failed.
-                                // Do NOT mark the fills processed — they will be
-                                // re-read and re-processed on the next cycle.
-                                bot.manager.logger.log(`[FILL] Deferred ${fillsToSync.length} fill(s) (stale accountTotals, refresh failed); retrying next cycle.`, 'warn');
+                                // Deferred: stale accountTotals refresh failed —
+                                // accounting NOT applied. Release the consumed
+                                // dedupe keys and park for a bounded retry.
+                                // (The old code returned here: the fills were
+                                // already spliced from the queue and their keys
+                                // stayed marked processed — silent fund loss.)
+                                releaseFillDedupeKeys(bot, processedFillKeys, fillsToSync);
+                                deferredRefills.push(...fillsToSync);
+                                bot.manager.logger.log(`[FILL] Deferred ${fillsToSync.length} fill(s) (stale accountTotals, refresh failed); parking for retry.`, 'warn');
                                 return resolvedOrders;
                             }
                             for (const fill of fillsToSync) {
@@ -837,7 +1084,11 @@ async function consumeFillQueue(bot, chainOrders) {
                                     historyId: fill?.id
                                 });
                                 if (resultHistory.deferred) {
-                                    bot.manager.logger.log(`[FILL] Deferred fill (stale accountTotals, refresh failed); retrying next cycle.`, 'warn');
+                                    // Same totals-refresh deferral as the batch
+                                    // path: release keys, park for retry.
+                                    releaseFillDedupeKeys(bot, processedFillKeys, [fill]);
+                                    deferredRefills.push(fill);
+                                    bot.manager.logger.log(`[FILL] Deferred fill (stale accountTotals, refresh failed); parking for retry.`, 'warn');
                                     continue;
                                 }
                                 if (fillKey)
@@ -914,6 +1165,10 @@ async function consumeFillQueue(bot, chainOrders) {
                         accumulatedOrders.push(...fallbackOrders);
                     }
                     allFilledOrders = accumulatedOrders;
+                    if (deferredRefills.length > 0) {
+                        parkedTotalsRetryThisRun = true;
+                        parkFillsForTotalsRetry(bot, chainOrders, deferredRefills);
+                    }
                     if (ordersNeedingCorrection.length > 0) {
                         const correctionResult = await correctAllPriceMismatches(bot.manager, bot.account, bot.privateKey, chainOrders);
                         if (correctionResult.failed > 0)
@@ -932,8 +1187,11 @@ async function consumeFillQueue(bot, chainOrders) {
                         // Accounting + crawls are applied; only the broadcast was
                         // deferred to avoid sleeping in-lock on the broadcast
                         // flag. Post-fill maintenance would immediately attempt
-                        // the same blocked broadcasts, so skip it here and let
-                        // the region-end hook run one no-fill rebalance.
+                        // the same blocked broadcasts, so skip it here:
+                        // _processFillsWithBatching already scheduled the
+                        // no-fill rebalance that applies the owed boundary
+                        // shift once the pipeline is clear (same idempotent
+                        // scheduler the region-end hook uses).
                         bot.manager?.logger?.log?.('[FILL-QUEUE] Fill rebalance deferred (broadcast active); post-fill maintenance deferred to region end', 'debug');
                     }
                     if (!abortedFillCycle) {
@@ -1026,6 +1284,9 @@ async function consumeFillQueue(bot, chainOrders) {
                 }
             }
             bot._markGridActivity('fill processing end');
+            // A run with no totals-deferrals breaks the retry backoff chain.
+            if (!parkedTotalsRetryThisRun)
+                bot._fillTotalsRetryAttempt = 0;
             bot._consecutiveConsumeFailures = 0;
             bot._consumeFailureFirstAt = 0;
         });
@@ -1059,9 +1320,16 @@ async function consumeFillQueue(bot, chainOrders) {
         if (err.stack)
             bot._log(err.stack, 'error');
     }
+    // Clean settle: a drain that reached the end with an empty queue is the
+    // only place the retry counter is retired — otherwise the elevated count
+    // only matters for log cadence (every 12th defer warns), so reset it here
+    // rather than waiting for a pending retry to fire against an empty queue.
+    if (!bot._incomingFillQueue || bot._incomingFillQueue.length === 0) {
+        bot._deferredFillRetryWaits = 0;
+    }
     if (!bot._shuttingDown && bot._incomingFillQueue.length > 0) {
         scheduleFillConsumerRestart(bot, chainOrders);
     }
 }
-export { wireProcessedFillTracking, flushProcessedFillPersistence, flushProcessedFillPersistenceForKeys, buildOrphanFillFallbackKey, applyReplaySafeFillAccounting, applyReplaySafeTrackedFillAccounting, applyReplaySafeOrphanFillAccounting, processSweepOrphanFill, createFillCallback, maxConsecutiveFillConsumerFailures, computeFillConsumerBackoffMs, scheduleFillConsumerRestart, shouldDeferFillForBroadcast, consumeFillQueue, processFillsWithBootstrapMode };
+export { wireProcessedFillTracking, flushProcessedFillPersistence, flushProcessedFillPersistenceForKeys, buildOrphanFillFallbackKey, applyReplaySafeFillAccounting, applyReplaySafeTrackedFillAccounting, applyReplaySafeOrphanFillAccounting, processSweepOrphanFill, createFillCallback, maxConsecutiveFillConsumerFailures, computeFillConsumerBackoffMs, scheduleFillConsumerRestart, scheduleDeferredFillRetry, shouldDeferFillForBroadcast, consumeFillQueue, processFillsWithBootstrapMode };
 //# sourceMappingURL=dexbot_fill_runtime.js.map