@senpi/runtime 3.0.4-dev.runtime-phase-2.20260626011132 → 3.0.6-dev.openclaw-upgrade-mai.20260701205227

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

@@ -6,9 +6,11 @@ import { formatDecisionErrorNotification } from '../../runtime/notifications.js'
 import { resolveLeverage } from '../../leverage/resolve-leverage.js';
 import { resolveMarginWithSource } from './resolve-margin.js';
 import { createLogger } from '../../utils/logger.js';
-import { positionRegistryKey } from '../../tracking/position-id-registry.js';
+import { positionRegistryKey } from '../../runtime/position-id-registry.js';
 import { resolveOpenOrderType, resolveFeeOptimizedLimitOptions } from '../../utils/resolve-order-type.js';
-import { emitTrackingDecision, emitTrackingActionResult, emitOrderPlaced, emitOrderFilled, emitOrderFailed } from '../tracking-helpers.js';
+import { emitActionResultEvents, emitOrderPlaced, emitOrderFilled, emitOrderFailed, buildActionEventContext } from '../action-events.js';
+import { withSpan } from '../../telemetry/tracing.js';
+import { SpanStatusCode } from '@opentelemetry/api';
 const logger = createLogger("[actions][open-position]");
 /** Hyperliquid minimum notional value (margin × leverage) required to open a position. */
 const MIN_NOTIONAL_VALUE = 10;
@@ -30,19 +32,18 @@ export class OpenPositionAction {
         this.decisionEngine.register(new RuleDecisionStrategy());
         this.decisionEngine.register(new NoDecisionStrategy());
     }
-    trackingCtx() {
-        return {
+    eventCtx() {
+        return buildActionEventContext({
             hookSystem: this.context.hookSystem,
             actionName: this.name,
             actionType: this.actionType,
             decisionMode: this.config.decision_mode,
             decisionModel: this.config.decision_model,
             minConfidence: this.config.min_confidence,
-        };
+            positionIdRegistry: this.context.positionIdRegistry,
+        });
     }
     async handle(event) {
-        // Telemetry: pass start = "action began handling the scan event" (NOT "LLM call dispatched").
-        const decisionStartedAt = Date.now();
         logger.info('handling open position', event);
         //check event type is on_signal_detected
         if (event.type !== HOOK_EVENT.ON_SIGNAL_DETECTED) {
@@ -125,7 +126,6 @@ export class OpenPositionAction {
             : undefined;
         // Get decision
         let decision;
-        let decisionEndedAt;
         try {
             decision = await this.decisionEngine.decide(this.config.decision_mode, {
                 prompt: interpolatedPrompt,
@@ -134,10 +134,8 @@ export class OpenPositionAction {
                 actionType: this.actionType,
                 event,
             });
-            decisionEndedAt = Date.now();
         }
         catch (error) {
-            decisionEndedAt = Date.now();
             const message = error instanceof Error ? error.message : String(error);
             logger.error('decision error', message);
             const notificationMessage = formatDecisionErrorNotification(message, {
@@ -145,8 +143,7 @@ export class OpenPositionAction {
                 model: this.config.decision_model,
             });
             await this.context.notifications.notify(notificationMessage).catch(() => { });
-            const trackingCtx = this.trackingCtx();
-            emitTrackingDecision(trackingCtx, event, address, scanResult, { error: message }, undefined, interpolatedPrompt, contextData);
+            const eventCtx = this.eventCtx();
             const errorResult = {
                 success: false,
                 action_type: this.actionType,
@@ -165,15 +162,14 @@ export class OpenPositionAction {
                     _decisionPrompt: interpolatedPrompt ?? null,
                 },
             };
-            emitTrackingActionResult(trackingCtx, event, address, errorResult, { scanResult, decisionStartedAt, decisionEndedAt });
+            emitActionResultEvents(eventCtx, event, address, errorResult, { scanResult });
             return errorResult;
         }
         logger.info('decision', decision);
-        const trackingCtx = this.trackingCtx();
+        const eventCtx = this.eventCtx();
         const minConfidence = this.config.min_confidence ?? 1;
-        const trackingExtras = { scanResult, decisionStartedAt, decisionEndedAt, minConfidence };
+        const trackingExtras = { scanResult, minConfidence };
         const isBelowConfidence = decision.execute && decision.confidence < minConfidence;
-        emitTrackingDecision(trackingCtx, event, address, scanResult, decision, minConfidence, interpolatedPrompt, contextData, isBelowConfidence ? 'below_confidence' : undefined);
         // Check decision
         if (!decision.execute) {
             logger.info('decision no execute', decision);
@@ -190,7 +186,7 @@ export class OpenPositionAction {
                     _decisionPrompt: interpolatedPrompt ?? null,
                 },
             };
-            emitTrackingActionResult(trackingCtx, event, address, rejectedResult, trackingExtras);
+            emitActionResultEvents(eventCtx, event, address, rejectedResult, trackingExtras);
             return rejectedResult;
         }
         // Check confidence threshold
@@ -209,7 +205,7 @@ export class OpenPositionAction {
                     _decisionPrompt: interpolatedPrompt ?? null,
                 },
             };
-            emitTrackingActionResult(trackingCtx, event, address, belowConfResult, trackingExtras);
+            emitActionResultEvents(eventCtx, event, address, belowConfResult, trackingExtras);
             return belowConfResult;
         }
         // ── Unified signals path ──
@@ -223,7 +219,7 @@ export class OpenPositionAction {
                 error: 'invalid_payload',
                 data: { _decisionMeta: meta, _decisionPrompt: interpolatedPrompt ?? null },
             };
-            emitTrackingActionResult(trackingCtx, event, address, invalidPayloadResult, trackingExtras);
+            emitActionResultEvents(eventCtx, event, address, invalidPayloadResult, trackingExtras);
             return invalidPayloadResult;
         }
         return this.handleSignals(signals, event, strategyState, decision.reasoning, meta, interpolatedPrompt, trackingExtras);
@@ -310,7 +306,7 @@ export class OpenPositionAction {
                     _decisionPrompt: decisionPrompt ?? null,
                 },
             };
-            emitTrackingActionResult(this.trackingCtx(), event, address, skipResult, trackingExtras);
+            emitActionResultEvents(this.eventCtx(), event, address, skipResult, trackingExtras);
             return skipResult;
         }
         const withdrawable = clearinghouseView.withdrawable;
@@ -324,238 +320,300 @@ export class OpenPositionAction {
         let submittedCount = 0;
         let failedCount = 0;
         for (const signal of sorted) {
-            // Telemetry: per-signal work window — every result entry below carries startedAt/endedAt.
-            const signalStartedAt = Date.now();
             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) {
-                results.push({ asset, direction, dex: submittedDex, score: signalScore, success: true, reason: 'no_slots', startedAt: signalStartedAt, endedAt: Date.now() });
-                continue;
-            }
-            if (!direction || (direction !== 'LONG' && direction !== 'SHORT')) {
-                results.push({ asset, direction, dex: submittedDex, score: signalScore, success: false, reason: 'invalid_direction', startedAt: signalStartedAt, endedAt: Date.now() });
-                failedCount++;
-                continue;
-            }
-            if (strategyState.hasOpenPosition(asset, dexForLookup)) {
-                results.push({ asset, direction, dex: submittedDex, score: signalScore, success: true, reason: 'position_already_exists', startedAt: signalStartedAt, endedAt: Date.now() });
-                continue;
-            }
-            // Risk guard per-open (real-time via MCP, with per-asset cooldown)
-            const gate = await this.context.riskGuard.checkGate(address, { candidateAsset: asset });
-            if (gate.gate !== 'OPEN') {
-                results.push({ asset, direction, dex: submittedDex, score: signalScore, success: true, reason: `risk_gate_${gate.gate}`, startedAt: signalStartedAt, endedAt: Date.now() });
-                continue;
-            }
-            // Leverage: LLM override > config-based resolution
-            const llmLeverage = typeof signal.leverage === 'number' ? signal.leverage : undefined;
-            const maxLeverage = await this.context.maxLeverageCache.get(asset, address) ?? 20;
-            const leverage = llmLeverage != null && llmLeverage > 0
-                ? Math.max(MIN_LEVERAGE, Math.min(llmLeverage, maxLeverage))
-                : resolveLeverage({
-                    tradingRisk: strategyState.config.tradingRisk,
-                    maxLeverage,
-                    defaultLeverage: strategyState.config.defaultLeverage,
-                    leverageMultipliers: strategyState.config.leverageMultipliers,
+            await withSpan("signal.evaluation", {
+                "senpi.signal.asset": asset,
+                "senpi.signal.direction": direction,
+                ...(typeof signalScore === "number" ? { "senpi.signal.score": signalScore } : {}),
+            }, async (span) => {
+                // Terminal outcome on this candidate's span. A failed result also shows red.
+                const outcome = (result, reason) => {
+                    span.setAttribute("senpi.outcome.result", result);
+                    span.setAttribute("senpi.outcome.reason_code", reason);
+                    if (result === "failed")
+                        span.setStatus({ code: SpanStatusCode.ERROR, message: reason });
+                };
+                // Telemetry: per-signal work window — every result entry below carries startedAt/endedAt.
+                const signalStartedAt = Date.now();
+                const signalDex = signal.dex;
+                const submittedDex = typeof signalDex === "string" && signalDex.trim() !== "" ? signalDex.trim() : "main";
+                const dexForLookup = submittedDex === "main" ? undefined : submittedDex;
+                if (remainingSlots <= 0) {
+                    results.push({ asset, direction, dex: submittedDex, score: signalScore, success: true, reason: 'no_slots', startedAt: signalStartedAt, endedAt: Date.now() });
+                    outcome("skipped", 'no_slots');
+                    return;
+                }
+                if (!direction || (direction !== 'LONG' && direction !== 'SHORT')) {
+                    results.push({ asset, direction, dex: submittedDex, score: signalScore, success: false, reason: 'invalid_direction', startedAt: signalStartedAt, endedAt: Date.now() });
+                    failedCount++;
+                    outcome("failed", 'invalid_direction');
+                    return;
+                }
+                if (strategyState.hasOpenPosition(asset, dexForLookup)) {
+                    results.push({ asset, direction, dex: submittedDex, score: signalScore, success: true, reason: 'position_already_exists', startedAt: signalStartedAt, endedAt: Date.now() });
+                    outcome("skipped", 'position_already_exists');
+                    return;
+                }
+                // Risk guard per-open (real-time via MCP, with per-asset cooldown)
+                const gate = await withSpan("risk.gate", {}, async (gateSpan) => {
+                    const g = await this.context.riskGuard.checkGate(address, { candidateAsset: asset });
+                    gateSpan.setAttribute("senpi.risk.gate", g.gate);
+                    if (g.gate !== 'OPEN')
+                        gateSpan.setStatus({ code: SpanStatusCode.ERROR, message: g.reason ?? g.gate });
+                    return g;
                 });
-            // Margin: per-signal marginPct (% of withdrawable) > config margin_pct
-            //         > margin_per_slot > budget / slots
-            const signalMarginPct = typeof signal.marginPct === 'number' ? signal.marginPct : undefined;
-            const { amount: marginAmount, source: marginSource } = resolveMarginWithSource({
-                signalMarginPct,
-                marginPct: strategyState.config.marginPct,
-                withdrawable,
-                marginPerSlot: strategyState.config.marginPerSlot,
-                budget: strategyState.config.budget,
-                slots: strategyState.config.slots,
-            });
-            if (marginAmount == null || marginAmount <= 0) {
-                logger.warn(`Skipping ${asset}: no margin source resolved. ` +
-                    `Set strategy.margin_per_slot, strategy.margin_pct, or strategy.budget + strategy.slots ` +
-                    `in the recipe, or have the LLM provide a per-signal margin override.`, {
-                    asset,
-                    wallet: address,
+                if (gate.gate !== 'OPEN') {
+                    results.push({ asset, direction, dex: submittedDex, score: signalScore, success: true, reason: `risk_gate_${gate.gate}`, startedAt: signalStartedAt, endedAt: Date.now() });
+                    outcome("skipped", `risk_gate_${gate.gate}`);
+                    return;
+                }
+                // Leverage: LLM override > config-based resolution
+                const llmLeverage = typeof signal.leverage === 'number' ? signal.leverage : undefined;
+                const maxLeverage = await this.context.maxLeverageCache.get(asset, address) ?? 20;
+                const leverage = llmLeverage != null && llmLeverage > 0
+                    ? Math.max(MIN_LEVERAGE, Math.min(llmLeverage, maxLeverage))
+                    : resolveLeverage({
+                        tradingRisk: strategyState.config.tradingRisk,
+                        maxLeverage,
+                        defaultLeverage: strategyState.config.defaultLeverage,
+                        leverageMultipliers: strategyState.config.leverageMultipliers,
+                    });
+                // Margin: per-signal marginPct (% of withdrawable) > config margin_pct
+                //         > margin_per_slot > budget / slots
+                const signalMarginPct = typeof signal.marginPct === 'number' ? signal.marginPct : undefined;
+                const { amount: marginAmount, source: marginSource } = resolveMarginWithSource({
                     signalMarginPct,
                     marginPct: strategyState.config.marginPct,
+                    withdrawable,
                     marginPerSlot: strategyState.config.marginPerSlot,
                     budget: strategyState.config.budget,
                     slots: strategyState.config.slots,
-                    withdrawable,
-                });
-                results.push({ asset, direction, dex: submittedDex, score: signalScore, leverage, success: false, reason: 'no_margin_configured', startedAt: signalStartedAt, endedAt: Date.now() });
-                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}`);
-                results.push({ asset, direction, dex: submittedDex, score: signalScore, leverage, marginAmount, notionalValue, success: false, reason: 'below_min_notional', startedAt: signalStartedAt, endedAt: Date.now() });
-                failedCount++;
-                continue;
-            }
-            // Free-margin pre-flight: 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)`);
-                results.push({ asset, direction, dex: submittedDex, score: signalScore, leverage, marginAmount, requiredMarginAmount: marginAmount, availableMarginAmount: remainingMargin, success: true, reason: 'insufficient_margin', startedAt: signalStartedAt, endedAt: Date.now() });
-                continue;
-            }
-            const signalReason = signal.reason ?? signal.signalType ?? reasoning;
-            try {
-                // Sizing breadcrumb: WHICH source set the margin + the numbers behind it,
-                // so a wrong size is attributable from logs without reverse-engineering.
-                logger.info('opening position', {
-                    wallet: address,
-                    asset,
-                    direction,
-                    source: marginSource,
-                    withdrawable,
-                    accountValue: clearinghouseView.accountValue,
-                    marginAmount,
-                    leverage,
-                    notional: notionalValue,
                 });
-                const result = await this.context.senpi.createPosition({
-                    strategyWalletAddress: address,
-                    orders: [
-                        {
-                            coin: asset,
+                // The applied percent — only meaningful for the two percent-of-withdrawable branches; the
+                // fixed/budget sources have no percent. Rides the result entry so the sizing attribution
+                // (source + percent) reaches the signal.outcome event, not just the structured log below.
+                const marginPct = marginSource === 'signal_marginPct' ? signalMarginPct
+                    : marginSource === 'config_margin_pct' ? strategyState.config.marginPct
+                        : undefined;
+                if (marginAmount == null || marginAmount <= 0) {
+                    logger.warn(`Skipping ${asset}: no margin source resolved. ` +
+                        `Set strategy.margin_per_slot, strategy.margin_pct, or strategy.budget + strategy.slots ` +
+                        `in the recipe, or have the LLM provide a per-signal margin override.`, {
+                        asset,
+                        wallet: address,
+                        signalMarginPct,
+                        marginPct: strategyState.config.marginPct,
+                        marginPerSlot: strategyState.config.marginPerSlot,
+                        budget: strategyState.config.budget,
+                        slots: strategyState.config.slots,
+                        withdrawable,
+                    });
+                    results.push({ asset, direction, dex: submittedDex, score: signalScore, leverage, success: false, reason: 'no_margin_configured', startedAt: signalStartedAt, endedAt: Date.now() });
+                    failedCount++;
+                    outcome("failed", 'no_margin_configured');
+                    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, marginSource, marginPct, notionalValue, success: false, reason: 'below_min_notional', startedAt: signalStartedAt, endedAt: Date.now() });
+                    failedCount++;
+                    outcome("failed", 'below_min_notional');
+                    return;
+                }
+                // Free-margin pre-flight: 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)`);
+                    results.push({ asset, direction, dex: submittedDex, score: signalScore, leverage, marginAmount, marginSource, marginPct, requiredMarginAmount: marginAmount, availableMarginAmount: remainingMargin, success: true, reason: 'insufficient_margin', startedAt: signalStartedAt, endedAt: Date.now() });
+                    outcome("skipped", 'insufficient_margin');
+                    return;
+                }
+                const signalReason = signal.reason ?? signal.signalType ?? reasoning;
+                try {
+                    // Sizing breadcrumb: WHICH source set the margin + the numbers behind it,
+                    // so a wrong size is attributable from logs without reverse-engineering.
+                    logger.info('opening position', {
+                        wallet: address,
+                        asset,
+                        direction,
+                        source: marginSource,
+                        withdrawable,
+                        accountValue: clearinghouseView.accountValue,
+                        marginAmount,
+                        leverage,
+                        notional: notionalValue,
+                    });
+                    const result = await withSpan("mcp.createPosition", { "senpi.signal.asset": asset, "senpi.signal.direction": direction }, async (mcpSpan) => {
+                        const r = await this.context.senpi.createPosition({
+                            strategyWalletAddress: address,
+                            orders: [
+                                {
+                                    coin: asset,
+                                    direction,
+                                    leverage,
+                                    marginAmount,
+                                    orderType,
+                                    ...(feeOptimizedLimitOptions ? { feeOptimizedLimitOptions } : {}),
+                                },
+                            ],
+                            reason: signalReason,
+                        });
+                        if (!r.success) {
+                            const orderErrors = r.orders
+                                .filter((o) => o.error)
+                                .map((o) => `${o.coin}: ${o.error}`)
+                                .join('; ');
+                            const detail = r.error || orderErrors || 'unknown error';
+                            mcpSpan.addEvent("order.failed");
+                            mcpSpan.setStatus({ code: SpanStatusCode.ERROR, message: detail });
+                        }
+                        else {
+                            const o = r.orders[0];
+                            if (o?.orderId != null)
+                                mcpSpan.setAttribute("senpi.order.id", o.orderId);
+                            if (o?.filled != null)
+                                mcpSpan.setAttribute("senpi.outcome.filled", o.filled);
+                            if (o?.executionAsMaker != null)
+                                mcpSpan.setAttribute("senpi.outcome.execution_as_maker", o.executionAsMaker);
+                            if (o?.entryPrice != null)
+                                mcpSpan.setAttribute("senpi.order.entry_price", o.entryPrice);
+                            if (o?.size != null)
+                                mcpSpan.setAttribute("senpi.order.size", o.size);
+                            mcpSpan.addEvent("order.placed");
+                            if (o?.filled)
+                                mcpSpan.addEvent("order.filled");
+                        }
+                        return r;
+                    });
+                    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, marginSource, marginPct, orderType,
+                            success: false, reason: 'position_open_failed', error: detail,
+                            startedAt: signalStartedAt, endedAt: Date.now(),
+                        });
+                        // Task 8a: the venue rejected the open submit.
+                        emitOrderFailed(this.context.hookSystem, event, address, {
+                            asset,
+                            direction,
+                            reason: 'position_open_failed',
+                            error: detail,
+                            reduceOnly: false,
+                        });
+                        failedCount++;
+                        outcome("failed", 'position_open_failed');
+                        return;
+                    }
+                    const submittedOrder = result.orders[0];
+                    // Mint the position.id at intent — the moment the open order is submitted,
+                    // before the position is confirmed open — so the id rides the action.open
+                    // emit and the open trace correlates by position.id directly (no ~60s
+                    // bridge on the read side).
+                    let mintedPositionId;
+                    if (this.context.positionIdRegistry) {
+                        try {
+                            const minted = this.context.positionIdRegistry.mintOnIntent(positionRegistryKey(address, submittedDex, asset));
+                            mintedPositionId = minted.positionId;
+                        }
+                        catch (err) {
+                            // The order is already on the exchange — a registry failure must not land in the
+                            // outer catch, which would mislabel this submit as an exception and skip the
+                            // slot/margin bookkeeping.
+                            const message = err instanceof Error ? err.message : String(err);
+                            logger.warn('position.id mint failed; continuing with submit emit', err, { asset });
+                        }
+                    }
+                    await this.context.hookSystem.fire({
+                        type: HOOK_EVENT.ON_OPEN_ORDER_SUBMITTED,
+                        runtimeName: event.runtimeName,
+                        address,
+                        data: {
+                            asset,
                             direction,
                             leverage,
                             marginAmount,
                             orderType,
-                            ...(feeOptimizedLimitOptions ? { feeOptimizedLimitOptions } : {}),
+                            wallet: address,
+                            dex: submittedDex,
+                            reasoning: signalReason,
+                            orderId: submittedOrder?.orderId,
+                            entryPrice: submittedOrder?.entryPrice ?? null,
+                            size: submittedOrder?.size ?? null,
+                            filled: submittedOrder?.filled ?? null,
+                            ...(mintedPositionId ? { __positionId: mintedPositionId } : {}),
                         },
-                    ],
-                    reason: signalReason,
-                });
-                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';
+                        timestamp: new Date().toISOString(),
+                    });
                     results.push({
                         asset, direction, dex: submittedDex, score: signalScore,
-                        leverage, marginAmount, orderType,
-                        success: false, reason: 'position_open_failed', error: detail,
+                        leverage, marginAmount, marginSource, marginPct, orderType,
+                        orderId: submittedOrder?.orderId ?? null,
+                        entryPrice: submittedOrder?.entryPrice ?? null,
+                        size: submittedOrder?.size ?? null,
+                        filled: submittedOrder?.filled ?? null,
+                        success: true, reason: 'submitted',
                         startedAt: signalStartedAt, endedAt: Date.now(),
                     });
-                    // Task 8a: the venue rejected the open submit.
-                    emitOrderFailed(this.context.hookSystem, event, address, {
+                    // Task 8a order-event log (additive, fire-and-forget — see emit helpers). The open submit
+                    // is an `order.placed`; a confirmed fill additionally emits `order.filled`.
+                    emitOrderPlaced(this.context.hookSystem, event, address, {
+                        orderId: submittedOrder?.orderId,
+                        orderType,
                         asset,
                         direction,
-                        reason: 'position_open_failed',
-                        error: detail,
+                        size: submittedOrder?.size,
                         reduceOnly: false,
+                        ...(mintedPositionId ? { __positionId: mintedPositionId } : {}),
                     });
-                    failedCount++;
-                    continue;
-                }
-                const submittedOrder = result.orders[0];
-                // Mint the position.id at intent — the moment the open order is submitted,
-                // before the position is confirmed open — so the id rides the action.open
-                // emit and the open trace correlates by position.id directly (no ~60s
-                // bridge on the read side).
-                let mintedPositionId;
-                if (this.context.positionIdRegistry) {
-                    try {
-                        const minted = this.context.positionIdRegistry.mintOnIntent(positionRegistryKey(address, submittedDex, asset));
-                        mintedPositionId = minted.positionId;
-                    }
-                    catch (err) {
-                        // The order is already on the exchange — a registry failure must not land in the
-                        // outer catch, which would mislabel this submit as an exception and skip the
-                        // slot/margin bookkeeping.
-                        const message = err instanceof Error ? err.message : String(err);
-                        logger.warn('position.id mint failed; continuing with submit emit', { asset, err: message });
+                    if (submittedOrder?.filled) {
+                        emitOrderFilled(this.context.hookSystem, event, address, {
+                            orderId: submittedOrder?.orderId,
+                            asset,
+                            fillPrice: submittedOrder?.entryPrice,
+                            fillSize: submittedOrder?.size,
+                            executionAsMaker: submittedOrder?.executionAsMaker,
+                            ...(mintedPositionId ? { __positionId: mintedPositionId } : {}),
+                        });
                     }
+                    submittedCount++;
+                    remainingSlots--;
+                    if (remainingMargin != null)
+                        remainingMargin -= marginAmount;
+                    outcome("submitted", 'submitted');
                 }
-                await this.context.hookSystem.fire({
-                    type: HOOK_EVENT.ON_OPEN_ORDER_SUBMITTED,
-                    runtimeName: event.runtimeName,
-                    address,
-                    data: {
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    logger.error('open failed', error, { asset });
+                    results.push({
+                        asset, direction, dex: submittedDex, score: signalScore,
+                        leverage, marginAmount, marginSource, marginPct, orderType,
+                        success: false, reason: 'exception', error: message,
+                        startedAt: signalStartedAt, endedAt: Date.now(),
+                    });
+                    // Task 8a: the open submit threw.
+                    emitOrderFailed(this.context.hookSystem, event, address, {
                         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,
-                        ...(mintedPositionId ? { __positionId: mintedPositionId } : {}),
-                    },
-                    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',
-                    startedAt: signalStartedAt, endedAt: Date.now(),
-                });
-                // Task 8a order-event log (additive, fire-and-forget — see emit helpers). The open submit
-                // is an `order.placed`; a confirmed fill additionally emits `order.filled`.
-                emitOrderPlaced(this.context.hookSystem, event, address, {
-                    orderId: submittedOrder?.orderId,
-                    orderType,
-                    asset,
-                    direction,
-                    size: submittedOrder?.size,
-                    reduceOnly: false,
-                    ...(mintedPositionId ? { __positionId: mintedPositionId } : {}),
-                });
-                if (submittedOrder?.filled) {
-                    emitOrderFilled(this.context.hookSystem, event, address, {
-                        orderId: submittedOrder?.orderId,
-                        asset,
-                        fillPrice: submittedOrder?.entryPrice,
-                        fillSize: submittedOrder?.size,
-                        executionAsMaker: submittedOrder?.executionAsMaker,
-                        ...(mintedPositionId ? { __positionId: mintedPositionId } : {}),
+                        reason: 'exception',
+                        error: message,
+                        errorName: error instanceof Error ? error.name : undefined,
+                        reduceOnly: false,
                     });
+                    failedCount++;
+                    outcome("failed", 'exception');
                 }
-                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,
-                    startedAt: signalStartedAt, endedAt: Date.now(),
-                });
-                // Task 8a: the open submit threw.
-                emitOrderFailed(this.context.hookSystem, event, address, {
-                    asset,
-                    direction,
-                    reason: 'exception',
-                    error: message,
-                    errorName: error instanceof Error ? error.name : undefined,
-                    reduceOnly: false,
-                });
-                failedCount++;
-            }
+            });
         }
         const skippedCount = results.length - submittedCount - failedCount;
         const actionResult = {
@@ -572,7 +630,7 @@ export class OpenPositionAction {
                 _decisionPrompt: decisionPrompt ?? null,
             },
         };
-        emitTrackingActionResult(this.trackingCtx(), event, address, actionResult, trackingExtras);
+        emitActionResultEvents(this.eventCtx(), event, address, actionResult, trackingExtras);
         return actionResult;
     }
 }