@50arms/session-telemetry 0.0.0-stage → 0.1.66

package/dist/subagent-live.js

@@ -0,0 +1,153 @@
+/**
+ * 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 relay'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 `platform-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 relay 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 relay
+ * (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, REPORT_NO_COMPACTIONS, 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;
+}
+/** `priceOf` is the caller's declared prices (the package holds none, DX-5611): the SAME lookup the server prices a credit with. */
+export function createSubagentLiveView(priceOf) {
+    const sources = new Map();
+    const dirty = new Set();
+    // DX-5333: no `recordMessages`, so the observer's end-of-poll confirm (`onPollComplete`) of a held report has nothing to store and this
+    // view never forwards it; the observer's maps stay capped.
+    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, priceOf).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, REPORT_NO_COMPACTIONS);
+            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/dist/tool-summary.d.ts

@@ -0,0 +1,19 @@
+/**
+ * DX-2962: moved from danxbot root `src/agent/tool-summary.ts` unchanged —
+ * used only by `session-log-watcher.ts` in the root repo, so it moved
+ * wholesale rather than being duplicated or injected.
+ *
+ * Summarizes a tool's input into a short human-readable string.
+ */
+export declare function summarizeToolInput(name: string, input: Record<string, unknown>): string;
+export declare function truncStr(s: string, max: number): string;
+/**
+ * Builds a human-readable summary for an assistant message from its content blocks.
+ * Returns "Tools: Read(...), Bash(...)" for tool calls, or "Text: <preview>" for text-only.
+ */
+export declare function buildAssistantSummary(content: Record<string, unknown>[]): string;
+/**
+ * Builds a human-readable summary for a user message containing tool results.
+ * Returns "Tool results: toolu_01, toolu_02".
+ */
+export declare function buildToolResultSummary(content: Record<string, unknown>[]): string;

package/dist/tool-summary.js

@@ -0,0 +1,58 @@
+/**
+ * DX-2962: moved from danxbot root `src/agent/tool-summary.ts` unchanged —
+ * used only by `session-log-watcher.ts` in the root repo, so it moved
+ * wholesale rather than being duplicated or injected.
+ *
+ * Summarizes a tool's input into a short human-readable string.
+ */
+export function summarizeToolInput(name, input) {
+    switch (name) {
+        case "Read":
+            return truncStr(String(input.file_path || ""), 80);
+        case "Grep":
+            return truncStr(String(input.pattern || ""), 60);
+        case "Glob":
+            return truncStr(String(input.pattern || ""), 60);
+        case "Bash":
+            return truncStr(String(input.command || ""), 100);
+        default:
+            return "";
+    }
+}
+export function truncStr(s, max) {
+    return s.length > max ? s.slice(0, max) + "..." : s;
+}
+/**
+ * Builds a human-readable summary for an assistant message from its content blocks.
+ * Returns "Tools: Read(...), Bash(...)" for tool calls, or "Text: <preview>" for text-only.
+ */
+export function buildAssistantSummary(content) {
+    const toolUses = content.filter((b) => b.type === "tool_use");
+    const textBlocks = content.filter((b) => b.type === "text");
+    const toolNames = toolUses
+        .map((t) => {
+        const name = t.name || "unknown";
+        const input = (t.input ?? {});
+        const detail = summarizeToolInput(name, input);
+        return detail ? `${name}(${detail})` : name;
+    })
+        .join(", ");
+    const textPreview = textBlocks
+        .map((b) => b.text)
+        .join(" ")
+        .slice(0, 200);
+    return toolNames
+        ? `Tools: ${toolNames}`
+        : `Text: ${textPreview || "(empty)"}`;
+}
+/**
+ * Builds a human-readable summary for a user message containing tool results.
+ * Returns "Tool results: toolu_01, toolu_02".
+ */
+export function buildToolResultSummary(content) {
+    const toolResults = content.filter((r) => r.type === "tool_result");
+    const ids = toolResults
+        .map((r) => r.tool_use_id || "result")
+        .join(", ");
+    return `Tool results: ${ids}`;
+}

package/dist/transcript-timing.d.ts

@@ -0,0 +1,100 @@
+/**
+ * DX-3964 - the per-source reducer that turns a transcript's lines into each reply's
+ * API time, agent time and lines added/removed, exactly per the `## Definitions` DX-3975
+ * measured on 18 real transcripts. Pure arithmetic (no `node:` imports), so the
+ * browser-safe entry exports it too.
+ *
+ * One reducer per SOURCE (one transcript file). It is fed every assistant, user,
+ * attachment and system line of that file in FILE ORDER, and reports, per reply, values
+ * that only ever grow as lines are appended (max semantics), so the ledger's
+ * `excess = max - credited` makes a resend, resume or restart credit nothing twice.
+ *
+ *  - Never sort by timestamp: `hwm` (the largest timestamp seen) is a running maximum
+ *    and a line older than it yields a 0 gap and never moves it back.
+ *  - A reducer that starts mid-file anchors `hwm` on the first assistant or tool_result
+ *    line it sees (a stale queued attachment at a restart must not be a gap), and
+ *    credits only what it derived from lines in its own window.
+ */
+import type { CompactionBoundary, LedgerLine } from "./usage-ledger.js";
+import { type LedgerTiming } from "./ledger-timing.js";
+/** A single gap above this is a suspend or an unanswered prompt, never work. */
+export declare const MAX_CREDITED_GAP_MS = 600000;
+export interface TimingToolUse {
+    id: string;
+    name: string;
+    input: Record<string, unknown> | null;
+}
+export interface PatchHunk {
+    lines: readonly string[];
+}
+export interface TimingToolResult {
+    toolUseId: string;
+    isError: boolean;
+    /** The result's text (a string content, or its text blocks joined). */
+    text: string;
+    /** `toolUseResult.structuredPatch` of the line carrying exactly this one result; absent from sub-agent transcripts. */
+    structuredPatch: readonly PatchHunk[] | null;
+}
+/** One transcript line of the fed set (assistant, user, attachment, system), parsed. */
+export type TranscriptLine = {
+    kind: "assistant";
+    line: LedgerLine;
+    /** The counter's own key for the reply (`message.id`, or the synthetic per-offset key). */
+    replyKey: string;
+    byteOffset: number;
+    /** `message.model` is `<synthetic>` (API error text): it measures nothing. */
+    synthetic: boolean;
+    toolUses: readonly TimingToolUse[];
+} | {
+    kind: "user";
+    source: string;
+    timestamp: number;
+    byteOffset: number;
+    /** Empty for a human prompt (string content, an array with no tool_result, an `isMeta` line). */
+    results: readonly TimingToolResult[];
+    /**
+     * DX-4939 - the length in characters of the text of a compaction's summary, when this is the `isCompactSummary` line Claude Code
+     * writes right after a `compact_boundary`; `null` for every other user line.
+     */
+    compactSummaryChars: number | null;
+} | {
+    kind: "attachment" | "system";
+    source: string;
+    timestamp: number;
+    byteOffset: number;
+}
+/** DX-4922 - a `system` line whose subtype is `compact_boundary`; it feeds the timing reducer exactly as any system line does. */
+ | {
+    kind: "compaction";
+    source: string;
+    timestamp: number;
+    byteOffset: number;
+    boundary: CompactionBoundary;
+};
+export declare function timestampOf(t: TranscriptLine): number;
+export declare class SourceTimingReducer {
+    /** `null` until anchored. */
+    private hwm;
+    private candidates;
+    /** Gap time ending at an attachment or system line: owned by the next reply to start. */
+    private carried;
+    private readonly replies;
+    private readonly tools;
+    private readonly pendingEdits;
+    /** Feed one line; returns the current values of every reply it touched. */
+    feed(t: TranscriptLine): Map<string, LedgerTiming>;
+    private feedAssistant;
+    private feedUser;
+    /** `S`: the largest request-side timestamp since the previous assistant line, clamped to the reply's first line. */
+    private sendTimeFor;
+}
+/** Number of lines in `s` (a trailing newline does not start another line). */
+export declare function countLines(s: string): number;
+/**
+ * The line diff of one Edit's `old_string` against its `new_string`: split on newline, common prefix and suffix trimmed,
+ * then the longest common subsequence. Equals Claude Code's own `structuredPatch` on 908 of 916 measured Edits.
+ */
+export declare function lineDiffCounts(oldText: string, newText: string): {
+    added: number;
+    removed: number;
+};

package/dist/transcript-timing.js

@@ -0,0 +1,231 @@
+import { zeroTiming } from "./ledger-timing.js";
+/** A single gap above this is a suspend or an unanswered prompt, never work. */
+export const MAX_CREDITED_GAP_MS = 600_000;
+/** Tools whose result is a parent WAITING on a child that carries that time in its own source. */
+const WAITING_TOOLS = new Set(["Agent", "Task"]);
+export function timestampOf(t) {
+    return t.kind === "assistant" ? t.line.timestamp : t.timestamp;
+}
+function snapshot(r) {
+    if (r.synthetic)
+        return zeroTiming();
+    return {
+        apiMs: Math.max(0, r.lastTs - r.sendTime),
+        agentMs: r.agentMs,
+        linesAdded: r.linesAdded,
+        linesRemoved: r.linesRemoved,
+    };
+}
+export class SourceTimingReducer {
+    /** `null` until anchored. */
+    hwm = null;
+    candidates = [];
+    /** Gap time ending at an attachment or system line: owned by the next reply to start. */
+    carried = 0;
+    replies = new Map();
+    tools = new Map();
+    pendingEdits = new Map();
+    /** Feed one line; returns the current values of every reply it touched. */
+    feed(t) {
+        const touched = new Set();
+        const ts = timestampOf(t);
+        let gap = 0;
+        if (this.hwm === null) {
+            // A reducer that starts mid-file anchors on its first assistant or tool_result line; a fresh file's own
+            // first line (offset 0) anchors it too. Before the anchor nothing is credited and nothing is remembered.
+            const anchors = t.byteOffset === 0 || t.kind === "assistant" || (t.kind === "user" && t.results.length > 0);
+            if (!anchors)
+                return new Map();
+            this.hwm = ts;
+        }
+        else {
+            gap = Math.max(0, ts - this.hwm);
+            if (gap > MAX_CREDITED_GAP_MS)
+                gap = 0;
+            this.hwm = Math.max(this.hwm, ts);
+        }
+        switch (t.kind) {
+            case "assistant":
+                this.feedAssistant(t, ts, gap, touched);
+                break;
+            case "user":
+                this.feedUser(t, gap, touched);
+                this.candidates.push({ ts, attachment: false });
+                break;
+            case "attachment":
+                this.carried += gap;
+                this.candidates.push({ ts, attachment: true });
+                break;
+            case "system":
+            case "compaction":
+                this.carried += gap;
+                break;
+        }
+        const out = new Map();
+        for (const key of touched)
+            out.set(key, snapshot(this.replies.get(key)));
+        return out;
+    }
+    feedAssistant(t, ts, gap, touched) {
+        let reply = this.replies.get(t.replyKey);
+        if (!reply) {
+            reply = {
+                sendTime: this.sendTimeFor(ts),
+                lastTs: ts,
+                synthetic: t.synthetic,
+                agentMs: this.carried,
+                linesAdded: 0,
+                linesRemoved: 0,
+                settled: new Set(),
+            };
+            this.carried = 0;
+            this.replies.set(t.replyKey, reply);
+        }
+        reply.lastTs = Math.max(reply.lastTs, ts);
+        reply.agentMs += gap;
+        touched.add(t.replyKey);
+        // Request-send candidates are the lines AFTER the previous assistant line, so every assistant line resets them.
+        this.candidates = [];
+        for (const use of t.toolUses) {
+            this.tools.set(use.id, { replyKey: t.replyKey, name: use.name });
+            if ((use.name === "Edit" || use.name === "Write") && use.input !== null && !reply.settled.has(use.id)) {
+                this.pendingEdits.set(use.id, { replyKey: t.replyKey, name: use.name, input: use.input });
+            }
+        }
+    }
+    feedUser(t, gap, touched) {
+        if (t.results.length === 0)
+            return; // a human prompt: the gap ending here is user or idle time
+        const owner = this.tools.get(t.results[0].toolUseId);
+        // A gap ending at an Agent/Task result is a parent waiting on a child whose own source carries that time.
+        if (owner && !WAITING_TOOLS.has(owner.name)) {
+            const reply = this.replies.get(owner.replyKey);
+            if (reply) {
+                reply.agentMs += gap;
+                touched.add(owner.replyKey);
+            }
+        }
+        for (const result of t.results) {
+            const pending = this.pendingEdits.get(result.toolUseId);
+            if (!pending)
+                continue;
+            this.pendingEdits.delete(result.toolUseId);
+            const reply = this.replies.get(pending.replyKey);
+            if (!reply)
+                continue;
+            reply.settled.add(result.toolUseId);
+            if (result.isError)
+                continue;
+            const lines = linesOf(pending, result);
+            reply.linesAdded += lines.added;
+            reply.linesRemoved += lines.removed;
+            touched.add(pending.replyKey);
+        }
+    }
+    /** `S`: the largest request-side timestamp since the previous assistant line, clamped to the reply's first line. */
+    sendTimeFor(firstTs) {
+        let best = null;
+        for (const c of this.candidates) {
+            // A `deferred_tools_record` attachment is written AFTER the response starts.
+            if (c.attachment && c.ts >= firstTs)
+                continue;
+            if (best === null || c.ts > best)
+                best = c.ts;
+        }
+        return best === null ? firstTs : Math.min(firstTs, best);
+    }
+}
+/** Number of lines in `s` (a trailing newline does not start another line). */
+export function countLines(s) {
+    if (s === "")
+        return 0;
+    const n = s.split("\n").length;
+    return s.endsWith("\n") ? n - 1 : n;
+}
+function patchCounts(patch) {
+    let added = 0;
+    let removed = 0;
+    for (const hunk of patch) {
+        for (const line of hunk.lines) {
+            if (line.startsWith("+"))
+                added++;
+            else if (line.startsWith("-"))
+                removed++;
+        }
+    }
+    return { added, removed };
+}
+function splitLines(s) {
+    return s === "" ? [] : s.split("\n");
+}
+/** Myers' shortest edit script length (insertions + deletions) between two line lists. */
+function editDistance(a, b) {
+    const n = a.length;
+    const m = b.length;
+    const max = n + m;
+    if (max === 0)
+        return 0;
+    const off = max;
+    const v = new Int32Array(2 * max + 2);
+    for (let d = 0; d <= max; d++) {
+        for (let k = -d; k <= d; k += 2) {
+            let x;
+            if (k === -d || (k !== d && v[off + k - 1] < v[off + k + 1]))
+                x = v[off + k + 1];
+            else
+                x = v[off + k - 1] + 1;
+            let y = x - k;
+            while (x < n && y < m && a[x] === b[y]) {
+                x++;
+                y++;
+            }
+            v[off + k] = x;
+            if (x >= n && y >= m)
+                return d;
+        }
+    }
+    throw new Error("editDistance: unreachable, the edit script is at most n + m long");
+}
+/**
+ * The line diff of one Edit's `old_string` against its `new_string`: split on newline, common prefix and suffix trimmed,
+ * then the longest common subsequence. Equals Claude Code's own `structuredPatch` on 908 of 916 measured Edits.
+ */
+export function lineDiffCounts(oldText, newText) {
+    const a = splitLines(oldText);
+    const b = splitLines(newText);
+    let start = 0;
+    while (start < a.length && start < b.length && a[start] === b[start])
+        start++;
+    let endA = a.length;
+    let endB = b.length;
+    while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+        endA--;
+        endB--;
+    }
+    const ta = a.slice(start, endA);
+    const tb = b.slice(start, endB);
+    const d = editDistance(ta, tb);
+    const lcs = (ta.length + tb.length - d) / 2;
+    return { added: tb.length - lcs, removed: ta.length - lcs };
+}
+function stringInput(input, key) {
+    const v = input[key];
+    return typeof v === "string" ? v : "";
+}
+/** The lines one successful Edit or Write result credits. Any other tool never reaches here. */
+function linesOf(pending, result) {
+    if (pending.name === "Edit") {
+        if (pending.input.replace_all === true && result.structuredPatch !== null) {
+            return patchCounts(result.structuredPatch);
+        }
+        return lineDiffCounts(stringInput(pending.input, "old_string"), stringInput(pending.input, "new_string"));
+    }
+    if (result.text.includes("File created successfully")) {
+        return { added: countLines(stringInput(pending.input, "content")), removed: 0 };
+    }
+    // An overwrite: the previous content is not in the input, so only a patch (main and worker transcripts) can say.
+    if (result.text.includes("has been updated successfully") && result.structuredPatch !== null) {
+        return patchCounts(result.structuredPatch);
+    }
+    return { added: 0, removed: 0 };
+}

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * DX-2962: moved from danxbot root `src/types.ts` — this package is the
+ * canonical source now. Root `src/types.ts` re-exports these two names
+ * verbatim so every existing root import (`from "../types.js"` /
+ * `from "./types.js"`) keeps working unchanged (Core Principle 1 — single
+ * canonical schema, one home).
+ */
+export interface AgentLogEntry {
+    timestamp: number;
+    type: string;
+    subtype?: string;
+    summary: string;
+    data: Record<string, unknown>;
+}
+/**
+ * Sub-agent lineage carried on AgentLogEntry.data (and propagated into every
+ * emitted EventPayload.data) so gpt-manager can attribute usage to the
+ * originating sub-agent within the same dispatch. Set by SessionLogWatcher for
+ * entries read from `<parent-session>/subagents/*.jsonl`; absent on parent entries.
+ */
+export interface AgentLineage {
+    subagent_id: string;
+    parent_session_id: string | null;
+    agent_type: string | undefined;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};