@senpi/runtime 3.0.6-dev.skill-manager-v2.20260629194505 → 3.0.9-dev.runtime-phase-2.20260707070820

package/dist/dsl/monitor/process-one-position.js

@@ -5,12 +5,17 @@ import { dslTick, exchangeStopLossTriggerPx } from "../engine/index.js";
 import { CLOSE_REASON, MAX_CONSECUTIVE_CLOSE_FAILURES, DSL_EXTERNAL_RETRIES, DSL_EXTERNAL_RETRY_DELAY_MS, DSL_EVENTS, EVENTS, DSL_PRICE_FETCH_FAILURE_WARN_THRESHOLD, DSL_HEARTBEAT_FIRST_HOUR_MS, DSL_HEARTBEAT_INTERVAL_MS, DSL_HEARTBEAT_TIER_SUPPRESS_MS, } from "../../constants/dsl/index.js";
 import { logger } from "../../utils/logger/dsl.js";
 import { withRetry } from "../../utils/retry.js";
+import { withSpan } from "../../telemetry/tracing.js";
+import { errorTypeOf } from "../../telemetry/spans/gen-ai.js";
+import { recordDslDegradation } from "../../telemetry/metrics.js";
 import { effectiveDex } from "./effective-dex.js";
 import { shouldSyncExchangeSl } from "./exchange-sync.js";
 import { mapTiersToEngineConfig, mapEnginePositionToStateFields, parseSlOrderId } from "../engine-client/config-mapping.js";
 import { mapBackendEventToBusEvent } from "../engine-client/event-mapping.js";
 import { buildDslClosedEventFromState } from "../events/build-closed-event.js";
 import { parseCloseFillDetail } from "../../senpi/client.js";
+import { emitEvent } from "../../actions/event-derivation.js";
+import { buildSlSyncFailedEvent, buildPriceFetchStaleEvent, buildHandoffFailedEvent, } from "./dsl-failure-events.js";
 /**
  * Re-read the key under its per-key lock; if it is still active, archive it and return true.
  * If a competing locked writer already archived/inactivated it, skip and return false (WARN).
@@ -60,11 +65,18 @@ async function setIfStillActive(stateManager, key, address, asset, buildNext, ct
 function closedEmitStamps(state, fill = {}) {
     return {
         __positionId: state.positionId ?? state.correlationId,
-        __correlationId: state.correlationId,
         ...fill,
     };
 }
-export async function processOnePosition(ctx, key, state, price) {
+/** The position identity a DSL failure event pins onto its record. */
+function failureContext(state) {
+    return {
+        asset: state.asset,
+        dex: state.dex || undefined,
+        positionId: state.positionId ?? state.correlationId,
+    };
+}
+export async function processOnePosition(ctx, key, state, price, span) {
     const { tickId, ts, now: isoNow, stateManager, strategyStates, bus, isSlPlacementInProgress = () => false } = ctx;
     const strategy = strategyStates.get(state.address);
     if (!strategy) {
@@ -93,13 +105,15 @@ export async function processOnePosition(ctx, key, state, price) {
     });
     if (state.slOrderId != null) {
         try {
-            const status = await withRetry(() => strategy.getOrderStatus(state.slOrderId), {
+            const status = await withSpan("dsl.sl_check", {}, () => withRetry(() => strategy.getOrderStatus(state.slOrderId), {
                 retries: DSL_EXTERNAL_RETRIES,
                 delayMs: DSL_EXTERNAL_RETRY_DELAY_MS,
                 label: "getOrderStatus (SL-hit check)",
                 onRetry: (attempt, remaining, err) => logger.warn("[dsl] getOrderStatus retry", { asset: state.asset, attempt, remaining, err }),
-            });
+            }));
             if (status?.filled) {
+                span.addEvent("external_close_detected", { source: "sl_order" });
+                span.setAttribute("senpi.dsl.close_reason", CLOSE_REASON.EXCHANGE_SL_HIT);
                 logger.info("[dsl] exchange SL filled, archiving position", {
                     tickId,
                     asset: state.asset,
@@ -145,10 +159,8 @@ export async function processOnePosition(ctx, key, state, price) {
             reason: closeReasonToUse,
             attempt: next.consecutiveCloseFailures,
         });
-        const closeStartedAt = Date.now();
-        let closeAttemptEmitted = false;
         try {
-            const closeResult = await withRetry(() => strategy.closePosition(state.asset, closeReasonToUse, state.dex || undefined, {
+            const closeResult = await withSpan("dsl.close_attempt", { "senpi.dsl.attempt": next.consecutiveCloseFailures }, () => withRetry(() => strategy.closePosition(state.asset, closeReasonToUse, state.dex || undefined, {
                 orderType: ctx.closeOrderType,
                 feeOptimizedLimitOptions: ctx.feeOptimizedLimitOptions,
             }), {
@@ -156,22 +168,8 @@ export async function processOnePosition(ctx, key, state, price) {
                 delayMs: DSL_EXTERNAL_RETRY_DELAY_MS,
                 label: "closePosition (pendingClose)",
                 onRetry: (attempt, remaining, err) => logger.warn("[dsl] closePosition retry", { asset: state.asset, attempt, remaining, err }),
-            });
-            // Telemetry-only fire-and-forget: the venue-call window for the dsl.close_attempt span.
-            bus.emit("tracking.dsl_close_attempt", {
-                tickId,
-                key,
-                asset: state.asset,
-                dex,
-                positionId: state.positionId ?? state.correlationId,
-                startedAt: closeStartedAt,
-                endedAt: Date.now(),
-                outcome: "ok",
-                closeReason: closeReasonToUse,
-                attempt: next.consecutiveCloseFailures,
-                timestamp: isoNow(),
-            });
-            closeAttemptEmitted = true;
+            }));
+            span.setAttribute("senpi.dsl.close_reason", closeReasonToUse);
             const closeFill = parseCloseFillDetail(closeResult);
             logger.info("[dsl] closePosition succeeded, archiving (pendingClose)", {
                 tickId,
@@ -199,25 +197,6 @@ export async function processOnePosition(ctx, key, state, price) {
         }
         catch (e) {
             logger.warn("closePosition retry failed", { asset: state.asset, err: e });
-            // Telemetry-only fire-and-forget: the failed venue-call window (dsl.close_attempt, error).
-            // Guarded: when the ok emit already fired, the venue call itself succeeded — a later
-            // state-write throw must not be misattributed to the venue.
-            if (!closeAttemptEmitted) {
-                bus.emit("tracking.dsl_close_attempt", {
-                    tickId,
-                    key,
-                    asset: state.asset,
-                    dex,
-                    positionId: state.positionId ?? state.correlationId,
-                    startedAt: closeStartedAt,
-                    endedAt: Date.now(),
-                    outcome: "error",
-                    closeReason: closeReasonToUse,
-                    attempt: next.consecutiveCloseFailures,
-                    error: String(e),
-                    timestamp: isoNow(),
-                });
-            }
             next.lastError = String(e);
             next.lastErrorAt = ts;
             const crossedThreshold = (next.consecutiveCloseFailures ?? 0) >= MAX_CONSECUTIVE_CLOSE_FAILURES;
@@ -249,7 +228,6 @@ export async function processOnePosition(ctx, key, state, price) {
                     attempt: next.consecutiveCloseFailures,
                     triggerReason: state.triggerReason,
                     __positionId: state.positionId ?? state.correlationId,
-                    __correlationId: state.correlationId,
                     timestamp: isoNow(),
                 });
             }
@@ -259,18 +237,23 @@ export async function processOnePosition(ctx, key, state, price) {
     if (price == null) {
         const next = { ...state, consecutiveFetchFailures: (state.consecutiveFetchFailures ?? 0) + 1 };
         next.tickCount = (state.tickCount ?? 0) + 1;
+        // Edge-triggered: fire once when the streak first reaches the stale threshold (the alertable
+        // transition); the per-tick info line below covers ongoing visibility. A `>=` test (not `===`)
+        // latched on the state so a counter rehydrated at/above the threshold mid-stall (post-restart)
+        // still fires once; the priced-tick re-arm below clears the latch for the next stall.
+        const shouldEmitStale = next.consecutiveFetchFailures >= DSL_PRICE_FETCH_FAILURE_WARN_THRESHOLD &&
+            !state.priceFetchStaleEmitted;
+        if (shouldEmitStale)
+            next.priceFetchStaleEmitted = true;
         await setIfStillActive(stateManager, key, state.address, state.asset, (current) => ({
             ...current,
             consecutiveFetchFailures: (current.consecutiveFetchFailures ?? 0) + 1,
             tickCount: (current.tickCount ?? 0) + 1,
+            ...(shouldEmitStale ? { priceFetchStaleEmitted: true } : {}),
         }), { tickId, skipMessage: "[dsl] skip no-price counter write: state already cleared (concurrent close)" });
-        if (next.consecutiveFetchFailures >= DSL_PRICE_FETCH_FAILURE_WARN_THRESHOLD) {
-            logger.warn("[dsl] sustained price fetch failures for position", {
-                tickId,
-                key,
-                asset: state.asset,
-                consecutiveFetchFailures: next.consecutiveFetchFailures,
-            });
+        if (shouldEmitStale) {
+            emitEvent(logger, () => buildPriceFetchStaleEvent(failureContext(state), next.consecutiveFetchFailures));
+            recordDslDegradation({ failure: "price_stale" });
         }
         logger.info("[dsl] monitor no price for position, skipping dslTick", {
             tickId,
@@ -281,8 +264,29 @@ export async function processOnePosition(ctx, key, state, price) {
         return;
     }
     const result = dslTick(state, price, ts);
+    if (result.floorChanged) {
+        span.addEvent("floorChanged", { "senpi.dsl.floor_price": result.state.floorPrice });
+    }
+    if (result.phaseChanged) {
+        span.addEvent("phaseChanged", { "senpi.dsl.phase": result.newPhase ?? 2 });
+    }
+    if (result.tierChanged && result.newTierIndex != null) {
+        span.addEvent("tier_advanced", { "senpi.dsl.tier_index": result.newTierIndex });
+    }
+    if ((result.state.currentBreachCount ?? 0) > (state.currentBreachCount ?? 0)) {
+        span.addEvent("breach_detected", {
+            count: result.state.currentBreachCount,
+            required: result.state.breachesRequired,
+        });
+    }
+    span.setAttribute("senpi.dsl.phase", result.state.phase);
+    if (result.state.currentTierIndex != null) {
+        span.setAttribute("senpi.dsl.tier_index", result.state.currentTierIndex);
+    }
     const next = { ...result.state };
     next.consecutiveFetchFailures = 0;
+    // Re-arm the stale-event latch: the price is back, so the next stall fires a fresh event.
+    next.priceFetchStaleEmitted = false;
     next.tickCount = (state.tickCount ?? 0) + 1;
     next.lastError = null;
     next.lastErrorAt = null;
@@ -314,6 +318,8 @@ export async function processOnePosition(ctx, key, state, price) {
     });
     if (result.action === "close") {
         const closeReasonToUse = result.closeReason ?? CLOSE_REASON.DSL_BREACH;
+        span.setAttribute("senpi.dsl.current_roe", next.currentROE);
+        span.setAttribute("senpi.dsl.floor_price", next.floorPrice);
         if (closeReasonToUse === CLOSE_REASON.DSL_BREACH && next.phase === 2) {
             logger.warn("[dsl] ignoring spurious dsl_breach close in phase 2 (exchange SL should exit)", {
                 tickId,
@@ -333,9 +339,12 @@ export async function processOnePosition(ctx, key, state, price) {
         // If backend owns Phase 2, also delete the position on the backend
         if (next.handoffStatus === "ok" && next.backendDslPositionId && strategy) {
             try {
-                await strategy.deleteRatchetStop({
-                    asset: state.asset,
-                    dex: state.dex || undefined,
+                await withSpan("dsl.handoff", { "senpi.dsl.handoff.op": "delete" }, async (handoffSpan) => {
+                    await strategy.deleteRatchetStop({
+                        asset: state.asset,
+                        dex: state.dex || undefined,
+                    });
+                    handoffSpan.setAttribute("senpi.dsl.handoff.status", "ok");
                 });
                 logger.info("[dsl] deleted backend dsl position (global settings close)", {
                     tickId,
@@ -353,10 +362,8 @@ export async function processOnePosition(ctx, key, state, price) {
             }
         }
         let closeFill = {};
-        const closeStartedAt = Date.now();
-        let closeAttemptEmitted = false;
         try {
-            const closeResult = await withRetry(() => strategy.closePosition(state.asset, closeReasonToUse, state.dex || undefined, {
+            const closeResult = await withSpan("dsl.close_attempt", { "senpi.dsl.attempt": (next.consecutiveCloseFailures ?? 0) + 1 }, () => withRetry(() => strategy.closePosition(state.asset, closeReasonToUse, state.dex || undefined, {
                 orderType: ctx.closeOrderType,
                 feeOptimizedLimitOptions: ctx.feeOptimizedLimitOptions,
             }), {
@@ -364,23 +371,7 @@ export async function processOnePosition(ctx, key, state, price) {
                 delayMs: DSL_EXTERNAL_RETRY_DELAY_MS,
                 label: "closePosition (dsl breach/timeout)",
                 onRetry: (attempt, remaining, err) => logger.warn("[dsl] closePosition retry", { asset: state.asset, attempt, remaining, err }),
-            });
-            // Telemetry-only fire-and-forget: the venue-call window for the dsl.close_attempt span.
-            // Emitted before any post-venue work (fill parsing) so its outcome reflects the venue call alone.
-            bus.emit("tracking.dsl_close_attempt", {
-                tickId,
-                key,
-                asset: state.asset,
-                dex,
-                positionId: state.positionId ?? state.correlationId,
-                startedAt: closeStartedAt,
-                endedAt: Date.now(),
-                outcome: "ok",
-                closeReason: closeReasonToUse,
-                attempt: (next.consecutiveCloseFailures ?? 0) + 1,
-                timestamp: isoNow(),
-            });
-            closeAttemptEmitted = true;
+            }));
             closeFill = parseCloseFillDetail(closeResult);
         }
         catch (e) {
@@ -393,26 +384,9 @@ export async function processOnePosition(ctx, key, state, price) {
                 lastError: String(e),
                 lastErrorAt: ts,
             };
-            // Telemetry-only fire-and-forget: the failed venue-call window (dsl.close_attempt, error).
-            // Guarded: when the ok emit already fired, the venue call itself succeeded — a later
-            // post-venue throw must not be misattributed to the venue.
-            if (!closeAttemptEmitted) {
-                bus.emit("tracking.dsl_close_attempt", {
-                    tickId,
-                    key,
-                    asset: state.asset,
-                    dex,
-                    positionId: state.positionId ?? state.correlationId,
-                    startedAt: closeStartedAt,
-                    endedAt: Date.now(),
-                    outcome: "error",
-                    closeReason: closeReasonToUse,
-                    attempt: pending.consecutiveCloseFailures,
-                    error: String(e),
-                    timestamp: isoNow(),
-                });
-            }
+            span.addEvent("pendingClose_set", { attempt: pending.consecutiveCloseFailures });
             if ((pending.consecutiveCloseFailures ?? 0) >= MAX_CONSECUTIVE_CLOSE_FAILURES) {
+                span.setAttribute("senpi.dsl.close_reason", CLOSE_REASON.CLOSE_POSITION_FAILED);
                 const failedCloseState = { ...pending, active: false, closedAt: isoNow(), closeReason: CLOSE_REASON.CLOSE_POSITION_FAILED };
                 const archived = await archiveIfStillActive(stateManager, key, state.address, state.asset, effectiveDex(state), () => failedCloseState, { tickId, skipMessage: "[dsl] skip breach close-fail archive: state already cleared (concurrent close)" });
                 if (!archived)
@@ -440,12 +414,12 @@ export async function processOnePosition(ctx, key, state, price) {
                     attempt: pending.consecutiveCloseFailures,
                     triggerReason: state.triggerReason,
                     __positionId: state.positionId ?? state.correlationId,
-                    __correlationId: state.correlationId,
                     timestamp: isoNow(),
                 });
             }
             return;
         }
+        span.setAttribute("senpi.dsl.close_reason", closeReasonToUse);
         logger.info("[dsl] closePosition succeeded, archiving (dsl breach/timeout)", {
             tickId,
             asset: state.asset,
@@ -488,7 +462,6 @@ export async function processOnePosition(ctx, key, state, price) {
                     newFloorPrice: dslEffectiveFloor,
                     triggerReason: next.triggerReason,
                     __positionId: next.positionId ?? next.correlationId,
-                    __correlationId: next.correlationId,
                     timestamp: ts,
                     direction: next.direction,
                     entryPrice: next.entryPrice,
@@ -519,13 +492,12 @@ export async function processOnePosition(ctx, key, state, price) {
                 tierIndex: result.newTierIndex ?? 0,
                 triggerReason: next.triggerReason,
                 __positionId: next.positionId ?? next.correlationId,
-                __correlationId: next.correlationId,
                 timestamp: ts,
             });
         }
     }
     if (next.handoffStatus === "ok" && strategy) {
-        await handleHandoffOk(ctx, key, next, state, strategy);
+        await handleHandoffOk(ctx, key, next, state, strategy, span);
         return;
     }
     // Catch-up: if position is already in Phase 2 but handoff was never attempted,
@@ -585,39 +557,22 @@ export async function processOnePosition(ctx, key, state, price) {
             phaseChanged: result.phaseChanged,
             prevSlOrderId: next.slOrderId,
         });
-        const slSyncStartedAt = Date.now();
-        let slUpdateEmitted = false;
         try {
-            const res = await withRetry(() => strategy.editPosition({
-                coin: state.asset,
-                dex: state.dex || undefined,
-                stopLoss: { triggerPx: exchangeTriggerPx },
-            }), {
-                retries: DSL_EXTERNAL_RETRIES,
-                delayMs: DSL_EXTERNAL_RETRY_DELAY_MS,
-                label: "editPosition (SL sync)",
-                onRetry: (attempt, remaining, err) => logger.warn("[dsl] editPosition retry", { asset: state.asset, attempt, remaining, err }),
-            });
-            const slSyncEndedAt = Date.now();
-            // Telemetry-only fire-and-forget: the venue-call window for the dsl.sl_update span. Emitted
-            // immediately after the venue call resolves — before any state read/write — so it fires even
-            // when a concurrent close returns early below, and reports the venue's own answer
-            // (`res.slOrderId`), the honest venue-call fact.
-            bus.emit("tracking.dsl_sl_update", {
-                tickId,
-                key,
-                asset: state.asset,
-                dex,
-                positionId: state.positionId ?? state.correlationId,
-                startedAt: slSyncStartedAt,
-                endedAt: slSyncEndedAt,
-                outcome: "ok",
-                newSLPrice: exchangeTriggerPx,
-                slOrderId: res.slOrderId,
-                syncReason,
-                timestamp: isoNow(),
+            const res = await withSpan("dsl.sl_update", {}, async (slSpan) => {
+                const r = await withRetry(() => strategy.editPosition({
+                    coin: state.asset,
+                    dex: state.dex || undefined,
+                    stopLoss: { triggerPx: exchangeTriggerPx },
+                }), {
+                    retries: DSL_EXTERNAL_RETRIES,
+                    delayMs: DSL_EXTERNAL_RETRY_DELAY_MS,
+                    label: "editPosition (SL sync)",
+                    onRetry: (attempt, remaining, err) => logger.warn("[dsl] editPosition retry", { asset: state.asset, attempt, remaining, err }),
+                });
+                if (r.slOrderId != null)
+                    slSpan.setAttribute("senpi.order.id", String(r.slOrderId));
+                return r;
             });
-            slUpdateEmitted = true;
             let syncedForEmit = null;
             await setIfStillActive(stateManager, key, state.address, state.asset, (current) => {
                 const synced = {
@@ -651,30 +606,10 @@ export async function processOnePosition(ctx, key, state, price) {
                 slOrderId: synced.slOrderId ?? 0,
                 triggerReason: synced.triggerReason,
                 __positionId: synced.positionId ?? synced.correlationId,
-                __correlationId: synced.correlationId,
                 timestamp: ts,
             });
         }
         catch (e) {
-            // Telemetry-only fire-and-forget: the failed venue-call window (dsl.sl_update, error).
-            // Guarded: when the ok emit already fired, the venue call itself succeeded — a later
-            // state-write throw must not be misattributed to the venue.
-            if (!slUpdateEmitted) {
-                bus.emit("tracking.dsl_sl_update", {
-                    tickId,
-                    key,
-                    asset: state.asset,
-                    dex,
-                    positionId: state.positionId ?? state.correlationId,
-                    startedAt: slSyncStartedAt,
-                    endedAt: Date.now(),
-                    outcome: "error",
-                    newSLPrice: exchangeTriggerPx,
-                    syncReason,
-                    error: String(e),
-                    timestamp: isoNow(),
-                });
-            }
             let syncFailureCount = null;
             await setIfStillActive(stateManager, key, state.address, state.asset, (current) => {
                 syncFailureCount = (current.slSyncFailureCount ?? 0) + 1;
@@ -688,14 +623,8 @@ export async function processOnePosition(ctx, key, state, price) {
             }, { tickId, skipMessage: "[dsl] skip SL sync-failure write: state no longer active (concurrent close)" });
             if (syncFailureCount == null)
                 return;
-            logger.warn("[dsl] editPosition (SL update) failed", {
-                tickId,
-                asset: state.asset,
-                exchangeTriggerPx,
-                dslEffectiveFloor,
-                slSyncFailureCount: syncFailureCount,
-                err: e,
-            });
+            emitEvent(logger, () => buildSlSyncFailedEvent(failureContext(state), syncFailureCount ?? 0, e));
+            recordDslDegradation({ failure: "sl_sync", errorType: errorTypeOf(e) });
         }
     }
     const hbState = await stateManager.getOrLoad(key);
@@ -728,7 +657,6 @@ export async function processOnePosition(ctx, key, state, price) {
                         elapsedMinutes: hbState.elapsedMinutes,
                         triggerReason: hbState.triggerReason,
                         __positionId: hbState.positionId ?? hbState.correlationId,
-                        __correlationId: hbState.correlationId,
                         margin: hbState.leverage > 0
                             ? (hbState.size * hbState.entryPrice) / hbState.leverage
                             : 0,
@@ -765,11 +693,11 @@ async function attemptHandoffRegistration(ctx, key, next, _original, strategy) {
     // attempt succeeded but we never persisted "ok"), adopt it instead of
     // sending another addRatchetStop that the backend turns into an EDIT.
     try {
-        const existing = await strategy.queryRatchetStops({
+        const existing = await withSpan("dsl.handoff", { "senpi.dsl.handoff.op": "register_precheck" }, () => strategy.queryRatchetStops({
             asset: next.asset,
             dex: next.dex || undefined,
             status: "ALL",
-        });
+        }));
         const active = existing.filter((p) => !BACKEND_TERMINAL_STATUSES.has(p.status));
         if (active.length > 0) {
             const adopted = active[0];
@@ -802,18 +730,24 @@ async function attemptHandoffRegistration(ctx, key, next, _original, strategy) {
         });
     }
     try {
-        const result = await strategy.addRatchetStop({
-            asset: next.asset,
-            dex: next.dex || undefined,
-            direction: next.direction,
-            entryPrice: next.entryPrice,
-            size: next.size,
-            leverage: next.leverage,
-            ratchetStopConfig: {
-                tiered: {
-                    tiers: mapTiersToEngineConfig(next.tiers),
+        const result = await withSpan("dsl.handoff", { "senpi.dsl.handoff.op": "register" }, async (handoffSpan) => {
+            const r = await strategy.addRatchetStop({
+                asset: next.asset,
+                dex: next.dex || undefined,
+                direction: next.direction,
+                entryPrice: next.entryPrice,
+                size: next.size,
+                leverage: next.leverage,
+                ratchetStopConfig: {
+                    tiered: {
+                        tiers: mapTiersToEngineConfig(next.tiers),
+                    },
                 },
-            },
+            });
+            if (r.success && r.position) {
+                handoffSpan.setAttribute("senpi.dsl.handoff.status", BACKEND_TERMINAL_STATUSES.has(r.position.status) ? "aborted" : "ok");
+            }
+            return r;
         });
         if (result.success && result.position) {
             if (BACKEND_TERMINAL_STATUSES.has(result.position.status)) {
@@ -854,22 +788,19 @@ async function attemptHandoffRegistration(ctx, key, next, _original, strategy) {
             });
         }
         else {
-            logger.warn("[dsl] addDslPosition returned success=false, staying pending", {
-                tickId,
-                asset: next.asset,
-                rawResult: JSON.stringify(result).slice(0, 800),
-            });
+            emitEvent(logger, () => buildHandoffFailedEvent(failureContext(next), {
+                failure: "register",
+                redact: { result: JSON.stringify(result).slice(0, 800) },
+            }));
+            recordDslDegradation({ failure: "handoff", handoffFailure: "register" });
         }
     }
     catch (e) {
-        logger.warn("[dsl] addDslPosition failed, staying pending (will retry next tick)", {
-            tickId,
-            asset: next.asset,
-            err: e,
-        });
+        emitEvent(logger, () => buildHandoffFailedEvent(failureContext(next), { failure: "register", error: e }));
+        recordDslDegradation({ failure: "handoff", handoffFailure: "register", errorType: errorTypeOf(e) });
     }
 }
-async function handleHandoffOk(ctx, key, next, original, strategy) {
+async function handleHandoffOk(ctx, key, next, original, strategy, span) {
     const { tickId, ts, stateManager, bus } = ctx;
     let updated = { ...next };
     // Snapshot pre-merge state so we can detect backend event echoes for tier/SL
@@ -877,24 +808,22 @@ async function handleHandoffOk(ctx, key, next, original, strategy) {
     const prevTierIndex = updated.currentTierIndex;
     const prevSlOrderId = updated.slOrderId;
     try {
-        const positions = await strategy.queryRatchetStops({
+        const positions = await withSpan("dsl.handoff", { "senpi.dsl.handoff.op": "poll_positions" }, () => strategy.queryRatchetStops({
             asset: original.asset,
             dex: original.dex || undefined,
             status: "ALL",
-        });
+        }));
         const backendPos = next.backendDslPositionId
             ? positions.find((p) => p.id === next.backendDslPositionId) ?? null
             : positions.filter((p) => !BACKEND_TERMINAL_STATUSES.has(p.status)).length === 1
                 ? positions.filter((p) => !BACKEND_TERMINAL_STATUSES.has(p.status))[0]
                 : null;
         if (!backendPos) {
-            logger.warn("[dsl] handoff ok but matching backend position not found, reverting to local Phase 2", {
-                tickId,
-                key,
-                asset: original.asset,
-                backendDslPositionId: next.backendDslPositionId,
-                returnedIds: positions.map((p) => p.id),
-            });
+            emitEvent(logger, () => buildHandoffFailedEvent(failureContext(original), {
+                failure: "rollback",
+                backendPositionId: next.backendDslPositionId ?? undefined,
+            }));
+            recordDslDegradation({ failure: "handoff", handoffFailure: "rollback" });
             const rolledBack = {
                 ...updated,
                 handoffStatus: null,
@@ -906,12 +835,14 @@ async function handleHandoffOk(ctx, key, next, original, strategy) {
         }
         else {
             if (BACKEND_TERMINAL_STATUSES.has(backendPos.status)) {
+                span.addEvent("external_close_detected", { source: "backend_terminal" });
                 logger.info("[dsl] backend reports terminal status, closing position locally", {
                     tickId,
                     asset: original.asset,
                     backendStatus: backendPos.status,
                 });
                 const closeReason = `backend_${backendPos.status.toLowerCase()}`;
+                span.setAttribute("senpi.dsl.close_reason", closeReason);
                 const closedState = {
                     ...updated,
                     active: false,
@@ -943,20 +874,21 @@ async function handleHandoffOk(ctx, key, next, original, strategy) {
         }
     }
     catch (e) {
-        logger.warn("[dsl] queryPositions failed during handoff poll", {
-            tickId,
-            asset: original.asset,
-            err: e,
-        });
+        emitEvent(logger, () => buildHandoffFailedEvent(failureContext(original), {
+            failure: "poll",
+            backendPositionId: next.backendDslPositionId ?? undefined,
+            error: e,
+        }));
+        recordDslDegradation({ failure: "handoff", handoffFailure: "poll", errorType: errorTypeOf(e) });
     }
     try {
         // ASC ordering is required: the cursor advances to the LAST element of the array
         // below, which must be the newest event. Backend default is DESC.
-        const events = await strategy.queryRatchetStopEvents({
+        const events = await withSpan("dsl.handoff", { "senpi.dsl.handoff.op": "poll_events" }, () => strategy.queryRatchetStopEvents({
             positionId: updated.backendDslPositionId ?? undefined,
             since: updated.lastBackendDslTick ?? undefined,
             sortOrder: "ASC",
-        });
+        }));
         // Filter out events already seen on the previous poll (since may be inclusive)
         const cursor = updated.lastBackendDslTick;
         const freshEvents = cursor
@@ -1037,7 +969,9 @@ async function handleHandoffOk(ctx, key, next, original, strategy) {
             });
             // Archive local state when backend reports position closed via event stream
             if (backendClosed) {
+                span.addEvent("external_close_detected", { source: "backend_terminal" });
                 const closeReason = backendCloseReason ?? "backend_closed";
+                span.setAttribute("senpi.dsl.close_reason", closeReason);
                 logger.info("[dsl] backend CLOSED event received, archiving local state", {
                     tickId,
                     key,