@senpi/runtime 1.1.0-dev.runtime-phase-2.20260609123811 → 1.1.0-dev.runtime-phase-2.20260609132603

package/dist/actions/open-position/open-position.action.js

@@ -8,11 +8,57 @@ import { resolveMargin } from './resolve-margin.js';
 import { createLogger } from '../../utils/logger.js';
 import { resolveOpenOrderType, resolveFeeOptimizedLimitOptions } from '../../utils/resolve-order-type.js';
 import { emitTrackingDecision, emitTrackingActionResult } from '../tracking-helpers.js';
+import { buildSignalAttrs, decisionAttrs, decisionErrorAttrs, emitBatchRejected, setPositionId, withSignalSpanScope, } from '../otel-helpers.js';
+import { randomUUID } from 'node:crypto';
 const logger = createLogger("[actions][open-position]");
 /** Hyperliquid minimum notional value (margin × leverage) required to open a position. */
 const MIN_NOTIONAL_VALUE = 10;
 /** Minimum leverage floor — positions cannot go below 1x. */
 const MIN_LEVERAGE = 1;
+// ─── Pure attr-shape helpers ─────────────────────────────────────────────────
+/**
+ * Flatten a senpi `createPosition` response into the queryable subset of
+ * `action.open` span attrs. Extracted (per D5) so the senpi-response shape
+ * evolves in one place rather than scattered across the action body.
+ */
+function flattenOpenResultAttrs(result) {
+    const submitted = result.orders[0];
+    return {
+        "action.success": result.success,
+        "action.outcome": result.success ? "submitted" : "failed",
+        "action.order_id": submitted?.orderId,
+        "action.entry_price": submitted?.entryPrice,
+        "action.size": submitted?.size,
+        "action.filled": submitted?.filled,
+        "action.failure_reason": submitted?.error,
+        "action.fill_type": submitted?.executionAsMaker === true
+            ? "maker"
+            : submitted?.executionAsMaker === false
+                ? "taker"
+                : "unfilled",
+        "action.metadata.trace_id": result.metadata?.traceId,
+        "action.metadata.execution_id": result.metadata?.executionId,
+        ...(submitted?.mainOrder ? {
+            "action.main_order.status": submitted.mainOrder.status,
+            "action.main_order.avg_price": submitted.mainOrder.avgPrice,
+            "action.main_order.requested_size": submitted.mainOrder.requestedSize,
+        } : {}),
+        ...(submitted?.stopLoss ? {
+            "action.stop_loss.enabled": submitted.stopLoss.enabled,
+            "action.stop_loss.order_id": submitted.stopLoss.orderId,
+            "action.stop_loss.status": submitted.stopLoss.status,
+            "action.stop_loss.trigger_price": submitted.stopLoss.triggerPrice,
+            "action.stop_loss.error": submitted.stopLoss.error,
+        } : {}),
+        ...(submitted?.takeProfit ? {
+            "action.take_profit.enabled": submitted.takeProfit.enabled,
+            "action.take_profit.order_id": submitted.takeProfit.orderId,
+            "action.take_profit.status": submitted.takeProfit.status,
+            "action.take_profit.trigger_price": submitted.takeProfit.triggerPrice,
+            "action.take_profit.error": submitted.takeProfit.error,
+        } : {}),
+    };
+}
 // ─── Open Position Action ───────────────────────────────────────────────────
 export class OpenPositionAction {
     config;
@@ -79,16 +125,7 @@ export class OpenPositionAction {
                 error: 'strategy_address_mismatch',
             };
         }
-        // Early exit: no slots.
-        // NOTE re "zero slots skips cap alerts": we intentionally do NOT evaluate risk
-        // halts/cap self-pause here. It would add a per-signal getPnlHistoryWithSnapshot
-        // MCP call on the full-book path (costly on a full + high-signal-rate strategy),
-        // and that halt data is fetched nowhere else to reuse (only risk-guard.checkGate
-        // fetches it; the DSL monitor fetches clearinghouse = different data). Self-pause
-        // alerts still fire via the normal open path once a slot frees and a signal
-        // arrives (delayed, not lost). The durable fix — a periodic lifecycle driven off
-        // the monitor tick / bus events (also catches a fully-silent producer) — is
-        // roadmap §5 (the merge), deliberately not blended into this §4 short-term PR.
+        // Early exit: no slots
         if (!strategyState.getAvailableSlots?.()) {
             return {
                 success: true,
@@ -120,15 +157,19 @@ export class OpenPositionAction {
                 ...(this.config.params ?? {}),
             })
             : undefined;
+        const fullContext = { ...contextData, scanResult };
+        const contextKeys = Object.keys(fullContext);
+        const minConfidence = this.config.min_confidence ?? 1;
         // Get decision
         let decision;
         try {
             decision = await this.decisionEngine.decide(this.config.decision_mode, {
                 prompt: interpolatedPrompt,
-                context: { ...contextData, scanResult },
+                context: fullContext,
                 model: this.config.decision_model,
                 actionType: this.actionType,
                 event,
+                minConfidence,
             });
         }
         catch (error) {
@@ -160,13 +201,29 @@ export class OpenPositionAction {
                 },
             };
             emitTrackingActionResult(trackingCtx, event, address, errorResult);
+            const errAttrs = decisionErrorAttrs({
+                mode: this.config.decision_mode,
+                message,
+                minConfidence,
+                actionType: this.actionType,
+                model: this.config.decision_model,
+                contextKeys,
+            });
+            emitBatchRejected(this.context.otel, scanResult, "decision_error", "OPEN", errAttrs, error);
             return errorResult;
         }
         logger.info('decision', decision);
         const trackingCtx = this.trackingCtx();
-        const minConfidence = this.config.min_confidence ?? 1;
         const isBelowConfidence = decision.execute && decision.confidence < minConfidence;
         emitTrackingDecision(trackingCtx, event, address, scanResult, decision, minConfidence, interpolatedPrompt, contextData, isBelowConfidence ? 'below_confidence' : undefined);
+        const decAttrs = decisionAttrs({
+            mode: this.config.decision_mode,
+            decision,
+            minConfidence,
+            actionType: this.actionType,
+            model: this.config.decision_model,
+            contextKeys,
+        });
         // Check decision
         if (!decision.execute) {
             logger.info('decision no execute', decision);
@@ -184,6 +241,7 @@ export class OpenPositionAction {
                 },
             };
             emitTrackingActionResult(trackingCtx, event, address, rejectedResult);
+            emitBatchRejected(this.context.otel, scanResult, "rejected_by_decision", "OPEN", decAttrs);
             return rejectedResult;
         }
         // Check confidence threshold
@@ -203,12 +261,17 @@ export class OpenPositionAction {
                 },
             };
             emitTrackingActionResult(trackingCtx, event, address, belowConfResult);
+            emitBatchRejected(this.context.otel, scanResult, "rejected_by_confidence", "OPEN", {
+                ...decAttrs,
+                "decision.skipped_reason": "below_confidence",
+            });
             return belowConfResult;
         }
         // ── Unified signals path ──
         const signals = this.normalizeSignals(decision.payload);
         const meta = decisionMetaFromDecision(this.config, decision);
         if (!signals.length) {
+            emitBatchRejected(this.context.otel, scanResult, "invalid_payload", "OPEN", decAttrs);
             return {
                 success: false,
                 action_type: this.actionType,
@@ -217,7 +280,7 @@ export class OpenPositionAction {
                 data: { _decisionMeta: meta, _decisionPrompt: interpolatedPrompt ?? null },
             };
         }
-        return this.handleSignals(signals, event, strategyState, decision.reasoning, meta, interpolatedPrompt);
+        return this.handleSignals(signals, event, strategyState, decision.reasoning, meta, interpolatedPrompt, decAttrs);
     }
     normalizeSignals(payload) {
         if (Array.isArray(payload.signals))
@@ -232,8 +295,10 @@ export class OpenPositionAction {
         }
         return [];
     }
-    async handleSignals(signals, event, strategyState, reasoning, meta, decisionPrompt) {
+    async handleSignals(signals, event, strategyState, reasoning, meta, decisionPrompt, decAttrs) {
         const address = event.address;
+        const eventScanResult = event.data?.scanResult;
+        const scannerId = eventScanResult?.scannerId;
         const orderType = resolveOpenOrderType(this.config.params?.order_type);
         const feeOptimizedLimitOptions = orderType === 'FEE_OPTIMIZED_LIMIT'
             ? resolveFeeOptimizedLimitOptions(this.config.params?.fee_optimized_limit_options)
@@ -271,38 +336,137 @@ export class OpenPositionAction {
         withdrawable = withdrawableResult;
         let remainingSlots = strategyState.getAvailableSlots?.() ?? 0;
         // Free-margin pre-flight budget (P1). Undefined when withdrawable is unknown
-        // (no clearinghouse read) — in that case we do NOT block, preserving prior behavior.
-        // Decremented per submitted signal so later signals in the same batch are
-        // evaluated against the margin already consumed by earlier ones.
+        // (no clearinghouse read) — in that case we do NOT block, preserving prior
+        // behavior. Decremented per submitted signal so later signals in the same
+        // batch are evaluated against the margin already consumed by earlier ones.
         let remainingMargin = withdrawable;
         const results = [];
         let submittedCount = 0;
         let failedCount = 0;
         for (const signal of sorted) {
-            const asset = signal.asset;
-            const direction = signal.direction;
-            const signalScore = signal.score;
-            const signalDex = signal.dex;
-            const submittedDex = typeof signalDex === "string" && signalDex.trim() !== "" ? signalDex.trim() : "main";
-            const dexForLookup = submittedDex === "main" ? undefined : submittedDex;
+            try {
+                const outcome = await this.processOpenSignal({
+                    signal,
+                    event,
+                    scannerId,
+                    strategyState,
+                    orderType,
+                    feeOptimizedLimitOptions,
+                    reasoning,
+                    decAttrs,
+                    withdrawable,
+                    remainingMargin,
+                    remainingSlots,
+                });
+                results.push(outcome.result);
+                if (outcome.kind === 'submitted') {
+                    submittedCount++;
+                    remainingSlots--;
+                    // Decrement the free-margin budget only on a real submit, so later
+                    // signals are evaluated against margin already consumed (P1).
+                    if (remainingMargin != null && typeof outcome.marginConsumed === 'number') {
+                        remainingMargin -= outcome.marginConsumed;
+                    }
+                }
+                else if (outcome.kind === 'failed') {
+                    failedCount++;
+                }
+            }
+            catch {
+                // withSignalSpanScope re-throws after stamping `exception` outcome /
+                // recording the exception event on the span. The per-signal failed
+                // result has already been pushed inside processOpenSignal; the
+                // failure must not interrupt the loop over remaining signals.
+            }
+        }
+        const skippedCount = results.length - submittedCount - failedCount;
+        const actionResult = {
+            success: submittedCount > 0 || failedCount === 0,
+            action_type: this.actionType,
+            summary: `Open submit: ${submittedCount} submitted, ${failedCount} failed, ${skippedCount} skipped`,
+            data: {
+                results,
+                submittedCount,
+                failedCount,
+                skippedCount,
+                ...(meta ? { _decisionMeta: meta } : {}),
+                ...(riskSnapshot ? { _riskSnapshot: riskSnapshot } : {}),
+                _decisionPrompt: decisionPrompt ?? null,
+            },
+        };
+        emitTrackingActionResult(this.trackingCtx(), event, address, actionResult);
+        return actionResult;
+    }
+    /**
+     * Process one signal end-to-end: gates → leverage/margin resolution →
+     * senpi.createPosition → hook fire. Opens a per-signal `signal.evaluated`
+     * funnel span (via `withSignalSpanScope`) and stamps the per-signal `position.id`
+     * on mint. Returns an outcome the caller applies to counters + results.
+     *
+     * The exception path inside the senpi.createPosition try/catch sets a
+     * 'failed' outcome and lets `withSignalSpanScope` complete normally — the
+     * outer for-loop's catch in `handleSignals` only fires on truly unexpected
+     * throws.
+     */
+    async processOpenSignal(opts) {
+        const { signal, event, scannerId, strategyState, orderType, feeOptimizedLimitOptions, reasoning, decAttrs, withdrawable, remainingMargin, remainingSlots } = opts;
+        const address = event.address;
+        const asset = signal.asset;
+        const direction = signal.direction;
+        const signalScore = signal.score;
+        const signalDex = signal.dex;
+        const submittedDex = typeof signalDex === "string" && signalDex.trim() !== "" ? signalDex.trim() : "main";
+        const dexForLookup = submittedDex === "main" ? undefined : submittedDex;
+        const signalAttrs = {
+            ...buildSignalAttrs(scannerId, {
+                asset,
+                direction: direction ?? null,
+                score: signalScore,
+                signalType: signal.signalType,
+                factors: signal.factors,
+                meta: signal.meta,
+            }, "OPEN"),
+            ...(decAttrs ?? {}),
+        };
+        // The per-signal ALS frame (opened by withSignalSpanScope) carries
+        // `currentSpan` so descendant spans/logs inherit parent automatically;
+        // `positionId` is set on mint and never leaks to the next iteration
+        // (H1/H2/B06). The closure mutates `outcome` so we can return it after
+        // the scope completes.
+        let outcome = {
+            kind: 'failed',
+            result: { asset, direction, dex: submittedDex, score: signalScore, success: false, reason: 'unknown' },
+        };
+        await withSignalSpanScope(this.context.otel, signalAttrs, async (signalSpan) => {
+            const endSignal = (label, status) => {
+                signalSpan.setAttr("signal.outcome", label);
+                signalSpan.end(status ? { statusCode: status } : undefined);
+            };
             if (remainingSlots <= 0) {
-                results.push({ asset, direction, dex: submittedDex, score: signalScore, success: true, reason: 'no_slots' });
-                continue;
+                outcome = { kind: 'skipped', result: { asset, direction, dex: submittedDex, score: signalScore, success: true, reason: 'no_slots' } };
+                endSignal("no_slots");
+                return;
             }
             if (!direction || (direction !== 'LONG' && direction !== 'SHORT')) {
-                results.push({ asset, direction, dex: submittedDex, score: signalScore, success: false, reason: 'invalid_direction' });
-                failedCount++;
-                continue;
+                outcome = { kind: 'failed', result: { asset, direction, dex: submittedDex, score: signalScore, success: false, reason: 'invalid_direction' } };
+                endSignal("invalid_direction", "Error");
+                return;
             }
             if (strategyState.hasOpenPosition(asset, dexForLookup)) {
-                results.push({ asset, direction, dex: submittedDex, score: signalScore, success: true, reason: 'position_already_exists' });
-                continue;
+                outcome = { kind: 'skipped', result: { asset, direction, dex: submittedDex, score: signalScore, success: true, reason: 'position_already_exists' } };
+                endSignal("position_already_exists");
+                return;
             }
-            // Risk guard per-open (real-time via MCP, with per-asset cooldown)
+            // Risk guard per-open (real-time via MCP, with per-asset cooldown).
+            // C11: outcome + reason stamped on signal.evaluated directly; the
+            // separate risk_gate.evaluated log was redundant.
             const gate = await this.context.riskGuard.checkGate(address, { candidateAsset: asset });
+            signalSpan.setAttr("gate.outcome", gate.gate);
+            signalSpan.setAttr("gate.reason", gate.reason);
             if (gate.gate !== 'OPEN') {
-                results.push({ asset, direction, dex: submittedDex, score: signalScore, success: true, reason: `risk_gate_${gate.gate}` });
-                continue;
+                outcome = { kind: 'skipped', result: { asset, direction, dex: submittedDex, score: signalScore, success: true, reason: `risk_gate_${gate.gate}` } };
+                endSignal(`rejected_by_gate_${gate.gate.toLowerCase()}`);
+                return;
             }
             // Leverage: LLM override > config-based resolution
             const llmLeverage = typeof signal.leverage === 'number' ? signal.leverage : undefined;
@@ -338,122 +502,181 @@ export class OpenPositionAction {
                     slots: strategyState.config.slots,
                     withdrawable,
                 });
-                results.push({ asset, direction, dex: submittedDex, score: signalScore, leverage, success: false, reason: 'no_margin_configured' });
-                failedCount++;
-                continue;
+                outcome = { kind: 'failed', result: { asset, direction, dex: submittedDex, score: signalScore, leverage, success: false, reason: 'no_margin_configured' } };
+                endSignal("no_margin_configured", "Error");
+                return;
             }
             const notionalValue = marginAmount * leverage;
             if (notionalValue < MIN_NOTIONAL_VALUE) {
                 logger.warn(`Skipping ${asset}: notional value $${notionalValue.toFixed(2)} ` +
                     `(margin $${marginAmount.toFixed(2)} × ${leverage}x) is below minimum $${MIN_NOTIONAL_VALUE}`);
-                results.push({ asset, direction, dex: submittedDex, score: signalScore, leverage, marginAmount, notionalValue, success: false, reason: 'below_min_notional' });
-                failedCount++;
-                continue;
+                outcome = { kind: 'failed', result: { asset, direction, dex: submittedDex, score: signalScore, leverage, marginAmount, notionalValue, success: false, reason: 'below_min_notional' } };
+                endSignal("below_min_notional", "Error");
+                return;
             }
-            // Free-margin pre-flight (P1): if we know free margin and it can't cover this
-            // position's margin, skip rather than fire a create the engine will reject
-            // (CREATE_INSUFFICIENT_FUNDS). Skip the check when free margin is unknown.
+            // Free-margin pre-flight (P1): if we know free margin and it can't cover
+            // this position's margin, skip rather than fire a create the engine will
+            // reject (CREATE_INSUFFICIENT_FUNDS). The check is skipped when free
+            // margin is unknown (withdrawable null), preserving prior behavior.
             if (remainingMargin != null && remainingMargin < marginAmount) {
                 logger.warn(`Skipping ${asset}: insufficient free margin ` +
                     `($${remainingMargin.toFixed(2)} available < $${marginAmount.toFixed(2)} required)`);
-                results.push({ asset, direction, dex: submittedDex, score: signalScore, leverage, marginAmount, requiredMarginAmount: marginAmount, availableMarginAmount: remainingMargin, success: true, reason: 'insufficient_margin' });
-                continue;
+                outcome = { kind: 'skipped', result: { asset, direction, dex: submittedDex, score: signalScore, leverage, marginAmount, requiredMarginAmount: marginAmount, availableMarginAmount: remainingMargin, success: true, reason: 'insufficient_margin' } };
+                endSignal("insufficient_margin");
+                return;
             }
             const signalReason = signal.reason ?? signal.signalType ?? reasoning;
+            // Mint position.id at intent — before order submission, after confidence + risk gates.
+            // The OTEL ALS frame opened by withSignalSpanScope is per-signal, so the id is stamped
+            // on signal.evaluated, action.open, and downstream logs without leaking across signals.
+            const positionId = randomUUID();
+            setPositionId(positionId);
+            signalSpan.setAttr("position.id", positionId);
+            const actionSpan = this.context.otel.startSpan("action.open", {
+                parent: signalSpan,
+                attrs: {
+                    "action.intent": "OPEN",
+                    "action.asset": asset,
+                    "action.direction": direction,
+                    "action.order_type": orderType,
+                    "action.dex": submittedDex,
+                    "action.leverage": leverage,
+                    "action.margin": marginAmount,
+                    "action.risk_gate": gate.gate,
+                    ...(typeof withdrawable === "number" ? { "action.withdrawable_balance": withdrawable } : {}),
+                },
+            });
+            const createRequest = {
+                strategyWalletAddress: address,
+                orders: [
+                    {
+                        coin: asset,
+                        direction,
+                        leverage,
+                        marginAmount,
+                        orderType,
+                        ...(feeOptimizedLimitOptions ? { feeOptimizedLimitOptions } : {}),
+                    },
+                ],
+                reason: signalReason,
+            };
+            let submittedOrder;
+            let resultSuccess = false;
+            let signalEnded = false;
             try {
                 logger.info('opening position', { wallet: address, asset, direction });
-                const result = await this.context.senpi.createPosition({
-                    strategyWalletAddress: address,
-                    orders: [
-                        {
-                            coin: asset,
-                            direction,
-                            leverage,
-                            marginAmount,
-                            orderType,
-                            ...(feeOptimizedLimitOptions ? { feeOptimizedLimitOptions } : {}),
-                        },
-                    ],
-                    reason: signalReason,
+                // D1: the standalone `action.order_execution` span is gone — ack
+                // latency + senpi metadata fold onto action.open directly.
+                const submitStart = Date.now();
+                let result;
+                try {
+                    result = await this.context.senpi.createPosition(createRequest);
+                }
+                catch (err) {
+                    actionSpan.setAttr("action.ack_latency_ms", Date.now() - submitStart);
+                    actionSpan.recordException(err);
+                    const e = err;
+                    actionSpan.setAttr("exception.type", e?.name ?? "Error");
+                    actionSpan.setAttr("action.outcome", "exception");
+                    actionSpan.end({ statusCode: "Error" });
+                    throw err;
+                }
+                actionSpan.setAttr("action.ack_latency_ms", Date.now() - submitStart);
+                // Source-of-truth blob for retrospection / fields not yet extracted.
+                // Span attrs carry the queryable subset; the log body carries the
+                // full response. Independent retention/sampling per the design.
+                this.context.otel.emitLog({
+                    eventName: "senpi.order_response",
+                    parent: actionSpan,
+                    attrs: { "senpi.operation": "create_position" },
+                    body: { request: createRequest, response: result },
                 });
+                actionSpan.setAttrs(flattenOpenResultAttrs(result));
+                actionSpan.end({ statusCode: result.success ? "Ok" : "Error" });
+                resultSuccess = result.success;
+                submittedOrder = result.orders[0];
                 if (!result.success) {
                     const orderErrors = result.orders
                         .filter((o) => o.error)
                         .map((o) => `${o.coin}: ${o.error}`)
                         .join('; ');
                     const detail = result.error || orderErrors || 'unknown error';
-                    results.push({
-                        asset, direction, dex: submittedDex, score: signalScore,
-                        leverage, marginAmount, orderType,
-                        success: false, reason: 'position_open_failed', error: detail,
-                    });
-                    failedCount++;
-                    continue;
+                    outcome = { kind: 'failed', result: {
+                            asset, direction, dex: submittedDex, score: signalScore,
+                            leverage, marginAmount, orderType,
+                            success: false, reason: 'position_open_failed', error: detail,
+                        } };
+                    endSignal("position_open_failed", "Error");
+                    signalEnded = true;
+                }
+                else {
+                    outcome = { kind: 'submitted', marginConsumed: marginAmount, result: {
+                            asset, direction, dex: submittedDex, score: signalScore,
+                            leverage, marginAmount, orderType,
+                            orderId: submittedOrder?.orderId ?? null,
+                            entryPrice: submittedOrder?.entryPrice ?? null,
+                            size: submittedOrder?.size ?? null,
+                            filled: submittedOrder?.filled ?? null,
+                            success: true, reason: 'submitted',
+                        } };
+                    endSignal("accepted", "Ok");
+                    signalEnded = true;
                 }
-                const submittedOrder = result.orders[0];
-                await this.context.hookSystem.fire({
-                    type: HOOK_EVENT.ON_OPEN_ORDER_SUBMITTED,
-                    runtimeName: event.runtimeName,
-                    address,
-                    data: {
-                        asset,
-                        direction,
-                        leverage,
-                        marginAmount,
-                        orderType,
-                        wallet: address,
-                        dex: submittedDex,
-                        reasoning: signalReason,
-                        orderId: submittedOrder?.orderId,
-                        entryPrice: submittedOrder?.entryPrice ?? null,
-                        size: submittedOrder?.size ?? null,
-                        filled: submittedOrder?.filled ?? null,
-                        __correlationId: event.data.__correlationId,
-                    },
-                    timestamp: new Date().toISOString(),
-                });
-                results.push({
-                    asset, direction, dex: submittedDex, score: signalScore,
-                    leverage, marginAmount, orderType,
-                    orderId: submittedOrder?.orderId ?? null,
-                    entryPrice: submittedOrder?.entryPrice ?? null,
-                    size: submittedOrder?.size ?? null,
-                    filled: submittedOrder?.filled ?? null,
-                    success: true, reason: 'submitted',
-                });
-                submittedCount++;
-                remainingSlots--;
-                if (remainingMargin != null)
-                    remainingMargin -= marginAmount;
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
                 logger.error('open failed', { asset, err: message });
-                results.push({
-                    asset, direction, dex: submittedDex, score: signalScore,
-                    leverage, marginAmount, orderType,
-                    success: false, reason: 'exception', error: message,
-                });
-                failedCount++;
+                if (!signalEnded) {
+                    signalSpan.recordException(error);
+                    const e = error;
+                    signalSpan.setAttr("exception.type", e?.name ?? "Error");
+                    endSignal("exception", "Error");
+                    signalEnded = true;
+                }
+                outcome = { kind: 'failed', result: {
+                        asset, direction, dex: submittedDex, score: signalScore,
+                        leverage, marginAmount, orderType,
+                        success: false, reason: 'exception', error: message,
+                    } };
+                return;
             }
-        }
-        const skippedCount = results.length - submittedCount - failedCount;
-        const actionResult = {
-            success: submittedCount > 0 || failedCount === 0,
-            action_type: this.actionType,
-            summary: `Open submit: ${submittedCount} submitted, ${failedCount} failed, ${skippedCount} skipped`,
-            data: {
-                results,
-                submittedCount,
-                failedCount,
-                skippedCount,
-                ...(meta ? { _decisionMeta: meta } : {}),
-                ...(riskSnapshot ? { _riskSnapshot: riskSnapshot } : {}),
-                _decisionPrompt: decisionPrompt ?? null,
-            },
-        };
-        emitTrackingActionResult(this.trackingCtx(), event, address, actionResult);
-        return actionResult;
+            // B12 — hook fire happens AFTER the signal verdict is final and
+            // OUTSIDE the senpi.createPosition try/catch. A hook-fire failure
+            // must not flip the signal's outcome to "exception" when the order
+            // in fact succeeded. The hook failure is logged on the action span
+            // but never propagates.
+            if (resultSuccess) {
+                try {
+                    await this.context.hookSystem.fire({
+                        type: HOOK_EVENT.ON_OPEN_ORDER_SUBMITTED,
+                        runtimeName: event.runtimeName,
+                        address,
+                        data: {
+                            asset,
+                            direction,
+                            leverage,
+                            marginAmount,
+                            orderType,
+                            wallet: address,
+                            dex: submittedDex,
+                            reasoning: signalReason,
+                            orderId: submittedOrder?.orderId,
+                            entryPrice: submittedOrder?.entryPrice ?? null,
+                            size: submittedOrder?.size ?? null,
+                            filled: submittedOrder?.filled ?? null,
+                            __correlationId: event.data.__correlationId,
+                        },
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+                catch (hookErr) {
+                    logger.warn('hook fire ON_OPEN_ORDER_SUBMITTED failed', {
+                        asset, err: hookErr instanceof Error ? hookErr.message : String(hookErr),
+                    });
+                }
+            }
+        });
+        return outcome;
     }
 }
 // ─── Factory & Manifest ─────────────────────────────────────────────────────