@thehammer/danx-session-telemetry 0.1.27 → 0.1.31

package/README.md

@@ -17,6 +17,10 @@ inside the MCP package.
   shape. Canonical home now; danxbot root's `src/types.ts` re-exports both
   names verbatim.
 - `tool-summary.ts` — human-readable summary builders the collector uses.
+- `subagent-live.ts` — `createSubagentLiveView` (DX-4508): per-sub-agent snapshots
+  (tokens, cost, tool calls, model, current activity, card) computed by the same
+  activity observer, ledger counter and pricing rule the dashboard's numbers come
+  from; streamed by `danx-dashboard-mcp subagents-live`.
 - `internal-logger.ts` — this package's own tiny logging shim (see its
   header for why it does not reuse root's `src/logger.ts`).
 - `index.ts` — the main entry (Node-only; imports `node:fs`/`node:path`/`node:os`).

package/dist/.source-hash

@@ -1 +1 @@
-46e2f294fe40d0bc967337a16d25bee3eeee3a6d9dae5af7ee213a4d519175f3
+ade91474df465c805cff25ba35ef8265728fbf4a6649e43ea3401b5812ed943c

package/dist/activity-observer.d.ts

@@ -37,7 +37,7 @@
  * | `lastActivityAt` | the timestamp of its latest `assistant` / `user` line |
  * | `effort` | its latest `assistant` line's top-level `effort` |
  * | `currentActivity` | its latest `tool_use` block, through {@link describeToolCall} |
- * | `briefIssueId` | the card id its brief (the root `user` line) opens with |
+ * | `briefIssueId` | the card its spawning `Agent` call names: the first card id in its `description` (redacted), else the first anywhere in its brief (the root `user` line) — see {@link firstIssueId} (DX-4508) |
  * | `finishedAt`, `endStatus` | the task notification Claude Code writes into the SPAWNER's transcript |
  *
  * Model, tokens, cost, tool-call count and the claimed card are NOT here: the
@@ -129,9 +129,11 @@ export declare function labelOf(value: unknown): string | null;
  */
 export declare function describeToolCall(name: string, input: Record<string, unknown>): string;
 /**
- * DX-4498 — the card id a brief opens with: the first token of its first non-empty line, when that token is shaped
- * like a card id (`DX-4498`, also `DX-4498:`). Worker briefs open with the card they are for; any other brief names
- * none. The server keeps it only when it names a real card of the team, so a plan ref (`PLAN-2`) never reaches a reader.
+ * DX-4508 — the first card-id-shaped token in a text (`DX-4498`, also `DX-4498:`, `(DX-4498)`), or null when it has
+ * none. A sub-agent's card is the one its spawning `Agent` call names: its `description` ("Review DX-4498 code gates")
+ * first, else its brief ("Quality gate for card DX-4421 ..."), where the first-word rule DX-4498 shipped missed most
+ * real briefs. Only the SHAPE is checked: the server keeps the id only when it is a real card of the team, so a plan ref
+ * (`PLAN-2`) or rule ref (`R-45`) never reaches a reader.
  */
-export declare function briefIssueId(brief: string): string | null;
+export declare function firstIssueId(text: string): string | null;
 export declare function createActivityObserver(deps: ActivityObserverDeps): ActivityObserver;

package/dist/activity-observer.js

@@ -37,7 +37,7 @@
  * | `lastActivityAt` | the timestamp of its latest `assistant` / `user` line |
  * | `effort` | its latest `assistant` line's top-level `effort` |
  * | `currentActivity` | its latest `tool_use` block, through {@link describeToolCall} |
- * | `briefIssueId` | the card id its brief (the root `user` line) opens with |
+ * | `briefIssueId` | the card its spawning `Agent` call names: the first card id in its `description` (redacted), else the first anywhere in its brief (the root `user` line) — see {@link firstIssueId} (DX-4508) |
  * | `finishedAt`, `endStatus` | the task notification Claude Code writes into the SPAWNER's transcript |
  *
  * Model, tokens, cost, tool-call count and the claimed card are NOT here: the
@@ -188,16 +188,19 @@ export function describeToolCall(name, input) {
     return text.length > CURRENT_ACTIVITY_MAX_CHARS ? `${text.slice(0, CURRENT_ACTIVITY_MAX_CHARS - 3)}...` : text;
 }
 /**
- * DX-4498 — the card id a brief opens with: the first token of its first non-empty line, when that token is shaped
- * like a card id (`DX-4498`, also `DX-4498:`). Worker briefs open with the card they are for; any other brief names
- * none. The server keeps it only when it names a real card of the team, so a plan ref (`PLAN-2`) never reaches a reader.
+ * DX-4508 — the first card-id-shaped token in a text (`DX-4498`, also `DX-4498:`, `(DX-4498)`), or null when it has
+ * none. A sub-agent's card is the one its spawning `Agent` call names: its `description` ("Review DX-4498 code gates")
+ * first, else its brief ("Quality gate for card DX-4421 ..."), where the first-word rule DX-4498 shipped missed most
+ * real briefs. Only the SHAPE is checked: the server keeps the id only when it is a real card of the team, so a plan ref
+ * (`PLAN-2`) or rule ref (`R-45`) never reaches a reader.
  */
-export function briefIssueId(brief) {
-    const firstLine = brief.split("\n").find((line) => line.trim() !== "");
-    if (firstLine === undefined)
-        return null;
-    const token = firstLine.trim().split(/\s+/)[0].replace(/[.,:;)]+$/, "");
-    return token.length <= ISSUE_ID_MAX_LENGTH && ISSUE_ID_PATTERN.test(token) ? token : null;
+export function firstIssueId(text) {
+    for (const token of text.split(/\s+/)) {
+        const bare = token.replace(WRAPPING_PUNCTUATION, "");
+        if (bare.length <= ISSUE_ID_MAX_LENGTH && ISSUE_ID_PATTERN.test(bare))
+            return bare;
+    }
+    return null;
 }
 /** The text of a `user` line's content: the string itself, or its first text block. */
 function userText(raw) {
@@ -276,6 +279,10 @@ export function createActivityObserver(deps) {
                 if (existing.description === null && description !== null) {
                     existing.description = description;
                     filled = true;
+                    // DX-4508 — the description outranks the brief: a late sidecar naming a card replaces a brief-derived id.
+                    const named = firstIssueId(description);
+                    if (named !== null && named !== existing.briefIssueId)
+                        existing.briefIssueId = named;
                 }
                 if (existing.parentActivityId === null && info.parentSource !== null) {
                     existing.parentActivityId = info.parentSource;
@@ -285,12 +292,13 @@ export function createActivityObserver(deps) {
                     report(existing);
                 return;
             }
+            // DX-4498 — the label its spawning `Agent` call gave it, from the sidecar, redacted like every label.
+            const description = labelOf(info.description);
             const change = {
                 kind: "agent",
                 activityId: info.source,
                 agentType: info.agentType,
-                // DX-4498 — the label its spawning `Agent` call gave it, from the sidecar, redacted like every label.
-                description: labelOf(info.description),
+                description,
                 startedAt: info.discoveredAt,
                 lastActivityAt: info.discoveredAt,
                 finishedAt: null,
@@ -298,7 +306,9 @@ export function createActivityObserver(deps) {
                 effort: null,
                 currentActivity: null,
                 endStatus: null,
-                briefIssueId: null,
+                // DX-4508 — the card the description names (the REDACTED label: the one way a label leaves a transcript); the
+                // brief fills it in only while this is still null.
+                briefIssueId: description === null ? null : firstIssueId(description),
             };
             const pending = pendingEnds.get(info.source);
             if (pending !== undefined) {
@@ -355,10 +365,10 @@ export function createActivityObserver(deps) {
             }
             if (raw.type === "user") {
                 // DX-4498 — the brief is the chain's root line (`parentUuid: null`), so a collector that resumes mid-file
-                // never mistakes a later prompt for it.
+                // never mistakes a later prompt for it. DX-4508 — read only while no card is known: a description's id wins.
                 if (change.briefIssueId === null && raw.parentUuid === null) {
                     const text = userText(raw);
-                    const id = text === null ? null : briefIssueId(text);
+                    const id = text === null ? null : firstIssueId(text);
                     if (id !== null) {
                         change.briefIssueId = id;
                         changed = true;

package/dist/claim-tracker.d.ts

@@ -1,5 +1,9 @@
-/** The one tool a sub-agent reaches the dashboard API through (the MCP server key is `danx-dashboard`). */
-export declare const DASHBOARD_API_TOOL_NAME = "mcp__danx-dashboard__danxbot_api";
+/** The `danxbot_api` tool of a dispatched worker's `danx-dashboard` server. */
+export declare const DISPATCH_API_TOOL_NAME = "mcp__danx-dashboard__danxbot_api";
+/** The `danxbot_api` tool of the danxbot plugin's server, which an operator session's sub-agent calls. */
+export declare const PLUGIN_API_TOOL_NAME = "mcp__plugin_danxbot_danx-dashboard__danxbot_api";
+/** Every tool name a sub-agent reaches the dashboard API through. */
+export declare const DASHBOARD_API_TOOL_NAMES: ReadonlySet<string>;
 /** A card id as the issue routes name it, e.g. `DX-3962`. Also the wire's validation for every card id a claim carries. */
 export declare const ISSUE_ID_PATTERN: RegExp;
 /** Longest card id a claim may carry (`dispatches.issue_id` is `VARCHAR(32)`). */

package/dist/claim-tracker.js

@@ -46,8 +46,14 @@
  * Pure bookkeeping — no `node:` imports, so it rides the browser-safe subpath too.
  */
 import { MAIN_SOURCE } from "./usage-ledger.js";
-/** The one tool a sub-agent reaches the dashboard API through (the MCP server key is `danx-dashboard`). */
-export const DASHBOARD_API_TOOL_NAME = "mcp__danx-dashboard__danxbot_api";
+// DX-4578: both names are live, neither a fallback. A dispatched worker's clean-room config names the server `danx-dashboard`; an operator
+// session's sub-agent reaches it through the danxbot plugin's server (`plugin:danxbot:danx-dashboard`, tools `mcp__plugin_danxbot_danx-dashboard__*`).
+/** The `danxbot_api` tool of a dispatched worker's `danx-dashboard` server. */
+export const DISPATCH_API_TOOL_NAME = "mcp__danx-dashboard__danxbot_api";
+/** The `danxbot_api` tool of the danxbot plugin's server, which an operator session's sub-agent calls. */
+export const PLUGIN_API_TOOL_NAME = "mcp__plugin_danxbot_danx-dashboard__danxbot_api";
+/** Every tool name a sub-agent reaches the dashboard API through. */
+export const DASHBOARD_API_TOOL_NAMES = new Set([DISPATCH_API_TOOL_NAME, PLUGIN_API_TOOL_NAME]);
 /** A card id as the issue routes name it, e.g. `DX-3962`. Also the wire's validation for every card id a claim carries. */
 export const ISSUE_ID_PATTERN = /^[A-Za-z][A-Za-z0-9]*-[0-9]+$/;
 /** Longest card id a claim may carry (`dispatches.issue_id` is `VARCHAR(32)`). */
@@ -102,7 +108,7 @@ function resultSucceeded(block) {
 }
 /** The transition a `tool_use` block asks for, or `null` when it is not a claim or release of a card. */
 function transitionOf(block) {
-    if (block.type !== "tool_use" || block.name !== DASHBOARD_API_TOOL_NAME)
+    if (block.type !== "tool_use" || typeof block.name !== "string" || !DASHBOARD_API_TOOL_NAMES.has(block.name))
         return null;
     const input = block.input;
     if (input === null || typeof input !== "object")

package/dist/index.d.ts

@@ -26,4 +26,5 @@ export * from "./stats-wire.js";
 export * from "./claim-tracker.js";
 export * from "./dispatch-usage.js";
 export * from "./activity-observer.js";
+export * from "./subagent-live.js";
 export * from "./write-queue.js";

package/dist/index.js

@@ -37,4 +37,6 @@ export * from "./stats-wire.js";
 export * from "./claim-tracker.js";
 export * from "./dispatch-usage.js";
 export * from "./activity-observer.js";
+// DX-4508 — the local live sub-agent view `danx-dashboard-mcp subagents-live` streams to the plugin pane.
+export * from "./subagent-live.js";
 export * from "./write-queue.js";

package/dist/pricing.d.ts

@@ -102,3 +102,16 @@ export type PriceResult = {
 export declare function priceUsage(model: string, speed: string, tokens: PricedTokens): PriceResult;
 /** True when `model` has a standard-speed price (used by tests + guards). */
 export declare function isPricedModel(model: string): boolean;
+/**
+ * DX-4508 — one ledger credit's cost, exactly as the server's usage-ledger writer stores it (moved here from
+ * `src/dashboard/usage-ledger.ts` so the live sub-agent view, `subagent-live.ts`, prices a reply with the SAME rule
+ * instead of a copy): a `<synthetic>` reply costs nothing and is never unpriced; a reply with no model is unpriced only
+ * when it carries tokens; any other model goes through {@link priceUsage}, an unpriced one costing 0 and naming itself.
+ */
+export declare function priceLedgerCredit(model: string | null, speed: string, tokens: PricedTokens): {
+    costUsd: number;
+    unpriced: {
+        model: string;
+        speed: string;
+    } | null;
+};

package/dist/pricing.js

@@ -170,3 +170,19 @@ export function isPricedModel(model) {
     // `Object.hasOwn` can't be fooled by it. See `priceUsage`'s own comment.
     return Object.hasOwn(PRICING, model);
 }
+/**
+ * DX-4508 — one ledger credit's cost, exactly as the server's usage-ledger writer stores it (moved here from
+ * `src/dashboard/usage-ledger.ts` so the live sub-agent view, `subagent-live.ts`, prices a reply with the SAME rule
+ * instead of a copy): a `<synthetic>` reply costs nothing and is never unpriced; a reply with no model is unpriced only
+ * when it carries tokens; any other model goes through {@link priceUsage}, an unpriced one costing 0 and naming itself.
+ */
+export function priceLedgerCredit(model, speed, tokens) {
+    if (model === SYNTHETIC_MODEL)
+        return { costUsd: 0, unpriced: null };
+    if (model === null) {
+        const zero = tokens.input === 0 && tokens.output === 0 && tokens.cacheRead === 0 && tokens.cacheWrite5m === 0 && tokens.cacheWrite1h === 0;
+        return zero ? { costUsd: 0, unpriced: null } : { costUsd: 0, unpriced: { model: "(none)", speed } };
+    }
+    const r = priceUsage(model, speed, tokens);
+    return r.kind === "priced" ? { costUsd: r.costUsd, unpriced: null } : { costUsd: 0, unpriced: { model: r.model, speed: r.speed } };
+}

package/dist/session-log-watcher.d.ts

@@ -127,6 +127,12 @@ export interface SessionLogWatcherOptions {
      * within it.
      */
     onSourceDiscovered?: (info: SourceDiscoveredInfo) => void;
+    /**
+     * DX-4508 — one poll (the main transcript, sub-agent discovery, then every sub-agent file) has finished handing its
+     * lines to subscribers. The live sub-agent view (`danx-dashboard-mcp subagents-live`) prints one line per poll from
+     * it, so a reader sees every change one poll made together. A throw is contained like every consumer's.
+     */
+    onPollComplete?: () => void;
 }
 /** DX-2954 — one source's stored cursor pair, as a collector starts from it. */
 export interface SourceCursorStart {
@@ -344,6 +350,7 @@ export declare class SessionLogWatcher {
     private readonly startExistingFilesAtEof;
     private readonly onCursorPastEof;
     private readonly onSourceDiscovered;
+    private readonly onPollComplete;
     private subagentDiscoveryDone;
     private running;
     private polling;

package/dist/session-log-watcher.js

@@ -495,6 +495,7 @@ export class SessionLogWatcher {
     startExistingFilesAtEof;
     onCursorPastEof;
     onSourceDiscovered;
+    onPollComplete;
     subagentDiscoveryDone = false;
     running = false;
     polling = false;
@@ -514,6 +515,7 @@ export class SessionLogWatcher {
         this.startExistingFilesAtEof = options.startExistingFilesAtEof ?? false;
         this.onCursorPastEof = options.onCursorPastEof;
         this.onSourceDiscovered = options.onSourceDiscovered;
+        this.onPollComplete = options.onPollComplete;
     }
     /**
      * DX-2954 — resolve one file's starting offset and replay boundary, per the
@@ -795,6 +797,13 @@ export class SessionLogWatcher {
         finally {
             this.polling = false;
         }
+        // DX-4508 — only a poll that ran to its end: a stop mid-poll returns above and reports nothing.
+        try {
+            this.onPollComplete?.();
+        }
+        catch (err) {
+            log.error("onPollComplete consumer error:", err);
+        }
     }
     /** Read any new bytes from `state.filePath` and emit resulting entries. */
     async pollFile(state) {

package/dist/stats-wire.d.ts

@@ -118,9 +118,11 @@ export interface ActivityChange {
     currentActivity: string | null;
     /** DX-4498 — how it ended, when an explicit end event named it; null while running and for an end that named none. */
     endStatus: ActivityEndStatus | null;
-    /** DX-4498 — the card id its brief opens with (`DX-4498
-  
-  ...`), or null when the brief names none. */
+    /**
+     * DX-4508 — the card its spawning `Agent` call names: the first card id in its (redacted) `description`, else the
+     * first anywhere in its brief; null when neither names one. The name stays `briefIssueId` (and the column
+     * `brief_issue_id`): renaming a required wire field would make every bridge already published fail the strict parser.
+     */
     briefIssueId: string | null;
 }
 /**

package/dist/stats-wire.js

@@ -122,8 +122,9 @@ export function collapseActivityChanges(changes) {
             // DX-4498 — COALESCE(incoming, stored): the latest explicit end status wins (a notification read after the session's
             // own close names how it really ended).
             endStatus: c.endStatus ?? prior.endStatus,
-            // DX-4498 — COALESCE(stored, incoming): the brief is the transcript's first line, read once.
-            briefIssueId: prior.briefIssueId ?? c.briefIssueId,
+            // DX-4508 — COALESCE(incoming, stored): the producer reports its best id and may improve it (a late sidecar's
+            // description outranks the brief); a null never erases one.
+            briefIssueId: c.briefIssueId ?? prior.briefIssueId,
         });
     }
     return [...byKey.values()];

package/dist/subagent-live.d.ts

@@ -0,0 +1,34 @@
+import type { EntryMeta, SourceDiscoveredInfo } from "./session-log-watcher.js";
+import type { ActivityEndStatus } from "./stats-wire.js";
+/** One sub-agent as the live view reports it. Every time is epoch ms. The plugin pane renders exactly this shape. */
+export interface SubagentLiveSnapshot {
+    /** `agent-<agentId>`: its transcript basename, the ledger source key and the dashboard row's activity id. */
+    id: string;
+    /** The sub-agent that spawned it, or null for one the session itself spawned. */
+    parentId: string | null;
+    description: string | null;
+    agentType: string | null;
+    /** Its newest reply's model, never `<synthetic>`; null before its first reply. */
+    model: string | null;
+    effort: string | null;
+    startedAt: number;
+    lastActivityAt: number;
+    finishedAt: number | null;
+    endStatus: ActivityEndStatus | null;
+    /** input + output + cacheRead + cacheWrite5m + cacheWrite1h, summed over its replies. */
+    tokensTotal: number;
+    costUsd: number;
+    toolCallCount: number;
+    currentActivity: string | null;
+    /** The card its spawning `Agent` call names (description first, then brief); shape-checked only. */
+    cardId: string | null;
+}
+export interface SubagentLiveView {
+    /** Wire to the watcher's `onSourceDiscovered`. */
+    onSourceDiscovered: (info: SourceDiscoveredInfo) => void;
+    /** Wire to the watcher's `onUsageLine` (the raw line feed, main transcript included: it carries task notifications). */
+    onLine: (raw: Record<string, unknown>, meta: EntryMeta) => void;
+    /** The snapshots that changed since the last call (each differs from the one last returned for it); clears the set. */
+    takeChanged: () => SubagentLiveSnapshot[];
+}
+export declare function createSubagentLiveView(): SubagentLiveView;

package/dist/subagent-live.js

@@ -0,0 +1,150 @@
+/**
+ * DX-4508 — a LOCAL live view of a session's sub-agents, for the plugin's plan pane.
+ *
+ * The pane shows one card per sub-agent: what it is, what it is doing, and what it has spent. Its dashboard path
+ * (`GET /api/plan-sessions/:id/subagents`) lags about 80s behind the transcript (the bridge's 5s poll, its 15s
+ * heartbeat flush, the pane's 60s read), so the same facts are also computed here, on the operator's own machine, from
+ * the transcript files themselves, and streamed by `danx-dashboard-mcp subagents-live` within a poll of being written.
+ *
+ * ## One place computes each number
+ *
+ * Nothing here counts or prices on its own. It consumes the SAME two watcher feeds the bridge wires
+ * (`onSourceDiscovered`, `onUsageLine`) into the SAME producers:
+ *
+ * | Snapshot field | Computed by | As the dashboard read derives it from |
+ * |---|---|---|
+ * | `description`, `agentType`, `parentId`, `effort`, `currentActivity`, `finishedAt`, `endStatus`, `cardId` | {@link createActivityObserver} (`cardId` is its `briefIssueId`) | the `dispatch_activities` row the same observer feeds |
+ * | `tokensTotal` | {@link UsageLedgerCounter} (per-reply per-field maximum) via {@link ledgerLineFromRaw} | `usage_by_source[<id>]`, all five fields summed |
+ * | `costUsd` | {@link priceLedgerCredit} over each reply | `usage_by_source[<id>].costUsd` (the ledger writer prices each credit with it) |
+ * | `toolCallCount` | the counter's distinct `tool_use` ids per reply | `SUM(cardinality(tool_use_ids))` |
+ * | `model` | the counter's newest reply whose model is not {@link SYNTHETIC_MODEL} | the newest non-synthetic `dispatch_message_usage.model` |
+ *
+ * Cost is priced per reply over the reply's whole usage, where the server prices each CREDIT (the excess a resend
+ * adds); pricing is linear, so the two agree whenever a reply keeps one model and speed, which Claude Code always writes.
+ *
+ * ## Where the live view differs from the observer's own stamps
+ *
+ * `startedAt` and `lastActivityAt` come from the sub-agent's own transcript lines (its first and newest `assistant` /
+ * `user` line). The observer stamps a start at the moment its watcher DISCOVERED the file, which is right for the bridge
+ * (its first discovery is the real start, and the server keeps the earliest), but this view reads every file from byte
+ * 0 each time it starts, so a discovery stamp would show every finished sub-agent as having started, and been active,
+ * just now. The discovery stamp is used only for a sub-agent that has written no line yet.
+ *
+ * ## Memory
+ *
+ * Per sub-agent: the observer's one small state record, and the counter's one small entry per reply. No transcript
+ * text is held; the watcher reads each file's new bytes and drops them once parsed.
+ */
+import { createActivityObserver } from "./activity-observer.js";
+import { SYNTHETIC_MODEL, priceLedgerCredit } from "./pricing.js";
+import { MAIN_SOURCE, UsageLedgerCounter, ledgerLineFromRaw, totalTokensOfUsage } from "./usage-ledger.js";
+/** The line's own timestamp in epoch ms, or null when it carries none that parses. */
+function lineTime(raw) {
+    if (typeof raw.timestamp !== "string")
+        return null;
+    const ms = Date.parse(raw.timestamp);
+    return Number.isNaN(ms) ? null : ms;
+}
+export function createSubagentLiveView() {
+    const sources = new Map();
+    const dirty = new Set();
+    const observer = createActivityObserver({
+        // The observer reports a source's FULL current state on every change.
+        recordActivities: (changes) => {
+            for (const change of changes) {
+                const state = sources.get(change.activityId);
+                if (state === undefined) {
+                    sources.set(change.activityId, {
+                        activity: change,
+                        counter: new UsageLedgerCounter(),
+                        firstLineAt: null,
+                        newestLineAt: null,
+                        lastSent: null,
+                    });
+                }
+                else {
+                    state.activity = change;
+                }
+                dirty.add(change.activityId);
+            }
+        },
+    });
+    const snapshot = (state) => {
+        let costUsd = 0;
+        let toolCallCount = 0;
+        let model = null;
+        let modelAt = -Infinity;
+        for (const entry of state.counter.all()) {
+            costUsd += priceLedgerCredit(entry.model, entry.speed, entry.usage).costUsd;
+            toolCallCount += entry.toolUseIds.length;
+            if (entry.model !== null && entry.model !== SYNTHETIC_MODEL && entry.repliedAt >= modelAt) {
+                model = entry.model;
+                modelAt = entry.repliedAt;
+            }
+        }
+        const a = state.activity;
+        const startedAt = state.firstLineAt ?? a.startedAt;
+        return {
+            id: a.activityId,
+            parentId: a.parentActivityId,
+            description: a.description,
+            agentType: a.agentType,
+            model,
+            effort: a.effort,
+            startedAt,
+            lastActivityAt: state.newestLineAt ?? startedAt,
+            finishedAt: a.finishedAt,
+            endStatus: a.endStatus,
+            tokensTotal: totalTokensOfUsage(state.counter.totals()),
+            costUsd,
+            toolCallCount,
+            currentActivity: a.currentActivity,
+            cardId: a.briefIssueId,
+        };
+    };
+    return {
+        onSourceDiscovered: observer.onSourceDiscovered,
+        onLine(raw, meta) {
+            // The observer first: it reads the main transcript's task notifications, and a line the ledger refuses (no
+            // timestamp) must not withhold them.
+            observer.onLine(raw, meta);
+            if (meta.source === MAIN_SOURCE)
+                return;
+            const state = sources.get(meta.source);
+            if (state === undefined)
+                return;
+            if (raw.type === "assistant" || raw.type === "user") {
+                const at = lineTime(raw);
+                if (at !== null) {
+                    if (state.firstLineAt === null || at < state.firstLineAt) {
+                        state.firstLineAt = at;
+                        dirty.add(meta.source);
+                    }
+                    if (state.newestLineAt === null || at > state.newestLineAt) {
+                        state.newestLineAt = at;
+                        dirty.add(meta.source);
+                    }
+                }
+            }
+            const line = ledgerLineFromRaw(raw, meta.source, meta.byteOffset);
+            if (line !== null && state.counter.observeLine(line))
+                dirty.add(meta.source);
+        },
+        takeChanged() {
+            const out = [];
+            for (const source of dirty) {
+                const state = sources.get(source);
+                if (state === undefined)
+                    continue;
+                const snap = snapshot(state);
+                const json = JSON.stringify(snap);
+                if (json === state.lastSent)
+                    continue;
+                state.lastSent = json;
+                out.push(snap);
+            }
+            dirty.clear();
+            return out;
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thehammer/danx-session-telemetry",
-  "version": "0.1.27",
+  "version": "0.1.31",
   "description": "Shared Claude Code transcript collector (DX-2962) — incremental JSONL tailing for the danxbot worker and the danx-dashboard-mcp desktop bridge, so both run identical collector code.",
   "license": "MIT",
   "type": "module",