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

package/dist/git-head.js

@@ -0,0 +1,19 @@
+/**
+ * DX-5333 - `git rev-parse HEAD` in a directory, for the activity observer's start commit.
+ *
+ * Returns the full object id git prints, or null when the directory is not a git checkout, does not exist, or git cannot be run
+ * (not installed, timed out). A null is a true "not known": the observer then tries the sub-agent's next working directory, and
+ * the replay that wants the commit is told there is none.
+ */
+import { execFile } from "node:child_process";
+import { GIT_OBJECT_ID } from "./stats-wire.js";
+/** A checkout that takes longer than this to answer `rev-parse` is not read. */
+const GIT_HEAD_TIMEOUT_MS = 5_000;
+export function readGitHead(cwd) {
+    return new Promise((resolve) => {
+        execFile("git", ["-C", cwd, "rev-parse", "HEAD"], { encoding: "utf8", timeout: GIT_HEAD_TIMEOUT_MS, windowsHide: true }, (error, stdout) => {
+            const out = error === null ? stdout.trim() : "";
+            resolve(GIT_OBJECT_ID.test(out) ? out : null);
+        });
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * DX-2962 — `@50arms/session-telemetry` main entry point.
+ *
+ * The shared Claude Code transcript collector: incremental tailing of the
+ * main and sub-agent JSONL transcripts, with no whole-transcript buffer
+ * (small per-reply bookkeeping only, kept in memory for the life of the
+ * process — see `session-log-watcher.ts`'s header). Consumed by the
+ * danxbot worker (Node, workspace-linked — see the README) and, from
+ * DX-2954, the `platform-mcp` MCP server's plan event relay (Node, npm-installed at
+ * a pinned exact version).
+ *
+ * A browser-safe subset with NO `node:` imports lives at the `./browser`
+ * subpath (see `browser.ts`) for consumers that cannot import Node builtins
+ * — the dashboard server, the dashboard SPA, and any future browser-side
+ * usage display.
+ */
+export { SessionLogWatcher, DISPATCH_TAG_PREFIX, encodeClaudeProjectsCwd, deriveSessionDir, sessionUuidExistsInCleanRoom, findNewestJsonlFile, findSessionFileByDispatchId, convertJsonlEntry, skipReplays, } from "./session-log-watcher.js";
+export type { EntryConsumer, UsageLineConsumer, SessionLogWatcherOptions, SourceCursorStart, CursorPastEofInfo, SourceDiscoveredInfo, EntryMeta, } from "./session-log-watcher.js";
+export type { AgentLogEntry, AgentLineage } from "./types.js";
+export { truncStr, summarizeToolInput, buildAssistantSummary, buildToolResultSummary, } from "./tool-summary.js";
+export * from "./usage-ledger.js";
+export * from "./real-work.js";
+export * from "./ledger-timing.js";
+export * from "./transcript-timing.js";
+export * from "./pricing.js";
+export * from "./catalog-prices.js";
+export * from "./stats-wire.js";
+export * from "./api-tool-names.js";
+export * from "./claim-tracker.js";
+export * from "./dispatch-usage.js";
+export * from "./activity-observer.js";
+export * from "./git-head.js";
+export * from "./subagent-live.js";
+export * from "./write-queue.js";
+export * from "./session-title-marks.js";

package/dist/index.js

@@ -0,0 +1,49 @@
+/**
+ * DX-2962 — `@50arms/session-telemetry` main entry point.
+ *
+ * The shared Claude Code transcript collector: incremental tailing of the
+ * main and sub-agent JSONL transcripts, with no whole-transcript buffer
+ * (small per-reply bookkeeping only, kept in memory for the life of the
+ * process — see `session-log-watcher.ts`'s header). Consumed by the
+ * danxbot worker (Node, workspace-linked — see the README) and, from
+ * DX-2954, the `platform-mcp` MCP server's plan event relay (Node, npm-installed at
+ * a pinned exact version).
+ *
+ * A browser-safe subset with NO `node:` imports lives at the `./browser`
+ * subpath (see `browser.ts`) for consumers that cannot import Node builtins
+ * — the dashboard server, the dashboard SPA, and any future browser-side
+ * usage display.
+ */
+export { SessionLogWatcher, DISPATCH_TAG_PREFIX, encodeClaudeProjectsCwd, deriveSessionDir, sessionUuidExistsInCleanRoom, findNewestJsonlFile, findSessionFileByDispatchId, convertJsonlEntry, skipReplays, } from "./session-log-watcher.js";
+// `truncStr` is a generic, dependency-free string helper that moved here
+// alongside the rest of `tool-summary.ts` (it has no other home now that
+// file is gone from root) — re-exported for danxbot root consumers that
+// truncate a string for display but have nothing else to do with the
+// transcript collector, e.g. `src/dashboard/dispatch-scout.ts`.
+export { truncStr, summarizeToolInput, buildAssistantSummary, buildToolResultSummary, } from "./tool-summary.js";
+// DX-2963 — the one usage counter and the one pricing function (also on the
+// browser-safe `./browser` subpath; both are pure arithmetic).
+export * from "./usage-ledger.js";
+export * from "./real-work.js";
+export * from "./ledger-timing.js";
+export * from "./transcript-timing.js";
+export * from "./pricing.js";
+export * from "./catalog-prices.js";
+// DX-2954 — the ONE stats collector and its wire, shared by the danxbot worker
+// and the MCP server's relay (operator sessions) so both report the same stats the
+// same way (epic DX-2958): the stats payload/response schema and its strict
+// parser, the collector that ships ledger entries + transcript cursors +
+// running-set changes, the transcript-side running-set producer, and the FIFO
+// that orders a dispatch's writes.
+export * from "./stats-wire.js";
+export * from "./api-tool-names.js";
+export * from "./claim-tracker.js";
+export * from "./dispatch-usage.js";
+export * from "./activity-observer.js";
+// DX-5333 — the start commit a sub-agent's activity row records.
+export * from "./git-head.js";
+// DX-4508 — the local live sub-agent view `platform-mcp subagents-live` streams to the plugin pane.
+export * from "./subagent-live.js";
+export * from "./write-queue.js";
+// DX-6078 - the one list of the 50arms plugin's session-title marks, stripped by the MCP's title reader and by the dashboard's title writes.
+export * from "./session-title-marks.js";

package/dist/internal-logger.d.ts

@@ -0,0 +1,16 @@
+/**
+ * DX-2962: minimal package-local logging shim. The collector previously
+ * imported danxbot root's `src/logger.ts` (`createLogger`), but that file
+ * is root-repo-only and this package must never reach back into the root
+ * repo (see the package README "Isolation"). `createLogger`'s own
+ * consumers span ~300+ unrelated root files, so it is not something this
+ * extraction "moves" — only the three log levels the collector actually
+ * calls (`info`/`warn`/`error`) are reproduced here, deliberately smaller
+ * than the root abstraction it replaces for this package's own use.
+ */
+export interface Logger {
+    info(message: string): void;
+    warn(message: string, error?: unknown): void;
+    error(message: string, error?: unknown): void;
+}
+export declare function createLogger(component: string): Logger;

package/dist/internal-logger.js

@@ -0,0 +1,27 @@
+function emit(level, component, message, error) {
+    const entry = {
+        timestamp: new Date().toISOString(),
+        level,
+        component,
+        message,
+    };
+    if (error instanceof Error) {
+        entry.error = error.message;
+        entry.stack = error.stack;
+    }
+    else if (error !== undefined) {
+        entry.error = String(error);
+    }
+    // DX-2954 — every level goes to STDERR. The MCP server's
+    // relay and the `subagents-live` subcommand run this collector; the subcommand's STDOUT is a protocol
+    // channel the plugin parses (and the MCP server's is JSON-RPC), so a log line there
+    // would corrupt it. The worker captures both streams.
+    console.error(JSON.stringify(entry));
+}
+export function createLogger(component) {
+    return {
+        info: (message) => emit("info", component, message),
+        warn: (message, error) => emit("warn", component, message, error),
+        error: (message, error) => emit("error", component, message, error),
+    };
+}

package/dist/ledger-timing.d.ts

@@ -0,0 +1,26 @@
+/**
+ * DX-3964 - one reply's measured time and code churn. Its own block on
+ * {@link LedgerEntry}, never part of {@link LedgerUsage}: `LedgerUsage` is the
+ * priced token set that `LEDGER_USAGE_FIELDS` iterates into pricing, per-model
+ * buckets and the worker's token estimate, and none of those may see these.
+ * Every field only GROWS as the reply's lines (and the tool results that settle
+ * them) are read, so the ledger's `excess = max - credited` makes a replay credit
+ * nothing twice.
+ */
+export interface LedgerTiming {
+    /** Request sent to the reply's last block written, ms (`## Definitions` on DX-3964). */
+    apiMs: number;
+    /** Credited gaps in the source's own timeline owned by this reply, ms. */
+    agentMs: number;
+    /** Lines the reply's successful Edit/Write calls added. */
+    linesAdded: number;
+    /** Lines the reply's successful Edit/Write calls removed. */
+    linesRemoved: number;
+}
+export declare const LEDGER_TIMING_FIELDS: readonly ["apiMs", "agentMs", "linesAdded", "linesRemoved"];
+export declare function zeroTiming(): LedgerTiming;
+export declare function maxTiming(a: LedgerTiming, b: LedgerTiming): LedgerTiming;
+export declare function addTiming(a: LedgerTiming, b: LedgerTiming): LedgerTiming;
+/** Per-field `max(0, a - b)`. */
+export declare function excessTiming(a: LedgerTiming, b: LedgerTiming): LedgerTiming;
+export declare function isZeroTiming(t: LedgerTiming): boolean;

package/dist/ledger-timing.js

@@ -0,0 +1,31 @@
+export const LEDGER_TIMING_FIELDS = [
+    "apiMs",
+    "agentMs",
+    "linesAdded",
+    "linesRemoved",
+];
+export function zeroTiming() {
+    return { apiMs: 0, agentMs: 0, linesAdded: 0, linesRemoved: 0 };
+}
+export function maxTiming(a, b) {
+    const out = zeroTiming();
+    for (const f of LEDGER_TIMING_FIELDS)
+        out[f] = Math.max(a[f], b[f]);
+    return out;
+}
+export function addTiming(a, b) {
+    const out = zeroTiming();
+    for (const f of LEDGER_TIMING_FIELDS)
+        out[f] = a[f] + b[f];
+    return out;
+}
+/** Per-field `max(0, a - b)`. */
+export function excessTiming(a, b) {
+    const out = zeroTiming();
+    for (const f of LEDGER_TIMING_FIELDS)
+        out[f] = Math.max(0, a[f] - b[f]);
+    return out;
+}
+export function isZeroTiming(t) {
+    return LEDGER_TIMING_FIELDS.every((f) => t[f] === 0);
+}

package/dist/pricing.d.ts

@@ -0,0 +1,93 @@
+/**
+ * DX-2963 - the ONE pricing function, shared by every consumer that turns token counts into dollars: the danxbot server's usage-ledger
+ * writer (which prices each credit once, when it is credited), the router's Haiku calls, the bench and the live sub-agent view. Exported
+ * through the browser-safe `./browser` subpath (pure arithmetic, no `node:` imports).
+ *
+ * DX-5611 (PLAN-53 G-3) - this package holds NO prices. Every function takes the price lookup of its caller, built from the dashboard's
+ * model-version catalog (`model_versions` / `model_version_prices`), so a price Anthropic changes reaches every consumer the day the catalog
+ * declares it. A model id the lookup has no price for is never silently $0: `priceUsage` returns `unpriced`, and the ledger writer records
+ * a visible `unpriced_model` dispatch event for it.
+ *
+ * DX-2963 - cache writes are TWO prices, never one: a 5-minute write is 1.25x base input and a 1-hour write is 2x base input. Claude Code
+ * reports each lifetime separately (`usage.cache_creation.ephemeral_5m_input_tokens` / `ephemeral_1h_input_tokens`), and both are material,
+ * so each field is priced with its own price.
+ */
+/** Price per MILLION tokens, USD. */
+export interface ModelPrice {
+    input: number;
+    output: number;
+    cacheWrite5m: number;
+    cacheWrite1h: number;
+    cacheRead: number;
+}
+/** Token counts for one priced unit (a ledger credit, a model bucket, a call). */
+export interface PricedTokens {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite5m: number;
+    cacheWrite1h: number;
+}
+/**
+ * Claude Code's literal model tag on an API-error entry (rate limit, context
+ * overflow). Its tokens count in a dispatch's flat totals but it is never a
+ * real priced model, so it never enters `usage_by_model` or cost.
+ */
+export declare const SYNTHETIC_MODEL = "<synthetic>";
+/** What a model costs at a speed, per million tokens; `null` when there is no price. */
+export type PriceLookup = (model: string, speed: string) => ModelPrice | null;
+/**
+ * DX-4867 - the rate cards of a model at a speed: its standard card, and the second card a reply whose prompt (input + cache reads + cache
+ * writes) is longer than `aboveTokens` is billed at, for the models that have one.
+ */
+export interface PriceCards {
+    standard: ModelPrice;
+    longPrompt: {
+        aboveTokens: number;
+        price: ModelPrice;
+    } | null;
+}
+/** What a model's rate cards are at a speed; `null` when the model has no price at that speed. */
+export type PriceCardLookup = (model: string, speed: string) => PriceCards | null;
+export type PriceResult = {
+    kind: "priced";
+    costUsd: number;
+} | {
+    kind: "unpriced";
+    model: string;
+    speed: string;
+};
+/**
+ * Price one unit of usage with `priceOf`. NEVER throws (DX-2963): a model, or a fast reply on a model with no fast price, that `priceOf`
+ * does not know returns `{kind: "unpriced"}` so the caller counts the tokens, leaves the cost out and records a visible `unpriced_model`
+ * event, instead of one new model id failing every write. `<synthetic>` is never passed here: callers exclude it before pricing.
+ */
+export declare function priceUsage(model: string, speed: string, tokens: PricedTokens, priceOf: PriceLookup): PriceResult;
+/** The prompt tokens of one reply: everything it sent in, cached or not. */
+export declare function promptTokensOf(tokens: PricedTokens): number;
+/** DX-4867 - whether a reply's prompt is long enough for the long-prompt card of `cards` (a model with one card never switches). */
+export declare function usesLongPromptCard(cards: PriceCards, tokens: PricedTokens): boolean;
+/**
+ * DX-4867 - price ONE reply (not a bucket of replies): like {@link priceUsage}, but a reply whose prompt is longer than the model's
+ * long-prompt threshold is charged its long-prompt card. A model with one rate card prices exactly as `priceUsage` does.
+ */
+export declare function priceReplyUsage(model: string, speed: string, tokens: PricedTokens, cardsOf: PriceCardLookup): PriceResult;
+/**
+ * DX-4595 - dollars for `tokens` at `price` (USD per million tokens): each bucket with its own price. The ONE copy of the formula: `priceUsage`
+ * charges the declared price with it, and spend pacing charges an account's own (editable) prices with it.
+ */
+export declare function costOfTokens(tokens: PricedTokens, price: ModelPrice): number;
+/**
+ * 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 is priced by `priceOf` (so as {@link priceUsage} does), an unpriced
+ * one costing 0 and naming itself. DX-4595: spend pacing passes an account's own prices as `priceOf` and so gets the same rule.
+ */
+export declare function priceLedgerCredit(model: string | null, speed: string, tokens: PricedTokens, priceOf: PriceLookup): {
+    costUsd: number;
+    unpriced: {
+        model: string;
+        speed: string;
+    } | null;
+};

package/dist/pricing.js

@@ -0,0 +1,77 @@
+/**
+ * DX-2963 - the ONE pricing function, shared by every consumer that turns token counts into dollars: the danxbot server's usage-ledger
+ * writer (which prices each credit once, when it is credited), the router's Haiku calls, the bench and the live sub-agent view. Exported
+ * through the browser-safe `./browser` subpath (pure arithmetic, no `node:` imports).
+ *
+ * DX-5611 (PLAN-53 G-3) - this package holds NO prices. Every function takes the price lookup of its caller, built from the dashboard's
+ * model-version catalog (`model_versions` / `model_version_prices`), so a price Anthropic changes reaches every consumer the day the catalog
+ * declares it. A model id the lookup has no price for is never silently $0: `priceUsage` returns `unpriced`, and the ledger writer records
+ * a visible `unpriced_model` dispatch event for it.
+ *
+ * DX-2963 - cache writes are TWO prices, never one: a 5-minute write is 1.25x base input and a 1-hour write is 2x base input. Claude Code
+ * reports each lifetime separately (`usage.cache_creation.ephemeral_5m_input_tokens` / `ephemeral_1h_input_tokens`), and both are material,
+ * so each field is priced with its own price.
+ */
+/**
+ * Claude Code's literal model tag on an API-error entry (rate limit, context
+ * overflow). Its tokens count in a dispatch's flat totals but it is never a
+ * real priced model, so it never enters `usage_by_model` or cost.
+ */
+export const SYNTHETIC_MODEL = "<synthetic>";
+/**
+ * Price one unit of usage with `priceOf`. NEVER throws (DX-2963): a model, or a fast reply on a model with no fast price, that `priceOf`
+ * does not know returns `{kind: "unpriced"}` so the caller counts the tokens, leaves the cost out and records a visible `unpriced_model`
+ * event, instead of one new model id failing every write. `<synthetic>` is never passed here: callers exclude it before pricing.
+ */
+export function priceUsage(model, speed, tokens, priceOf) {
+    const price = priceOf(model, speed);
+    return price === null ? { kind: "unpriced", model, speed } : { kind: "priced", costUsd: costOfTokens(tokens, price) };
+}
+/** The prompt tokens of one reply: everything it sent in, cached or not. */
+export function promptTokensOf(tokens) {
+    return tokens.input + tokens.cacheRead + tokens.cacheWrite5m + tokens.cacheWrite1h;
+}
+/** DX-4867 - whether a reply's prompt is long enough for the long-prompt card of `cards` (a model with one card never switches). */
+export function usesLongPromptCard(cards, tokens) {
+    return cards.longPrompt !== null && promptTokensOf(tokens) > cards.longPrompt.aboveTokens;
+}
+/**
+ * DX-4867 - price ONE reply (not a bucket of replies): like {@link priceUsage}, but a reply whose prompt is longer than the model's
+ * long-prompt threshold is charged its long-prompt card. A model with one rate card prices exactly as `priceUsage` does.
+ */
+export function priceReplyUsage(model, speed, tokens, cardsOf) {
+    const cards = cardsOf(model, speed);
+    if (cards === null)
+        return { kind: "unpriced", model, speed };
+    const price = usesLongPromptCard(cards, tokens) ? cards.longPrompt.price : cards.standard;
+    return { kind: "priced", costUsd: costOfTokens(tokens, price) };
+}
+/**
+ * DX-4595 - dollars for `tokens` at `price` (USD per million tokens): each bucket with its own price. The ONE copy of the formula: `priceUsage`
+ * charges the declared price with it, and spend pacing charges an account's own (editable) prices with it.
+ */
+export function costOfTokens(tokens, price) {
+    return ((tokens.input * price.input +
+        tokens.output * price.output +
+        tokens.cacheRead * price.cacheRead +
+        tokens.cacheWrite5m * price.cacheWrite5m +
+        tokens.cacheWrite1h * price.cacheWrite1h) /
+        1_000_000);
+}
+/**
+ * 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 is priced by `priceOf` (so as {@link priceUsage} does), an unpriced
+ * one costing 0 and naming itself. DX-4595: spend pacing passes an account's own prices as `priceOf` and so gets the same rule.
+ */
+export function priceLedgerCredit(model, speed, tokens, priceOf) {
+    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 price = priceOf(model, speed);
+    return price === null ? { costUsd: 0, unpriced: { model, speed } } : { costUsd: costOfTokens(tokens, price), unpriced: null };
+}

package/dist/real-work.d.ts

@@ -0,0 +1,13 @@
+/** Tools that edit or write a file. */
+export declare const FILE_WRITE_TOOL_NAMES: ReadonlySet<string>;
+/** Tools that spawn a sub-agent (Claude Code names the tool `Agent`; it was `Task` before). */
+export declare const SUBAGENT_TOOL_NAMES: ReadonlySet<string>;
+/** The fields of a tool use the real-work decision reads. */
+export interface RealWorkToolUse {
+    name: string;
+    input: Record<string, unknown> | null;
+}
+/** Whether one tool use is real work. */
+export declare function isRealWorkToolUse(use: RealWorkToolUse): boolean;
+/** Whether any of a reply line's tool uses is real work. */
+export declare function hasRealWork(uses: readonly RealWorkToolUse[]): boolean;

package/dist/real-work.js

@@ -0,0 +1,57 @@
+/**
+ * DX-4939 - what counts as a reply's REAL WORK, the ONE list.
+ *
+ * After a compaction an agent spends calls re-reading its card, plan and git state before it does real work again (its
+ * RE-ORIENTATION). PLAN-42 measured that as the calls up to the first reply that edits or writes a file, writes a card, or
+ * spawns a sub-agent. The collector marks each reply with that flag (`LedgerEntry.realWork`), decided from the reply's tool
+ * uses by name only, so the cost report can measure re-orientation exactly instead of inferring it from context growth.
+ *
+ * A Bash call is never real work here: whether a command writes anything cannot be told from its name. `SendMessage` to a sub-agent never
+ * is either: it continues work whose start (the `Agent` spawn) already counted, and a reply that only talks to an agent has not done anything
+ * itself. A card write is a write to the card's own content or state (`/api/issues`, `/api/issues/:id` and its sub-routes such as `edit`,
+ * `transition`, `checklists`, `problems`, `retro`), read from the tool input's `method` and `path`. A comment (`.../comments`) and a quality-gate
+ * verdict (`.../quality-gates/...`) are not card content, and a plan, Slack or dispatch-callback call is no card write. The input is all there is
+ * to judge by, so the one thing that can still be miscounted is a card route this list does not name: it follows the rule (anything under
+ * `/api/issues` other than a comment or a verdict), so it counts.
+ *
+ * Pure, no `node:` imports (exported through the browser-safe subpath too).
+ */
+import { API_SERVER_PREFIXES, API_TOOL_BASE_NAMES } from "./api-tool-names.js";
+/** Tools that edit or write a file. */
+export const FILE_WRITE_TOOL_NAMES = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+/** Tools that spawn a sub-agent (Claude Code names the tool `Agent`; it was `Task` before). */
+export const SUBAGENT_TOOL_NAMES = new Set(["Agent", "Task"]);
+/**
+ * The platform MCP's tool names: the operator session's server is the plugin's (`plugin_50arms_platform`) and a dispatched agent's is `platform`; every older
+ * server key and the older tool name `danxbot_api` are recognised too (`API_SERVER_PREFIXES`, DX-6847 / DX-6864), because a transcript is read by what its
+ * session called. `50arms_api` writes a card when its `method` is not GET and its `path` is a card route that is not a comment or a quality-gate verdict
+ * (`isCardContentWrite`); `attach_file` always writes (it attaches a file to a card).
+ */
+const DASHBOARD_TOOL = new RegExp(`^(?:${API_SERVER_PREFIXES.join("|")})(${API_TOOL_BASE_NAMES.join("|")}|attach_file)$`);
+/** The sub-routes of a card that are not its content: a comment and a quality-gate verdict. */
+const NOT_CARD_CONTENT = new Set(["comments", "quality-gates"]);
+/** Whether a dashboard call is a write to a card's content or state: not a GET, on `/api/issues[/:id[/<sub>...]]`, the sub-route not a comment or a verdict. */
+function isCardContentWrite(input) {
+    if (input === null || typeof input.method !== "string" || typeof input.path !== "string")
+        return false;
+    if (input.method.toUpperCase() === "GET")
+        return false;
+    const [api, issues, , sub] = input.path.split("?")[0].split("/").filter((s) => s !== "");
+    return api === "api" && issues === "issues" && !(sub !== undefined && NOT_CARD_CONTENT.has(sub));
+}
+/** Whether one tool use is real work. */
+export function isRealWorkToolUse(use) {
+    if (FILE_WRITE_TOOL_NAMES.has(use.name) || SUBAGENT_TOOL_NAMES.has(use.name))
+        return true;
+    const dashboard = DASHBOARD_TOOL.exec(use.name);
+    if (dashboard === null)
+        return false;
+    if (dashboard[1] === "attach_file")
+        return true;
+    // An input without a method or a path is not counted: never a guess that it wrote a card.
+    return isCardContentWrite(use.input);
+}
+/** Whether any of a reply line's tool uses is real work. */
+export function hasRealWork(uses) {
+    return uses.some(isRealWorkToolUse);
+}