@thehammer/danx-session-telemetry 0.1.26 → 0.1.29

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 @@
-3ffba7fcfab27ba33e21879f9c097dc9eaafaf4a688857098edbd721e2f81300
+2f856d47ffedab1236ae8ab337dfdd4c37c3d578a819f50ffee9f8603865c721

package/dist/activity-observer.d.ts

@@ -33,11 +33,11 @@
  *
  * | Field | Read from |
  * |---|---|
- * | `agentType`, `description`, `parentActivityId` | the sub-agent's `meta.json` sidecar (via `SourceDiscoveredInfo`) |
+ * | `agentType`, `description`, `parentActivityId` | the sub-agent's `meta.json` sidecar (via `SourceDiscoveredInfo`); the description through {@link redactLabel} |
  * | `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
@@ -111,17 +111,29 @@ export declare function parseTaskNotification(raw: Record<string, unknown>): {
     taskId: string;
     endStatus: ActivityEndStatus;
 } | null;
+/**
+ * DX-4498 — an agent-written label as the stats wire may carry it: on one line, with every path-shaped token (any token
+ * holding a `/` or `\`) read as `[path]`, and every secret-shaped token (an `ENV_NAME=value` value, or an opaque run of
+ * 20+ letters and digits such as a key, token or full SHA) read as `[redacted]`. A label is free text the agent wrote
+ * for a person to read (real shell descriptions name absolute paths), and it reaches every reader of the team, so this
+ * is the one way any label leaves a transcript. Empty for a blank label.
+ */
+export declare function redactLabel(label: string): string;
+/** DX-4498 — a transcript value read as a label: {@link redactLabel}'s text, or null for a non-string or blank one. */
+export declare function labelOf(value: unknown): string | null;
 /**
  * DX-4498 — a sub-agent's current activity, from one `tool_use` block: the tool's name, plus a label only where the
  * agent wrote one AS a label (a shell call's `description`, an `Agent` call's `description`, a `Skill` call's skill
- * name). Never a command, a file path or a prompt: the stats wire carries ids, numbers and labels, never free-form
- * transcript content.
+ * name), through {@link labelOf}. Never a command, a file path, a secret or a prompt: the stats wire carries ids,
+ * numbers and redacted labels, never free-form transcript content.
  */
 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

@@ -33,11 +33,11 @@
  *
  * | Field | Read from |
  * |---|---|
- * | `agentType`, `description`, `parentActivityId` | the sub-agent's `meta.json` sidecar (via `SourceDiscoveredInfo`) |
+ * | `agentType`, `description`, `parentActivityId` | the sub-agent's `meta.json` sidecar (via `SourceDiscoveredInfo`); the description through {@link redactLabel} |
  * | `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
@@ -122,40 +122,85 @@ export function parseTaskNotification(raw) {
     const endStatus = NOTIFICATION_END_STATUS[match[2].trim()];
     return endStatus === undefined ? null : { taskId: match[1].trim(), endStatus };
 }
+/** DX-4498 — what {@link redactLabel} puts in place of a path-shaped token. */
+const REDACTED_PATH = "[path]";
+/** DX-4498 — what {@link redactLabel} puts in place of a secret-shaped token, or an assignment's value. */
+const REDACTED_SECRET = "[redacted]";
+/** An `ENV_NAME=value` token: its value may be a credential. */
+const ASSIGNMENT_TOKEN = /^([A-Za-z_][A-Za-z0-9_]*)=.+$/;
+/** The characters a key, token, hash or id is written in. */
+const OPAQUE_TOKEN = /^[A-Za-z0-9_+.-]+$/;
+/** The shortest opaque run of letters and digits treated as a key, token, hash or id (a card id or short SHA is far shorter). */
+const OPAQUE_TOKEN_MIN_CHARS = 20;
+/** Punctuation a token may be wrapped in, which never stops it from being read as opaque. */
+const WRAPPING_PUNCTUATION = /^[("'`[]+|[)"'`\],.:;!?]+$/g;
+function redactToken(token) {
+    if (/[\\/]/.test(token))
+        return REDACTED_PATH;
+    const assignment = ASSIGNMENT_TOKEN.exec(token);
+    if (assignment !== null)
+        return `${assignment[1]}=${REDACTED_SECRET}`;
+    const bare = token.replace(WRAPPING_PUNCTUATION, "");
+    const opaque = bare.length >= OPAQUE_TOKEN_MIN_CHARS && OPAQUE_TOKEN.test(bare) && /[0-9]/.test(bare) && /[A-Za-z]/.test(bare);
+    return opaque ? REDACTED_SECRET : token;
+}
+/**
+ * DX-4498 — an agent-written label as the stats wire may carry it: on one line, with every path-shaped token (any token
+ * holding a `/` or `\`) read as `[path]`, and every secret-shaped token (an `ENV_NAME=value` value, or an opaque run of
+ * 20+ letters and digits such as a key, token or full SHA) read as `[redacted]`. A label is free text the agent wrote
+ * for a person to read (real shell descriptions name absolute paths), and it reaches every reader of the team, so this
+ * is the one way any label leaves a transcript. Empty for a blank label.
+ */
+export function redactLabel(label) {
+    return label
+        .split(/\s+/)
+        .filter((token) => token !== "")
+        .map(redactToken)
+        .join(" ");
+}
+/** DX-4498 — a transcript value read as a label: {@link redactLabel}'s text, or null for a non-string or blank one. */
+export function labelOf(value) {
+    if (typeof value !== "string")
+        return null;
+    const label = redactLabel(value);
+    return label === "" ? null : label;
+}
 /**
  * DX-4498 — a sub-agent's current activity, from one `tool_use` block: the tool's name, plus a label only where the
  * agent wrote one AS a label (a shell call's `description`, an `Agent` call's `description`, a `Skill` call's skill
- * name). Never a command, a file path or a prompt: the stats wire carries ids, numbers and labels, never free-form
- * transcript content.
+ * name), through {@link labelOf}. Never a command, a file path, a secret or a prompt: the stats wire carries ids,
+ * numbers and redacted labels, never free-form transcript content.
  */
 export function describeToolCall(name, input) {
-    const label = (v) => (typeof v === "string" && v.trim() !== "" ? v.trim() : null);
     let detail = null;
     switch (name) {
         case "Bash":
         case "PowerShell":
         case "Agent":
         case "Task":
-            detail = label(input.description);
+            detail = labelOf(input.description);
             break;
         case "Skill":
-            detail = label(input.skill);
+            detail = labelOf(input.skill);
             break;
     }
-    const text = (detail === null ? name : `${name}: ${detail}`).replace(/\s+/g, " ");
+    const text = detail === null ? name : `${name}: ${detail}`;
     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) {
@@ -230,9 +275,14 @@ export function createActivityObserver(deps) {
                     existing.agentType = info.agentType;
                     filled = true;
                 }
-                if (existing.description === null && info.description !== null) {
-                    existing.description = info.description;
+                const description = labelOf(info.description);
+                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;
@@ -242,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.
-                description: info.description,
+                description,
                 startedAt: info.discoveredAt,
                 lastActivityAt: info.discoveredAt,
                 finishedAt: null,
@@ -255,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) {
@@ -312,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/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.26",
+  "version": "0.1.29",
   "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",