@senpi/runtime 1.1.0-dev.runtime-phase-2.20260612060625 → 1.1.0-dev.runtime-phase-2.20260617180011

package/dist/recording/wiring/record-builders.d.ts

@@ -7,19 +7,20 @@
  * Timestamps: the bus carries ISO strings (and, for a scan result, an epoch-ms number); every record
  * stores epoch ms, converted once here.
  */
-import type { DslTransitionKind, DslTransitionRecord, PositionLifecycleEvent, PositionLifecycleRecord, RuntimeErrorRecord, RuntimeLifecycleRecord, RuntimeStateRecord, ScannerRunRecord, SignalDecision, SignalEvaluatedRecord, SignalSummary } from "../records.js";
+import type { DecisionMadeRecord, DslCloseAttemptRecord, DslTickRecord, DslTickUnit, DslTransitionKind, DslTransitionRecord, OrderEventKind, OrderEventRecord, PositionLifecycleEvent, PositionLifecycleRecord, RuntimeErrorRecord, RuntimeLifecycleRecord, RuntimeStateRecord, ScannerRunRecord, ScannerSummaryRecord, SignalEvaluatedRecord, SignalOutcomeRecord } from "../records.js";
 /** From a `tracking.scanner_run` / `tracking.scanner_run_skipped` / `tracking.scanner_run_error`
  * event (complete runs carry the whole `ScanResult`; skip/error carry status + reason). */
 export declare function buildScannerRun(payload: unknown, nowMs: number): ScannerRunRecord | null;
-/** Pass-level decision state held between `tracking.decision` and its `tracking.action_result`. */
-export interface PendingDecision {
-    readonly scannerId?: string;
-    readonly startedAtMs: number;
-    readonly decision: SignalDecision;
-    readonly signals: readonly SignalSummary[];
-}
-/** Build the pending decision from a `tracking.decision` payload. */
-export declare function buildPendingDecision(payload: unknown, nowMs: number): PendingDecision | null;
+/**
+ * The `scanner.summary` anti-spam log record, derived from the SAME `tracking.scanner_run` payload
+ * that {@link buildScannerRun} reads (its `data.summary.funnel.dropped`) — no new bus event.
+ *
+ * Returns `null` when there is no `data.summary.funnel`: skip/error runs and scanners without a
+ * funnel produce no summary event (the survivors are detailed by their own `signal.outcome` events,
+ * and "didn't run at all" is `scanner_run.skipped`). One record per scan; the dropped candidates are
+ * one Body array, never one row per drop.
+ */
+export declare function buildScannerSummary(payload: unknown, nowMs: number): ScannerSummaryRecord | null;
 /**
  * Read-only position.id lookup, (address, dex, asset) → the live id or undefined. Injected by
  * the runtime as a narrow accessor over the PositionIdRegistry — the registry is the single
@@ -27,27 +28,48 @@ export declare function buildPendingDecision(payload: unknown, nowMs: number): P
  */
 export type PositionIdResolver = (address: string, dex: string, asset: string) => string | undefined;
 /**
- * Pair a held {@link PendingDecision} with its `tracking.action_result` payload into one record.
- * `evaluations` is one entry per per-signal result, each enriched with the matching input signal.
- * The pass span runs decision-ts → action_result-ts; on clock skew (`endedAt < startedAt`) the start
- * is pulled up to `endedAt`, yielding a zero (never negative) duration.
+ * Build the whole pass record from a `tracking.action_result` payload alone — the producers echo
+ * the decision window and scan provenance onto the payload (`scannerId`, `scannerSignals`,
+ * `minConfidence`, `decisionStartedAt`, `decisionEndedAt`, `runId`), and the decision itself rides
+ * `result.data._decisionMeta`, so no pairing with `tracking.decision` is needed.
+ *
+ * `evaluations` is one entry per per-signal result, each enriched with the matching input signal
+ * (or a summary synthesized from the result entry when none matches — e.g. close-position's
+ * static-params path, which carries no `scannerSignals`). A pass without `_decisionMeta` yields no
+ * `decision` (the contract allows a decision-less pass).
+ *
+ * The pass span runs `decisionStartedAt` → action_result-ts; when the start stamp is absent
+ * (defensive only — the bus is in-process) `startedAt = endedAt`. On clock skew
+ * (`endedAt < startedAt`) the start is pulled up to `endedAt`, yielding a zero (never negative)
+ * duration.
+ */
+export declare function buildSignalEvaluated(actionResultPayload: unknown, nowMs: number, resolvePositionId?: PositionIdResolver): SignalEvaluatedRecord | null;
+/**
+ * The pass's `decision.made` log record, derived from the built pass record — `null` when the pass
+ * carried no decision (a decision-less pass yields no judgment event). One per pass.
+ */
+export declare function buildDecisionMade(record: SignalEvaluatedRecord): DecisionMadeRecord | null;
+/**
+ * One `signal.outcome` log record per evaluation in the pass, derived from the built pass record.
+ * `rawSignal` is the evaluation's {@link SignalSummary} (incl. its `meta`/`factors`) — the variable
+ * scanner evidence; redaction over it happens in the mapper, not here.
  */
-export declare function buildSignalEvaluated(pending: PendingDecision, actionResultPayload: unknown, nowMs: number, resolvePositionId?: PositionIdResolver): SignalEvaluatedRecord;
+export declare function buildSignalOutcomes(record: SignalEvaluatedRecord): SignalOutcomeRecord[];
 /**
- * A `tracking.action_result` with no held decision — a producer that never emits `tracking.decision`
- * for the pass (e.g. close-position's static-params path, `decision_mode: 'none'` + `params.asset`).
- * The record carries the per-signal outcomes with signals synthesized from the result entries and no
- * `decision` (the contract allows a decision-less pass); zero duration (`startedAt = endedAt` = the
- * action_result timestamp).
+ * From the existing `tracking.dsl_close_attempt` monitor event — the second consumer (alongside the
+ * tick trace). Fields at the payload root: `positionId`, `asset`, `dex`, `closeReason`, `attempt`,
+ * `outcome` ("ok"|"error"), `error`, ISO `timestamp`. `null` when the payload is not an object.
  */
-export declare function buildResultOnlyEvaluated(actionResultPayload: unknown, nowMs: number, resolvePositionId?: PositionIdResolver): SignalEvaluatedRecord | null;
+export declare function buildDslCloseAttempt(payload: unknown, nowMs: number): DslCloseAttemptRecord | null;
 /**
- * A decision that never received its action_result (the action threw or returned before emitting
- * one). Flushed when the same action's next decision arrives, so a decided-but-unresulted pass is
- * visible on the signal axis rather than silently dropped: no evaluations, zero duration
- * (`startedAt = endedAt =` the decision timestamp).
+ * From the additive `tracking.order_*` events the open/close actions fire (the HookEvent shape:
+ * fields under a `data` envelope). One record per event; `eventKind` discriminates which fields the
+ * payload carries (placed: order/size; filled: fill; failed: reason/error). `positionId` maps from
+ * `__positionId`. `null` when no `asset` is resolvable — the asset is the one always-present scalar.
+ *
+ * Faithful population only (no redaction here — the mapper is the single redaction seam).
  */
-export declare function buildDecisionOnlyEvaluated(pending: PendingDecision): SignalEvaluatedRecord;
+export declare function buildOrderEvent(eventKind: OrderEventKind, payload: unknown, nowMs: number): OrderEventRecord | null;
 /**
  * From an `on_position_*` event. Action-driven events arrive as HookEvents (fields under a `data`
  * envelope); the DSL monitor / reconcile paths emit `on_position_closed` flat (fields at the root,
@@ -59,6 +81,17 @@ export declare function buildDecisionOnlyEvaluated(pending: PendingDecision): Si
 export declare function buildPositionLifecycle(event: PositionLifecycleEvent, payload: unknown, nowMs: number): PositionLifecycleRecord | null;
 /** From a `dsl.*` event (fields live at the payload root, with an ISO `timestamp`). */
 export declare function buildDslTransition(transition: DslTransitionKind, payload: unknown, nowMs: number): DslTransitionRecord | null;
+/**
+ * From the monitor's `tracking.dsl_tick` / `tracking.dsl_position` / `tracking.dsl_close_attempt`
+ * / `tracking.dsl_sl_update` events (fields at the payload root). Each event yields one record —
+ * the deterministic ids derived from `tickId` (and `tickId:positionKey`, both bootId-scoped by
+ * the mapper) thread them into one trace, so no pairing is needed here. Essentials are `tickId`
+ * plus a numeric work window; on clock skew (`endedAt < startedAt`) the start is pulled up to the
+ * end, matching the pass-window convention. The price-fetch window is kept only when both stamps
+ * are present (a half window is fabricated extent). No `nowMs` fallback: work windows are
+ * producer-stamped; nothing here is fabricated.
+ */
+export declare function buildDslTick(unit: DslTickUnit, payload: unknown): DslTickRecord | null;
 /** From `signal_processing_error` — a bucket-2 error with no specific domain record home. */
 export declare function buildRuntimeError(payload: unknown, nowMs: number): RuntimeErrorRecord | null;
 /**

package/dist/recording/wiring/record-builders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"record-builders.d.ts","sourceRoot":"","sources":["../../../src/recording/wiring/record-builders.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EACnB,sBAAsB,EACtB,uBAAuB,EACvB,kBAAkB,EAClB,sBAAsB,EACtB,kBAAkB,EAElB,gBAAgB,EAChB,cAAc,EACd,qBAAqB,EAIrB,aAAa,EAEd,MAAM,eAAe,CAAC;AAoDvB;2FAC2F;AAC3F,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CA4BxF;AAID,mGAAmG;AACnG,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;CAC5C;AAED,qEAAqE;AACrE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAwB5F;AA+DD;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;AA8CrG;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,eAAe,EACxB,mBAAmB,EAAE,OAAO,EAC5B,KAAK,EAAE,MAAM,EACb,iBAAiB,CAAC,EAAE,kBAAkB,GACrC,qBAAqB,CAuBvB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,mBAAmB,EAAE,OAAO,EAC5B,KAAK,EAAE,MAAM,EACb,iBAAiB,CAAC,EAAE,kBAAkB,GACrC,qBAAqB,GAAG,IAAI,CAY9B;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,eAAe,GAAG,qBAAqB,CAS1F;AAUD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,sBAAsB,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,uBAAuB,GAAG,IAAI,CAqCrI;AAID,uFAAuF;AACvF,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,iBAAiB,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI,CAgD7H;AAID,6FAA6F;AAC7F,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CA0B5F;AAID;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,sBAAsB,GAAG,IAAI,CAczJ;AAED,uCAAuC;AACvC,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,sBAAsB,GAAG,IAAI,CAWlG;AAID,6GAA6G;AAC7G,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAcrH"}
+{"version":3,"file":"record-builders.d.ts","sourceRoot":"","sources":["../../../src/recording/wiring/record-builders.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAEV,kBAAkB,EAClB,qBAAqB,EACrB,aAAa,EACb,WAAW,EACX,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,sBAAsB,EACtB,uBAAuB,EACvB,kBAAkB,EAClB,sBAAsB,EACtB,kBAAkB,EAElB,gBAAgB,EAChB,oBAAoB,EAEpB,qBAAqB,EAIrB,mBAAmB,EAIpB,MAAM,eAAe,CAAC;AAoDvB;2FAC2F;AAC3F,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CA6BxF;AAID;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI,CA6ChG;AAsED;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;AA0DrG;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,mBAAmB,EAAE,OAAO,EAC5B,KAAK,EAAE,MAAM,EACb,iBAAiB,CAAC,EAAE,kBAAkB,GACrC,qBAAqB,GAAG,IAAI,CAkD9B;AA8BD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,qBAAqB,GAAG,kBAAkB,GAAG,IAAI,CAiB1F;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,qBAAqB,GAAG,mBAAmB,EAAE,CA0BxF;AASD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAclG;AAID;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CA2BnH;AAUD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,sBAAsB,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,uBAAuB,GAAG,IAAI,CAuCrI;AAID,uFAAuF;AACvF,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,iBAAiB,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI,CAgD7H;AASD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,GAAG,aAAa,GAAG,IAAI,CAkCtF;AAID,6FAA6F;AAC7F,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CA2B5F;AAID;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,sBAAsB,GAAG,IAAI,CAczJ;AAED,uCAAuC;AACvC,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,sBAAsB,GAAG,IAAI,CAWlG;AAID,6GAA6G;AAC7G,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAcrH"}

package/dist/recording/wiring/record-builders.js

@@ -71,6 +71,7 @@ export function buildScannerRun(payload, nowMs) {
     return {
         type: "scanner_run",
         scannerId: str(data.scannerId) ?? "",
+        runId: str(data.runId),
         outcome,
         statusDetail: status,
         startedAt,
@@ -84,33 +85,63 @@ export function buildScannerRun(payload, nowMs) {
         error: outcome === "error" ? str(data.reason) : undefined,
     };
 }
-/** Build the pending decision from a `tracking.decision` payload. */
-export function buildPendingDecision(payload, nowMs) {
+// ─── Scanner funnel summary (Task 8a, derived from `tracking.scanner_run`) ────────
+/**
+ * The `scanner.summary` anti-spam log record, derived from the SAME `tracking.scanner_run` payload
+ * that {@link buildScannerRun} reads (its `data.summary.funnel.dropped`) — no new bus event.
+ *
+ * Returns `null` when there is no `data.summary.funnel`: skip/error runs and scanners without a
+ * funnel produce no summary event (the survivors are detailed by their own `signal.outcome` events,
+ * and "didn't run at all" is `scanner_run.skipped`). One record per scan; the dropped candidates are
+ * one Body array, never one row per drop.
+ */
+export function buildScannerSummary(payload, nowMs) {
     const p = asObject(payload);
     const data = asObject(p?.data);
     if (!data)
         return null;
-    const startedAtMs = toEpochMs(p?.timestamp, nowMs);
-    const d = asObject(data.decision) ?? {};
-    const tel = asObject(d.decisionTelemetry);
-    const decision = {
-        execute: bool(d.execute) ?? false,
-        actionType: str(data.actionType) ?? str(d.actionType) ?? "",
-        actionName: str(data.actionName),
-        mode: str(data.decisionMode),
-        confidence: num(d.confidence) ?? 0,
-        confidenceThreshold: num(data.minConfidence),
-        reasoning: str(d.reasoning) ?? "",
-        model: str(data.decisionModel) ?? str(tel?.model),
-        tokensUsed: numOrNull(tel?.tokensUsed),
-        durationMs: num(tel?.durationMs),
-        payload: asObject(d.payload),
-    };
-    const signals = Array.isArray(data.scannerSignals)
-        ? data.scannerSignals.map((s) => buildSignalSummary(s, startedAtMs))
+    const summary = asObject(data.summary);
+    const funnel = asObject(summary?.funnel);
+    if (!funnel)
+        return null;
+    const droppedCandidates = Array.isArray(funnel.dropped)
+        ? funnel.dropped
+            .map((d) => asObject(d))
+            .filter((d) => d !== undefined)
         : [];
-    return { scannerId: str(data.scannerId), startedAtMs, decision, signals };
+    // Survivors: the emitted signals' assets — a small linkage list to the per-signal events.
+    const passedAssets = Array.isArray(data.signals)
+        ? data.signals
+            .map((s) => str(asObject(s)?.asset))
+            .filter((a) => a !== undefined)
+        : [];
+    const droppedByReason = {};
+    for (const d of droppedCandidates) {
+        const reason = str(d.reason);
+        if (reason === undefined)
+            continue;
+        droppedByReason[reason] = (droppedByReason[reason] ?? 0) + 1;
+    }
+    const droppedCount = droppedCandidates.length;
+    const passedCount = num(data.signalCount) ?? passedAssets.length;
+    // Grain is "one per scan that *considered* candidates": an idle scan (nothing passed, nothing
+    // dropped) carries an empty funnel and yields no summary — emitting an all-empty row every tick
+    // would defeat the anti-spam intent and risk evicting high-value rows on transport overflow.
+    if (droppedCount === 0 && passedCount === 0)
+        return null;
+    return {
+        type: "scanner_summary",
+        occurredAt: toEpochMs(data.timestamp, toEpochMs(p?.timestamp, nowMs)),
+        scannerId: str(data.scannerId) ?? "",
+        scannedCount: num(data.scannedCount) ?? passedCount + droppedCount,
+        passedCount,
+        droppedCount,
+        droppedByReason: Object.keys(droppedByReason).length > 0 ? droppedByReason : undefined,
+        passedAssets: passedAssets.length > 0 ? passedAssets : undefined,
+        droppedCandidates: droppedCount > 0 ? droppedCandidates : undefined,
+    };
 }
+// ─── Signal evaluation (single-sourced from `tracking.action_result`) ────────────
 /** Reason codes where the system evaluated a trade and actively blocked it (see {@link classifyOutcome}). */
 const REJECTED_REASONS = new Set(["insufficient_margin", "invalid_direction", "no_margin_configured", "below_min_notional"]);
 /** Reason codes where no trade was applicable / attempted. */
@@ -164,13 +195,13 @@ function buildOutcome(raw, positionId) {
         availableMarginAmount: num(r.availableMarginAmount),
     };
 }
-/** The per-signal `results[]` entries from a `tracking.action_result` payload. */
+/** The `data` envelope, embedded `result`, and per-signal `results[]` entries from a `tracking.action_result` payload. */
 function actionResults(actionResultPayload) {
     const p = asObject(actionResultPayload);
     const data = asObject(p?.data);
     const result = asObject(data?.result);
     const resultData = asObject(result?.data);
-    return { data, results: Array.isArray(resultData?.results) ? resultData.results : [] };
+    return { data, result, resultData, results: Array.isArray(resultData?.results) ? resultData.results : [] };
 }
 /**
  * The V2 stamping rule: every per-signal outcome that pertains to a real position — open,
@@ -188,6 +219,11 @@ function resolveOutcomePositionId(resolve, address, r, asset) {
 /**
  * One {@link SignalEvaluation} per per-signal result entry, each enriched with the matching input
  * signal (via `findSignal`) or a synthesized summary from the result entry itself when none matches.
+ *
+ * The per-signal work window (`startedAt`/`endedAt`, stamped by the action loop) is threaded onto
+ * the evaluation. A half window is fabricated extent, so both stamps must be present or neither is
+ * kept; on clock skew (`endedAt < startedAt`) the start is pulled up to the end, matching the
+ * pass-window convention.
  */
 function buildEvaluations(results, findSignal, fallbackTs, resolvePositionId, address) {
     return results.map((raw) => {
@@ -200,67 +236,223 @@ function buildEvaluations(results, findSignal, fallbackTs, resolvePositionId, ad
             score: num(r.score) ?? 0,
             timestamp: fallbackTs,
         };
-        return { signal, outcome: buildOutcome(r, resolveOutcomePositionId(resolvePositionId, address, r, asset)) };
+        let startedAt = num(r.startedAt);
+        const endedAt = num(r.endedAt);
+        if (startedAt !== undefined && endedAt !== undefined && endedAt < startedAt)
+            startedAt = endedAt;
+        return {
+            signal,
+            outcome: buildOutcome(r, resolveOutcomePositionId(resolvePositionId, address, r, asset)),
+            ...(startedAt !== undefined && endedAt !== undefined ? { startedAt, endedAt } : {}),
+        };
     });
 }
 /**
- * Pair a held {@link PendingDecision} with its `tracking.action_result` payload into one record.
- * `evaluations` is one entry per per-signal result, each enriched with the matching input signal.
- * The pass span runs decision-ts → action_result-ts; on clock skew (`endedAt < startedAt`) the start
- * is pulled up to `endedAt`, yielding a zero (never negative) duration.
+ * Build the whole pass record from a `tracking.action_result` payload alone — the producers echo
+ * the decision window and scan provenance onto the payload (`scannerId`, `scannerSignals`,
+ * `minConfidence`, `decisionStartedAt`, `decisionEndedAt`, `runId`), and the decision itself rides
+ * `result.data._decisionMeta`, so no pairing with `tracking.decision` is needed.
+ *
+ * `evaluations` is one entry per per-signal result, each enriched with the matching input signal
+ * (or a summary synthesized from the result entry when none matches — e.g. close-position's
+ * static-params path, which carries no `scannerSignals`). A pass without `_decisionMeta` yields no
+ * `decision` (the contract allows a decision-less pass).
+ *
+ * The pass span runs `decisionStartedAt` → action_result-ts; when the start stamp is absent
+ * (defensive only — the bus is in-process) `startedAt = endedAt`. On clock skew
+ * (`endedAt < startedAt`) the start is pulled up to `endedAt`, yielding a zero (never negative)
+ * duration.
  */
-export function buildSignalEvaluated(pending, actionResultPayload, nowMs, resolvePositionId) {
+export function buildSignalEvaluated(actionResultPayload, nowMs, resolvePositionId) {
+    const { data, result, resultData, results } = actionResults(actionResultPayload);
+    if (!data)
+        return null;
     const p = asObject(actionResultPayload);
-    const { results } = actionResults(actionResultPayload);
-    const evaluations = buildEvaluations(results, (asset) => pending.signals.find((s) => s.asset === asset), pending.startedAtMs, resolvePositionId, str(p?.address));
-    let startedAt = pending.startedAtMs;
-    let endedAt = toEpochMs(p?.timestamp, nowMs);
+    const endedAt = toEpochMs(p?.timestamp, nowMs);
+    let startedAt = num(data.decisionStartedAt) ?? endedAt;
     if (endedAt < startedAt)
         startedAt = endedAt;
+    const signals = Array.isArray(data.scannerSignals)
+        ? data.scannerSignals.map((s) => buildSignalSummary(s, startedAt))
+        : [];
+    // Indexed once (first occurrence wins, matching find() semantics) — this runs in the producer's
+    // synchronous emit path, so the per-evaluation lookup must not rescan the signal array.
+    const byAsset = new Map();
+    for (const s of signals)
+        if (!byAsset.has(s.asset))
+            byAsset.set(s.asset, s);
+    const evaluations = buildEvaluations(results, (asset) => byAsset.get(asset), startedAt, resolvePositionId, str(p?.address));
+    const meta = asObject(resultData?._decisionMeta);
+    const decision = meta
+        ? {
+            execute: bool(meta.execute) ?? false,
+            actionType: str(result?.action_type) ?? "",
+            actionName: str(data.actionName),
+            mode: str(meta.mode),
+            confidence: num(meta.confidence) ?? 0,
+            confidenceThreshold: num(data.minConfidence),
+            reasoning: str(meta.reasoning) ?? "",
+            model: str(meta.model),
+            tokensUsed: numOrNull(meta.tokensUsed),
+            durationMs: num(meta.durationMs),
+            endedAt: num(data.decisionEndedAt),
+        }
+        : undefined;
     return {
         type: "signal_evaluated",
-        scannerId: pending.scannerId,
+        scannerId: str(data.scannerId),
+        runId: str(data.runId),
         startedAt,
         endedAt,
-        decision: pending.decision,
+        decision,
         evaluations,
     };
 }
+// ─── Self-learning event log: decision.made + signal.outcome (Task 8) ─────────────
+//
+// Both are DERIVED from the SAME built SignalEvaluatedRecord (single-source, DRY) — no re-parse of
+// the payload, no new bus event. The mapper does the redaction; these builders populate faithfully.
+/** Decision action type → the coarse open/close/none intent. */
+function actionIntent(actionType) {
+    if (actionType === "open_position")
+        return "open";
+    if (actionType === "close_position")
+        return "close";
+    return "none";
+}
+/** The four-value disposition from the granular per-signal {@link SignalOutcomeResult}. */
+function disposition(result) {
+    switch (result) {
+        case "executed":
+            return "accepted";
+        case "below_confidence":
+            return "rejected";
+        case "error":
+            return "error";
+        // rejected (actively blocked by a gate) and skipped (not attempted) both read as "blocked"
+        // at the disposition grain; the granular `reasonCode` is kept verbatim for the why.
+        default:
+            return "blocked";
+    }
+}
 /**
- * A `tracking.action_result` with no held decision — a producer that never emits `tracking.decision`
- * for the pass (e.g. close-position's static-params path, `decision_mode: 'none'` + `params.asset`).
- * The record carries the per-signal outcomes with signals synthesized from the result entries and no
- * `decision` (the contract allows a decision-less pass); zero duration (`startedAt = endedAt` = the
- * action_result timestamp).
+ * The pass's `decision.made` log record, derived from the built pass record — `null` when the pass
+ * carried no decision (a decision-less pass yields no judgment event). One per pass.
  */
-export function buildResultOnlyEvaluated(actionResultPayload, nowMs, resolvePositionId) {
-    const { data, results } = actionResults(actionResultPayload);
-    if (!data)
+export function buildDecisionMade(record) {
+    const d = record.decision;
+    if (!d)
         return null;
-    const p = asObject(actionResultPayload);
-    const endedAt = toEpochMs(p?.timestamp, nowMs);
     return {
-        type: "signal_evaluated",
-        scannerId: str(data.scannerId),
-        startedAt: endedAt,
-        endedAt,
-        evaluations: buildEvaluations(results, () => undefined, endedAt, resolvePositionId, str(p?.address)),
+        type: "decision_made",
+        occurredAt: record.endedAt,
+        mode: d.mode,
+        byLlm: d.mode === "llm",
+        model: d.model,
+        tokensUsed: d.tokensUsed,
+        confidence: d.confidence,
+        confidenceThreshold: d.confidenceThreshold,
+        durationMs: d.durationMs,
+        actionIntent: actionIntent(d.actionType),
+        // Market context + marginSource are NOT on the payload today → left undefined (see impl notes).
+        reasoning: d.reasoning,
+    };
+}
+/**
+ * One `signal.outcome` log record per evaluation in the pass, derived from the built pass record.
+ * `rawSignal` is the evaluation's {@link SignalSummary} (incl. its `meta`/`factors`) — the variable
+ * scanner evidence; redaction over it happens in the mapper, not here.
+ */
+export function buildSignalOutcomes(record) {
+    return record.evaluations.map((ev) => {
+        const { signal, outcome } = ev;
+        return {
+            type: "signal_outcome",
+            occurredAt: record.endedAt,
+            scannerId: record.scannerId,
+            signalType: signal.signalType !== "" ? signal.signalType : undefined,
+            asset: signal.asset,
+            direction: signal.direction,
+            score: signal.score,
+            signalTs: signal.timestamp,
+            factors: signal.factors,
+            result: disposition(outcome.result),
+            reasonCode: outcome.reasonCode,
+            positionId: outcome.positionId,
+            marginAmount: outcome.marginAmount,
+            leverage: outcome.leverage,
+            notionalValue: outcome.notionalValue,
+            size: outcome.size,
+            // marginSource is NOT on the payload today → left undefined (see impl notes).
+            orderId: outcome.orderId,
+            errorName: outcome.errorName,
+            rawSignal: { ...signal },
+        };
+    });
+}
+// ─── Self-learning event log: dsl.close_attempt (Task 8) ──────────────────────────
+/** Coerces the producer's outcome string to the close-attempt result enum; default `error`. */
+function closeAttemptResult(value) {
+    return value === "ok" ? "ok" : "error";
+}
+/**
+ * From the existing `tracking.dsl_close_attempt` monitor event — the second consumer (alongside the
+ * tick trace). Fields at the payload root: `positionId`, `asset`, `dex`, `closeReason`, `attempt`,
+ * `outcome` ("ok"|"error"), `error`, ISO `timestamp`. `null` when the payload is not an object.
+ */
+export function buildDslCloseAttempt(payload, nowMs) {
+    const p = asObject(payload);
+    if (!p)
+        return null;
+    return {
+        type: "dsl_close_attempt",
+        occurredAt: toEpochMs(p.timestamp, nowMs),
+        positionId: str(p.positionId),
+        asset: str(p.asset),
+        dex: str(p.dex),
+        reason: str(p.closeReason),
+        attempt: num(p.attempt),
+        result: closeAttemptResult(p.outcome),
+        error: str(p.error),
     };
 }
+// ─── Self-learning event log: order.{placed,filled,failed} (Task 8a) ──────────────
 /**
- * A decision that never received its action_result (the action threw or returned before emitting
- * one). Flushed when the same action's next decision arrives, so a decided-but-unresulted pass is
- * visible on the signal axis rather than silently dropped: no evaluations, zero duration
- * (`startedAt = endedAt =` the decision timestamp).
+ * From the additive `tracking.order_*` events the open/close actions fire (the HookEvent shape:
+ * fields under a `data` envelope). One record per event; `eventKind` discriminates which fields the
+ * payload carries (placed: order/size; filled: fill; failed: reason/error). `positionId` maps from
+ * `__positionId`. `null` when no `asset` is resolvable — the asset is the one always-present scalar.
+ *
+ * Faithful population only (no redaction here — the mapper is the single redaction seam).
  */
-export function buildDecisionOnlyEvaluated(pending) {
+export function buildOrderEvent(eventKind, payload, nowMs) {
+    const p = asObject(payload);
+    const data = asObject(p?.data);
+    if (!data)
+        return null;
+    const asset = str(data.asset);
+    if (asset === undefined)
+        return null;
     return {
-        type: "signal_evaluated",
-        scannerId: pending.scannerId,
-        startedAt: pending.startedAtMs,
-        endedAt: pending.startedAtMs,
-        decision: pending.decision,
-        evaluations: [],
+        type: "order_event",
+        event: eventKind,
+        occurredAt: toEpochMs(p?.timestamp, nowMs),
+        positionId: str(data.__positionId),
+        orderId: str(data.orderId),
+        asset,
+        direction: direction(data.direction),
+        orderType: str(data.orderType),
+        size: num(data.size),
+        limitPrice: num(data.limitPrice),
+        reduceOnly: bool(data.reduceOnly),
+        fillPrice: num(data.fillPrice),
+        fillSize: num(data.fillSize),
+        executionAsMaker: boolOrNull(data.executionAsMaker),
+        fees: num(data.fees),
+        partial: bool(data.partial),
+        reason: str(data.reason),
+        errorName: str(data.errorName),
+        error: str(data.error),
     };
 }
 // ─── Position lifecycle ──────────────────────────────────────────────────────
@@ -316,6 +508,8 @@ export function buildPositionLifecycle(event, payload, nowMs) {
         marginAmount: num(data.marginAmount),
         filled: boolOrNull(data.filled),
         reasoning: str(data.reasoning),
+        // Stamped by the position-tracker action on `on_position_opened` only (absent elsewhere).
+        reconciliationSource: str(data.reconciliationSource),
     };
 }
 // ─── DSL transitions ─────────────────────────────────────────────────────────
@@ -370,6 +564,59 @@ export function buildDslTransition(transition, payload, nowMs) {
         backendDslPositionId: typeof p.backendDslPositionId === "string" ? p.backendDslPositionId : p.backendDslPositionId === null ? null : undefined,
     };
 }
+// ─── DSL monitor tick work units ─────────────────────────────────────────────
+/** Coerces the producer's outcome string to the record's closed enum; anything else is dropped. */
+function dslTickOutcome(value) {
+    return value === "ok" || value === "error" ? value : undefined;
+}
+/**
+ * From the monitor's `tracking.dsl_tick` / `tracking.dsl_position` / `tracking.dsl_close_attempt`
+ * / `tracking.dsl_sl_update` events (fields at the payload root). Each event yields one record —
+ * the deterministic ids derived from `tickId` (and `tickId:positionKey`, both bootId-scoped by
+ * the mapper) thread them into one trace, so no pairing is needed here. Essentials are `tickId`
+ * plus a numeric work window; on clock skew (`endedAt < startedAt`) the start is pulled up to the
+ * end, matching the pass-window convention. The price-fetch window is kept only when both stamps
+ * are present (a half window is fabricated extent). No `nowMs` fallback: work windows are
+ * producer-stamped; nothing here is fabricated.
+ */
+export function buildDslTick(unit, payload) {
+    const p = asObject(payload);
+    if (!p)
+        return null;
+    const tickId = str(p.tickId);
+    let startedAt = num(p.startedAt);
+    const endedAt = num(p.endedAt);
+    if (tickId === undefined || startedAt === undefined || endedAt === undefined)
+        return null;
+    if (endedAt < startedAt)
+        startedAt = endedAt;
+    const pricesStartedAt = num(p.pricesStartedAt);
+    const pricesEndedAt = num(p.pricesEndedAt);
+    const bothPrices = pricesStartedAt !== undefined && pricesEndedAt !== undefined;
+    return {
+        type: "dsl_tick",
+        unit,
+        tickId,
+        startedAt,
+        endedAt,
+        strategyCount: num(p.strategyCount),
+        activePositionCount: num(p.activePositionCount),
+        positionsProcessed: num(p.positionsProcessed),
+        pricesStartedAt: bothPrices ? pricesStartedAt : undefined,
+        pricesEndedAt: bothPrices ? pricesEndedAt : undefined,
+        positionKey: str(p.key),
+        positionId: str(p.positionId),
+        asset: str(p.asset),
+        dex: str(p.dex),
+        outcome: dslTickOutcome(p.outcome),
+        error: str(p.error),
+        closeReason: str(p.closeReason),
+        attempt: num(p.attempt),
+        newSLPrice: num(p.newSLPrice),
+        slOrderId: num(p.slOrderId),
+        syncReason: str(p.syncReason),
+    };
+}
 // ─── Runtime error ───────────────────────────────────────────────────────────
 /** From `signal_processing_error` — a bucket-2 error with no specific domain record home. */
 export function buildRuntimeError(payload, nowMs) {
@@ -398,6 +645,7 @@ export function buildRuntimeError(payload, nowMs) {
         message,
         errorName,
         scannerId: str(p.scannerId),
+        runId: str(p.runId),
         stack,
     };
 }