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

package/dist/recording/otel/mappers.js

@@ -1,683 +0,0 @@
-/**
- * The mapper: `RecordingRecord → TraceRow[] | LogRow[]`. Pure functions given their deps (identity,
- * an injected {@link IdGenerator}, scope) — that is what makes the golden `record → row` tests
- * deterministic. No `@opentelemetry/*`: this builds wire rows, it is not a span SDK.
- *
- * Per-record key maps and the trace-vs-log routing are pinned in {@link ./constants} and appended
- * to the Task 2 brief. Order within a row: redact (typed-field) → flatten → cap.
- */
-import { AttrBuilder, durationNs, msToNs } from "./attributes.js";
-import { EXCEPTION_EVENT_NAME, eventNameFor, ROUTING, severityFor, SPAN_NAME, TRACE_FLAGS_SAMPLED, } from "./constants.js";
-import { deterministicSpanId, deterministicTraceId } from "./ids.js";
-import { redactBody, redactRuntimeError, redactRuntimeState, redactSignalEvaluated, } from "./redaction.js";
-import { createLogger } from "../../utils/logger.js";
-const logger = createLogger("[recording][otel][mapper]");
-/**
- * Identity → `ResourceAttributes` (server-required `service.name` included) + the derived `address`.
- * Built once per emitter and shared (frozen) across every row it produces. `address` is derived from
- * `identity.strategyAddress` directly — not read back from the attribute map — so a future attr-budget
- * edge can never silently empty the ownership/keying field.
- */
-export function buildResource(identity) {
-    const resourceAttributes = new AttrBuilder()
-        .put("service.name", identity.service)
-        .put("strategy.address", identity.strategyAddress)
-        .put("recipe", identity.recipe)
-        .put("recipe.version", identity.recipeVersion)
-        .put("runtime", identity.runtime)
-        .put("boot.id", identity.bootId)
-        .put("config.hash", identity.configHash)
-        .build();
-    // Frozen: the single resource object is shared by reference across all of an emitter's rows, so
-    // any accidental mutation would corrupt every row at once.
-    Object.freeze(resourceAttributes);
-    return Object.freeze({
-        resourceAttributes,
-        address: (identity.strategyAddress ?? "").toLowerCase(),
-    });
-}
-function spanKindFor(type) {
-    const route = ROUTING[type];
-    return route.kind === "trace" ? route.spanKind : "Internal";
-}
-function makeTraceRow(deps, f) {
-    return {
-        Timestamp: msToNs(f.timestampMs),
-        TraceId: f.traceId,
-        SpanId: f.spanId,
-        ParentSpanId: f.parentSpanId ?? "",
-        TraceState: "",
-        SpanName: f.spanName,
-        SpanKind: f.spanKind,
-        ServiceName: deps.identity.service,
-        Duration: durationNs(f.startedAt, f.endedAt),
-        StatusCode: f.statusCode,
-        StatusMessage: f.statusMessage ?? "",
-        SpanAttributes: f.attrs,
-        ResourceAttributes: deps.resource.resourceAttributes,
-        Events: f.events ?? [],
-        ScopeName: deps.scopeName,
-        ScopeVersion: deps.scopeVersion,
-        TraceFlags: TRACE_FLAGS_SAMPLED,
-        address: deps.resource.address,
-    };
-}
-/**
- * Build the single log row for a record: severity/event-name are derived from the record and the
- * caller supplies the timestamp (`occurredAt` for the point-in-time records, `endedAt` for the
- * skipped scanner run), so each log mapper only adds its `Body` and flattened attrs. Each log gets
- * fresh, self-rooted ids (minimal per-record correlation; cross-record threading is deferred).
- */
-function logRowFor(deps, record, timestampMs, body, attrs) {
-    const severity = severityFor(record);
-    return {
-        Timestamp: msToNs(timestampMs),
-        TraceId: deps.ids.traceId(),
-        SpanId: deps.ids.spanId(),
-        TraceFlags: TRACE_FLAGS_SAMPLED,
-        SeverityText: severity.text,
-        SeverityNumber: severity.number,
-        ServiceName: deps.identity.service,
-        Body: body,
-        ResourceAttributes: deps.resource.resourceAttributes,
-        ScopeName: deps.scopeName,
-        ScopeVersion: deps.scopeVersion,
-        LogAttributes: attrs,
-        EventName: eventNameFor(record),
-        address: deps.resource.address,
-    };
-}
-/**
- * Clamp a child window into its parent: never negative, never outside `[lo, hi]`; a window
- * entirely before the parent pins to its start.
- */
-function clampWindow(start, end, lo, hi) {
-    if (start < lo)
-        start = lo;
-    if (end > hi)
-        end = hi;
-    if (end < lo)
-        end = lo; // window entirely before the parent → pin to its start
-    if (end < start)
-        start = end;
-    return { start, end };
-}
-/** OTEL `exception` span event — the idiomatic home for the error-grouping key on a span. */
-function exceptionEvent(timestampMs, errorName, message) {
-    const attrs = new AttrBuilder()
-        .put("exception.type", errorName)
-        .put("exception.message", message)
-        .build();
-    return { Timestamp: msToNs(timestampMs), Name: EXCEPTION_EVENT_NAME, Attributes: attrs };
-}
-// ── scanner_run → one span (complete/error) or one skip log ───────────────────
-/** Shared `scanner.*` attrs — identical keys whether the run routes to a span or to a skip log. */
-function scannerRunAttrs(record) {
-    // Individual `signals[]` are omitted here — counts + summary capture the run's shape, and
-    // per-signal detail lives on `signal_evaluated` children (avoids re-flattening signal meta).
-    return new AttrBuilder()
-        .put("scanner.id", record.scannerId)
-        .put("scan.run_id", record.runId)
-        .put("scanner.outcome", record.outcome)
-        .put("scanner.status_detail", record.statusDetail)
-        .put("scanner.scanned_count", record.scannedCount)
-        .put("scanner.actionable_count", record.actionableCount)
-        .put("scanner.signal_count", record.signalCount)
-        .put("scanner.reason", record.reason)
-        .put("scanner.error", record.error)
-        .put("scanner.error_name", record.errorName)
-        .putBag("scanner.summary", record.summary)
-        .build();
-}
-/** A run that actually ran (`complete`/`error`) → one span. Skips go to {@link mapScannerRunSkipped}. */
-export function mapScannerRun(record, deps) {
-    const attrs = scannerRunAttrs(record);
-    const isError = record.outcome === "error";
-    // Deterministic ids from the run id thread scan → pass into one trace; absent (older payloads)
-    // → fresh self-rooted ids as before.
-    return [
-        makeTraceRow(deps, {
-            timestampMs: record.startedAt,
-            traceId: record.runId !== undefined ? deterministicTraceId(record.runId) : deps.ids.traceId(),
-            spanId: record.runId !== undefined ? deterministicSpanId(record.runId) : deps.ids.spanId(),
-            spanName: SPAN_NAME.scannerRun,
-            spanKind: spanKindFor("scanner_run"),
-            startedAt: record.startedAt,
-            endedAt: record.endedAt,
-            statusCode: isError ? "Error" : "Ok",
-            statusMessage: isError ? (record.error ?? "") : "",
-            attrs,
-            events: isError ? [exceptionEvent(record.endedAt, record.errorName, record.error)] : [],
-        }),
-    ];
-}
-/**
- * The {@link ROUTING} exception: a skipped run (`outcome === "skipped"` — engine statuses
- * skipped/disabled/halted) is a discrete "didn't run" fact, not work, so it becomes an INFO log
- * (`scanner_run.skipped`) instead of a zero-duration span. Same `scanner.*` attrs as the span
- * (counts are simply absent on skip payloads); `Timestamp` from `endedAt` (the builder synthesizes
- * `startedAt = endedAt` for skips — only the end is observed).
- */
-export function mapScannerRunSkipped(record, deps) {
-    const reason = record.reason ? `: ${record.reason}` : "";
-    const body = `scanner skipped ${record.scannerId}${reason}`;
-    return [logRowFor(deps, record, record.endedAt, body, scannerRunAttrs(record))];
-}
-// ── signal_evaluated → pass-span root + llm.decision child + one child span per evaluation ──
-export function mapSignalEvaluated(record, deps) {
-    const red = redactSignalEvaluated(record);
-    // Deterministic ids from the scan run id thread the pass under its scanner.run span (same
-    // TraceId, ParentSpanId = the scanner.run SpanId); absent runId → fresh self-rooted ids as
-    // before. Intentional: the pass child starts after its parent ends (queue wait, visible as the
-    // gap) — never "fixed" by faking timestamps.
-    const traceId = red.runId !== undefined ? deterministicTraceId(red.runId) : deps.ids.traceId();
-    const rootSpanId = deps.ids.spanId();
-    const parentSpanId = red.runId !== undefined ? deterministicSpanId(red.runId) : undefined;
-    const errored = red.evaluations.filter((ev) => ev.outcome.result === "error");
-    const rootAttrs = new AttrBuilder()
-        .put("scanner.id", red.scannerId)
-        .put("scan.run_id", red.runId)
-        .put("signal.evaluation_count", red.evaluations.length)
-        .put("signal.error_count", errored.length);
-    const rows = [
-        makeTraceRow(deps, {
-            timestampMs: red.startedAt,
-            traceId,
-            spanId: rootSpanId,
-            parentSpanId,
-            spanName: SPAN_NAME.signalPass,
-            spanKind: spanKindFor("signal_evaluated"),
-            startedAt: red.startedAt,
-            endedAt: red.endedAt,
-            // Status propagates: any errored evaluation child fails the pass root (filterable even
-            // when the trace root is the always-Ok scanner.run span).
-            statusCode: errored.length > 0 ? "Error" : "Ok",
-            statusMessage: errored.length > 0 ? (errored[0].outcome.error ?? "") : "",
-            attrs: rootAttrs.build(),
-        }),
-    ];
-    // The decision phase as its own child span (carries the decision.* attrs). Mapped defensively,
-    // like the evaluation children: a bad decision must not sink the pass span or its siblings.
-    if (red.decision) {
-        try {
-            rows.push(mapLlmDecisionChild(red.decision, deps, traceId, rootSpanId, red.startedAt, red.endedAt));
-        }
-        catch (err) {
-            logger.warn("dropping llm.decision child (mapping error)", {
-                err: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    // One child span per evaluation, sharing the root's TraceId (intra-record parenting). Each child
-    // is mapped defensively: a single bad evaluation must not sink the pass span or its siblings.
-    for (const ev of red.evaluations) {
-        try {
-            rows.push(mapEvaluationChild(ev, deps, traceId, rootSpanId, red.startedAt, red.endedAt));
-        }
-        catch (err) {
-            logger.warn("dropping signal evaluation child (mapping error)", {
-                err: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    return rows;
-}
-/**
- * The `llm.decision` child span: the pass's decision phase, window
- * `[decision.endedAt − durationMs, decision.endedAt]` — the gap after the pass start is context
- * building, deliberately visible. Defensive fallback when `endedAt` is absent (older payloads):
- * start at the pass start. The window is then clamped into the pass (`start` up to the pass start,
- * `end` down to the pass end, and `start = end` when that inverts) so it is never negative and
- * never outside the pass.
- */
-function mapLlmDecisionChild(d, deps, traceId, parentSpanId, passStartedAt, passEndedAt) {
-    const attrs = new AttrBuilder()
-        .put("decision.execute", d.execute)
-        .put("decision.action_type", d.actionType)
-        .put("decision.action_name", d.actionName)
-        .put("decision.mode", d.mode)
-        .put("decision.confidence", d.confidence)
-        .put("decision.confidence_threshold", d.confidenceThreshold)
-        .put("decision.reasoning", d.reasoning) // kept (length-capped) — high-value agent rationale
-        .put("decision.model", d.model)
-        .put("decision.tokens_used", d.tokensUsed)
-        .put("decision.duration_ms", d.durationMs)
-        // The record no longer carries the raw LLM payload (dropped when the pass was single-sourced
-        // from `_decisionMeta`); its bounded content lands on the per-signal child spans.
-        .build();
-    const durationMs = d.durationMs ?? 0;
-    const rawEnd = d.endedAt ?? passStartedAt + durationMs;
-    const { start, end } = clampWindow(rawEnd - durationMs, rawEnd, passStartedAt, passEndedAt);
-    return makeTraceRow(deps, {
-        timestampMs: start,
-        traceId,
-        spanId: deps.ids.spanId(),
-        parentSpanId,
-        spanName: SPAN_NAME.llmDecision,
-        spanKind: "Internal",
-        startedAt: start,
-        endedAt: end,
-        statusCode: "Ok",
-        attrs,
-    });
-}
-function mapEvaluationChild(ev, deps, traceId, parentSpanId, 
-// The action loop stamps a real per-signal window (`startedAt`/`endedAt`) on each result entry;
-// when present it is the child's measured extent, clamped into the pass like the llm.decision
-// child. Absent (older payloads) → point-in-time at the pass start, Duration 0, as before.
-passStartedAt, passEndedAt) {
-    const { signal, outcome } = ev;
-    // position.id is the flat cross-record group-by key (V2 read layer); TraceId stays
-    // per-pass — never derived from positionId.
-    const attrs = new AttrBuilder()
-        .put("position.id", outcome.positionId)
-        .put("signal.type", signal.signalType)
-        .put("signal.asset", signal.asset)
-        .put("signal.direction", signal.direction)
-        .put("signal.score", signal.score)
-        .put("signal.timestamp", signal.timestamp)
-        .putFactors("signal.factor", signal.factors)
-        // signal.meta is dropped by redaction upstream.
-        .put("outcome.result", outcome.result)
-        .put("outcome.summary", outcome.summary)
-        .put("outcome.reason_code", outcome.reasonCode)
-        .put("outcome.reason", outcome.reason)
-        .put("outcome.error", outcome.error)
-        .put("outcome.error_name", outcome.errorName)
-        .put("outcome.leverage", outcome.leverage)
-        .put("outcome.margin_amount", outcome.marginAmount)
-        .put("outcome.notional_value", outcome.notionalValue)
-        .put("outcome.order_id", outcome.orderId)
-        .put("outcome.entry_price", outcome.entryPrice)
-        .put("outcome.size", outcome.size)
-        .put("outcome.filled", outcome.filled)
-        .put("outcome.execution_as_maker", outcome.executionAsMaker)
-        .put("outcome.required_margin_amount", outcome.requiredMarginAmount)
-        .put("outcome.available_margin_amount", outcome.availableMarginAmount)
-        .build();
-    const hasWindow = ev.startedAt !== undefined && ev.endedAt !== undefined;
-    const { start, end } = clampWindow(hasWindow ? ev.startedAt : passStartedAt, hasWindow ? ev.endedAt : passStartedAt, passStartedAt, passEndedAt);
-    const isError = outcome.result === "error";
-    return makeTraceRow(deps, {
-        timestampMs: start,
-        traceId,
-        spanId: deps.ids.spanId(),
-        parentSpanId,
-        spanName: SPAN_NAME.signalEvaluation,
-        spanKind: spanKindFor("signal_evaluated"),
-        startedAt: start,
-        endedAt: end,
-        statusCode: isError ? "Error" : "Ok",
-        statusMessage: isError ? (outcome.error ?? "") : "",
-        attrs,
-        events: isError ? [exceptionEvent(end, outcome.errorName, outcome.error)] : [],
-    });
-}
-// ── position_lifecycle → one log ─────────────────────────────────────────────────
-export function mapPositionLifecycle(record, deps) {
-    // No bag/PII to scrub here: `reasoning` is kept (length-capped) as high-value agent rationale.
-    const attrs = new AttrBuilder()
-        .put("position.id", record.positionId)
-        .put("position.event", record.event)
-        .put("position.asset", record.asset)
-        .put("position.dex", record.dex)
-        .put("position.direction", record.direction)
-        .put("position.entry_price", record.entryPrice)
-        .put("position.size", record.size)
-        .put("position.leverage", record.leverage)
-        .put("position.leverage_type", record.leverageType)
-        .put("position.margin", record.margin)
-        .put("position.unrealized_pnl", record.unrealizedPnl)
-        .put("position.roe", record.roe)
-        .put("position.liquidation_price", record.liquidationPrice)
-        .put("position.reason", record.reason)
-        .put("position.close_reason", record.closeReason)
-        .put("position.closed_price", record.closedPrice)
-        .put("position.closed_size", record.closedSize)
-        .put("position.execution_as_maker", record.executionAsMaker)
-        .put("position.previous_entry_price", record.previousEntryPrice)
-        .put("position.previous_size", record.previousSize)
-        .put("position.size_delta", record.sizeDelta)
-        .put("position.new_asset", record.newAsset)
-        .put("position.order_id", record.orderId)
-        .put("position.order_type", record.orderType)
-        .put("position.margin_amount", record.marginAmount)
-        .put("position.filled", record.filled)
-        .put("position.reasoning", record.reasoning) // kept (length-capped)
-        .put("position.reconciliation_source", record.reconciliationSource) // opened only; absent elsewhere
-        .build();
-    const dir = record.direction ? ` ${record.direction}` : "";
-    return [logRowFor(deps, record, record.occurredAt, `position ${record.event} ${record.asset}${dir}`, attrs)];
-}
-// ── dsl_transition → one log ─────────────────────────────────────────────────────
-export function mapDslTransition(record, deps) {
-    const attrs = new AttrBuilder()
-        .put("position.id", record.positionId)
-        .put("dsl.transition", record.transition)
-        .put("dsl.asset", record.asset)
-        .put("dsl.dex", record.dex)
-        .put("dsl.trigger_reason", record.triggerReason)
-        .put("dsl.preset", record.preset)
-        .putJson("dsl.tiers", record.tiers)
-        .put("dsl.direction", record.direction)
-        .put("dsl.entry_price", record.entryPrice)
-        .put("dsl.leverage", record.leverage)
-        .put("dsl.margin", record.margin)
-        .put("dsl.size", record.size)
-        .put("dsl.floor_price", record.floorPrice)
-        .put("dsl.new_floor_price", record.newFloorPrice)
-        .put("dsl.phase", record.phase)
-        .put("dsl.tier_index", record.tierIndex)
-        .put("dsl.lock_hw_pct", record.lockHwPct)
-        .put("dsl.trigger_pct", record.triggerPct)
-        .put("dsl.locked_profit_pct", record.lockedProfitPct)
-        .put("dsl.new_sl_price", record.newSLPrice)
-        .put("dsl.sl_order_id", record.slOrderId)
-        .put("dsl.reason", record.reason)
-        .put("dsl.close_reason", record.closeReason)
-        .put("dsl.created_at", record.createdAt)
-        .put("dsl.current_roe", record.currentROE)
-        .put("dsl.high_water_roe", record.highWaterRoe)
-        .put("dsl.high_water_price", record.highWaterPrice)
-        .put("dsl.peak_roe", record.peakROE)
-        .put("dsl.last_price", record.lastPrice)
-        .put("dsl.attempt", record.attempt)
-        .putJson("dsl.updated", record.updated)
-        .put("dsl.backend_dsl_position_id", record.backendDslPositionId)
-        .build();
-    return [logRowFor(deps, record, record.occurredAt, `dsl ${record.transition} ${record.asset}`, attrs)];
-}
-// ── dsl_tick → one span per work unit (deterministic-id threaded tick family) ─────
-/**
- * Maps one DSL-tick work unit to its span. No buffering or pairing: each record maps
- * independently, and the deterministic ids derived from `bootId:tickId` (and
- * `bootId:tickId:positionKey`) thread the units into one trace — root `dsl.tick`, `dsl.position`
- * children, and `dsl.close_attempt`/`dsl.sl_update` under their position. `tick.id` rides every
- * span (the cross-store join key); `position.id` rides the position-grain spans. A child unit
- * missing its `positionKey` (defensive) parents to the tick root so the row still joins the trace.
- */
-export function mapDslTick(record, deps) {
-    // The seeds are scoped by the emitter's bootId: tickId is a ms-resolution wall-clock string, so
-    // two runtimes ticking in the same millisecond (or a restart re-deriving the same ms) would
-    // otherwise collide and merge unrelated tick families into one trace with duplicate span ids.
-    // The `tick.id` ATTRIBUTE stays the raw tickId — it is the join key to the monitor's logs.
-    const tickSeed = `${deps.identity.bootId}:${record.tickId}`;
-    const traceId = deterministicTraceId(tickSeed);
-    const rootSpanId = deterministicSpanId(tickSeed);
-    if (record.unit === "tick") {
-        const attrs = new AttrBuilder()
-            .put("tick.id", record.tickId)
-            .put("dsl.strategy_count", record.strategyCount)
-            .put("dsl.active_position_count", record.activePositionCount)
-            .put("dsl.positions_processed", record.positionsProcessed)
-            .build();
-        const rows = [
-            makeTraceRow(deps, {
-                timestampMs: record.startedAt,
-                traceId,
-                spanId: rootSpanId,
-                spanName: SPAN_NAME.dslTick,
-                spanKind: spanKindFor("dsl_tick"),
-                startedAt: record.startedAt,
-                endedAt: record.endedAt,
-                statusCode: "Ok",
-                attrs,
-            }),
-        ];
-        // The batched price fetch as an intra-record child of the tick root — only when both stamps
-        // were observed (a half window is fabricated extent), clamped into the tick window like the
-        // other intra-record children.
-        if (record.pricesStartedAt !== undefined && record.pricesEndedAt !== undefined) {
-            const { start, end } = clampWindow(record.pricesStartedAt, record.pricesEndedAt, record.startedAt, record.endedAt);
-            rows.push(makeTraceRow(deps, {
-                timestampMs: start,
-                traceId,
-                spanId: deps.ids.spanId(),
-                parentSpanId: rootSpanId,
-                spanName: SPAN_NAME.dslPrices,
-                spanKind: spanKindFor("dsl_tick"),
-                startedAt: start,
-                endedAt: end,
-                statusCode: "Ok",
-                attrs: new AttrBuilder().put("tick.id", record.tickId).build(),
-            }));
-        }
-        return rows;
-    }
-    // The per-position span id is seeded from `bootId:tickId:positionKey`, so the position span and
-    // its close/SL children agree on it without any pairing state.
-    const positionSpanId = record.positionKey !== undefined
-        ? deterministicSpanId(`${tickSeed}:${record.positionKey}`)
-        : undefined;
-    if (record.unit === "position") {
-        const attrs = new AttrBuilder()
-            .put("tick.id", record.tickId)
-            .put("position.id", record.positionId)
-            .put("dsl.asset", record.asset)
-            .put("dsl.dex", record.dex)
-            .build();
-        return [
-            makeTraceRow(deps, {
-                timestampMs: record.startedAt,
-                traceId,
-                spanId: positionSpanId ?? deps.ids.spanId(),
-                parentSpanId: rootSpanId,
-                spanName: SPAN_NAME.dslPosition,
-                spanKind: spanKindFor("dsl_tick"),
-                startedAt: record.startedAt,
-                endedAt: record.endedAt,
-                statusCode: "Ok",
-                attrs,
-            }),
-        ];
-    }
-    // close_attempt / sl_update — the venue calls, nested under their position span.
-    const isError = record.outcome === "error";
-    const attrs = new AttrBuilder()
-        .put("tick.id", record.tickId)
-        .put("position.id", record.positionId)
-        .put("dsl.asset", record.asset)
-        .put("dsl.dex", record.dex)
-        .put("dsl.error", record.error);
-    if (record.unit === "close_attempt") {
-        attrs.put("dsl.close_reason", record.closeReason).put("dsl.attempt", record.attempt);
-    }
-    else {
-        attrs
-            .put("dsl.new_sl_price", record.newSLPrice)
-            .put("dsl.sl_order_id", record.slOrderId)
-            .put("dsl.sync_reason", record.syncReason);
-    }
-    return [
-        makeTraceRow(deps, {
-            timestampMs: record.startedAt,
-            traceId,
-            spanId: deps.ids.spanId(),
-            // Defensive fallback: no positionKey → parent to the tick root so the row still joins.
-            parentSpanId: positionSpanId ?? rootSpanId,
-            spanName: record.unit === "close_attempt" ? SPAN_NAME.dslCloseAttempt : SPAN_NAME.dslSlUpdate,
-            spanKind: spanKindFor("dsl_tick"),
-            startedAt: record.startedAt,
-            endedAt: record.endedAt,
-            statusCode: isError ? "Error" : "Ok",
-            statusMessage: isError ? (record.error ?? "") : "",
-            attrs: attrs.build(),
-            // No error class name at the emit site — exception.type is omitted, message kept.
-            events: isError ? [exceptionEvent(record.endedAt, undefined, record.error)] : [],
-        }),
-    ];
-}
-// ── decision.made → one log (Task 8) ──────────────────────────────────────────────
-/**
- * The pass's judgment as a discrete log. Attributes are the queryable scalars; the **Body is the
- * LLM reasoning prose, uncapped** (the catalog calls for full reasoning — no per-value cap applied
- * to it) and routed through {@link redactBody}, which passes a flat string through verbatim (a
- * string has no keys to scrub) while still keeping the redaction seam over both Bodies. When
- * reasoning is absent, a short templated Body stands in. Market-context keys are reserved and
- * absent in 8a (see the brief's impl notes).
- */
-export function mapDecisionMade(record, deps) {
-    const attrs = new AttrBuilder()
-        .put("decision.mode", record.mode)
-        .put("decision.by_llm", record.byLlm)
-        .put("decision.model", record.model)
-        .put("decision.tokens_used", record.tokensUsed)
-        .put("decision.confidence", record.confidence)
-        .put("decision.confidence_threshold", record.confidenceThreshold)
-        .put("decision.duration_ms", record.durationMs)
-        .put("decision.action_intent", record.actionIntent)
-        .put("decision.funding_regime", record.fundingRegime)
-        .put("decision.market_regime", record.marketRegime)
-        .put("decision.mark_price", record.markPrice)
-        .build();
-    // Body = the reasoning prose (uncapped), through the Body redaction seam. A string has no
-    // sensitive keys, so it survives verbatim; the short fallback keeps a non-empty, useful Body.
-    const reasoning = record.reasoning ? String(redactBody(record.reasoning)) : "";
-    const body = reasoning || `decision ${record.actionIntent} (${record.mode ?? "none"})`;
-    return [logRowFor(deps, record, record.occurredAt, body, attrs)];
-}
-// ── signal.outcome → one log (Task 8) ──────────────────────────────────────────────
-/**
- * One considered signal's disposition as a discrete log. Attributes are the queryable raw-signal
- * scalars, factors, disposition, and sizing; the **Body is the raw scanner evidence**
- * (`JSON.stringify(redactBody(rawSignal))`) — the variable-shaped payload whose arbitrary scanner
- * `meta` Task 2 dropped from attributes and Task 8 keeps here, scrubbed by key name. Empty Body when
- * there is no rawSignal.
- */
-export function mapSignalOutcome(record, deps) {
-    const attrs = new AttrBuilder()
-        .put("scanner.id", record.scannerId)
-        .put("signal.type", record.signalType)
-        .put("signal.asset", record.asset)
-        .put("signal.direction", record.direction)
-        .put("signal.score", record.score)
-        .put("signal.timestamp", record.signalTs)
-        .putFactors("signal.factor", record.factors)
-        .put("outcome.result", record.result)
-        .put("outcome.reason_code", record.reasonCode)
-        .put("position.id", record.positionId)
-        .put("outcome.margin_amount", record.marginAmount)
-        .put("outcome.leverage", record.leverage)
-        .put("outcome.notional_value", record.notionalValue)
-        .put("outcome.size", record.size)
-        .put("outcome.margin_source", record.marginSource)
-        .put("outcome.order_id", record.orderId)
-        .put("outcome.error_name", record.errorName)
-        .build();
-    const body = record.rawSignal ? JSON.stringify(redactBody(record.rawSignal)) : "";
-    return [logRowFor(deps, record, record.occurredAt, body, attrs)];
-}
-// ── scanner.summary → one log (Task 8 anti-spam funnel) ─────────────────────────────
-/**
- * One scan's funnel roll-up as a discrete log — ONE row, never one per drop. Attributes are the
- * queryable aggregate surface (counts, per-reason counts via `putBag`, the survivors' assets as a
- * single JSON array). The **Body is the dropped-candidate array**
- * (`JSON.stringify(redactBody(droppedCandidates))`) — variable-shaped scanner data, scrubbed by
- * key name, read only after the row is selected. Empty Body when nothing was dropped.
- */
-export function mapScannerSummary(record, deps) {
-    const attrs = new AttrBuilder()
-        .put("scanner.id", record.scannerId)
-        .put("scanner.scanned_count", record.scannedCount)
-        .put("scanner.passed_count", record.passedCount)
-        .put("scanner.dropped_count", record.droppedCount)
-        .putBag("scanner.dropped_by_reason", record.droppedByReason)
-        .putJson("scanner.passed_assets", record.passedAssets)
-        .build();
-    const dropped = record.droppedCandidates;
-    const body = dropped && dropped.length > 0 ? JSON.stringify(redactBody(dropped)) : "";
-    return [
-        logRowFor(deps, record, record.occurredAt, body, attrs),
-    ];
-}
-// ── dsl.close_attempt → one log (Task 8) ────────────────────────────────────────────
-/**
- * One DSL exit attempt as a discrete log (the second consumer of `tracking.dsl_close_attempt`,
- * alongside the tick trace). No Body — the attempt is fully described by its scalars. No
- * `error_name`: only `String(e)` is available at the producer emit site.
- */
-export function mapDslCloseAttempt(record, deps) {
-    const attrs = new AttrBuilder()
-        .put("position.id", record.positionId)
-        .put("dsl.asset", record.asset)
-        .put("dsl.dex", record.dex)
-        .put("dsl.reason", record.reason)
-        .put("dsl.attempt", record.attempt)
-        .put("dsl.result", record.result)
-        .build();
-    return [logRowFor(deps, record, record.occurredAt, `dsl close_attempt ${record.asset ?? ""} ${record.result}`, attrs)];
-}
-/**
- * One order-execution event as a discrete log under the `order.*` namespace — the execution
- * granularity `position_lifecycle` can't carry. Null/undefined attrs are omitted by the builder, so
- * each event subtype naturally carries only its own fields (placed: order/size; filled: fill; failed:
- * reason/error_name). `position.id` is the cross-flow join key (coexists with `outcome.order_id` /
- * `position.order_id`; 8b coalesces). **Body** = the venue raw response on `failed`
- * (`JSON.stringify(redactBody(error))`); `placed`/`filled` carry no Body (short templated message).
- */
-export function mapOrderEvent(record, deps) {
-    const attrs = new AttrBuilder()
-        .put("order.id", record.orderId)
-        .put("order.type", record.orderType)
-        .put("order.asset", record.asset)
-        .put("order.direction", record.direction)
-        .put("order.size", record.size)
-        .put("order.limit_price", record.limitPrice)
-        .put("order.reduce_only", record.reduceOnly)
-        .put("order.fill_price", record.fillPrice)
-        .put("order.fill_size", record.fillSize)
-        .put("order.execution_as_maker", record.executionAsMaker)
-        .put("order.fees", record.fees)
-        .put("order.partial", record.partial)
-        .put("order.reason", record.reason)
-        .put("order.error_name", record.errorName)
-        .put("position.id", record.positionId)
-        .build();
-    const body = record.event === "failed" && record.error ? JSON.stringify(redactBody(record.error)) : "";
-    const dir = record.direction ? ` ${record.direction}` : "";
-    const fallback = `order ${record.event} ${record.asset}${dir}`;
-    return [logRowFor(deps, record, record.occurredAt, body || fallback, attrs)];
-}
-// ── runtime_error → one log ───────────────────────────────────────────────────────
-export function mapRuntimeError(record, deps) {
-    const red = redactRuntimeError(record);
-    const attrs = new AttrBuilder()
-        .put("runtime.phase", red.phase)
-        .put("runtime.message", red.message)
-        .put("runtime.error_name", red.errorName)
-        .put("runtime.asset", red.asset)
-        .put("runtime.scanner_id", red.scannerId)
-        .put("scan.run_id", red.runId)
-        .put("runtime.stack", red.stack)
-        .build();
-    return [logRowFor(deps, red, red.occurredAt, `${red.phase}: ${red.message}`, attrs)];
-}
-// ── runtime_lifecycle → one log ───────────────────────────────────────────────────
-export function mapRuntimeLifecycle(record, deps) {
-    const attrs = new AttrBuilder()
-        .put("runtime.phase", record.phase)
-        .put("runtime.version", record.runtimeVersion)
-        .put("runtime.has_dsl", record.hasDsl)
-        .put("runtime.scanner_count", record.scannerCount)
-        .put("runtime.action_count", record.actionCount)
-        .put("runtime.uptime_ms", record.uptimeMs)
-        // Unresolved config blob: single JSON key, size-capped, never flattened (no secrets to scrub).
-        .putConfig("runtime.config", record.config)
-        .build();
-    return [logRowFor(deps, record, record.occurredAt, `runtime ${record.phase}`, attrs)];
-}
-// ── runtime_state → one log ───────────────────────────────────────────────────────
-export function mapRuntimeState(record, deps) {
-    const red = redactRuntimeState(record);
-    const attrs = new AttrBuilder()
-        .put("runtime.phase", red.phase)
-        .put("runtime.gate_id", red.gateId)
-        .put("runtime.gate_name", red.gateName)
-        .put("runtime.source", red.source)
-        .put("runtime.reason", red.reason)
-        // runtime.metrics dropped by redaction upstream.
-        .build();
-    // `|| gateId` (not `??`): an empty-string gateName must still fall back to the stable id.
-    return [logRowFor(deps, red, red.occurredAt, `trading ${red.phase}: ${red.gateName || red.gateId}`, attrs)];
-}
-//# sourceMappingURL=mappers.js.map