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

package/dist/runtime/runtime.js

@@ -35,7 +35,7 @@ import { createTrackingHandler, EventTracker, BatchingTransport, NoOpTransport,
 import { VERSION } from "../version.js";
 import { randomUUID } from "node:crypto";
 import { trackingContext } from "../tracking/context.js";
-import { OtelEmitter, otelContext } from "../otel/index.js";
+import { buildIdentity, createRecordingComponents, createRecordingSubscriber, resolveTelemetryEnabled, } from "../recording/wiring/index.js";
 const logger = createLogger("[senpi-core][runtime]");
 export class Runtime {
     config;
@@ -49,6 +49,8 @@ export class Runtime {
     senpi = null;
     healthStateModule = null;
     trackingHandler = null;
+    recordingSubscriber = null;
+    recordingBatcher = null;
     started = false;
     startedAt = null;
     /** Serial signal processing: queue and consumer so only one signal is handled at a time. */
@@ -61,6 +63,8 @@ export class Runtime {
     actionRuntimeModule;
     /** Stored so we can call off() in stop() and avoid retaining Runtime via scanner EventEmitter. */
     onScannerRunComplete = null;
+    onScannerRunSkip = null;
+    onScannerRunError = null;
     /** Cached strategy id resolved from the runtime wallet on first {@link auditQuery} call. */
     cachedStrategyId = null;
     /** In-flight resolution promise; ensures concurrent first-burst callers reuse one `listStrategies`. */
@@ -73,21 +77,9 @@ export class Runtime {
      * telemetry).
      */
     runtimeBootId = randomUUID();
-    /** OTEL V2 emitter. Identity envelope baked in at construction. */
-    otel;
     constructor(config, options) {
         this.config = config;
         this.options = options;
-        this.otel = new OtelEmitter({
-            identity: {
-                serviceName: "senpi-trading-runtime",
-                strategyAddress: this.config.strategy?.wallet,
-                recipeName: this.config.name,
-                recipeVersion: this.config.version != null ? String(this.config.version) : undefined,
-                runtimeVersion: VERSION,
-                runtimeBootId: this.runtimeBootId,
-            },
-        });
     }
     get dsl() {
         return this.dslPlugin;
@@ -308,165 +300,231 @@ export class Runtime {
         }
         this.senpi = senpi;
         this.strategyConfig = resolveStrategyConfig(this.config);
-        // try {
-        //   const { reconcileStateWithBackend } = await import("./reconcile-state.js");
-        //   await reconcileStateWithBackend(this.stateManager, senpi, [this.strategyConfig.address]);
-        // } catch (err) {
-        //   logger.warn("reconcile after hydrate failed, continuing", { err });
-        // }
-        const llmDecision = createLlmDecision({ otel: this.otel });
-        const contextBuilder = createContextBuilder();
-        const notifications = createNotificationService({
-            ...this.config.notifications,
-            mcpTransport: this.options.mcpTransport,
-        });
-        const riskBlock = this.config.risk;
-        const strategyAddress = this.strategyConfig.address;
-        const auditLog = riskBlock ? createRiskAuditLog(stateDir) : undefined;
-        // In-memory strategy-lifecycle tracker (§4 seed): owns the self-pause state that
-        // RiskGuard used to hold and fires the hook + notification on a running→paused
-        // transition. RiskGuard stays stateless and only reports gate evaluations.
-        const lifecycle = createStrategyLifecycle({
-            hookSystem: this.hookSystem,
-            notifications,
-            runtimeName: this.config.name,
+        // Telemetry recording: subscribe the emitter to the bus (on by default; degrades to a noop
+        // emitter when disabled or when no token is present — never a boot failure). Identity + config
+        // fingerprint are built lazily from the unresolved config — only on the live path, and never
+        // from the resolved config (which would inline secrets).
+        const telemetryConfig = this.config.telemetry;
+        const recording = createRecordingComponents({
+            enabled: resolveTelemetryEnabled(telemetryConfig?.enabled, process.env.SENPI_TELEMETRY_ENABLED),
+            token: trackingApiKey,
+            identity: () => buildIdentity({
+                name: this.config.name,
+                recipeVersion: this.config.version,
+                strategyAddress: this.strategyConfig.address,
+                bootId: this.runtimeBootId,
+                unresolvedConfig: this.options.unresolvedConfig,
+            }),
+            scopeVersion: VERSION,
+            baseUrl: telemetryConfig?.url,
+            flushIntervalMs: telemetryConfig?.flush_interval_ms,
         });
-        const riskGuard = riskBlock && senpi
-            ? createRiskGuard({
+        this.recordingBatcher = recording.batcher;
+        // Only attach the subscriber when telemetry is live (batcher present): with a noop emitter,
+        // per-event record assembly on the serial signal path would be pure dead work.
+        if (recording.batcher) {
+            this.recordingSubscriber = createRecordingSubscriber(this.bus, recording.emitter, {
+                unresolvedConfig: this.options.unresolvedConfig,
+            });
+        }
+        // Everything from here to `started = true` can throw; without the catch, stop() would
+        // early-return on `!this.started` and the recording batcher/subscriber would leak.
+        try {
+            // try {
+            //   const { reconcileStateWithBackend } = await import("./reconcile-state.js");
+            //   await reconcileStateWithBackend(this.stateManager, senpi, [this.strategyConfig.address]);
+            // } catch (err) {
+            //   logger.warn("reconcile after hydrate failed, continuing", { err });
+            // }
+            const llmDecision = createLlmDecision({});
+            const contextBuilder = createContextBuilder();
+            const notifications = createNotificationService({
+                ...this.config.notifications,
+                mcpTransport: this.options.mcpTransport,
+            });
+            const riskBlock = this.config.risk;
+            const strategyAddress = this.strategyConfig.address;
+            const auditLog = riskBlock ? createRiskAuditLog(stateDir) : undefined;
+            // In-memory strategy-lifecycle tracker (§4 seed): owns the self-pause state that
+            // RiskGuard used to hold and fires the hook + notification on a running→paused
+            // transition. RiskGuard stays stateless and only reports gate evaluations.
+            const lifecycle = createStrategyLifecycle({
+                hookSystem: this.hookSystem,
+                notifications,
+                runtimeName: this.config.name,
+            });
+            const riskGuard = riskBlock && senpi
+                ? createRiskGuard({
+                    senpi,
+                    notifications,
+                    strategies: new Map([[strategyAddress, this.strategyConfig]]),
+                    // Human strategy label for alerts; risk-guard falls back to the
+                    // truncated address when an address has no name here.
+                    strategyNames: { [strategyAddress]: this.config.name },
+                    auditLog,
+                    lifecycleTracker: lifecycle,
+                })
+                : createRiskGuardStub();
+            logger.info("Runtime.start() creating scanner module");
+            const layout = buildStateLayout(stateDir);
+            // Augment caller-supplied providers with StateManager-backed DSL state access
+            const augmentedProviders = {
+                ...scannerProviders,
+                getDslStatesForStrategy: scannerProviders?.getDslStatesForStrategy
+                    ?? (async (address) => this.stateManager.listDslStates(address)),
+            };
+            this.scannerModule = createScannerModuleFromRuntimeConfig(this.config, layout.scannerRoot, augmentedProviders);
+            logger.info("Runtime.start() scanner module created, calling start()");
+            // Pre-load max leverage cache (non-blocking — log warning on failure)
+            const maxLeverageCache = new MaxLeverageCache(senpi);
+            try {
+                await maxLeverageCache.load();
+            }
+            catch (err) {
+                logger.warn("failed to pre-load max leverage cache, will retry on first use", { err });
+            }
+            // Build RuntimeContext once per trading recipe and reuse for all actions.
+            const runtimeContext = createRuntimeContext(this.strategyConfig, {
                 senpi,
+                hookSystem: this.hookSystem,
+                llmDecision,
+                contextBuilder,
+                riskGuard,
                 notifications,
-                strategies: new Map([[strategyAddress, this.strategyConfig]]),
-                // Human strategy label for alerts; risk-guard falls back to the
-                // truncated address when an address has no name here.
-                strategyNames: { [strategyAddress]: this.config.name },
-                auditLog,
-                lifecycleTracker: lifecycle,
-            })
-            : createRiskGuardStub();
-        logger.info("Runtime.start() creating scanner module");
-        const layout = buildStateLayout(stateDir);
-        // Augment caller-supplied providers with StateManager-backed DSL state access
-        const augmentedProviders = {
-            ...scannerProviders,
-            getDslStatesForStrategy: scannerProviders?.getDslStatesForStrategy
-                ?? (async (address) => this.stateManager.listDslStates(address)),
-        };
-        this.scannerModule = createScannerModuleFromRuntimeConfig(this.config, layout.scannerRoot, augmentedProviders, undefined, this.otel);
-        logger.info("Runtime.start() scanner module created, calling start()");
-        // Pre-load max leverage cache (non-blocking — log warning on failure)
-        const maxLeverageCache = new MaxLeverageCache(senpi);
-        try {
-            await maxLeverageCache.load();
-        }
-        catch (err) {
-            logger.warn("failed to pre-load max leverage cache, will retry on first use", { err });
-        }
-        // Build RuntimeContext once per trading recipe and reuse for all actions.
-        const runtimeContext = createRuntimeContext(this.strategyConfig, {
-            senpi,
-            hookSystem: this.hookSystem,
-            llmDecision,
-            contextBuilder,
-            riskGuard,
-            notifications,
-            scannerModule: this.scannerModule,
-            maxLeverageCache,
-            otel: this.otel,
-        });
-        this.actionRuntimeModule = new ActionRuntimeModule({ stateDir: layout.actionRoot });
-        const { runActionsForSignal } = await createActions(this.config, {
-            bus: this.bus,
-            senpi,
-            stateManager: this.stateManager,
-            hookSystem: this.hookSystem,
-            llmDecision,
-            contextBuilder,
-            riskGuard,
-            notifications,
-            runtimeContext,
-            actionModule: this.actionRuntimeModule,
-        });
-        this.runActionsForSignal = runActionsForSignal;
-        const notificationsConfig = this.config.notifications;
-        if (hasDsl) {
-            const dslNotificationsDisabled = notificationsConfig?.dsl_lifecycle === false;
-            const dslNotifySlUpdates = notificationsConfig?.dsl_notify_sl_updates === true;
-            this.dslPlugin = await DslPluginClass.create({
-                config: exitConfig,
+                scannerModule: this.scannerModule,
+                maxLeverageCache,
+            });
+            this.actionRuntimeModule = new ActionRuntimeModule({ stateDir: layout.actionRoot });
+            const { runActionsForSignal } = await createActions(this.config, {
                 bus: this.bus,
-                stateDir,
+                senpi,
                 stateManager: this.stateManager,
-                senpiClient: senpi,
-                strategyStates: createStrategyStatesMap(this.strategyConfig, senpi),
-                notifications: dslNotificationsDisabled ? undefined : notifications,
-                notifySlUpdates: dslNotifySlUpdates,
-                strategyName: this.config.name,
-            });
-        }
-        else {
-            this.dslPlugin = null;
-        }
-        if (isActionLifecycleNotificationsEnabled(notificationsConfig)) {
-            this.actionNotificationSubscriber = createActionNotificationSubscriber(this.bus, notifications, {
-                strategyName: this.config.name,
+                hookSystem: this.hookSystem,
+                llmDecision,
+                contextBuilder,
+                riskGuard,
+                notifications,
+                runtimeContext,
+                actionModule: this.actionRuntimeModule,
             });
-        }
-        else {
-            this.actionNotificationSubscriber = null;
-        }
-        this.wireDslOtelLogs();
-        initRisk(this.bus);
-        this.healthStateModule = createHealthStateModule({
-            runtimeName: this.config.name,
-            stateDir,
-            startedAt: this.startedAt,
-            providers: {
-                scanners: this.scannerModule,
-                dsl: this.dslPlugin ?? createDisabledDslProvider(),
-                actions: this.actionRuntimeModule,
-                risk: riskBlock
-                    ? createRiskHealthProvider(riskGuard, strategyAddress)
-                    : undefined,
-            },
-        });
-        this.onScannerRunComplete = (event) => {
-            console.info("[senpi-runtime] [ingest-trace] onScannerRunComplete → enqueue", JSON.stringify({
-                address: event.result.address,
-                scannerId: event.result.scannerId,
-                signalCount: Array.isArray(event.result.signals) ? event.result.signals.length : 0,
-                status: event.result.status,
-                queueDepth: this.signalQueue.length + 1,
-            }));
-            const correlationId = randomUUID();
-            this.signalQueue.push({ result: event.result, correlationId });
-            if (this.signalQueueWait) {
-                const w = this.signalQueueWait;
-                this.signalQueueWait = null;
-                w();
+            this.runActionsForSignal = runActionsForSignal;
+            const notificationsConfig = this.config.notifications;
+            if (hasDsl) {
+                const dslNotificationsDisabled = notificationsConfig?.dsl_lifecycle === false;
+                const dslNotifySlUpdates = notificationsConfig?.dsl_notify_sl_updates === true;
+                this.dslPlugin = await DslPluginClass.create({
+                    config: exitConfig,
+                    bus: this.bus,
+                    stateDir,
+                    stateManager: this.stateManager,
+                    senpiClient: senpi,
+                    strategyStates: createStrategyStatesMap(this.strategyConfig, senpi),
+                    notifications: dslNotificationsDisabled ? undefined : notifications,
+                    notifySlUpdates: dslNotifySlUpdates,
+                    strategyName: this.config.name,
+                });
+            }
+            else {
+                this.dslPlugin = null;
+            }
+            if (isActionLifecycleNotificationsEnabled(notificationsConfig)) {
+                this.actionNotificationSubscriber = createActionNotificationSubscriber(this.bus, notifications, {
+                    strategyName: this.config.name,
+                });
+            }
+            else {
+                this.actionNotificationSubscriber = null;
             }
-            // Emit scanner run for tracking
-            this.bus.emit("tracking.scanner_run", {
-                address: event.result.address,
-                data: {
-                    ...event.result,
-                    __correlationId: correlationId,
+            initRisk(this.bus);
+            this.healthStateModule = createHealthStateModule({
+                runtimeName: this.config.name,
+                stateDir,
+                startedAt: this.startedAt,
+                providers: {
+                    scanners: this.scannerModule,
+                    dsl: this.dslPlugin ?? createDisabledDslProvider(),
+                    actions: this.actionRuntimeModule,
+                    risk: riskBlock
+                        ? createRiskHealthProvider(riskGuard, strategyAddress)
+                        : undefined,
                 },
-                timestamp: new Date().toISOString(),
             });
-            // Forward scanner summary alerts (e.g. watchdog) to notification service
-            const alerts = event.result.summary?.alerts;
-            if (Array.isArray(alerts) && alerts.length > 0) {
-                const header = `[${event.result.scannerId}] ${alerts.length} alert(s):`;
-                const lines = alerts.map((a) => `  ${a.level ?? "ALERT"}: ${a.message ?? ""}`);
-                notifications.notify(`${header}\n${lines.join("\n")}`).catch(() => { });
-            }
-        };
-        this.scannerModule.on("scanner:run:complete", this.onScannerRunComplete);
-        this.signalConsumerDone = this.runSignalConsumer();
-        logger.info("Runtime.start() invoking scannerModule.start()");
-        await this.scannerModule.start();
-        logger.info("Runtime.start() scannerModule.start() returned");
-        this.started = true;
+            this.onScannerRunComplete = (event) => {
+                console.info("[senpi-runtime] [ingest-trace] onScannerRunComplete → enqueue", JSON.stringify({
+                    address: event.result.address,
+                    scannerId: event.result.scannerId,
+                    signalCount: Array.isArray(event.result.signals) ? event.result.signals.length : 0,
+                    status: event.result.status,
+                    queueDepth: this.signalQueue.length + 1,
+                }));
+                const correlationId = randomUUID();
+                this.signalQueue.push({ result: event.result, correlationId });
+                if (this.signalQueueWait) {
+                    const w = this.signalQueueWait;
+                    this.signalQueueWait = null;
+                    w();
+                }
+                // Emit scanner run for tracking (startedAt is data stamping for telemetry durations)
+                this.bus.emit("tracking.scanner_run", {
+                    address: event.result.address,
+                    data: {
+                        ...event.result,
+                        startedAt: event.startedAt,
+                        __correlationId: correlationId,
+                    },
+                    timestamp: new Date().toISOString(),
+                });
+                // Forward scanner summary alerts (e.g. watchdog) to notification service
+                const alerts = event.result.summary?.alerts;
+                if (Array.isArray(alerts) && alerts.length > 0) {
+                    const header = `[${event.result.scannerId}] ${alerts.length} alert(s):`;
+                    const lines = alerts.map((a) => `  ${a.level ?? "ALERT"}: ${a.message ?? ""}`);
+                    notifications.notify(`${header}\n${lines.join("\n")}`).catch(() => { });
+                }
+            };
+            this.scannerModule.on("scanner:run:complete", this.onScannerRunComplete);
+            // Surface skipped/errored scanner runs on the bus for telemetry (add-only observation events —
+            // distinct names so existing `tracking.scanner_run` consumers see an unchanged payload mix).
+            // Neither enqueues a signal: only completed runs feed the signal queue.
+            this.onScannerRunSkip = (event) => {
+                this.bus.emit("tracking.scanner_run_skipped", {
+                    address: event.address,
+                    data: {
+                        scannerId: event.scannerId,
+                        status: event.status,
+                        reason: event.reason,
+                        timestamp: event.timestamp,
+                        startedAt: event.startedAt,
+                    },
+                    timestamp: new Date().toISOString(),
+                });
+            };
+            this.onScannerRunError = (event) => {
+                this.bus.emit("tracking.scanner_run_error", {
+                    address: event.address,
+                    data: {
+                        scannerId: event.scannerId,
+                        status: "error",
+                        reason: typeof event.error === "string" ? event.error : String(event.error),
+                        timestamp: event.timestamp,
+                        startedAt: event.startedAt,
+                    },
+                    timestamp: new Date().toISOString(),
+                });
+            };
+            this.scannerModule.on("scanner:run:skip", this.onScannerRunSkip);
+            this.scannerModule.on("scanner:run:error", this.onScannerRunError);
+            this.signalConsumerDone = this.runSignalConsumer();
+            logger.info("Runtime.start() invoking scannerModule.start()");
+            await this.scannerModule.start();
+            logger.info("Runtime.start() scannerModule.start() returned");
+            this.started = true;
+        }
+        catch (err) {
+            // Recording-only cleanup (telemetry must not leak on a failed boot); the error rethrows.
+            await this.disposeRecording();
+            throw err;
+        }
         this.bus.emit("tracking.runtime_started", {
             address: this.strategyConfig.address,
             data: {
@@ -479,49 +537,6 @@ export class Runtime {
             },
             timestamp: new Date().toISOString(),
         });
-        this.emitRuntimeBootLogs(hasDsl);
-    }
-    /** Joins to spans by position.id at query time, replacing trace-tree linkage. */
-    wireDslOtelLogs() {
-        const DSL_LOG_EVENTS = [
-            "dsl.created",
-            "dsl.tier_advanced",
-            "dsl.phase_changed",
-            "dsl.sl_updated",
-            "dsl.close_pending",
-            "dsl.closed",
-            "dsl.deleted",
-        ];
-        const on = (name, handler) => {
-            this.bus.on(name, handler);
-        };
-        for (const name of DSL_LOG_EVENTS) {
-            on(name, (p) => {
-                this.otel.emitLog({ eventName: name, attrs: dslAttrs(p), body: p });
-            });
-        }
-    }
-    emitRuntimeBootLogs(hasDsl) {
-        this.otel.emitLog({
-            eventName: "runtime.boot",
-            attrs: { "runtime.boot_id": this.runtimeBootId },
-        });
-        // Body carries the full config; attrs are only the summary set kept queryable
-        // without scanning the body (per remediation-plan D6).
-        this.otel.emitLog({
-            eventName: "runtime.config_loaded",
-            body: this.config,
-            attrs: {
-                "config.recipe_name": this.config.name,
-                // `config.recipe_version` is the recipe author's `version:` field;
-                // absent when the YAML omits it. `runtime.version` (build version) is
-                // on ResourceAttributes via the OTEL identity envelope.
-                "config.recipe_version": this.config.version != null ? String(this.config.version) : null,
-                "config.dsl_enabled": hasDsl,
-                "config.scanner_count": this.config.scanners?.length ?? 0,
-                "config.action_count": this.config.actions?.length ?? 0,
-            },
-        });
     }
     /**
      * Cancel exchange SLs and archive DSL state for the strategy, then log removal.
@@ -566,7 +581,7 @@ export class Runtime {
                 runtimeId: this.options.runtimeId ?? "",
                 runtimeVersion: VERSION,
                 runtimeBootId: this.runtimeBootId,
-            }, () => otelContext.run({}, async () => {
+            }, async () => {
                 try {
                     console.info("[senpi-runtime] [ingest-trace] consumer dequeue → runActionsForSignal", JSON.stringify({
                         address: queuedItem.result.address,
@@ -579,24 +594,6 @@ export class Runtime {
                         usedSlotsByStrategy,
                         address: queuedItem.result.address,
                     });
-                    const slots = payload.strategySlots?.[queuedItem.result.address];
-                    if (slots && slots.available <= 0) {
-                        // D9: one log per slot-exhaustion, not one per signal — same query
-                        // power (signal.assets[] preserves cardinality), 20× fewer rows.
-                        const signalList = queuedItem.result.signals ?? [];
-                        this.otel.emitLog({
-                            eventName: "runtime.slot_unavailable",
-                            severity: "warn",
-                            attrs: {
-                                "scanner.id": queuedItem.result.scannerId,
-                                "signal.assets": signalList.map((s) => s.asset),
-                                "signal.directions": signalList.map((s) => s.direction),
-                                "signal.count": signalList.length,
-                                "slots_in_use": slots.used,
-                                "slots_max": slots.total,
-                            },
-                        });
-                    }
                     const hookEvent = {
                         type: HOOK_EVENT.ON_SIGNAL_DETECTED,
                         runtimeName: this.config.name,
@@ -615,18 +612,6 @@ export class Runtime {
                     const message = err instanceof Error ? err.message : String(err);
                     const stack = err instanceof Error ? err.stack : undefined;
                     console.error("[senpi-runtime] signal processing error", message, stack ?? "");
-                    this.otel.emitLog({
-                        eventName: "runtime.task_error",
-                        severity: "error",
-                        attrs: {
-                            "task.name": "signal_consumer",
-                            "task.kind": "loop",
-                            "exception.type": err instanceof Error ? err.name : "Error",
-                            "exception.message": message,
-                            "exception.stacktrace": stack ?? "",
-                            "scanner.id": queuedItem.result.scannerId,
-                        },
-                    });
                     this.bus.emit("signal_processing_error", {
                         error: err,
                         address: queuedItem.result.address,
@@ -634,7 +619,21 @@ export class Runtime {
                         timestamp: new Date().toISOString(),
                     });
                 }
-            }));
+            });
+        }
+    }
+    /**
+     * Dispose the recording subscriber, then flush + stop the batcher (best-effort). Idempotent;
+     * shared by stop() and the failed-start cleanup path in start().
+     */
+    async disposeRecording() {
+        if (this.recordingSubscriber) {
+            this.recordingSubscriber.dispose();
+            this.recordingSubscriber = null;
+        }
+        if (this.recordingBatcher) {
+            await this.recordingBatcher.shutdown().catch(() => { });
+            this.recordingBatcher = null;
         }
     }
     async stop() {
@@ -665,6 +664,14 @@ export class Runtime {
             this.scannerModule.off("scanner:run:complete", this.onScannerRunComplete);
             this.onScannerRunComplete = null;
         }
+        if (this.onScannerRunSkip != null) {
+            this.scannerModule.off("scanner:run:skip", this.onScannerRunSkip);
+            this.onScannerRunSkip = null;
+        }
+        if (this.onScannerRunError != null) {
+            this.scannerModule.off("scanner:run:error", this.onScannerRunError);
+            this.onScannerRunError = null;
+        }
         if (this.actionNotificationSubscriber != null) {
             this.actionNotificationSubscriber.dispose();
             this.actionNotificationSubscriber = null;
@@ -683,46 +690,14 @@ export class Runtime {
             await this.trackingHandler.dispose();
             this.trackingHandler = null;
         }
-        await this.otel.shutdown();
+        // Telemetry recording teardown: stop the subscriber, then flush + stop the batcher (best-effort)
+        // so the just-recorded runtime_stopped row ships before the process exits.
+        await this.disposeRecording();
         if (this.bus.removeAllListeners) {
             this.bus.removeAllListeners();
         }
     }
 }
-/**
- * Pure attr extractor for dsl.* log events.
- *
- * C12 (DSL position.id plumbing): the DSL state currently exposes
- * `__correlationId` (DSL-internal lifecycle id) and `backendDslPositionId`
- * (backend-side id, optional). The runtime's minted `position.id` is not
- * threaded into the DSL state yet — that's the position-state-machine PR.
- * Until then, dsl.* logs join by `dsl.correlation_id` / `dsl.backend_position_id`
- * + `dsl.asset` + `strategy.address` (the latter is on ResourceAttributes).
- * When the state machine lands, add `position.id` here.
- */
-function dslAttrs(payload) {
-    return {
-        "dsl.asset": payload.asset,
-        "dsl.dex": payload.dex,
-        "dsl.phase": payload.phase,
-        "dsl.tier_index": payload.tier ?? payload.tierIndex,
-        "dsl.floor_price": payload.newFloorPrice ?? payload.floorPrice,
-        "dsl.current_price": payload.lastPrice ?? payload.currentPrice,
-        "dsl.high_water_price": payload.highWaterPrice,
-        "dsl.high_water_roe": payload.highWaterRoe,
-        "dsl.current_roe": payload.currentROE,
-        "dsl.trigger_reason": payload.triggerReason,
-        "dsl.close_reason": payload.closeReason,
-        "dsl.locked_profit_pct": payload.lockedProfitPct,
-        "dsl.new_sl_price": payload.newSlPrice ?? payload.slPrice,
-        "dsl.direction": payload.direction,
-        "dsl.entry_price": payload.entryPrice,
-        "dsl.leverage": payload.leverage,
-        "dsl.margin": payload.margin,
-        "dsl.correlation_id": payload.__correlationId,
-        "dsl.backend_position_id": payload.backendDslPositionId,
-    };
-}
 /**
  * Coerce the (already envelope-unwrapped) MCP `audit_query` payload to the
  * public {@link AuditQueryResult} shape. Missing or malformed fields are