@senpi/runtime 3.0.0-dev.runtime-phase-2.20260623210537 → 3.0.1-dev.openclaw-upgrade-mai.20260625140818

package/dist/dsl/events/handlers.js

@@ -51,7 +51,7 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
                 normalizeDslCoinDex(event.coin, event.dex ?? "").coin &&
             s.direction === newDirection);
     }
-    async function handlePositionOpened(payload, triggerReason) {
+    async function handlePositionOpened(payload, triggerReason, opts) {
         let event = null;
         if (isHookEvent(payload)) {
             event = hookToPositionOpenedEvent(payload);
@@ -72,105 +72,125 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
             return;
         event = normalizePositionOpenedEvent(event);
         const dexKey = event.dex ?? "";
-        const existing = await stateManager.getDslState(event.address, event.coin, dexKey);
-        if (existing?.active) {
-            logger.warn("[dsl] position.opened ignored: DSL state already active for this asset/dex", {
-                address: event.address,
-                asset: event.coin,
-                dex: dexKey,
-            });
-            return;
-        }
-        if (await isDuplicatePositionEvent(event)) {
-            logger.warn("[dsl] duplicate position event ignored (same entry, size, coin, direction)", {
+        const posKey = stateKey(event.address, event.coin, dexKey);
+        // Serialize concurrent opens on the same (address,coin,dex) key.
+        // NON-REENTRANT: callers must NOT hold posKey when calling this function.
+        await stateManager.withKeyLock(posKey, async () => {
+            // Re-read inside the lock so a racing adopt that already wrote is visible.
+            const existing = await stateManager.getDslState(event.address, event.coin, dexKey);
+            if (existing?.active) {
+                logger.warn("[dsl] position.opened ignored: DSL state already active for this asset/dex", {
+                    address: event.address,
+                    asset: event.coin,
+                    dex: dexKey,
+                });
+                return;
+            }
+            if (await isDuplicatePositionEvent(event)) {
+                logger.warn("[dsl] duplicate position event ignored (same entry, size, coin, direction)", {
+                    address: event.address,
+                    asset: event.coin,
+                });
+                return;
+            }
+            const presetName = event.preset ?? config.preset;
+            const preset = config.presets[presetName];
+            if (!preset) {
+                logger.warn("preset not found, skipping DSL", { presetName, asset: event.coin });
+                return;
+            }
+            const entryPrice = parseFloat(String(event.entryPx));
+            const direction = parseFloat(String(event.szi)) > 0 ? "LONG" : "SHORT";
+            const leverage = event.leverage ?? 1;
+            const phase1Floor = phase1FloorFromPreset(entryPrice, direction, preset.maxLossPct, leverage);
+            const resolvedTrigger = triggerReason ?? "position_opened";
+            const state = buildInitialState(event, preset, phase1Floor, resolvedTrigger);
+            const floor = state.floorPrice;
+            logger.info("[dsl] position.opened handling", {
                 address: event.address,
                 asset: event.coin,
-            });
-            return;
-        }
-        const presetName = event.preset ?? config.preset;
-        const preset = config.presets[presetName];
-        if (!preset) {
-            logger.warn("preset not found, skipping DSL", { presetName, asset: event.coin });
-            return;
-        }
-        const entryPrice = parseFloat(String(event.entryPx));
-        const direction = parseFloat(String(event.szi)) > 0 ? "LONG" : "SHORT";
-        const leverage = event.leverage ?? 1;
-        const phase1Floor = phase1FloorFromPreset(entryPrice, direction, preset.maxLossPct, leverage);
-        const resolvedTrigger = triggerReason ?? "position_opened";
-        const state = buildInitialState(event, preset, phase1Floor, resolvedTrigger);
-        const floor = state.floorPrice;
-        logger.info("[dsl] position.opened handling", {
-            address: event.address,
-            asset: event.coin,
-            dex: event.dex ?? "",
-            preset: presetName,
-            floor,
-            wallet: event.wallet,
-        });
-        const strategy = strategyStates.get(event.address);
-        if (!strategy) {
-            logger.warn("[dsl] no strategy found for address, skipping initial SL", { address: event.address });
-            state.slOrderId = null;
-            state.lastSlSyncError = "no strategy state for address";
-            state.lastError = state.lastSlSyncError;
-            state.lastErrorAt = now();
-            await stateManager.setDslState(event.address, event.coin, event.dex ?? "", state);
-            bus.emit(DSL_EVENTS.CREATED, buildDslCreatedPayload(event, presetName, preset, state, now()));
-            return;
-        }
-        const posKey = stateKey(event.address, event.coin, event.dex ?? "");
-        slPlacementInProgress.add(posKey);
-        try {
-            await stateManager.setDslState(event.address, event.coin, event.dex ?? "", state);
-            logger.info("[dsl] initial state written, calling editPosition for initial SL", {
-                asset: event.coin,
-                wallet: event.wallet,
-                dex: event.dex || undefined,
+                dex: event.dex ?? "",
+                preset: presetName,
                 floor,
+                wallet: event.wallet,
             });
+            const strategy = strategyStates.get(event.address);
+            if (!strategy) {
+                logger.warn("[dsl] no strategy found for address, skipping initial SL", { address: event.address });
+                state.slOrderId = null;
+                state.lastSlSyncError = "no strategy state for address";
+                state.lastError = state.lastSlSyncError;
+                state.lastErrorAt = now();
+                await stateManager.setDslState(event.address, event.coin, event.dex ?? "", state);
+                bus.emit(DSL_EVENTS.CREATED, buildDslCreatedPayload(event, presetName, preset, state, now()));
+                return;
+            }
+            const shouldPlaceSl = opts?.placeSl !== false;
+            if (!shouldPlaceSl) {
+                // Adoption with deferred SL: monitor places it on the next tick via shouldSyncExchangeSl.
+                state.slOrderId = null;
+                state.lastSlSyncError = "adopt: SL deferred to monitor";
+                logger.info("[dsl] initial state written, SL deferred to monitor (adopt)", {
+                    asset: event.coin,
+                    wallet: event.wallet,
+                    dex: event.dex || undefined,
+                    floor,
+                });
+                await stateManager.setDslState(event.address, event.coin, event.dex ?? "", state);
+                bus.emit(DSL_EVENTS.CREATED, buildDslCreatedPayload(event, presetName, preset, state, now()));
+                return;
+            }
+            slPlacementInProgress.add(posKey);
             try {
-                const res = await withRetry(() => strategy.editPosition({
-                    coin: event.coin,
+                await stateManager.setDslState(event.address, event.coin, event.dex ?? "", state);
+                logger.info("[dsl] initial state written, calling editPosition for initial SL", {
+                    asset: event.coin,
+                    wallet: event.wallet,
                     dex: event.dex || undefined,
-                    stopLoss: { triggerPx: floor },
-                }), {
-                    retries: DSL_EXTERNAL_RETRIES,
-                    delayMs: DSL_EXTERNAL_RETRY_DELAY_MS,
-                    label: "editPosition (initial SL)",
-                    onRetry: (attempt, remaining, err) => logger.warn("[dsl] editPosition retry", { attempt, remaining, asset: event.coin, err }),
+                    floor,
                 });
-                state.slOrderId = res.slOrderId ?? null;
-                state.lastSyncedFloorPrice = floor;
-                state.slOrderIdUpdatedAt = now();
-                state.lastSlSyncError = null;
-                logger.info("[dsl] exchange SL created (position.opened)", {
+                try {
+                    const res = await withRetry(() => strategy.editPosition({
+                        coin: event.coin,
+                        dex: event.dex || undefined,
+                        stopLoss: { triggerPx: floor },
+                    }), {
+                        retries: DSL_EXTERNAL_RETRIES,
+                        delayMs: DSL_EXTERNAL_RETRY_DELAY_MS,
+                        label: "editPosition (initial SL)",
+                        onRetry: (attempt, remaining, err) => logger.warn("[dsl] editPosition retry", { attempt, remaining, asset: event.coin, err }),
+                    });
+                    state.slOrderId = res.slOrderId ?? null;
+                    state.lastSyncedFloorPrice = floor;
+                    state.slOrderIdUpdatedAt = now();
+                    state.lastSlSyncError = null;
+                    logger.info("[dsl] exchange SL created (position.opened)", {
+                        asset: event.coin,
+                        address: event.address,
+                        slOrderId: state.slOrderId,
+                        floorPrice: floor,
+                        entryPrice: state.entryPrice,
+                    });
+                }
+                catch (err) {
+                    state.slOrderId = null;
+                    state.lastSlSyncError = String(err);
+                    state.lastError = String(err);
+                    state.lastErrorAt = now();
+                    logger.warn("initial SL place failed", { asset: event.coin, err });
+                }
+                logger.info("[dsl] writing state after initial SL", {
                     asset: event.coin,
-                    address: event.address,
                     slOrderId: state.slOrderId,
-                    floorPrice: floor,
-                    entryPrice: state.entryPrice,
+                    key: posKey,
                 });
+                await stateManager.setDslState(event.address, event.coin, event.dex ?? "", state);
+                bus.emit(DSL_EVENTS.CREATED, buildDslCreatedPayload(event, presetName, preset, state, now()));
             }
-            catch (err) {
-                state.slOrderId = null;
-                state.lastSlSyncError = String(err);
-                state.lastError = String(err);
-                state.lastErrorAt = now();
-                logger.warn("initial SL place failed", { asset: event.coin, err });
+            finally {
+                slPlacementInProgress.delete(posKey);
             }
-            logger.info("[dsl] writing state after initial SL", {
-                asset: event.coin,
-                slOrderId: state.slOrderId,
-                key: posKey,
-            });
-            await stateManager.setDslState(event.address, event.coin, event.dex ?? "", state);
-            bus.emit(DSL_EVENTS.CREATED, buildDslCreatedPayload(event, presetName, preset, state, now()));
-        }
-        finally {
-            slPlacementInProgress.delete(posKey);
-        }
+        });
     }
     async function handlePositionClosed(payload) {
         let event = null;
@@ -188,62 +208,65 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
             asset: event.asset,
             dex: event.dex ?? "",
         });
-        const state = await stateManager.getDslStateByAsset(event.address, event.asset, event.dex);
-        if (!state?.active)
-            return;
-        logger.info("[dsl] closing active state", { asset: state.asset, slOrderId: state.slOrderId });
-        let reason = CLOSE_REASON.MANUAL_CLOSE;
-        if (state.slOrderId != null) {
-            try {
-                const strategy = strategyStates.get(state.address);
-                const status = strategy
-                    ? await withRetry(() => strategy.getOrderStatus(state.slOrderId), {
-                        retries: DSL_EXTERNAL_RETRIES,
-                        delayMs: DSL_EXTERNAL_RETRY_DELAY_MS,
-                        label: "getOrderStatus (position.closed)",
-                        onRetry: (attempt, remaining, err) => logger.warn("[dsl] getOrderStatus retry", { attempt, remaining, asset: event.asset, err }),
-                    })
-                    : null;
-                if (status?.filled)
-                    reason = CLOSE_REASON.EXCHANGE_SL_HIT;
+        const closedKey = stateKey(event.address, event.asset, event.dex ?? "");
+        await stateManager.withKeyLock(closedKey, async () => {
+            const state = await stateManager.getDslStateByAsset(event.address, event.asset, event.dex);
+            if (!state?.active)
+                return;
+            logger.info("[dsl] closing active state", { asset: state.asset, slOrderId: state.slOrderId });
+            let reason = CLOSE_REASON.MANUAL_CLOSE;
+            if (state.slOrderId != null) {
+                try {
+                    const strategy = strategyStates.get(state.address);
+                    const status = strategy
+                        ? await withRetry(() => strategy.getOrderStatus(state.slOrderId), {
+                            retries: DSL_EXTERNAL_RETRIES,
+                            delayMs: DSL_EXTERNAL_RETRY_DELAY_MS,
+                            label: "getOrderStatus (position.closed)",
+                            onRetry: (attempt, remaining, err) => logger.warn("[dsl] getOrderStatus retry", { attempt, remaining, asset: event.asset, err }),
+                        })
+                        : null;
+                    if (status?.filled)
+                        reason = CLOSE_REASON.EXCHANGE_SL_HIT;
+                }
+                catch (e) {
+                    logger.warn("getOrderStatus failed, assuming manual_close", { asset: event.asset, err: e });
+                }
             }
-            catch (e) {
-                logger.warn("getOrderStatus failed, assuming manual_close", { asset: event.asset, err: e });
+            const rawCloseReason = fromHook ? payload.data?.closeReason : undefined;
+            const dataCloseReason = typeof rawCloseReason === "string" ? rawCloseReason : null;
+            const archiveCloseReason = reason === CLOSE_REASON.MANUAL_CLOSE && dataCloseReason ? dataCloseReason : reason;
+            logger.info("[dsl] archiving position (position.closed)", {
+                address: event.address,
+                asset: state.asset,
+                closeReason: archiveCloseReason,
+                slOrderId: state.slOrderId,
+                fromHook: fromHook,
+            });
+            const closedState = { ...state, active: false, closedAt: now(), closeReason: archiveCloseReason };
+            await stateManager.archiveAndDeleteDslState(state.address, state.asset, state.dex, closedState);
+            if (state.handoffStatus === "ok" && state.backendDslPositionId != null) {
+                fireAndForgetBackendDelete(state, "position.closed");
             }
-        }
-        const rawCloseReason = fromHook ? payload.data?.closeReason : undefined;
-        const dataCloseReason = typeof rawCloseReason === "string" ? rawCloseReason : null;
-        const archiveCloseReason = reason === CLOSE_REASON.MANUAL_CLOSE && dataCloseReason ? dataCloseReason : reason;
-        logger.info("[dsl] archiving position (position.closed)", {
-            address: event.address,
-            asset: state.asset,
-            closeReason: archiveCloseReason,
-            slOrderId: state.slOrderId,
-            fromHook: fromHook,
-        });
-        const closedState = { ...state, active: false, closedAt: now(), closeReason: archiveCloseReason };
-        await stateManager.archiveAndDeleteDslState(state.address, state.asset, state.dex, closedState);
-        if (state.handoffStatus === "ok" && state.backendDslPositionId != null) {
-            fireAndForgetBackendDelete(state, "position.closed");
-        }
-        const closedTs = now();
-        bus.emit(EVENTS.POSITION_CLOSED, {
-            address: state.address,
-            asset: state.asset,
-            wallet: state.wallet,
-            reason,
-            closeReason: archiveCloseReason,
-            timestamp: closedTs,
-            // Provenance marker (data only, no consumer branches on it): this emit re-broadcasts a close
-            // after archiving DSL state; the recording subscriber skips it to avoid double-counting a
-            // close already recorded from the original (enveloped or flat) emit.
-            source: "dsl_archive",
+            const closedTs = now();
+            bus.emit(EVENTS.POSITION_CLOSED, {
+                address: state.address,
+                asset: state.asset,
+                wallet: state.wallet,
+                reason,
+                closeReason: archiveCloseReason,
+                timestamp: closedTs,
+                // Provenance marker (data only, no consumer branches on it): this emit re-broadcasts a close
+                // after archiving DSL state; the recording subscriber skips it to avoid double-counting a
+                // close already recorded from the original (enveloped or flat) emit.
+                source: "dsl_archive",
+            });
+            bus.emit(DSL_EVENTS.CLOSED, buildDslClosedEventFromState(closedState, {
+                reason: archiveCloseReason,
+                closeReason: archiveCloseReason,
+                timestamp: closedTs,
+            }));
         });
-        bus.emit(DSL_EVENTS.CLOSED, buildDslClosedEventFromState(closedState, {
-            reason: archiveCloseReason,
-            closeReason: archiveCloseReason,
-            timestamp: closedTs,
-        }));
     }
     async function handlePositionFlipped(payload) {
         let event = null;
@@ -260,26 +283,36 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
             archiveAsset: event.asset,
             newCoin: event.coin,
         });
+        // Archive the OLD state under its own key — lock released before calling handlePositionOpened
+        // (which locks the NEW key itself; keys differ after a flip).
         const oldState = await stateManager.getDslStateByAsset(event.address, event.asset, event.dex);
         if (oldState?.active) {
-            logger.info("[dsl] archiving position (position.flipped)", {
-                address: event.address,
-                asset: oldState.asset,
-                dex: oldState.dex ?? "",
-                closeReason: CLOSE_REASON.FLIPPED,
-                slOrderId: oldState.slOrderId,
+            const oldKey = stateKey(event.address, oldState.asset, oldState.dex ?? "");
+            await stateManager.withKeyLock(oldKey, async () => {
+                // Re-read to confirm still active (concurrent close could have already archived it).
+                const currentOld = await stateManager.getDslStateByAsset(event.address, event.asset, event.dex);
+                if (!currentOld?.active)
+                    return;
+                logger.info("[dsl] archiving position (position.flipped)", {
+                    address: event.address,
+                    asset: currentOld.asset,
+                    dex: currentOld.dex ?? "",
+                    closeReason: CLOSE_REASON.FLIPPED,
+                    slOrderId: currentOld.slOrderId,
+                });
+                const closedState = { ...currentOld, active: false, closedAt: now(), closeReason: CLOSE_REASON.FLIPPED };
+                // Must use canonical keys from loaded state — not event.asset (e.g. xyz:BASE vs BASE + dex xyz
+                // produce different stateKey paths; wrong asset would archive nothing and leave the live file active).
+                await stateManager.archiveAndDeleteDslState(event.address, currentOld.asset, currentOld.dex ?? "", closedState);
+                if (currentOld.handoffStatus === "ok" && currentOld.backendDslPositionId != null) {
+                    fireAndForgetBackendDelete(currentOld, "position.flipped");
+                }
             });
-            const closedState = { ...oldState, active: false, closedAt: now(), closeReason: CLOSE_REASON.FLIPPED };
-            // Must use canonical keys from loaded state — not event.asset (e.g. xyz:BASE vs BASE + dex xyz
-            // produce different stateKey paths; wrong asset would archive nothing and leave the live file active).
-            await stateManager.archiveAndDeleteDslState(event.address, oldState.asset, oldState.dex ?? "", closedState);
-            if (oldState.handoffStatus === "ok" && oldState.backendDslPositionId != null) {
-                fireAndForgetBackendDelete(oldState, "position.flipped");
-            }
         }
         else {
             logger.warn("[dsl] position.flipped: no active DSL state matched for archive (check asset/dex vs state file). If a live file still exists for this market, the next position.opened may be ignored as duplicate.", { address: event.address, asset: event.asset, dex: event.dex ?? "" });
         }
+        // Old-key lock is released above. handlePositionOpened locks the NEW key itself.
         // New row uses `coin` (and dex) from the flip payload — not `asset`, which identifies the pre-flip state for archival.
         const openedPayload = {
             address: event.address,
@@ -305,8 +338,13 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
         if (!raw)
             return;
         const event = normalizePositionOpenedEvent(raw);
-        const oldState = await stateManager.getDslStateByAsset(event.address, event.coin, event.dex);
-        if (oldState?.active) {
+        // Archive the OLD state under its key — lock released BEFORE calling handlePositionOpened
+        // (which re-locks the same key; holding it across the nested call would deadlock).
+        const archiveKey = stateKey(event.address, event.coin, event.dex ?? "");
+        await stateManager.withKeyLock(archiveKey, async () => {
+            const oldState = await stateManager.getDslStateByAsset(event.address, event.coin, event.dex);
+            if (!oldState?.active)
+                return;
             const closedState = {
                 ...oldState,
                 active: false,
@@ -319,7 +357,8 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
             if (oldState.handoffStatus === "ok" && oldState.backendDslPositionId != null) {
                 fireAndForgetBackendDelete(oldState, "position.increased");
             }
-        }
+        });
+        // archiveKey lock is released; handlePositionOpened re-acquires it safely.
         await handlePositionOpened(event, "position_increased");
     }
     async function handlePositionDecreased(payload) {
@@ -333,8 +372,13 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
         if (!raw)
             return;
         const event = normalizePositionOpenedEvent(raw);
-        const oldState = await stateManager.getDslStateByAsset(event.address, event.coin, event.dex);
-        if (oldState?.active) {
+        // Archive the OLD state under its key — lock released BEFORE calling handlePositionOpened
+        // (which re-locks the same key; holding it across the nested call would deadlock).
+        const archiveKey = stateKey(event.address, event.coin, event.dex ?? "");
+        await stateManager.withKeyLock(archiveKey, async () => {
+            const oldState = await stateManager.getDslStateByAsset(event.address, event.coin, event.dex);
+            if (!oldState?.active)
+                return;
             const closedState = {
                 ...oldState,
                 active: false,
@@ -347,7 +391,8 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
             if (oldState.handoffStatus === "ok" && oldState.backendDslPositionId != null) {
                 fireAndForgetBackendDelete(oldState, "position.decreased");
             }
-        }
+        });
+        // archiveKey lock is released; handlePositionOpened re-acquires it safely.
         await handlePositionOpened(event, "position_decreased");
     }
     async function deleteDslsForStrategy(address) {
@@ -355,62 +400,70 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
         const ts = now();
         let abandoned = 0;
         for (const key of keys) {
-            const state = await stateManager.getOrLoad(key);
-            if (!state?.active)
+            // Peek outside the lock to skip inactive entries cheaply.
+            const peeked = await stateManager.getOrLoad(key);
+            if (!peeked?.active)
                 continue;
-            abandoned += 1;
-            const strategy = strategyStates.get(state.address);
-            const cleanupPromises = [];
-            if (strategy) {
-                cleanupPromises.push(withRetry(() => strategy.editPosition({ coin: state.asset, dex: state.dex || undefined }), {
-                    retries: DSL_EXTERNAL_RETRIES,
-                    delayMs: DSL_EXTERNAL_RETRY_DELAY_MS,
-                    label: "editPosition (cancel SL, dsl delete)",
-                    onRetry: (attempt, remaining, err) => logger.warn("[dsl] editPosition cancel SL retry", { attempt, remaining, err }),
-                }).then(() => undefined).catch((err) => {
-                    logger.warn("[dsl] cancel SL failed during deleteDslsForStrategy; continuing archive", {
-                        address,
+            // Lock the per-position key for the archive RMW.
+            const perPosKey = stateKey(peeked.address, peeked.asset, peeked.dex ?? "");
+            await stateManager.withKeyLock(perPosKey, async () => {
+                const state = await stateManager.getOrLoad(key);
+                if (!state?.active)
+                    return;
+                abandoned += 1;
+                const strategy = strategyStates.get(state.address);
+                const cleanupPromises = [];
+                if (strategy) {
+                    cleanupPromises.push(withRetry(() => strategy.editPosition({ coin: state.asset, dex: state.dex || undefined }), {
+                        retries: DSL_EXTERNAL_RETRIES,
+                        delayMs: DSL_EXTERNAL_RETRY_DELAY_MS,
+                        label: "editPosition (cancel SL, dsl delete)",
+                        onRetry: (attempt, remaining, err) => logger.warn("[dsl] editPosition cancel SL retry", { attempt, remaining, err }),
+                    }).then(() => undefined).catch((err) => {
+                        logger.warn("[dsl] cancel SL failed during deleteDslsForStrategy; continuing archive", {
+                            address,
+                            asset: state.asset,
+                            err,
+                        });
+                    }));
+                }
+                else {
+                    logger.warn("[dsl] no strategy found for address, skipping SL cancel", { address });
+                }
+                if (state.handoffStatus === "ok" && state.backendDslPositionId != null && strategy) {
+                    cleanupPromises.push(strategy.deleteRatchetStop({
                         asset: state.asset,
-                        err,
-                    });
-                }));
-            }
-            else {
-                logger.warn("[dsl] no strategy found for address, skipping SL cancel", { address });
-            }
-            if (state.handoffStatus === "ok" && state.backendDslPositionId != null && strategy) {
-                cleanupPromises.push(strategy.deleteRatchetStop({
+                        dex: state.dex || undefined,
+                    }).then(() => {
+                        logger.info("[dsl] deleted backend dsl position (deleteDslsForStrategy)", {
+                            address,
+                            asset: state.asset,
+                        });
+                    }).catch((err) => {
+                        logger.warn("[dsl] failed to delete backend dsl position (deleteDslsForStrategy)", {
+                            address,
+                            asset: state.asset,
+                            err,
+                        });
+                    }));
+                }
+                await Promise.all(cleanupPromises);
+                const closedState = {
+                    ...state,
+                    active: false,
+                    closedAt: ts,
+                    closeReason: CLOSE_REASON.DSL_DELETED,
+                };
+                await stateManager.archiveAndDeleteDslState(state.address, state.asset, state.dex, closedState);
+                bus.emit(DSL_EVENTS.DELETED, {
+                    address: state.address,
                     asset: state.asset,
-                    dex: state.dex || undefined,
-                }).then(() => {
-                    logger.info("[dsl] deleted backend dsl position (deleteDslsForStrategy)", {
-                        address,
-                        asset: state.asset,
-                    });
-                }).catch((err) => {
-                    logger.warn("[dsl] failed to delete backend dsl position (deleteDslsForStrategy)", {
-                        address,
-                        asset: state.asset,
-                        err,
-                    });
-                }));
-            }
-            await Promise.all(cleanupPromises);
-            const closedState = {
-                ...state,
-                active: false,
-                closedAt: ts,
-                closeReason: CLOSE_REASON.DSL_DELETED,
-            };
-            await stateManager.archiveAndDeleteDslState(state.address, state.asset, state.dex, closedState);
-            bus.emit(DSL_EVENTS.DELETED, {
-                address: state.address,
-                asset: state.asset,
-                dex: state.dex ?? "",
-                triggerReason: state.triggerReason,
-                __positionId: state.positionId ?? state.correlationId,
-                __correlationId: state.correlationId,
-                timestamp: ts,
+                    dex: state.dex ?? "",
+                    triggerReason: state.triggerReason,
+                    __positionId: state.positionId ?? state.correlationId,
+                    __correlationId: state.correlationId,
+                    timestamp: ts,
+                });
             });
         }
         return abandoned;
@@ -418,6 +471,40 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
     function isSlPlacementInProgress(key) {
         return slPlacementInProgress.has(key);
     }
+    /**
+     * Adopt an orphaned exchange position into DSL.
+     * Calls handlePositionOpened directly — NO bus emit of on_position_opened / position.opened.
+     * triggerReason is always "adopted" so formatDslCreated returns null (no user "Opened" message).
+     */
+    async function adoptPosition(payload, opts) {
+        await handlePositionOpened(payload, "adopted", opts);
+    }
+    /**
+     * Resize: archive any existing ACTIVE DSL state for the (coin, dex), then call adoptPosition.
+     * Archive uses CLOSE_REASON.RECONCILE_RESIZE. Lock is released before the nested adopt
+     * (same pattern as handlePositionIncreased) to avoid deadlock.
+     */
+    async function resizePosition(payload, opts) {
+        const dexKey = payload.dex ?? "";
+        const archiveKey = stateKey(payload.address, payload.coin, dexKey);
+        await stateManager.withKeyLock(archiveKey, async () => {
+            const oldState = await stateManager.getDslStateByAsset(payload.address, payload.coin, dexKey);
+            if (!oldState?.active)
+                return;
+            const closedState = {
+                ...oldState,
+                active: false,
+                closedAt: now(),
+                closeReason: CLOSE_REASON.RECONCILE_RESIZE,
+            };
+            await stateManager.archiveAndDeleteDslState(payload.address, oldState.asset, oldState.dex, closedState);
+            if (oldState.handoffStatus === "ok" && oldState.backendDslPositionId != null) {
+                fireAndForgetBackendDelete(oldState, "reconcile_resize");
+            }
+        });
+        // archiveKey lock released above; adoptPosition (via handlePositionOpened) re-acquires it safely.
+        await adoptPosition(payload, opts);
+    }
     function fireAndForgetBackendDelete(state, trigger) {
         const resolveAndDelete = async () => {
             const strategy = strategyStates.get(state.address);
@@ -465,6 +552,8 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
         handlePositionDecreased,
         deleteDslsForStrategy,
         isSlPlacementInProgress,
+        adoptPosition,
+        resizePosition,
     };
 }
 //# sourceMappingURL=handlers.js.map