@agentdeck/bridge 1.0.24 → 1.2.0

package/dist/apme/collector.js

@@ -18,7 +18,7 @@ import { mkdirSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { debug } from '../logger.js';
 import { resolveProjectName } from '../utils/project-name.js';
-import { priceUsd, providerFor } from '@agentdeck/shared';
+import { AGENT_IDLE_GAP_MS, deriveTaskTitle, isPricedModel, normalizeModelProvider, priceUsd } from '@agentdeck/shared';
 import { classifyRunSmart, computeSignals, classify } from './classifier.js';
 import { readOpenTurnEvidence } from './claude-transcript-reader.js';
 /** A turn_start with the same prompt landing on a fresh, still-empty turn
@@ -32,10 +32,42 @@ const DUPLICATE_TURN_OPEN_WINDOW_MS = 15_000;
  *  a cancel milliseconds into a turn reads as belonging to the previous one.
  *  Matches the watchdog's `TURN_OPEN_SLACK_MS` — same comparison, same risk. */
 const TURN_INTERRUPT_SLACK_MS = 2_000;
+/**
+ * Is `echo` the same user prompt as `original`, arriving a second time?
+ *
+ * Two producers open a turn for one prompt: our own `chat.send` span, which
+ * carries the text verbatim, and the Gateway's `session.message`(user) echo,
+ * which has been trimmed, envelope-stripped and capped at 8,000 characters
+ * before it reaches us. Exact equality therefore misses on inputs as ordinary
+ * as a trailing newline — and a miss is not benign: the duplicate then closes
+ * the open turn with `resolveDisplacedTurnSource`, which for a non-`claude-code`
+ * agent returns `next_prompt`, i.e. the unrecovered-Stop-loss bucket. A stray
+ * "\n" would invent a Stop loss for an agent that has no Stop hook at all,
+ * strand an empty turn, and shift every later `turn_index`.
+ *
+ * Comparing TRIMMED is the whole fix, and deliberately all of it. A first pass
+ * here also allowed a prefix match when the shorter side sat at the Gateway's
+ * 8,000-character cap — that branch could never fire: both operands reach this
+ * function through the caller's own `slice(0, 8_000)`, so "the shorter one is
+ * at 8,000" forces both to be exactly 8,000 characters, and two equal-length
+ * strings where one is a prefix of the other are identical, which the equality
+ * check above already answered. Reintroducing truncation tolerance means
+ * comparing BEFORE that slice, not adding a branch after it.
+ *
+ * Known and NOT closed by this: because the caller slices first, two genuinely
+ * different prompts that share their first 8,000 characters compare equal and
+ * collapse into one turn — an eval harness sending a long fixed preamble with a
+ * differing tail is exactly that shape. That predates this comparison and is
+ * fixed by keying on a hash of the unsliced prompt, not here.
+ */
+function samePromptEcho(original, echo) {
+    return original.trim() === echo.trim();
+}
 export class ApmeCollector {
     store;
     hwSampler;
     openTurnProbe;
+    idleGapMs;
     sessionToRun = new Map(); // sessionId → runId
     sessionToAgentType = new Map(); // sessionId → agentType (survives closeRun for late-attributed timeline rows)
     sessionToTurn = new Map(); // sessionId → current turn
@@ -43,6 +75,13 @@ export class ApmeCollector {
     sessionToTask = new Map(); // sessionId → current task
     runTaskCount = new Map(); // runId → next task_index
     sessionToUsage = new Map(); // last cumulative usage
+    /** Running cost total for producers that report PER-MESSAGE cost.
+     *  Separate from `sessionToUsage` because `updateUsage` writes the cost
+     *  column absolutely and would otherwise stamp one message's cost as the
+     *  run's. `seen` keeps a reported ZERO distinct from nothing reported —
+     *  glm-5.2 answers `usage.cost.total = 0` on every message, so folding the
+     *  two would record "free" as "unknown" for a whole class of run. */
+    sessionToCostTotal = new Map();
     /** Optional listener fired after `closeTask` persists the row. The runner
      *  wires this to enqueue a task-level judge call. */
     onTaskClosed = null;
@@ -58,14 +97,21 @@ export class ApmeCollector {
     /** Last milestone key (`taskId:turnIndex`) per session — a turn can carry
      *  several all-completed TodoWrite calls; surface only the first. */
     sessionToLastMilestone = new Map();
+    /** Per-session idle-gap timers — armed in `closeTurn`, cleared on the next
+     *  turn open / task close. See `AGENT_IDLE_GAP_MS` for the measurement the
+     *  constant rests on. */
+    sessionToIdleGapTimer = new Map();
     constructor(store, hwSampler, 
     /** What the transcript proves about a turn open since a timestamp — cancel,
      *  client abort, or never having run at all. Injectable for tests; the
      *  default reads the Claude transcript tail once for all three. */
-    openTurnProbe = readOpenTurnEvidence) {
+    openTurnProbe = readOpenTurnEvidence, 
+    /** Injectable for tests only — production call sites take the default. */
+    idleGapMs = AGENT_IDLE_GAP_MS) {
         this.store = store;
         this.hwSampler = hwSampler;
         this.openTurnProbe = openTurnProbe;
+        this.idleGapMs = idleGapMs;
     }
     /** Start a new run and return its id. Safe to call if store disabled (returns ''). */
     openRun(input) {
@@ -78,6 +124,7 @@ export class ApmeCollector {
             sessionId: input.sessionId,
             agentType: input.agentType,
             modelId: input.modelId ?? null,
+            provider: input.modelId ? normalizeModelProvider(undefined, input.modelId) : null,
             projectName: input.projectName ?? (input.projectPath ? resolveProjectName({ cwd: input.projectPath }) : null),
             projectPath: input.projectPath ?? null,
             taskPrompt: input.taskPrompt ?? null,
@@ -126,7 +173,8 @@ export class ApmeCollector {
             // empty phantom turn and shift every later turn_index, so an identical
             // prompt landing on a fresh, still-empty turn is a no-op.
             const openTurn = this.sessionToTurn.get(sessionId);
-            if (openTurn && prompt !== null && openTurn.prompt === prompt &&
+            if (openTurn && prompt !== null && openTurn.prompt !== null &&
+                samePromptEcho(openTurn.prompt, prompt) &&
                 openTurn.toolCalls === 0 && !openTurn.hasResponse &&
                 Date.now() - openTurn.startedAt < DUPLICATE_TURN_OPEN_WINDOW_MS) {
                 debug('APME', `duplicate turn_start ignored (echo) turn=${openTurn.id.slice(0, 8)}`);
@@ -164,14 +212,18 @@ export class ApmeCollector {
                 prompt, hasResponse: false,
             };
             this.sessionToTurn.set(sessionId, turn);
+            // A new turn is the "still working" signal the idle-gap timer waits on.
+            this.clearIdleGapTimer(sessionId);
             // Ensure an active task exists so this turn can attach to it. Tasks group
             // consecutive turns between boundary signals (TodoWrite all-completed,
             // /clear, session_end). First turn in a run opens task 0.
             const task = this.openTaskIfNone(sessionId, runId);
             if (task) {
                 const wasFirstTurn = task.firstTurnIndex === null;
-                if (wasFirstTurn)
+                if (wasFirstTurn) {
                     task.firstTurnIndex = turnIndex;
+                    task.firstPrompt = prompt ?? null;
+                }
                 task.lastTurnIndex = turnIndex;
                 // Second (or later) turn on the same task proves it's a real,
                 // multi-turn work unit → promote the deferred TASK header so the
@@ -415,6 +467,9 @@ export class ApmeCollector {
         catch (err) {
             debug('APME', `closeTurn failed: ${String(err)}`);
         }
+        // Idle starts when the turn ends. The timer is cleared by the next turn
+        // open (still working) or by closeTask (boundary reached another way).
+        this.armIdleGapTimer(sessionId);
     }
     /** Get the current active turn ID for a session (if any). */
     getActiveTurnId(sessionId) {
@@ -479,6 +534,7 @@ export class ApmeCollector {
             startedAt: Date.now(),
             firstTurnIndex: null,
             lastTurnIndex: null,
+            firstPrompt: null,
             timelineEmitted: false,
         };
         this.sessionToTask.set(sessionId, task);
@@ -519,12 +575,40 @@ export class ApmeCollector {
                 projectName: run?.projectName ?? null,
                 taskIndex: task.index,
                 startedAt: task.startedAt,
+                title: deriveTaskTitle(task.firstPrompt),
             });
         }
         catch (err) {
             debug('APME', `onTaskOpened listener threw: ${String(err)}`);
         }
     }
+    /** Arm the per-session idle-gap timer. Called from `closeTurn` — the turn
+     *  just finished, so the gap being measured is genuine idle time, never the
+     *  agent's own working time. Re-arming replaces any previous timer. */
+    armIdleGapTimer(sessionId) {
+        this.clearIdleGapTimer(sessionId);
+        const timer = setTimeout(() => {
+            this.sessionToIdleGapTimer.delete(sessionId);
+            // A turn opened since (and its clear lost a race), or work is mid-turn:
+            // never split under an active turn.
+            if (this.sessionToTurn.has(sessionId))
+                return;
+            if (!this.sessionToTask.has(sessionId))
+                return;
+            debug('APME', `idle gap (${Math.round(this.idleGapMs / 1000)}s) → closing task for ${sessionId.slice(0, 8)}`);
+            this.closeTask(sessionId, 'idle_gap');
+        }, this.idleGapMs);
+        // Never hold the process open for an idle bookkeeping timer.
+        timer.unref?.();
+        this.sessionToIdleGapTimer.set(sessionId, timer);
+    }
+    clearIdleGapTimer(sessionId) {
+        const timer = this.sessionToIdleGapTimer.get(sessionId);
+        if (timer) {
+            clearTimeout(timer);
+            this.sessionToIdleGapTimer.delete(sessionId);
+        }
+    }
     /** Public wrapper for closeTask. Used by the manual-boundary CLI /
      *  HTTP route + the macOS detail-pane button — lets the user declare
      *  "this task is done" without `/clear` (which would also split the
@@ -557,6 +641,7 @@ export class ApmeCollector {
             return;
         this.sessionToTask.delete(sessionId);
         this.sessionToLastMilestone.delete(sessionId);
+        this.clearIdleGapTimer(sessionId);
         // Empty task: no turns ever attached. Drop the row so the dashboard
         // doesn't show phantom entries from back-to-back boundary signals.
         if (task.firstTurnIndex === null) {
@@ -599,6 +684,14 @@ export class ApmeCollector {
         try {
             this.store.updateTask(task.id, {
                 endedAt: Date.now(),
+                // `first_turn_index` too, not just the last. The task row is INSERTed
+                // from inside the turn_start handler, i.e. before the turn exists, so
+                // it is written NULL and the real index only ever landed in memory —
+                // 294 of 1080 closed claude-code tasks carry NULL here, and the task
+                // rollup the layer-2 judge reads is keyed on these two columns.
+                // `reapAbandonedRun` already COALESCEs a value in at reap time, which
+                // is this defect's workaround rather than its fix.
+                firstTurnIndex: task.firstTurnIndex,
                 lastTurnIndex: task.lastTurnIndex ?? task.firstTurnIndex,
                 boundarySignal,
                 taskCategory,
@@ -700,6 +793,7 @@ export class ApmeCollector {
             inputTokens: ev.inputTokens ?? null,
             outputTokens: ev.outputTokens ?? null,
             costUsd: ev.costUsd ?? null,
+            costKnown: ev.costKnown ?? null,
             latencyMs: ev.latencyMs ?? null,
             toolName: ev.toolName ?? null,
             toolStatus: ev.toolStatus ?? null,
@@ -742,7 +836,7 @@ export class ApmeCollector {
      *  Falls back to the last closed turn if closeTurn() already ran (race with session exit).
      *  Tags turns.efficiency_json.response_kind so the runner can skip tool-only / empty
      *  turns — judging silence produces noise scores. */
-    setTurnResponse(sessionId, response) {
+    setTurnResponse(sessionId, response, source = 'direct') {
         if (!this.store.enabled)
             return;
         const turn = this.sessionToTurn.get(sessionId);
@@ -750,15 +844,27 @@ export class ApmeCollector {
         debug('APME', `setTurnResponse session=${sessionId.slice(0, 8)} turnId=${turnId?.slice(0, 8) ?? 'null'} respLen=${response.length}`);
         if (!turnId)
             return;
+        const existingTurn = this.store.getTurn(turnId);
+        const existingMeta = parseEfficiencyJson(existingTurn);
+        const existingSource = typeof existingMeta.response_source === 'string'
+            ? existingMeta.response_source
+            : (existingTurn?.response ? 'direct' : undefined);
+        if (responseSourcePriority(source) < responseSourcePriority(existingSource)) {
+            debug('APME', `setTurnResponse ignored lower-priority source=${source} existing=${existingSource}`);
+            return;
+        }
         const trimmedLen = response.trim().length;
         // Active-turn toolCalls is authoritative; after closeTurn() the counter is
         // already flushed to the DB row, so we fetch from there instead.
         const toolCalls = turn?.toolCalls
-            ?? (this.store.getTurn(turnId)?.tool_calls ?? 0);
+            ?? (existingTurn?.tool_calls ?? 0);
         const kind = trimmedLen >= 1
             ? 'text'
             : (toolCalls > 0 ? 'tool_only' : 'empty');
-        const efficiencyJson = mergeEfficiencyJson(this.store.getTurn(turnId), { response_kind: kind });
+        const efficiencyJson = mergeEfficiencyJson(existingTurn, {
+            response_kind: kind,
+            response_source: source,
+        });
         try {
             this.store.updateTurn(turnId, {
                 response: response.slice(0, 10_000),
@@ -773,11 +879,18 @@ export class ApmeCollector {
         // Sample trajectory: the assistant response closes the turn's event arc.
         const ctx = this.sampleCtxForTurn(sessionId, turnId);
         if (ctx) {
-            this.appendSampleEvent(ctx, {
-                kind: 'assistant_message',
-                dedupCore: hashCore(response.slice(0, 400)),
-                payloadObj: { text: response.slice(0, 10_000), responseKind: kind },
-            });
+            const payload = safeStringify({ text: response.slice(0, 10_000), responseKind: kind });
+            const existingEvent = this.store.findAssistantMessageEvent(ctx.taskId, turnId);
+            if (existingEvent?.id != null) {
+                this.store.updateSampleEvent(existingEvent.id, { payload, ts: Date.now() });
+            }
+            else {
+                this.appendSampleEvent(ctx, {
+                    kind: 'assistant_message',
+                    dedupCore: `turn:${turnId}`,
+                    payloadObj: { text: response.slice(0, 10_000), responseKind: kind },
+                });
+            }
         }
     }
     /** Apply response to the last closed turn if it has no response yet.
@@ -835,16 +948,27 @@ export class ApmeCollector {
             }
             case 'turn_response': {
                 const text = a['agentdeck.response_text'] ?? '';
+                const source = a['agentdeck.response_source'] ?? 'direct';
                 const fallback = a['agentdeck.fallback_to_last_closed'] === true;
                 if (fallback)
                     this.setLastClosedTurnResponse(sessionId, text);
                 else
-                    this.setTurnResponse(sessionId, text);
+                    this.setTurnResponse(sessionId, text, source);
                 return;
             }
-            case 'turn_end':
-                // No-op: turns auto-close on the next `turn_start` or session end.
+            case 'turn_end': {
+                // An explicit close, from a source that HAS a stop signal of its own.
+                // This used to be a no-op on the theory that turns auto-close on the
+                // next `turn_start` — which is true, and is exactly the shape the
+                // `end_source` column exists to avoid: closing at the next prompt puts
+                // the user's thinking time inside the turn's duration, and a
+                // conversation with one turn never closes it at all. OpenClaw is the
+                // first emitter (its `chat.final` is the stop signal); every other
+                // adapter still auto-closes, unchanged.
+                const source = a['agentdeck.turn_end_source'] ?? 'stop';
+                this.closeTurn(sessionId, source);
                 return;
+            }
             case 'tool_call': {
                 const toolName = (a['gen_ai.tool.name'] ?? a['agentdeck.tool_name']);
                 const raw = a['agentdeck.raw_payload'] ?? {};
@@ -891,17 +1015,18 @@ export class ApmeCollector {
             }
             case 'session_meta': {
                 const model = a['gen_ai.request.model'];
-                if (model)
-                    this.updateModel(sessionId, model);
+                const rawProvider = a['gen_ai.system'];
+                if (model || rawProvider)
+                    this.updateTurnIdentity(sessionId, model, rawProvider);
                 const inputTokens = a['agentdeck.usage.input_tokens'];
                 const outputTokens = a['agentdeck.usage.output_tokens'];
                 const costUsd = a['agentdeck.usage.cost_usd'];
                 if (inputTokens !== undefined || outputTokens !== undefined || costUsd !== undefined) {
-                    // Synthesize a UsageSnapshot-compatible shape. Missing fields stay null.
-                    this.updateUsage(sessionId, {
+                    // PER-MESSAGE numbers, not a running total — see `addUsageIncrement`.
+                    this.addUsageIncrement(sessionId, {
                         inputTokens: inputTokens ?? 0,
                         outputTokens: outputTokens ?? 0,
-                        estimatedCostUsd: costUsd ?? null,
+                        costUsd: costUsd ?? null,
                     });
                 }
                 return;
@@ -957,45 +1082,128 @@ export class ApmeCollector {
      *  Snapshots carry CUMULATIVE session totals, so we emit a priced ModelEvent
      *  for the delta and attribute it to the active task (the SessionSample cost
      *  is the sum of its ModelEvents). */
+    /**
+     * Record usage a producer reports for ONE message.
+     *
+     * `updateUsage` is cumulative by contract: it assigns `inputTokens` to the run
+     * row absolutely and derives its per-task ModelEvent as `max(0, cur - prev)`.
+     * Its original and only other caller is the PTY poller's `UsageTracker`
+     * snapshot, which really is a running total.
+     *
+     * A `session.message`(assistant) frame reports THIS message's tokens, and those
+     * are not monotonic — measured on a real OpenClaw session: 30302, 21375, 335,
+     * 96, 114. Fed to `updateUsage` directly, the run row ends at the LAST
+     * message's count (114 for a session that consumed 52,222), every decrease
+     * clamps its delta to 0 so most messages append no ModelEvent at all, and
+     * `recomputeSampleCost` then prices the run from what survives. Two messages
+     * sharing an `(in,out)` pair are additionally deduped away, because the dedup
+     * key assumes cumulative values are unique.
+     *
+     * So convert here rather than at each producer: keep the running total and
+     * hand `updateUsage` the cumulative series its arithmetic is written for.
+     */
+    addUsageIncrement(sessionId, delta) {
+        if (!this.store.enabled)
+            return;
+        // ONE guard for both accumulators. `updateUsage` drops everything when the
+        // session has no open run, so advancing the cost total before that check
+        // let cost count messages the token total did not: a span arriving before
+        // the run opened, then one after, recorded 7 tokens at $10.50. Two
+        // accumulators with different failure modes is the same defect shape as a
+        // guard cleared only by a `defer` it shares a failure mode with.
+        if (!this.sessionToRun.get(sessionId))
+            return;
+        const prev = this.sessionToUsage.get(sessionId) ?? { in: 0, out: 0, cost: null };
+        const prevCost = this.sessionToCostTotal.get(sessionId) ?? { total: 0, seen: false };
+        const reported = typeof delta.costUsd === 'number';
+        const cost = { total: prevCost.total + (reported ? delta.costUsd : 0),
+            seen: prevCost.seen || reported };
+        this.sessionToCostTotal.set(sessionId, cost);
+        this.updateUsage(sessionId, {
+            // The clamp is deliberate, not defensive: `updateUsage` derives its
+            // ModelEvent as `max(0, cur - prev)`, so the series handed to it must be
+            // monotonic. No producer here reports a negative correction; if one ever
+            // does, it needs its own path rather than silently shrinking the total.
+            inputTokens: prev.in + Math.max(0, delta.inputTokens),
+            outputTokens: prev.out + Math.max(0, delta.outputTokens),
+            estimatedCostUsd: cost.seen ? cost.total : null,
+        });
+    }
     updateUsage(sessionId, snapshot) {
         if (!this.store.enabled)
             return;
         const runId = this.sessionToRun.get(sessionId);
         if (!runId)
             return;
+        const curIn = snapshot.inputTokens ?? 0;
+        const curOut = snapshot.outputTokens ?? 0;
+        const prev = this.sessionToUsage.get(sessionId) ?? { in: 0, out: 0, cost: null };
+        const hadPreviousUsage = prev.in > 0 || prev.out > 0;
+        const dIn = Math.max(0, curIn - prev.in);
+        const dOut = Math.max(0, curOut - prev.out);
+        const run = this.store.getRun(runId);
+        const turnId = this.turnIdFor(sessionId);
+        const turn = turnId ? this.store.getTurn(turnId) : null;
+        const model = turn?.model_id ?? run?.modelId ?? null;
+        const reportedTotal = snapshot.estimatedCostUsd ?? snapshot.costSpent ?? null;
+        const reportedDelta = reportedTotal == null
+            ? null
+            : Math.max(0, reportedTotal - (prev.cost ?? 0));
+        const priced = isPricedModel(model);
+        const eventCostKnown = priced || (reportedDelta != null && reportedDelta > 0);
+        const eventCost = reportedDelta ?? priceUsd(model, dIn, dOut);
+        const hasUsageDelta = dIn > 0 || dOut > 0;
+        const hasAccountingDelta = hasUsageDelta || (reportedDelta ?? 0) > 0;
+        const runCostKnown = !hasAccountingDelta
+            ? Boolean(run?.costKnown)
+            : hadPreviousUsage
+                ? Boolean(run?.costKnown) && eventCostKnown
+                : eventCostKnown;
+        const runCost = reportedTotal ?? (priced ? priceUsd(model, curIn, curOut) : null);
+        this.sessionToUsage.set(sessionId, { in: curIn, out: curOut, cost: reportedTotal });
         try {
             this.store.updateRun(runId, {
                 inputTokens: snapshot.inputTokens,
                 outputTokens: snapshot.outputTokens,
-                costUsd: snapshot.estimatedCostUsd ?? snapshot.costSpent ?? null,
+                costUsd: runCost,
+                costKnown: runCostKnown,
             });
         }
         catch { /* ignore */ }
         // ── Per-task ModelEvent from the cumulative delta ──
-        const curIn = snapshot.inputTokens ?? 0;
-        const curOut = snapshot.outputTokens ?? 0;
-        const prev = this.sessionToUsage.get(sessionId) ?? { in: 0, out: 0 };
-        const dIn = Math.max(0, curIn - prev.in);
-        const dOut = Math.max(0, curOut - prev.out);
-        this.sessionToUsage.set(sessionId, { in: curIn, out: curOut });
         if (dIn === 0 && dOut === 0)
             return;
         const task = this.sessionToTask.get(sessionId);
         if (!task)
             return;
-        const run = this.store.getRun(runId);
-        const model = run?.modelId ?? null;
+        const provider = turn?.provider
+            ?? run?.provider
+            ?? normalizeModelProvider(undefined, model);
+        const taskRow = this.store.getTask(task.id);
+        const taskModel = !model
+            ? taskRow?.modelId
+            : !taskRow?.modelId || taskRow.modelId === model
+                ? model
+                : 'mixed';
+        const taskProvider = !provider || provider === 'unknown'
+            ? taskRow?.provider
+            : !taskRow?.provider || taskRow.provider === provider
+                ? provider
+                : 'mixed';
         const turnIndex = this.sessionToTurn.get(sessionId)?.index ?? task.lastTurnIndex ?? 0;
-        // Prefer the agent-reported marginal cost when available, else price the delta.
-        const cost = priceUsd(model, dIn, dOut);
-        this.appendSampleEvent({ taskId: task.id, runId, turnIndex, turnId: this.turnIdFor(sessionId) }, {
+        this.appendSampleEvent({ taskId: task.id, runId, turnIndex, turnId }, {
             kind: 'model', model: model ?? undefined, inputTokens: dIn, outputTokens: dOut,
-            costUsd: cost, latencyMs: 0, dedupCore: `${curIn}:${curOut}`,
+            costUsd: eventCost, costKnown: eventCostKnown,
+            latencyMs: 0, dedupCore: `${curIn}:${curOut}`,
         });
         try {
             this.store.updateTask(task.id, {
-                modelId: model ?? undefined,
-                modelConfig: JSON.stringify({ modelId: model ?? 'unknown', provider: providerFor(model) }),
+                modelId: taskModel,
+                provider: taskProvider,
+                modelConfig: JSON.stringify({
+                    modelId: taskModel ?? 'unknown',
+                    provider: taskProvider ?? null,
+                }),
             });
             this.store.recomputeSampleCost(task.id);
         }
@@ -1046,7 +1254,71 @@ export class ApmeCollector {
         if (!runId)
             return;
         try {
-            this.store.updateRun(runId, { modelId });
+            this.store.updateRun(runId, {
+                modelId,
+                provider: normalizeModelProvider(undefined, modelId),
+            });
+        }
+        catch { /* ignore */ }
+    }
+    /** Persist the model/provider on the assistant message's own turn.
+     * `session_meta` can arrive after `chat.final` closed that turn, so the same
+     * current→last fallback used by setTurnResponse is required here too. */
+    updateTurnIdentity(sessionId, reportedModel, reportedProvider) {
+        const runId = this.sessionToRun.get(sessionId);
+        if (!runId)
+            return;
+        const turnId = this.turnIdFor(sessionId);
+        const turn = turnId ? this.store.getTurn(turnId) : null;
+        const run = this.store.getRun(runId);
+        const model = reportedModel ?? turn?.model_id ?? run?.modelId ?? undefined;
+        if (!model && !reportedProvider)
+            return;
+        const normalized = normalizeModelProvider(reportedProvider, model);
+        const provider = normalized === 'unknown' ? null : normalized;
+        if (turnId) {
+            try {
+                this.store.updateTurn(turnId, {
+                    ...(model ? { modelId: model } : {}),
+                    provider,
+                });
+            }
+            catch { /* ignore */ }
+        }
+        // Preserve the established run-level "latest observed model" contract for
+        // legacy consumers. Scorecards no longer depend on it when a turn has its
+        // own identity, so updating this compatibility fallback cannot reassign
+        // earlier turns.
+        if (run) {
+            const patch = {
+                ...(model ? { modelId: model } : {}),
+                provider,
+            };
+            if (Object.keys(patch).length > 0) {
+                try {
+                    this.store.updateRun(runId, patch);
+                }
+                catch { /* ignore */ }
+            }
+        }
+        const taskId = turn?.task_id ?? this.sessionToTask.get(sessionId)?.id;
+        if (!taskId || !model)
+            return;
+        const task = this.store.getTask(taskId);
+        if (!task)
+            return;
+        const taskModel = !task.modelId || task.modelId === model ? model : 'mixed';
+        const taskProvider = !provider
+            ? task.provider
+            : task.provider == null || task.provider === provider
+                ? provider
+                : 'mixed';
+        try {
+            this.store.updateTask(taskId, {
+                modelId: taskModel,
+                provider: taskProvider,
+                modelConfig: JSON.stringify({ modelId: taskModel, provider: taskProvider }),
+            });
         }
         catch { /* ignore */ }
     }
@@ -1068,6 +1340,7 @@ export class ApmeCollector {
         this.sessionToLastTurnId.delete(sessionId);
         this.runTaskCount.delete(runId);
         this.sessionToUsage.delete(sessionId);
+        this.sessionToCostTotal.delete(sessionId);
         // Mark empty runs so the dashboard can filter them out.
         // Don't delete — FK constraints and concurrent access make deletion risky.
         const run = this.store.getRun(runId);
@@ -1260,6 +1533,10 @@ function safeStringify(v) {
  *  sibling keys. Returns a JSON string suitable for the column. Unparseable
  *  existing values are replaced outright. */
 function mergeEfficiencyJson(turn, patch) {
+    const base = parseEfficiencyJson(turn);
+    return JSON.stringify({ ...base, ...patch });
+}
+function parseEfficiencyJson(turn) {
     let base = {};
     const raw = turn?.efficiency_json;
     if (typeof raw === 'string' && raw.length > 0) {
@@ -1271,6 +1548,16 @@ function mergeEfficiencyJson(turn, patch) {
         }
         catch { /* replace */ }
     }
-    return JSON.stringify({ ...base, ...patch });
+    return base;
+}
+/** Full/final responses outrank lossy session-message projections. Unknown
+ *  historical provenance is treated as direct so a new projection cannot
+ *  downgrade data written before source tracking existed. */
+function responseSourcePriority(source) {
+    if (source === 'session_message_projection')
+        return 1;
+    if (source === 'chat_final')
+        return 3;
+    return source ? 2 : 0;
 }
 //# sourceMappingURL=collector.js.map