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

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, opts) {
+    async function handlePositionOpened(payload, triggerReason) {
         let event = null;
         if (isHookEvent(payload)) {
             event = hookToPositionOpenedEvent(payload);
@@ -72,125 +72,105 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
             return;
         event = normalizePositionOpenedEvent(event);
         const dexKey = event.dex ?? "";
-        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", {
+        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: event.dex ?? "",
-                preset: presetName,
-                floor,
+                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,
+            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,
+                floor,
             });
-            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 {
-                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,
+                const res = await withRetry(() => strategy.editPosition({
+                    coin: event.coin,
                     dex: event.dex || undefined,
-                    floor,
+                    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 }),
                 });
-                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", {
+                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,
-                    key: posKey,
+                    floorPrice: floor,
+                    entryPrice: state.entryPrice,
                 });
-                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);
+            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,
+                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;
@@ -208,65 +188,62 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
             asset: event.asset,
             dex: event.dex ?? "",
         });
-        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 });
-                }
+        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 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");
+            catch (e) {
+                logger.warn("getOrderStatus failed, assuming manual_close", { asset: event.asset, err: e });
             }
-            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,
-            }));
+        }
+        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",
         });
+        bus.emit(DSL_EVENTS.CLOSED, buildDslClosedEventFromState(closedState, {
+            reason: archiveCloseReason,
+            closeReason: archiveCloseReason,
+            timestamp: closedTs,
+        }));
     }
     async function handlePositionFlipped(payload) {
         let event = null;
@@ -283,36 +260,26 @@ 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) {
-            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");
-                }
+            logger.info("[dsl] archiving position (position.flipped)", {
+                address: event.address,
+                asset: oldState.asset,
+                dex: oldState.dex ?? "",
+                closeReason: CLOSE_REASON.FLIPPED,
+                slOrderId: oldState.slOrderId,
             });
+            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,
@@ -338,13 +305,8 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
         if (!raw)
             return;
         const event = normalizePositionOpenedEvent(raw);
-        // 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 oldState = await stateManager.getDslStateByAsset(event.address, event.coin, event.dex);
+        if (oldState?.active) {
             const closedState = {
                 ...oldState,
                 active: false,
@@ -357,8 +319,7 @@ 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) {
@@ -372,13 +333,8 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
         if (!raw)
             return;
         const event = normalizePositionOpenedEvent(raw);
-        // 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 oldState = await stateManager.getDslStateByAsset(event.address, event.coin, event.dex);
+        if (oldState?.active) {
             const closedState = {
                 ...oldState,
                 active: false,
@@ -391,8 +347,7 @@ 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) {
@@ -400,70 +355,62 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
         const ts = now();
         let abandoned = 0;
         for (const key of keys) {
-            // Peek outside the lock to skip inactive entries cheaply.
-            const peeked = await stateManager.getOrLoad(key);
-            if (!peeked?.active)
+            const state = await stateManager.getOrLoad(key);
+            if (!state?.active)
                 continue;
-            // 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({
+            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,
-                        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,
+                        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,
-                    dex: state.dex ?? "",
-                    triggerReason: state.triggerReason,
-                    __positionId: state.positionId ?? state.correlationId,
-                    __correlationId: state.correlationId,
-                    timestamp: ts,
-                });
+                    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,
             });
         }
         return abandoned;
@@ -471,40 +418,6 @@ 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);
@@ -552,8 +465,6 @@ export function createEventHandlers(config, stateManager, strategyStates, bus, _
         handlePositionDecreased,
         deleteDslsForStrategy,
         isSlPlacementInProgress,
-        adoptPosition,
-        resizePosition,
     };
 }
 //# sourceMappingURL=handlers.js.map