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

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

@@ -8,57 +8,11 @@ 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;
@@ -125,7 +79,16 @@ export class OpenPositionAction {
                 error: 'strategy_address_mismatch',
             };
         }
-        // Early exit: no slots
+        // 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.
         if (!strategyState.getAvailableSlots?.()) {
             return {
                 success: true,
@@ -157,19 +120,15 @@ 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: fullContext,
+                context: { ...contextData, scanResult },
                 model: this.config.decision_model,
                 actionType: this.actionType,
                 event,
-                minConfidence,
             });
         }
         catch (error) {
@@ -201,29 +160,13 @@ 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);
@@ -241,7 +184,6 @@ export class OpenPositionAction {
                 },
             };
             emitTrackingActionResult(trackingCtx, event, address, rejectedResult);
-            emitBatchRejected(this.context.otel, scanResult, "rejected_by_decision", "OPEN", decAttrs);
             return rejectedResult;
         }
         // Check confidence threshold
@@ -261,17 +203,12 @@ 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,
@@ -280,7 +217,7 @@ export class OpenPositionAction {
                 data: { _decisionMeta: meta, _decisionPrompt: interpolatedPrompt ?? null },
             };
         }
-        return this.handleSignals(signals, event, strategyState, decision.reasoning, meta, interpolatedPrompt, decAttrs);
+        return this.handleSignals(signals, event, strategyState, decision.reasoning, meta, interpolatedPrompt);
     }
     normalizeSignals(payload) {
         if (Array.isArray(payload.signals))
@@ -295,10 +232,8 @@ export class OpenPositionAction {
         }
         return [];
     }
-    async handleSignals(signals, event, strategyState, reasoning, meta, decisionPrompt, decAttrs) {
+    async handleSignals(signals, event, strategyState, reasoning, meta, decisionPrompt) {
         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)
@@ -336,137 +271,38 @@ 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) {
-            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);
-            };
+            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;
             if (remainingSlots <= 0) {
-                outcome = { kind: 'skipped', result: { asset, direction, dex: submittedDex, score: signalScore, success: true, reason: 'no_slots' } };
-                endSignal("no_slots");
-                return;
+                results.push({ asset, direction, dex: submittedDex, score: signalScore, success: true, reason: 'no_slots' });
+                continue;
             }
             if (!direction || (direction !== 'LONG' && direction !== 'SHORT')) {
-                outcome = { kind: 'failed', result: { asset, direction, dex: submittedDex, score: signalScore, success: false, reason: 'invalid_direction' } };
-                endSignal("invalid_direction", "Error");
-                return;
+                results.push({ asset, direction, dex: submittedDex, score: signalScore, success: false, reason: 'invalid_direction' });
+                failedCount++;
+                continue;
             }
             if (strategyState.hasOpenPosition(asset, dexForLookup)) {
-                outcome = { kind: 'skipped', result: { asset, direction, dex: submittedDex, score: signalScore, success: true, reason: 'position_already_exists' } };
-                endSignal("position_already_exists");
-                return;
+                results.push({ asset, direction, dex: submittedDex, score: signalScore, success: true, reason: 'position_already_exists' });
+                continue;
             }
-            // 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.
+            // Risk guard per-open (real-time via MCP, with per-asset cooldown)
             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') {
-                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;
+                results.push({ asset, direction, dex: submittedDex, score: signalScore, success: true, reason: `risk_gate_${gate.gate}` });
+                continue;
             }
             // Leverage: LLM override > config-based resolution
             const llmLeverage = typeof signal.leverage === 'number' ? signal.leverage : undefined;
@@ -502,181 +338,122 @@ export class OpenPositionAction {
                     slots: strategyState.config.slots,
                     withdrawable,
                 });
-                outcome = { kind: 'failed', result: { asset, direction, dex: submittedDex, score: signalScore, leverage, success: false, reason: 'no_margin_configured' } };
-                endSignal("no_margin_configured", "Error");
-                return;
+                results.push({ asset, direction, dex: submittedDex, score: signalScore, leverage, success: false, reason: 'no_margin_configured' });
+                failedCount++;
+                continue;
             }
             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}`);
-                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;
+                results.push({ asset, direction, dex: submittedDex, score: signalScore, leverage, marginAmount, notionalValue, success: false, reason: 'below_min_notional' });
+                failedCount++;
+                continue;
             }
-            // 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.
+            // 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.
             if (remainingMargin != null && remainingMargin < marginAmount) {
                 logger.warn(`Skipping ${asset}: insufficient free margin ` +
                     `($${remainingMargin.toFixed(2)} available < $${marginAmount.toFixed(2)} required)`);
-                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;
+                results.push({ asset, direction, dex: submittedDex, score: signalScore, leverage, marginAmount, requiredMarginAmount: marginAmount, availableMarginAmount: remainingMargin, success: true, reason: 'insufficient_margin' });
+                continue;
             }
             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 });
-                // 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 },
+                const result = await this.context.senpi.createPosition({
+                    strategyWalletAddress: address,
+                    orders: [
+                        {
+                            coin: asset,
+                            direction,
+                            leverage,
+                            marginAmount,
+                            orderType,
+                            ...(feeOptimizedLimitOptions ? { feeOptimizedLimitOptions } : {}),
+                        },
+                    ],
+                    reason: signalReason,
                 });
-                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';
-                    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;
+                    results.push({
+                        asset, direction, dex: submittedDex, score: signalScore,
+                        leverage, marginAmount, orderType,
+                        success: false, reason: 'position_open_failed', error: detail,
+                    });
+                    failedCount++;
+                    continue;
                 }
+                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 });
-                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;
-            }
-            // 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),
-                    });
-                }
+                results.push({
+                    asset, direction, dex: submittedDex, score: signalScore,
+                    leverage, marginAmount, orderType,
+                    success: false, reason: 'exception', error: message,
+                });
+                failedCount++;
             }
-        });
-        return outcome;
+        }
+        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;
     }
 }
 // ─── Factory & Manifest ─────────────────────────────────────────────────────