@agentdeck/bridge 1.2.0 → 1.2.1

package/dist/apme/collector.js

@@ -20,7 +20,8 @@ import { debug } from '../logger.js';
 import { resolveProjectName } from '../utils/project-name.js';
 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';
+import { readOpenTurnEvidence, claudeTurnCompletionSince } from './claude-transcript-reader.js';
+import { codexTurnCompletionSince } from '../codex-rollout-response.js';
 /** A turn_start with the same prompt landing on a fresh, still-empty turn
  *  within this window is treated as a transport echo (e.g. OpenClaw
  *  `chat.send` span + the gateway's `session.message` role=user re-delivery
@@ -32,6 +33,10 @@ 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;
+/** How long after a turn closed a late-arriving reply may still be attached
+ *  to it once the run itself is gone from memory — the deferred transcript
+ *  re-read tops out at 7.5 s; a minute leaves room for a slow disk. */
+const LATE_REPLY_WINDOW_MS = 60_000;
 /**
  * Is `echo` the same user prompt as `original`, arriving a second time?
  *
@@ -68,6 +73,8 @@ export class ApmeCollector {
     hwSampler;
     openTurnProbe;
     idleGapMs;
+    codexCompletionProbe;
+    claudeCompletionProbe;
     sessionToRun = new Map(); // sessionId → runId
     sessionToAgentType = new Map(); // sessionId → agentType (survives closeRun for late-attributed timeline rows)
     sessionToTurn = new Map(); // sessionId → current turn
@@ -101,17 +108,191 @@ export class ApmeCollector {
      *  turn open / task close. See `AGENT_IDLE_GAP_MS` for the measurement the
      *  constant rests on. */
     sessionToIdleGapTimer = new Map();
+    /** Sessions whose run was re-adopted from the store at startup — lets a
+     *  newer open run for the same session replace the older one during the
+     *  same rehydrate pass without touching runs opened live since. */
+    rehydratedSessions = new Set();
     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, 
     /** Injectable for tests only — production call sites take the default. */
-    idleGapMs = AGENT_IDLE_GAP_MS) {
+    idleGapMs = AGENT_IDLE_GAP_MS, 
+    /** Whether a Codex turn open at startup completed per its rollout — see
+     *  `rehydrateOpenRuns`. Injectable for tests; the default reads the
+     *  rollout tail under `~/.codex/sessions`. */
+    codexCompletionProbe = codexTurnCompletionSince, 
+    /** Whether a Claude turn open at startup ended per its transcript — the
+     *  Claude half of the same question. Injectable for tests; the default
+     *  locates the transcript under `~/.claude/projects` by session id. */
+    claudeCompletionProbe = claudeTurnCompletionSince) {
         this.store = store;
         this.hwSampler = hwSampler;
         this.openTurnProbe = openTurnProbe;
         this.idleGapMs = idleGapMs;
+        this.codexCompletionProbe = codexCompletionProbe;
+        this.claudeCompletionProbe = claudeCompletionProbe;
+    }
+    /** Re-adopt every run the store still holds open, so the daemon that just
+     *  started continues them instead of stranding them.
+     *
+     *  The collector's whole state is in-memory maps, and a daemon restart drops
+     *  all of it while the sessions it was observing carry on. Before this, the
+     *  next hook from such a session found no run, opened a fresh one, and the
+     *  old one sat open until the abandoned-run reaper closed it two hours
+     *  later — its task `orphaned`, its open turn's tool counters at zero, and
+     *  the Stop that did arrive discarded for want of a turn to close. Measured
+     *  over 5.5 days (2026-09-03) on a dev machine that restarted the daemon 40
+     *  times: 60 of the 68 tasks the reaper closed straddled a restart, and the
+     *  idle-gap boundary that had just been added could not fire for any of
+     *  them, since its timer lived in the process that died.
+     *
+     *  Per open run, in store order: the session→run edge is restored; the open
+     *  task (if any) is rebuilt with its real turn span and first prompt; an
+     *  open turn is rebuilt with its counters recovered from the trajectory it
+     *  wrote; and when there is no open turn but a closed one, the idle-gap
+     *  timer is armed for whatever remains of the gap — zero if it already
+     *  elapsed during the downtime, which closes the task on the next tick as
+     *  the `idle_gap` it always was. A Codex turn still open is checked once
+     *  against its rollout: a `task_complete` newer than the turn is the Stop
+     *  this daemon never received, and closes it as `synthetic_stop` with the
+     *  reply the rollout recorded.
+     *
+     *  Two runs open under one session id (an older defect's residue) resolve
+     *  to the newest; the rest stay for the reaper. Must run before the first
+     *  hook is served, and only in the process that owns the hook port — a
+     *  session bridge adopting the daemon's runs would steal them. */
+    rehydrateOpenRuns(now = Date.now()) {
+        const out = { runs: 0, tasks: 0, turns: 0, armed: 0, recovered: 0 };
+        if (!this.store.enabled)
+            return out;
+        let runs;
+        try {
+            runs = this.store.listOpenRuns();
+        }
+        catch (err) {
+            debug('APME', `rehydrate: listOpenRuns failed: ${String(err)}`);
+            return out;
+        }
+        for (const run of runs) {
+            // Newest run per session wins; store order is oldest-first, so a later
+            // row simply replaces the mapping an earlier one set.
+            if (this.sessionToRun.has(run.sessionId) && !this.rehydratedSessions.has(run.sessionId))
+                continue;
+            this.rehydratedSessions.add(run.sessionId);
+            this.sessionToRun.set(run.sessionId, run.id);
+            this.sessionToAgentType.set(run.sessionId, run.agentType);
+            out.runs++;
+            let turns = [];
+            let tasks = [];
+            try {
+                turns = this.store.listTurns(run.id);
+                tasks = this.store.listTasksForRun(run.id);
+            }
+            catch (err) {
+                debug('APME', `rehydrate: run ${run.id.slice(0, 8)} unreadable: ${String(err)}`);
+                continue;
+            }
+            this.runTaskCount.set(run.id, tasks.length);
+            const lastTurn = turns.length > 0 ? turns[turns.length - 1] : null;
+            if (lastTurn)
+                this.sessionToLastTurnId.set(run.sessionId, String(lastTurn.id));
+            const openTask = tasks.find((t) => t.endedAt == null) ?? null;
+            let activeTask = null;
+            if (openTask) {
+                const taskTurns = turns.filter((t) => t.task_id === openTask.id);
+                const first = taskTurns[0];
+                const firstIndex = openTask.firstTurnIndex ?? (first ? Number(first.turn_index) : null);
+                const lastIndex = taskTurns.length > 0
+                    ? Number(taskTurns[taskTurns.length - 1].turn_index)
+                    : (openTask.lastTurnIndex ?? firstIndex);
+                activeTask = {
+                    id: openTask.id,
+                    runId: run.id,
+                    index: openTask.taskIndex,
+                    startedAt: openTask.startedAt,
+                    firstTurnIndex: firstIndex,
+                    lastTurnIndex: lastIndex,
+                    firstPrompt: typeof first?.prompt === 'string' ? first.prompt : null,
+                    // The header is promoted on the second turn; a task that already
+                    // has two either emitted it or is owed it — either way the closure
+                    // row must be allowed to render. Single-turn tasks stay deferred.
+                    timelineEmitted: taskTurns.length >= 2,
+                };
+                this.sessionToTask.set(run.sessionId, activeTask);
+                out.tasks++;
+            }
+            this.sessionToUsage.delete(run.sessionId);
+            const openTurn = lastTurn && lastTurn.ended_at == null ? lastTurn : null;
+            if (openTurn) {
+                const index = Number(openTurn.turn_index);
+                const counters = activeTask
+                    ? this.store.countToolEventsForTurn(activeTask.id, index)
+                    : { toolCalls: 0, filesModified: 0, filesCreated: 0 };
+                this.sessionToTurn.set(run.sessionId, {
+                    id: String(openTurn.id),
+                    runId: run.id,
+                    index,
+                    startedAt: Number(openTurn.started_at),
+                    toolCalls: counters.toolCalls,
+                    filesModified: counters.filesModified,
+                    filesCreated: counters.filesCreated,
+                    gitBefore: typeof openTurn.git_before === 'string' ? openTurn.git_before : null,
+                    prompt: typeof openTurn.prompt === 'string' ? openTurn.prompt : null,
+                    hasResponse: typeof openTurn.response === 'string' && openTurn.response.length > 0,
+                });
+                out.turns++;
+                // The agent's own record says whether the Stop this turn was owed
+                // ever happened. Closed at the RECORD's time, not now: the daemon was
+                // down in between, and that gap is nobody's turn duration.
+                if (run.agentType === 'codex-cli') {
+                    let completion = null;
+                    try {
+                        completion = this.codexCompletionProbe(run.sessionId, Number(openTurn.started_at));
+                    }
+                    catch {
+                        completion = null;
+                    }
+                    if (completion) {
+                        if (completion.text)
+                            this.setTurnResponse(run.sessionId, completion.text);
+                        // A turn Codex itself failed (usage limit, dead endpoint) fires no
+                        // Stop and is not a dropped hook.
+                        const source = completion.error ? 'aborted' : 'synthetic_stop';
+                        this.closeTurn(run.sessionId, source, completion.completedAt);
+                        out.recovered++;
+                        debug('APME', `rehydrate: codex turn ${String(openTurn.id).slice(0, 8)} ${completion.error ? 'failed' : 'completed'} at ${new Date(completion.completedAt).toISOString()} per rollout — closed as ${source}`);
+                    }
+                }
+                else if (run.agentType === 'claude-code') {
+                    let completion = null;
+                    try {
+                        completion = this.claudeCompletionProbe(run.sessionId, run.projectPath ?? null, Number(openTurn.started_at));
+                    }
+                    catch {
+                        completion = null;
+                    }
+                    if (completion) {
+                        if (completion.text)
+                            this.setTurnResponse(run.sessionId, completion.text);
+                        this.closeTurn(run.sessionId, completion.source, completion.endedAt);
+                        out.recovered++;
+                        debug('APME', `rehydrate: claude turn ${String(openTurn.id).slice(0, 8)} ended at ${new Date(completion.endedAt).toISOString()} per transcript — closed as ${completion.source}`);
+                    }
+                }
+            }
+            else if (activeTask && lastTurn) {
+                const lastEnd = Number(lastTurn.ended_at);
+                const remaining = Math.max(0, this.idleGapMs - Math.max(0, now - lastEnd));
+                this.armIdleGapTimer(run.sessionId, remaining);
+                out.armed++;
+            }
+        }
+        if (out.runs > 0) {
+            debug('APME', `rehydrated ${out.runs} open run(s): ${out.tasks} task(s), ${out.turns} open turn(s), ${out.armed} idle timer(s) re-armed, ${out.recovered} turn(s) closed from the agent's own record`);
+        }
+        return out;
     }
     /** Start a new run and return its id. Safe to call if store disabled (returns ''). */
     openRun(input) {
@@ -158,6 +339,7 @@ export class ApmeCollector {
         const runId = this.sessionToRun.get(sessionId);
         if (!runId)
             return;
+        this.heard(sessionId);
         const event = normalizeHookEventName(rawEvent);
         const toolName = typeof data.tool_name === 'string' ? data.tool_name : null;
         // ── Turn management ──
@@ -198,7 +380,10 @@ export class ApmeCollector {
             // and no watchdog recovered it either, or the synthetic Stop would have
             // closed it already. That is the unrecovered-loss bucket, UNLESS the
             // user cancelled it, in which case no Stop was ever owed.
-            this.closeTurn(sessionId, this.resolveDisplacedTurnSource(sessionId, data));
+            const displaced = this.resolveDisplacedTurn(sessionId, data);
+            if (displaced.response)
+                this.setTurnResponse(sessionId, displaced.response);
+            this.closeTurn(sessionId, displaced.source, displaced.endedAt);
             // Open new turn
             const turnIndex = prevIndex + 1;
             const run = this.store.getRun(runId);
@@ -369,6 +554,7 @@ export class ApmeCollector {
     noteTurnStop(sessionId, opts = {}) {
         if (!this.store.enabled)
             return;
+        this.heard(sessionId);
         // `interrupted` and `aborted` both outrank `synthetic`: neither ending
         // produces a real Stop, so each can only ever arrive AS a synthetic one,
         // and reading the flags the other way round would file every user cancel
@@ -403,26 +589,47 @@ export class ApmeCollector {
      *     model turn and owes exactly one Stop, which closes the LAST of them.
      *     A displaced row with no assistant record behind it at all is that
      *     artifact, not a lost hook. */
-    resolveDisplacedTurnSource(sessionId, data) {
+    resolveDisplacedTurn(sessionId, data) {
         const turn = this.sessionToTurn.get(sessionId);
         // No open turn: closeTurn no-ops, so the value is immaterial.
         if (!turn)
-            return 'next_prompt';
-        // Claude-only: the marker and the JSONL shape are Claude Code's.
-        if (this.sessionToAgentType.get(sessionId) !== 'claude-code')
-            return 'next_prompt';
+            return { source: 'next_prompt' };
+        const agentType = this.sessionToAgentType.get(sessionId);
+        // Codex: the rollout is the record. Measured over one week (2026-09-03),
+        // 23 codex turns reached the next prompt open; the rollout held a
+        // completed reply for 16 of them (the Stop alone was lost), a failure for
+        // 2 (a dead endpoint — no Stop is ever fired for those), and nothing for
+        // 5. Only the last five were dropped hooks; the rest are recovered here
+        // with the reply and Codex's own end time, the way the watchdog recovers
+        // a Claude turn.
+        if (agentType === 'codex-cli') {
+            try {
+                const completion = this.codexCompletionProbe(sessionId, turn.startedAt - TURN_INTERRUPT_SLACK_MS);
+                if (!completion)
+                    return { source: 'next_prompt' };
+                if (completion.error)
+                    return { source: 'aborted', endedAt: completion.completedAt };
+                return { source: 'synthetic_stop', endedAt: completion.completedAt, response: completion.text || undefined };
+            }
+            catch {
+                return { source: 'next_prompt' };
+            }
+        }
+        // Claude: the marker and the JSONL shape are Claude Code's.
+        if (agentType !== 'claude-code')
+            return { source: 'next_prompt' };
         const transcriptPath = typeof data.transcript_path === 'string' ? data.transcript_path : '';
         if (!transcriptPath)
-            return 'next_prompt';
+            return { source: 'next_prompt' };
         try {
             const evidence = this.openTurnProbe(transcriptPath, turn.startedAt - TURN_INTERRUPT_SLACK_MS);
             // An unreadable transcript is no evidence of anything — never guess.
             if (!evidence)
-                return 'next_prompt';
+                return { source: 'next_prompt' };
             if (evidence.interruptedAt != null)
-                return 'interrupted';
+                return { source: 'interrupted' };
             if (evidence.abortedAt != null)
-                return 'aborted';
+                return { source: 'aborted' };
             // Ordered last on purpose: a cancelled or aborted turn that also wrote
             // nothing is still a cancel or an abort, not a superseded prompt.
             //
@@ -434,17 +641,17 @@ export class ApmeCollector {
             // truncate the walk and hide the assistant work behind it. A turn that
             // called tools demonstrably ran whatever the transcript says.
             if (!evidence.sawAssistant && turn.toolCalls === 0)
-                return 'superseded';
-            return 'next_prompt';
+                return { source: 'superseded' };
+            return { source: 'next_prompt' };
         }
         catch {
-            return 'next_prompt';
+            return { source: 'next_prompt' };
         }
     }
     /** Close the current turn for a session (called on Stop, new prompt, or
      *  session end). `source` records which of those it was — see
      *  `TurnEndSource`. */
-    closeTurn(sessionId, source) {
+    closeTurn(sessionId, source, endedAt = Date.now()) {
         const turn = this.sessionToTurn.get(sessionId);
         if (!turn)
             return;
@@ -455,7 +662,7 @@ export class ApmeCollector {
         const gitAfter = readGitHead(projectPath);
         try {
             this.store.updateTurn(turn.id, {
-                endedAt: Date.now(),
+                endedAt,
                 toolCalls: turn.toolCalls,
                 filesModified: turn.filesModified,
                 filesCreated: turn.filesCreated,
@@ -467,9 +674,12 @@ 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);
+        // Idle starts when the turn ends — at the turn's OWN end time, so a turn
+        // closed from the agent's record after the fact (rehydrate, next-prompt
+        // recovery) is already as idle as the record says it is. The timer is
+        // cleared by the next turn open (still working) or by closeTask
+        // (boundary reached another way).
+        this.armIdleGapTimer(sessionId, Math.max(0, this.idleGapMs - Math.max(0, Date.now() - endedAt)));
     }
     /** Get the current active turn ID for a session (if any). */
     getActiveTurnId(sessionId) {
@@ -585,7 +795,7 @@ export class ApmeCollector {
     /** 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) {
+    armIdleGapTimer(sessionId, delayMs = this.idleGapMs) {
         this.clearIdleGapTimer(sessionId);
         const timer = setTimeout(() => {
             this.sessionToIdleGapTimer.delete(sessionId);
@@ -597,7 +807,7 @@ export class ApmeCollector {
                 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);
+        }, delayMs);
         // Never hold the process open for an idle bookkeeping timer.
         timer.unref?.();
         this.sessionToIdleGapTimer.set(sessionId, timer);
@@ -733,11 +943,39 @@ export class ApmeCollector {
      *  whose user simply stepped away mid-turn, and the row would then be closed
      *  underneath the collector that is still writing to it. */
     isLiveRun(runId) {
-        for (const id of this.sessionToRun.values())
-            if (id === runId)
-                return true;
+        for (const [sessionId, id] of this.sessionToRun) {
+            if (id !== runId)
+                continue;
+            // Adoption at startup is PROVISIONAL: a run re-adopted from the store
+            // whose session has not sent a single hook since is owned in name only.
+            // Counting it live forever meant a session that ended while the daemon
+            // was down could never be reaped — its run had no Stop coming, no idle
+            // timer (those arm on turn close), and a reaper that deferred to us.
+            // Measured 2026-09-03: two such runs open 17 hours after the restart.
+            return !this.rehydratedSessions.has(sessionId);
+        }
         return false;
     }
+    /** Drop every in-memory edge to `runId` after the reaper closed it in the
+     *  store, so a hook that arrives later opens a fresh run instead of writing
+     *  turns into a row that is already finalised. */
+    releaseRun(runId) {
+        for (const [sessionId, id] of [...this.sessionToRun]) {
+            if (id !== runId)
+                continue;
+            this.clearIdleGapTimer(sessionId);
+            this.sessionToRun.delete(sessionId);
+            this.sessionToTask.delete(sessionId);
+            this.sessionToTurn.delete(sessionId);
+            this.sessionToLastTurnId.delete(sessionId);
+            this.rehydratedSessions.delete(sessionId);
+        }
+        this.runTaskCount.delete(runId);
+    }
+    /** The session spoke: an adopted run is now owned for real. */
+    heard(sessionId) {
+        this.rehydratedSessions.delete(sessionId);
+    }
     /** Agent type established for a session at `openRun` (survives closeRun so a
      *  late-attributed timeline row still resolves its brand). This is the single
      *  authoritative agentType source the timeline attributor backfills from, so
@@ -825,6 +1063,126 @@ export class ApmeCollector {
             }
         }
     }
+    /** Persist a child-agent lifecycle event on its parent task. Child hooks are
+     *  deliberately consumed before ordinary APME ingestion so they cannot
+     *  mutate parent state or controls; SubagentTimelineTracker explicitly
+     *  hands just this observation-safe evidence back to the collector.
+     *
+     *  This is the producer for SampleModelConfig.subagents. The richer event
+     *  also powers the judge rollup and Graph node without promoting a child to
+     *  a separately steerable session. Returns false when no parent task is
+     *  active, which is honest: there is no task edge to guess. */
+    noteSubagentLifecycle(sessionId, event) {
+        if (!this.store.enabled)
+            return false;
+        const ctx = this.sampleCtxForTurn(sessionId);
+        if (!ctx)
+            return false;
+        const task = this.store.getTask(ctx.taskId);
+        if (!task)
+            return false;
+        const name = event.name.trim();
+        if (!name)
+            return false;
+        try {
+            this.store.updateTask(ctx.taskId, {
+                modelConfig: this.mergedTaskModelConfig(task, undefined, undefined, name),
+            });
+        }
+        catch { /* keep the lifecycle event even if the header update failed */ }
+        const durationMs = event.startedAt == null
+            ? null
+            : Math.max(0, event.ts - event.startedAt);
+        this.appendSampleEvent(ctx, {
+            kind: 'subagent',
+            ts: event.ts,
+            dedupCore: `${event.phase}:${event.id}`,
+            payloadObj: {
+                id: event.id,
+                name,
+                phase: event.phase,
+                ...(event.summary ? { summary: event.summary } : {}),
+                ...(durationMs == null ? {} : { durationMs }),
+            },
+        });
+        return true;
+    }
+    /** Persist a free-form annotation on the session's active task (a task-list
+     *  item checked off, a team event without a child identity). Returns false
+     *  when no task is open — there is nothing honest to attach it to. */
+    noteInfo(sessionId, event) {
+        if (!this.store.enabled)
+            return false;
+        const label = event.label.trim();
+        if (!label)
+            return false;
+        const ctx = this.sampleCtxForTurn(sessionId);
+        if (!ctx)
+            return false;
+        const ts = event.ts ?? Date.now();
+        this.appendSampleEvent(ctx, {
+            kind: 'info',
+            ts,
+            dedupCore: `${label}:${ts}:${event.detail ?? ''}`,
+            payloadObj: { label, ...(event.detail ? { detail: event.detail } : {}) },
+        });
+        return true;
+    }
+    /** Persist a cross-session coordination observation (`RelationEvent`) on
+     *  the session's active task. Like child lifecycle, this is evidence for the
+     *  work board and the collaboration lens, never a steerable session or a
+     *  parent link guessed from project membership: the producer
+     *  (`CoordinationTracker`) only calls this with what a process table, a
+     *  SendMessage tool call or a cross-session envelope actually said. */
+    noteRelation(sessionId, event) {
+        if (!this.store.enabled)
+            return false;
+        const ctx = this.sampleCtxForTurn(sessionId);
+        if (!ctx)
+            return false;
+        const ts = event.ts ?? Date.now();
+        this.appendSampleEvent(ctx, {
+            kind: 'relation',
+            ts,
+            dedupCore: `${event.relation}:${event.direction}:${event.phase}:${event.key}`,
+            payloadObj: {
+                relation: event.relation,
+                direction: event.direction,
+                phase: event.phase,
+                ...(event.peerSessionId ? { peerSessionId: event.peerSessionId } : {}),
+                ...(event.peerName ? { peerName: event.peerName } : {}),
+                evidence: event.evidence,
+                ...(event.detail ? { detail: event.detail } : {}),
+            },
+        });
+        return true;
+    }
+    /** Merge instead of replacing the sample identity header. Model updates can
+     *  arrive after subagent starts (and vice versa); overwriting model_config
+     *  here was why a future subagents producer would have appeared to work and
+     *  then silently vanished on the next usage/model hook. */
+    mergedTaskModelConfig(task, modelId, provider, subagent) {
+        let previous = {};
+        if (task.modelConfig) {
+            try {
+                const parsed = JSON.parse(task.modelConfig);
+                if (parsed && typeof parsed === 'object')
+                    previous = parsed;
+            }
+            catch { /* malformed legacy value: rebuild from row columns */ }
+        }
+        const subagents = new Set(Array.isArray(previous.subagents)
+            ? previous.subagents.filter((v) => typeof v === 'string' && v.length > 0)
+            : []);
+        if (subagent)
+            subagents.add(subagent);
+        return JSON.stringify({
+            ...previous,
+            modelId: modelId ?? task.modelId ?? previous.modelId ?? 'unknown',
+            provider: provider === undefined ? (task.provider ?? previous.provider ?? null) : provider,
+            ...(subagents.size > 0 ? { subagents: [...subagents].sort() } : {}),
+        });
+    }
     /** Reverse-lookup sessionId for a runId (best-effort; only the live map). */
     runToSessionId(runId) {
         for (const [sid, rid] of this.sessionToRun)
@@ -898,7 +1256,16 @@ export class ApmeCollector {
     setLastClosedTurnResponse(sessionId, response) {
         if (!this.store.enabled)
             return;
-        const turnId = this.sessionToLastTurnId.get(sessionId);
+        // The in-memory edge is dropped at closeRun, and a one-turn session
+        // (`claude -p`, a spawned worker) sends its SessionEnd 80–130 ms after
+        // its Stop — before the deferred transcript re-read (1.5 s) that exists
+        // because the Stop's own read found nothing. The reply then arrived to
+        // no turn and was dropped: 6 of 13 such sessions in one day (2026-09-03).
+        // The store still knows the turn; a bounded window keeps a late reply
+        // from landing on a session's turn from an earlier life.
+        const turnId = this.sessionToLastTurnId.get(sessionId)
+            ?? this.store.latestClosedTurnIdForSession(sessionId, Date.now() - LATE_REPLY_WINDOW_MS)
+            ?? undefined;
         if (!turnId)
             return;
         const existing = this.store.getTurn(turnId);
@@ -1180,14 +1547,16 @@ export class ApmeCollector {
             ?? run?.provider
             ?? normalizeModelProvider(undefined, model);
         const taskRow = this.store.getTask(task.id);
+        if (!taskRow)
+            return;
         const taskModel = !model
-            ? taskRow?.modelId
-            : !taskRow?.modelId || taskRow.modelId === model
+            ? taskRow.modelId
+            : !taskRow.modelId || taskRow.modelId === model
                 ? model
                 : 'mixed';
         const taskProvider = !provider || provider === 'unknown'
-            ? taskRow?.provider
-            : !taskRow?.provider || taskRow.provider === provider
+            ? taskRow.provider
+            : !taskRow.provider || taskRow.provider === provider
                 ? provider
                 : 'mixed';
         const turnIndex = this.sessionToTurn.get(sessionId)?.index ?? task.lastTurnIndex ?? 0;
@@ -1200,10 +1569,7 @@ export class ApmeCollector {
             this.store.updateTask(task.id, {
                 modelId: taskModel,
                 provider: taskProvider,
-                modelConfig: JSON.stringify({
-                    modelId: taskModel ?? 'unknown',
-                    provider: taskProvider ?? null,
-                }),
+                modelConfig: this.mergedTaskModelConfig(taskRow, taskModel ?? 'unknown', taskProvider ?? null),
             });
             this.store.recomputeSampleCost(task.id);
         }
@@ -1250,16 +1616,14 @@ export class ApmeCollector {
     updateModel(sessionId, modelId) {
         if (!this.store.enabled || !modelId)
             return;
-        const runId = this.sessionToRun.get(sessionId);
-        if (!runId)
+        if (!this.sessionToRun.has(sessionId))
             return;
-        try {
-            this.store.updateRun(runId, {
-                modelId,
-                provider: normalizeModelProvider(undefined, modelId),
-            });
-        }
-        catch { /* ignore */ }
+        // The TURN is the scorecard's identity source (`turns.model_id`), and
+        // this used to write the run only — so every hook-observed Claude and
+        // Codex turn carried NULL there (465 + 183 in one week, 2026-09-03) and
+        // the per-model scorecard ranked nothing. The run keeps its
+        // latest-observed value for legacy readers.
+        this.updateTurnIdentity(sessionId, modelId);
     }
     /** Persist the model/provider on the assistant message's own turn.
      * `session_meta` can arrive after `chat.final` closed that turn, so the same
@@ -1317,7 +1681,7 @@ export class ApmeCollector {
             this.store.updateTask(taskId, {
                 modelId: taskModel,
                 provider: taskProvider,
-                modelConfig: JSON.stringify({ modelId: taskModel, provider: taskProvider }),
+                modelConfig: this.mergedTaskModelConfig(task, taskModel, taskProvider),
             });
         }
         catch { /* ignore */ }