@agentdeck/bridge 0.2.1 → 0.2.3

package/dist/apme/collector.js

@@ -18,18 +18,38 @@ import { mkdirSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { debug } from '../logger.js';
 import { resolveProjectName } from '../utils/project-name.js';
-import { classifyRunSmart } from './classifier.js';
+import { priceUsd, providerFor } from '@agentdeck/shared';
+import { classifyRunSmart, computeSignals, classify } from './classifier.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
+ *  of the same text), not a new turn. */
+const DUPLICATE_TURN_OPEN_WINDOW_MS = 15_000;
 export class ApmeCollector {
     store;
     hwSampler;
     sessionToRun = new Map(); // sessionId → runId
+    sessionToAgentType = new Map(); // sessionId → agentType (survives closeRun for late-attributed timeline rows)
     sessionToTurn = new Map(); // sessionId → current turn
     sessionToLastTurnId = new Map(); // survives closeTurn()
     sessionToTask = new Map(); // sessionId → current task
     runTaskCount = new Map(); // runId → next task_index
+    sessionToUsage = new Map(); // last cumulative usage
     /** Optional listener fired after `closeTask` persists the row. The runner
      *  wires this to enqueue a task-level judge call. */
     onTaskClosed = null;
+    /** Optional listener fired after `openTaskIfNone` inserts a fresh task row.
+     *  The dashboard timeline emitter wires this to push a `task_start` entry. */
+    onTaskOpened = null;
+    /** Optional listener fired after a typed trajectory event is persisted.
+     *  The timeline projection (Phase 3) consumes this. */
+    onSampleEvent = null;
+    /** Optional listener fired on the TodoWrite-all-completed soft hint.
+     *  The timeline emitter wires this to push a `task_milestone` row. */
+    onTaskMilestone = null;
+    /** Last milestone key (`taskId:turnIndex`) per session — a turn can carry
+     *  several all-completed TodoWrite calls; surface only the first. */
+    sessionToLastMilestone = new Map();
     constructor(store, hwSampler) {
         this.store = store;
         this.hwSampler = hwSampler;
@@ -54,6 +74,7 @@ export class ApmeCollector {
         try {
             this.store.insertRun(row);
             this.sessionToRun.set(input.sessionId, runId);
+            this.sessionToAgentType.set(input.sessionId, input.agentType);
             debug('APME', `openRun ${runId} session=${input.sessionId} agent=${input.agentType} model=${input.modelId ?? '-'}`);
         }
         catch (err) {
@@ -61,13 +82,23 @@ export class ApmeCollector {
         }
         return runId;
     }
-    /** Record a hook event as a step + manage turn lifecycle. */
-    ingestHook(sessionId, event, data) {
+    /** Record a hook event as a step + manage turn lifecycle.
+     *
+     *  `event` is normalized up-front so callers may pass EITHER the PascalCase
+     *  hook name (`UserPromptSubmit`, managed session bridge + span ingest) OR
+     *  the snake_case name the daemon's `/hooks/` handler maps to
+     *  (`user_prompt_submit`, `tool_start`, `tool_end`). Before this, snake_case
+     *  silently fell through every branch — the daemon's direct-`claude` hooks
+     *  never opened a turn, so those sessions produced no tasks and the device
+     *  timeline showed every prompt as a bare top-level chat. Making the matcher
+     *  case-tolerant means no caller can quietly no-op the segmentation. */
+    ingestHook(sessionId, rawEvent, data) {
         if (!this.store.enabled)
             return;
         const runId = this.sessionToRun.get(sessionId);
         if (!runId)
             return;
+        const event = normalizeHookEventName(rawEvent);
         const toolName = typeof data.tool_name === 'string' ? data.tool_name : null;
         // ── Turn management ──
         if (event === 'UserPromptSubmit') {
@@ -77,8 +108,31 @@ export class ApmeCollector {
                     ? data.message?.content
                     : undefined);
             const prompt = typeof rawPrompt === 'string' ? rawPrompt.slice(0, 8_000) : null;
-            // Close previous turn if open — read index BEFORE delete
-            const prevIndex = this.sessionToTurn.get(sessionId)?.index ?? -1;
+            // Duplicate-open guard: one user prompt can reach the collector more
+            // than once within moments. Closing and reopening here would strand an
+            // 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 &&
+                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)}`);
+                return;
+            }
+            // Close previous turn if open. Resolve prevIndex carefully: the active
+            // turn may already have been closed by an explicit closeTurnForSession
+            // (Codex `codex_stop` hook), in which case sessionToTurn is empty. Fall
+            // back to the last closed turn's row in the store so subsequent turns
+            // keep monotonically increasing turn_index instead of resetting to 0.
+            let prevIndex = this.sessionToTurn.get(sessionId)?.index ?? -1;
+            if (prevIndex === -1) {
+                const lastTurnId = this.sessionToLastTurnId.get(sessionId);
+                if (lastTurnId) {
+                    const lastIdx = this.store.getTurn(lastTurnId)?.turn_index;
+                    if (typeof lastIdx === 'number')
+                        prevIndex = lastIdx;
+                }
+            }
             this.closeTurn(sessionId);
             // Open new turn
             const turnIndex = prevIndex + 1;
@@ -90,6 +144,7 @@ export class ApmeCollector {
                 startedAt: Date.now(), toolCalls: 0,
                 filesModified: 0, filesCreated: 0,
                 gitBefore: readGitHead(projectPath),
+                prompt, hasResponse: false,
             };
             this.sessionToTurn.set(sessionId, turn);
             // Ensure an active task exists so this turn can attach to it. Tasks group
@@ -97,9 +152,16 @@ export class ApmeCollector {
             // /clear, session_end). First turn in a run opens task 0.
             const task = this.openTaskIfNone(sessionId, runId);
             if (task) {
-                if (task.firstTurnIndex === null)
+                const wasFirstTurn = task.firstTurnIndex === null;
+                if (wasFirstTurn)
                     task.firstTurnIndex = turnIndex;
                 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
+                // follow-up prompts render grouped under one row instead of as
+                // separate top-level chats. Single-turn Q&A never reaches here.
+                if (!wasFirstTurn)
+                    this.emitDeferredTaskStartIfNeeded(sessionId);
             }
             try {
                 this.store.insertTurn({
@@ -111,6 +173,10 @@ export class ApmeCollector {
             catch (err) {
                 debug('APME', `insertTurn failed: ${String(err)}`);
             }
+            // Sample trajectory: the user message opens the turn's typed event log.
+            if (task) {
+                this.appendSampleEvent({ taskId: task.id, runId, turnIndex }, { kind: 'user_message', ts: turn.startedAt, dedupCore: hashCore(prompt ?? `turn${turnIndex}`), payloadObj: { text: prompt ?? '' } });
+            }
             // Also set run's task_prompt from first prompt
             try {
                 if (run && !run.taskPrompt && prompt) {
@@ -127,16 +193,70 @@ export class ApmeCollector {
                 activeTurn.filesModified++;
             if (toolName === 'Write')
                 activeTurn.filesCreated++;
+            // Sample trajectory: a tool call starts as a pending ToolEvent; its
+            // PostToolUse result resolves the SAME row (one row, not two).
+            const task = this.sessionToTask.get(sessionId);
+            if (task && toolName) {
+                this.appendSampleEvent({ taskId: task.id, runId, turnIndex: activeTurn.index }, {
+                    kind: 'tool', toolName, toolStatus: 'pending',
+                    dedupCore: `${toolName}:${activeTurn.toolCalls}`,
+                    payloadObj: { input: extractToolInput(data) },
+                });
+            }
         }
-        // ── Task boundary: TodoWrite all-completed ──
-        // Claude Code's TodoWrite PostToolUse payload contains tool_input.todos.
-        // When every todo status is "completed", treat it as the agent declaring
-        // the task finished. Close the current task; the next UserPromptSubmit
-        // opens a fresh one.
+        // Sample trajectory: resolve the pending ToolEvent on PostToolUse / tool_result.
+        if ((event === 'PostToolUse' || event === 'tool_result') && toolName) {
+            const task = this.sessionToTask.get(sessionId);
+            const turnIndex = this.sessionToTurn.get(sessionId)?.index;
+            if (task && turnIndex !== undefined) {
+                const isError = Boolean(data.is_error || data.error);
+                const output = extractToolOutput(data);
+                const pending = this.store.findPendingToolEvent(task.id, turnIndex, toolName);
+                if (pending?.id != null) {
+                    let payload = pending.payload;
+                    try {
+                        const obj = pending.payload ? JSON.parse(pending.payload) : {};
+                        if (output !== undefined)
+                            obj.output = output;
+                        payload = safeStringify(obj);
+                    }
+                    catch { /* keep existing payload */ }
+                    this.store.updateSampleEvent(pending.id, {
+                        toolStatus: isError ? 'error' : 'success',
+                        toolError: isError ? String(data.error ?? 'error').slice(0, 500) : null,
+                        payload,
+                    });
+                }
+                else {
+                    // No pending row (PostToolUse without a matching PreToolUse) — record
+                    // a resolved tool event directly.
+                    this.appendSampleEvent({ taskId: task.id, runId, turnIndex }, {
+                        kind: 'tool', toolName,
+                        toolStatus: isError ? 'error' : 'success',
+                        toolError: isError ? String(data.error ?? 'error').slice(0, 500) : null,
+                        dedupCore: `${toolName}:resolved:${turnIndex}:${this.store.nextSampleSeq(task.id)}`,
+                        payloadObj: { output },
+                    });
+                }
+            }
+        }
+        // ── Task boundary HINT: TodoWrite all-completed ──
+        // Demoted from a hard boundary to a non-segmenting hint (2026-06).
+        // TodoWrite-all-complete fires unreliably (~18% on Claude Code v2.1) and,
+        // when it did fire, fragmented a single logical task into several units.
+        // Tasks now segment only on EXPLICIT boundaries (`/task close`, `/clear`)
+        // or `session_end` — a stable, user-controlled unit. We still record the
+        // milestone in the trajectory so the task rollup can see that the agent
+        // declared its todos done, without splitting the task.
         if (event === 'PostToolUse' && toolName === 'TodoWrite') {
             const todos = extractTodos(data);
             if (todos && todos.length > 0 && todos.every((t) => t.status === 'completed')) {
-                this.closeTask(sessionId, 'todo_complete');
+                const task = this.sessionToTask.get(sessionId);
+                const turnIndex = this.sessionToTurn.get(sessionId)?.index;
+                if (task && turnIndex !== undefined) {
+                    this.appendSampleEvent({ taskId: task.id, runId, turnIndex }, { kind: 'state', dedupCore: `todos_complete:${turnIndex}:${todos.length}`, payloadObj: { state: 'todos_completed', count: todos.length } });
+                    this.fireTaskMilestone(sessionId, task.id, runId, turnIndex, todos.length);
+                }
             }
         }
         // Record step
@@ -150,6 +270,14 @@ export class ApmeCollector {
             debug('APME', `ingestHook failed: ${String(err)}`);
         }
     }
+    /** Public wrapper for the private `closeTurn`. Used by adapters that
+     *  see an explicit turn-end signal (Codex `codex_stop` hook) and want
+     *  to finalize the turn row immediately rather than wait for the next
+     *  UserPromptSubmit / closeRun to flush endedAt + buffered counters.
+     *  Idempotent — no-op when no active turn for the session. */
+    closeTurnForSession(sessionId) {
+        this.closeTurn(sessionId);
+    }
     /** Close the current turn for a session (called on new prompt or session end). */
     closeTurn(sessionId) {
         const turn = this.sessionToTurn.get(sessionId);
@@ -182,9 +310,48 @@ export class ApmeCollector {
     getActiveTaskId(sessionId) {
         return this.sessionToTask.get(sessionId)?.id ?? null;
     }
+    /** Fire the `onTaskMilestone` listener for a TodoWrite-all-completed hint,
+     *  at most once per (task, turn) — the agent may rewrite an all-completed
+     *  todo list several times inside one turn. */
+    fireTaskMilestone(sessionId, taskId, runId, turnIndex, todoCount) {
+        if (!this.onTaskMilestone)
+            return;
+        const key = `${taskId}:${turnIndex}`;
+        if (this.sessionToLastMilestone.get(sessionId) === key)
+            return;
+        this.sessionToLastMilestone.set(sessionId, key);
+        // A TodoWrite plan implies a task worth showing — promote the deferred
+        // task_start first so the milestone row never renders orphaned above a
+        // task with no header.
+        this.emitDeferredTaskStartIfNeeded(sessionId);
+        const run = this.store.getRun(runId);
+        try {
+            this.onTaskMilestone({
+                taskId,
+                runId,
+                sessionId,
+                agentType: (run?.agentType ?? null),
+                projectName: run?.projectName ?? null,
+                turnIndex,
+                todoCount,
+                at: Date.now(),
+            });
+        }
+        catch (err) {
+            debug('APME', `onTaskMilestone listener threw: ${String(err)}`);
+        }
+    }
     /** Open a new task if none is active for this session. Returns the active
      *  task (new or existing), or null if no run is open. Idempotent: repeat
-     *  calls while a task is already active are no-ops. */
+     *  calls while a task is already active are no-ops.
+     *
+     *  The `task_start` timeline row is NOT emitted here — it is deferred to
+     *  `emitDeferredTaskStartIfNeeded`, fired when a "real task" signal lands
+     *  (a second turn on the same task, or a TodoWrite plan). Short single-turn
+     *  conversations therefore never produce a TASK header on the dashboard,
+     *  keeping the timeline focused on the turn rows worth evaluating. The DB
+     *  `tasks` row is inserted immediately so eval/analytics see every unit.
+     *  Mirrors ApmeCollector.swift `openTaskIfNone` + `emitDeferredTaskStartIfNeeded`. */
     openTaskIfNone(sessionId, runId) {
         const existing = this.sessionToTask.get(sessionId);
         if (existing)
@@ -198,6 +365,7 @@ export class ApmeCollector {
             startedAt: Date.now(),
             firstTurnIndex: null,
             lastTurnIndex: null,
+            timelineEmitted: false,
         };
         this.sessionToTask.set(sessionId, task);
         try {
@@ -214,6 +382,57 @@ export class ApmeCollector {
         }
         return task;
     }
+    /** Emit the deferred `task_start` timeline row for the session's active task,
+     *  once. Idempotent — repeat calls after the first are no-ops. Uses the
+     *  task's original `startedAt` as the row ts so the TASK header anchors above
+     *  the first turn it groups instead of jumping in mid-conversation. Called
+     *  when a task proves itself "real" (second turn, or TodoWrite plan).
+     *  Mirrors ApmeCollector.swift `emitDeferredTaskStartIfNeeded`. */
+    emitDeferredTaskStartIfNeeded(sessionId) {
+        const task = this.sessionToTask.get(sessionId);
+        if (!task || task.timelineEmitted)
+            return;
+        task.timelineEmitted = true;
+        if (!this.onTaskOpened)
+            return;
+        const run = this.store.getRun(task.runId);
+        try {
+            this.onTaskOpened({
+                taskId: task.id,
+                runId: task.runId,
+                sessionId,
+                agentType: (run?.agentType ?? null),
+                projectName: run?.projectName ?? null,
+                taskIndex: task.index,
+                startedAt: task.startedAt,
+            });
+        }
+        catch (err) {
+            debug('APME', `onTaskOpened listener threw: ${String(err)}`);
+        }
+    }
+    /** 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
+     *  run). No-op when no task is active. Passing `outcome` overrides the
+     *  judge's coarse score-derived class — handy for `task cancel` where
+     *  the user wants the row tagged "abandoned" regardless of partial
+     *  progress. */
+    closeTaskExternal(sessionId, boundarySignal = 'manual', outcome) {
+        const task = this.sessionToTask.get(sessionId);
+        if (!task)
+            return false;
+        this.closeTask(sessionId, boundarySignal);
+        if (outcome) {
+            try {
+                this.store.updateTask(task.id, { outcome });
+            }
+            catch (err) {
+                debug('APME', `manual outcome write failed: ${String(err)}`);
+            }
+        }
+        return true;
+    }
     /** Close the current task for a session, persisting boundary metadata.
      *  No-op if no task is active. Fires `onTaskClosed` so the runner can
      *  enqueue a task-level judge call. Tasks that never saw a turn
@@ -223,6 +442,7 @@ export class ApmeCollector {
         if (!task)
             return;
         this.sessionToTask.delete(sessionId);
+        this.sessionToLastMilestone.delete(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) {
@@ -237,10 +457,31 @@ export class ApmeCollector {
             debug('APME', `closeTask ${task.id.slice(0, 8)} — empty, dropped`);
             return;
         }
-        // Derive task category from the run (best-effort). Turn-level categories
-        // may diverge, but for now tasks inherit from the run.
+        // Category, present-at-close. Prefer the run's already-resolved category;
+        // otherwise classify synchronously from the run's signals so the task row
+        // (and its rollup judge rubric) always carries a stable category. The
+        // async run-level classifier (classifyRunSmart at closeRun) frequently
+        // resolves AFTER the task has already closed — leaving taskCategory null
+        // and the judge falling back to the wrong generic rubric.
         const run = this.store.getRun(task.runId);
-        const taskCategory = run?.taskCategory ?? null;
+        let taskCategory = run?.taskCategory ?? null;
+        if (!taskCategory || taskCategory === 'unknown') {
+            try {
+                const signals = computeSignals(this.store, task.runId);
+                // run.endedAt is still null at session_end close (updateRun runs after
+                // closeTask), so sessionDurationSec would be 0 and skew the duration
+                // rules — derive it from the task span instead.
+                if (signals.sessionDurationSec === 0) {
+                    signals.sessionDurationSec = Math.max(0, Math.round((Date.now() - task.startedAt) / 1000));
+                }
+                const category = classify(signals);
+                if (category && category !== 'unknown')
+                    taskCategory = category;
+            }
+            catch (err) {
+                debug('APME', `closeTask classify failed: ${String(err)}`);
+            }
+        }
         try {
             this.store.updateTask(task.id, {
                 endedAt: Date.now(),
@@ -253,14 +494,20 @@ export class ApmeCollector {
             debug('APME', `updateTask failed: ${String(err)}`);
         }
         debug('APME', `closeTask ${task.id.slice(0, 8)} signal=${boundarySignal} turns=${task.firstTurnIndex}..${task.lastTurnIndex}`);
-        // Notify listeners (runner enqueueTask is wired via apme/index.ts).
+        // Notify listeners (runner enqueueTask + timeline emitter wired via apme/index.ts).
         if (this.onTaskClosed) {
             try {
                 this.onTaskClosed({
                     taskId: task.id,
                     runId: task.runId,
+                    sessionId,
+                    agentType: (run?.agentType ?? null),
+                    projectName: run?.projectName ?? null,
+                    startedAt: task.startedAt,
+                    endedAt: Date.now(),
                     boundarySignal,
                     taskCategory,
+                    timelineEmitted: task.timelineEmitted,
                 });
             }
             catch (err) {
@@ -272,6 +519,92 @@ export class ApmeCollector {
     getRunId(sessionId) {
         return this.sessionToRun.get(sessionId) ?? null;
     }
+    /** 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
+     *  every timeline entry ships with an agentType regardless of which emitter
+     *  produced it (observed hook `chat_start`, relayed managed `tool_exec`, …). */
+    getRunAgentType(sessionId) {
+        return this.sessionToAgentType.get(sessionId) ?? null;
+    }
+    // ─── SessionSample trajectory (the normalizer's typed event log) ────────────
+    /** Resolve the (taskId, runId, turnIndex) a sample event should attach to.
+     *  Prefers the active task/turn; falls back to a turn row in the DB when the
+     *  task already closed (e.g. PTY response captured after session_end). */
+    sampleCtxForTurn(sessionId, turnId) {
+        const active = this.sessionToTask.get(sessionId);
+        if (turnId) {
+            const row = this.store.getTurn(turnId);
+            const taskId = row?.task_id ?? active?.id;
+            const runId = row?.run_id ?? active?.runId;
+            const turnIndex = row?.turn_index
+                ?? this.sessionToTurn.get(sessionId)?.index ?? active?.lastTurnIndex ?? 0;
+            if (taskId && runId)
+                return { taskId, runId, turnIndex };
+        }
+        if (active) {
+            const turnIndex = this.sessionToTurn.get(sessionId)?.index ?? active.lastTurnIndex ?? 0;
+            return { taskId: active.id, runId: active.runId, turnIndex };
+        }
+        return null;
+    }
+    /** Append one typed trajectory event to the active sample. Storage-time dedup
+     *  is handled by the UNIQUE (task_id, dedup_key) index. Fires `onSampleEvent`
+     *  only when a row was actually inserted (not a dup), so the timeline
+     *  projection never double-emits. */
+    appendSampleEvent(ctx, ev) {
+        if (!this.store.enabled)
+            return;
+        const dedupKey = createHash('sha1').update(`${ev.kind}|${ctx.turnIndex}|${ev.dedupCore}`).digest('hex').slice(0, 24);
+        const row = {
+            taskId: ctx.taskId,
+            runId: ctx.runId,
+            turnIndex: ctx.turnIndex,
+            seq: this.store.nextSampleSeq(ctx.taskId),
+            ts: ev.ts ?? Date.now(),
+            kind: ev.kind,
+            model: ev.model ?? null,
+            inputTokens: ev.inputTokens ?? null,
+            outputTokens: ev.outputTokens ?? null,
+            costUsd: ev.costUsd ?? null,
+            latencyMs: ev.latencyMs ?? null,
+            toolName: ev.toolName ?? null,
+            toolStatus: ev.toolStatus ?? null,
+            toolError: ev.toolError ?? null,
+            payload: ev.payloadObj ? safeStringify(ev.payloadObj) : null,
+            dedupKey,
+        };
+        let inserted = false;
+        try {
+            inserted = this.store.insertSampleEvent(row);
+        }
+        catch (err) {
+            debug('APME', `appendSampleEvent failed: ${String(err)}`);
+            return;
+        }
+        if (inserted && this.onSampleEvent) {
+            const run = this.store.getRun(ctx.runId);
+            try {
+                this.onSampleEvent({
+                    taskId: ctx.taskId, runId: ctx.runId,
+                    sessionId: this.runToSessionId(ctx.runId),
+                    agentType: (run?.agentType ?? null),
+                    projectName: run?.projectName ?? null,
+                    event: row,
+                });
+            }
+            catch (err) {
+                debug('APME', `onSampleEvent listener threw: ${String(err)}`);
+            }
+        }
+    }
+    /** Reverse-lookup sessionId for a runId (best-effort; only the live map). */
+    runToSessionId(runId) {
+        for (const [sid, rid] of this.sessionToRun)
+            if (rid === runId)
+                return sid;
+        return '';
+    }
     /** Store Claude's response text on the current turn.
      *  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
@@ -298,10 +631,21 @@ export class ApmeCollector {
                 response: response.slice(0, 10_000),
                 efficiencyJson,
             });
+            if (turn)
+                turn.hasResponse = true;
         }
         catch (err) {
             debug('APME', `setTurnResponse failed: ${String(err)}`);
         }
+        // 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 },
+            });
+        }
     }
     /** Apply response to the last closed turn if it has no response yet.
      *  Used as fallback when Stop hook doesn't fire (PTY output capture). */
@@ -327,6 +671,14 @@ export class ApmeCollector {
             });
         }
         catch { /* ignore */ }
+        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 },
+            });
+        }
     }
     /** Single-entrypoint ingestion using the shared TelemetrySpan envelope.
      *
@@ -381,11 +733,27 @@ export class ApmeCollector {
                     this.splitRun(sessionId, a['agentdeck.cwd']);
                     return;
                 }
-                // Other boundary signals (todo_complete, session_end) are handled
-                // automatically: tool_result detects todo_complete, closeRun closes
-                // the current task with session_end. Adapters that emit those
-                // spans explicitly are no-ops here by design — preserving the
-                // single-source-of-truth for those transitions.
+                // Adapter-emitted boundaries (OpenClaw chat.aborted → 'manual',
+                // OpenClaw idle-gap timer → 'idle_gap') close the active task.
+                // `session_end` is intentionally excluded: closeRun fires that
+                // path itself, and a duplicate here would double-emit onTaskClosed.
+                if (signal === 'manual' || signal === 'idle_gap') {
+                    this.closeTask(sessionId, signal);
+                    return;
+                }
+                // `todo_complete` is a soft hint, not a boundary (see ingestHook
+                // TodoWrite handling) — record it in the trajectory without splitting
+                // the task. OpenCode's TodoWrite-all-completed routes here.
+                if (signal === 'todo_complete') {
+                    const task = this.sessionToTask.get(sessionId);
+                    const turnIndex = this.sessionToTurn.get(sessionId)?.index;
+                    if (task && turnIndex !== undefined) {
+                        this.appendSampleEvent({ taskId: task.id, runId: task.runId, turnIndex }, { kind: 'state', dedupCore: `todos_complete:${turnIndex}`, payloadObj: { state: 'todos_completed' } });
+                        this.fireTaskMilestone(sessionId, task.id, task.runId, turnIndex, null);
+                    }
+                    return;
+                }
+                debug('APME', `task_boundary span dropped: unknown signal=${signal ?? '<none>'}`);
                 return;
             }
             case 'session_meta': {
@@ -429,7 +797,10 @@ export class ApmeCollector {
         }
         catch { /* ignore */ }
     }
-    /** Update token / cost columns from the bridge's UsageTracker snapshot. */
+    /** Update token / cost columns from the bridge's UsageTracker snapshot.
+     *  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). */
     updateUsage(sessionId, snapshot) {
         if (!this.store.enabled)
             return;
@@ -444,6 +815,35 @@ export class ApmeCollector {
             });
         }
         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 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 }, {
+            kind: 'model', model: model ?? undefined, inputTokens: dIn, outputTokens: dOut,
+            costUsd: cost, latencyMs: 0, dedupCore: `${curIn}:${curOut}`,
+        });
+        try {
+            this.store.updateTask(task.id, {
+                modelId: model ?? undefined,
+                modelConfig: JSON.stringify({ modelId: model ?? 'unknown', provider: providerFor(model) }),
+            });
+            this.store.recomputeSampleCost(task.id);
+        }
+        catch { /* ignore */ }
     }
     /** Split the current run — closes the active run and opens a fresh one.
      *  Triggered on `/clear` or other context-reset events so each logical
@@ -500,6 +900,7 @@ export class ApmeCollector {
         this.sessionToRun.delete(sessionId);
         this.sessionToLastTurnId.delete(sessionId);
         this.runTaskCount.delete(runId);
+        this.sessionToUsage.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);
@@ -593,6 +994,21 @@ export class ApmeCollector {
 /** Extract the todos array from a TodoWrite PostToolUse payload. Returns null
  *  if the shape doesn't match (payload malformed, older CC versions). Accepts
  *  `tool_input.todos` (hook standard) and `todos` (legacy flat shape). */
+/** Canonicalize a hook event name to the PascalCase form `ingestHook` matches
+ *  on. Accepts the daemon's snake_case (`user_prompt_submit`, `tool_start`,
+ *  `tool_end`, `pre/post_tool_use`) and passes PascalCase / span aliases
+ *  (`tool_result`) through unchanged. Keeps segmentation working regardless of
+ *  which surface (managed bridge, daemon `/hooks/`, OTel span) drives it. */
+function normalizeHookEventName(event) {
+    switch (event) {
+        case 'user_prompt_submit': return 'UserPromptSubmit';
+        case 'tool_start':
+        case 'pre_tool_use': return 'PreToolUse';
+        case 'tool_end':
+        case 'post_tool_use': return 'PostToolUse';
+        default: return event;
+    }
+}
 function extractTodos(data) {
     const fromToolInput = data.tool_input?.todos;
     const fromFlat = data.todos;
@@ -615,6 +1031,37 @@ function extractTodos(data) {
     }
     return items;
 }
+/** Short stable hash for sample-event dedup keys (content-derived). */
+function hashCore(s) {
+    return createHash('sha1').update(s).digest('hex').slice(0, 16);
+}
+/** Best-effort tool-input extraction from a hook/span payload. Claude Code
+ *  hooks carry `tool_input`; spans pass the raw payload directly. Capped to
+ *  keep the trajectory row small. */
+function extractToolInput(data) {
+    const ti = data.tool_input ?? data.input ?? null;
+    return clampPayload(ti);
+}
+/** Best-effort tool-output extraction. Claude Code PostToolUse carries
+ *  `tool_response`; other sources use `output` / `result`. */
+function extractToolOutput(data) {
+    const out = data.tool_response ?? data.output ?? data.result;
+    return out === undefined ? undefined : clampPayload(out);
+}
+/** Trim large tool payloads so a single event row stays bounded (≤4KB JSON). */
+function clampPayload(v) {
+    if (v == null)
+        return v;
+    try {
+        const s = typeof v === 'string' ? v : JSON.stringify(v);
+        if (s.length <= 4_000)
+            return v;
+        return (typeof v === 'string' ? v : s).slice(0, 4_000) + '…';
+    }
+    catch {
+        return undefined;
+    }
+}
 function readGitHead(cwd) {
     if (!cwd)
         return null;