@threadcrumbs/common 0.1.2 → 0.1.4

package/telemetry/README.md

@@ -51,20 +51,71 @@ adapter in `../harnesses/`, so a session has the same id in both apps. Add the h
 | `cwd`, `gitBranch` | string | Where it's working |
 | `model`, `effort` | string | The harness's own ids, as recorded |
 | `status` | string | `asking`, `working`, `delegating`, `done`, `error`, or `idle`. See [Done, needing you, and archived](#done-needing-you-and-archived) |
+| `statusReason` | string | What the reader saw that decided `status`, one code from a fixed list. See [Why this status](#why-this-status) |
+| `ask` | object or `null` | What the thread needs from you, while it's `asking` or `error`; `null` otherwise. See [What a thread needs](#what-a-thread-needs) |
+| `usageLimits` | `{ at, subscription, windows: [{ id, usedPercent, windowMinutes, resetsAt }] }` or `null` | The plan's usage limits as the harness last recorded them in this session, at `at`. They cover the whole account, so an app shows the newest across a harness's sessions. `subscription` is the plan's name, such as `pro`, or `null`. `resetsAt` is epoch ms. Codex only, from `token_count`'s `rate_limits`, whose `primary` and `secondary` become the window ids; `null` elsewhere |
 | `live` | boolean | A process for it is running now. A harness that keeps no record of its processes reports `true` while a turn is open |
 | `startedAt`, `lastActivityAt` | number | Epoch ms |
-| `tool` | `{ name, startedAt }` or `null` | The tool running right now, only while working or delegating |
+| `tool` | `{ name, startedAt, target, kind }` or `null` | The tool running right now, only while working or delegating. `target` is its short file path, command, or search, as in `Detail.activity`, or `''` when the harness doesn't record one. `kind` is one of the [tool kinds](#tool-kinds) |
 | `tokens` | `{ input, output, cacheRead, cacheWrite }` or `null` | Totals for the session's own thread. `input` leaves out cache reads and writes |
 | `context` | `{ used, limit }` or `null` | Tokens in the window after the last reply; `limit` is `0` when unknown |
+| `contextHistory` | number[] or `null` | The context after each reply, oldest first, for a sparkline: at most 24 whole numbers, evenly spaced across the session and always ending at `context.used`. A reply written twice counts once. Each reader keeps a running sample as it reads, never the whole history; OpenCode 2.x reads only the replies newer than the last one it saw, once the session changes, leaves the newest for the next read while it has no `time.completed`, and starts over if replies were removed. `null` for Cursor, Antigravity, and Hermes, whose session scan sees no per-reply counts, and before the first reply |
 | `costUsd` | number or `null` | Spend as the harness records it; `null` when it doesn't |
 | `lines` | `{ added, removed }` or `null` | Lines changed, as the harness records it |
 | `plan` | `{ total, done, current }` or `null` | Plan progress, if the agent keeps one |
 | `subagents` | number | Subagents still working for it |
+| `workingSubagents` | `[{ id, name }]` or `null` | Those subagents, oldest first, named as `Detail.subagents` names them. `null` for Antigravity, which records none |
 | `awaiting` | `[{ id, title }]` | Claude Code only: other sessions it asked to hear from that are still busy, by their own `id`. Either this or `subagents` makes an idle session `delegating`. Other harnesses leave it out |
 | `prompts` | number or `null` | Prompts typed in this session |
+| `turnStartedAt` | number or `null` | Epoch ms when the open turn began, for a turn timer. `null` when no turn is open, which includes a session waiting only on its subagents after handing its turn back. See [When a turn began](#when-a-turn-began) |
 
 `null` means "this harness doesn't record it". Threadgauge shows "—" instead of guessing.
 
+### When a turn began
+
+| Harness | `turnStartedAt` comes from |
+| --- | --- |
+| Claude Code | The first record after a reply that handed the turn back: a prompt, a message from another session, or anything else that reopens it |
+| Codex | `task_started` or `turn_started`, whichever opened the turn |
+| Cursor | The `<timestamp>` on the prompt that opened the turn, which is to the minute |
+| Antigravity CLI | The newest prompt in `history.jsonl`, the one that shows the turn underway |
+| Hermes | The newest user message across the compression chain |
+| OpenCode, Kilo Code | 1.x: the newest user message. 2.x: `time_busy`, or the newest user message without it |
+
+### Why this status
+
+| `status` | `statusReason` | Meaning | Harnesses |
+| --- | --- | --- | --- |
+| `asking` | `question` | A question tool is open | Claude Code, Codex, Hermes (clarify), OpenCode, Kilo Code |
+| | `approval` | A tool waits for your permission | Claude Code, Codex, Hermes |
+| | `waiting` | The live process says it waits on you, with no open tool to say why | Claude Code |
+| | `marked-blocked` | The Claude app marked the turn as waiting on you | Claude Code |
+| `working` | `turn-open` | The transcript or database shows a turn underway | All but Antigravity |
+| | `process-busy` | The live process says it's busy | Claude Code |
+| | `new-prompt` | A prompt is newer than the transcript | Antigravity |
+| `delegating` | `subagents` | Its subagents are working, or its only open calls start them | All but Antigravity |
+| | `awaiting` | It asked to hear from other sessions that are still busy (`awaiting`) | Claude Code |
+| `error` | `turn-failed` | The last turn ended in an error | All but Hermes |
+| `done` | `unread` | The harness records that you haven't read the reply | Claude Code (the app's record), Codex, Hermes, OpenCode 2.x |
+| | `recent` | No record of reading, and the turn ended in the last 30 minutes | All |
+| `idle` | `read` | The harness records that you've read the reply | Claude Code (the app's record), Codex, Hermes, OpenCode 2.x |
+| | `quiet` | No record of reading, and nothing for 30 minutes | All |
+
+### What a thread needs
+
+`ask` is one of these. Free text is cut like an activity target: headers and labels to 160
+characters, questions, descriptions, and error text to 500, with "…" at the cut. At most four
+questions with eight options each are kept.
+- `{ type: 'question', questions: [{ header, text, options: [{ label, description }], multiple }] }`
+  comes from the open question tool's input: Claude Code's AskUserQuestion, Codex's
+  `request_user_input`, and OpenCode's and Kilo Code's `question`.
+- `{ type: 'approval', tool, target, kind }` is the open tool waiting for permission: Claude
+  Code's newest open call while its process waits on you, and Codex's `request_permissions`.
+- `{ type: 'error', text }` is the newest error's text while the status is `error`. It can be
+  `''` when the harness records the failure but not its text.
+- `{ type: 'unknown' }` means the thread needs you but the harness doesn't say why: the Claude
+  app's mark, or Hermes, whose activity label is all it records.
+
 ### Done, needing you, and archived
 
 These follow the session readers in `../harnesses/`, so Threadgauge and Threadnauts count a
@@ -92,29 +143,104 @@ thread the same way.
 | `contextParts` | `{ input, cacheRead, cacheWrite, output }` | What filled the context in the latest request: new input, cache reads, cache writes, and its output. They add up to the session's `context.used`. `null` for Cursor, Antigravity, and Hermes |
 | `history` | `[{ at, context, output }]` | Context and output after each reply, the newest 600 |
 | `compactions` | `[{ at, before, after }]` | When the context was compacted, and its size before and after |
-| `activity` | `[{ id, name, target, input, path, line, startedAt, endedAt, running, error, errorText }]` | The newest 100 tool calls. `target` is a short file path, command, or search, never the output. `input` is the full command, or the call's input as JSON without file contents, cut to 2,000 characters. `path` and `line` are the file a call names, relative to the session's folder, and its line where known. `errorText` is the start of a failed call's own error output, cut to 500 characters. Any of these is `null` when the harness doesn't record it |
-| `tools` | `[{ name, calls, errors, ms }]` | Every call in the session, per tool |
+| `activity` | `[{ id, name, kind, server, target, input, path, line, startedAt, endedAt, running, error, errorText }]` | The newest 100 tool calls. `kind` and `server` are described under [Tool kinds](#tool-kinds). `target` is a short file path, command, or search, never the output. `input` is the full command, or the call's input as JSON without file contents, cut to 2,000 characters. `path` and `line` are the file a call names, relative to the session's folder, and its line where known. `errorText` is the start of a failed call's own error output, cut to 500 characters. Any of these is `null` when the harness doesn't record it |
+| `tools` | `[{ name, kind, server, calls, errors, ms }]` | Every call in the session, per tool. A tool's `kind` comes from its name alone, so a shell tool is `execute` here even when some of its calls are `search` |
 | `plan` | `[{ content, status }]` | Every plan step; `[]` when the agent kept none |
-| `subagents` | `[{ id, name, type, status, model, tokens, tool, startedAt, lastActivityAt }]` | Every subagent it started, finished or not |
+| `subagents` | `[{ id, name, type, status, model, tokens, tool, startedAt, lastActivityAt }]` | Every subagent it started, finished or not. `tool` has the Session's `tool` shape |
 | `files` | `[{ path, added, removed, edits, line, hunks }]` | Lines changed per file, with paths relative to the session's folder. `line` is where its latest change starts. `hunks` (`[{ line, oldLine, lines, cut }]`) are its newest 5 changes as diff lines, each with at most 60 lines of 240 characters, and `cut` counts the lines left out. Only the 25 most recently edited files keep hunks; older ones have `[]`. `line` and `hunks` are `null` when the harness doesn't record them, and a hunk's `line` is `null` when the patch has no line numbers |
 | `prompts` | `[{ at, text }]` | The newest 50 prompts, each cut to 2,000 characters, with line breaks kept |
+| `thoughts` | `[{ at, text }]` | The agent's reasoning, where the harness writes it as text: the newest 20 messages that had some, each cut to 2,000 characters. Encrypted, redacted, and signature-only reasoning is skipped |
+| `replies` | `[{ at, text }]` | The agent's text to you, one entry per message with its text blocks joined: the newest 50, each cut to 2,000 characters. Tool calls and API errors are left out |
 | `errors` | `[{ at, message }]` | The newest 20 API errors and failed turns, each cut to 500 characters |
+| `contextBreakdown` | `{ at, total, limit, reserved, parts }` | What fills the context, like Claude Code's `/context`. Only `total` is measured; every part is an estimate. See [Context breakdown](#context-breakdown). `null` for Cursor, Antigravity, Hermes, OpenCode, and Kilo Code |
 
 Again, a `null` field means the harness doesn't record it. The shared helpers for building one
 (`startCall`, `endCall`, `toolTarget`, `keepNewest`, `fileList`, and the limits) are in
 `../lib/telemetry-fields.mjs`.
 
+### Context breakdown
+
+`contextBreakdown` splits the context into parts, so an app can show what fills it.
+- **Only `total` is measured.** It's the harness's own count of the latest request, the same
+  number as the Session's `context.used`, and `at` is that request's time. Every part is an
+  estimate scaled to it, and the parts always add up to it. An app should say so.
+- **`limit`** is the context limit, and **`reserved`** is what the harness keeps free for
+  compacting by default: 33,000 tokens for Claude Code, and for Codex the gap between the
+  window it reports and the 90% of its full window where it compacts. The settings that change
+  them aren't read, so an app should call it the default. Free space is `limit - total -
+  reserved`.
+- **`parts`** are `[{ id, tokens, items }]` in this order: `messages`, `system`,
+  `builtInTools`, `mcpTools`, `skills`, `memory`. A part a harness doesn't let us size is left
+  out, and its tokens stay in `system`.
+  - `messages` items: `{ id: 'prompts' }`, `{ id: 'replies' }`, `{ id: 'summary' }` (from the
+    last compaction), and `{ id: 'tool', name }` for each tool's calls and results.
+  - `mcpTools` items: `{ name, tools }` per server, `tools` a count or `null`.
+  - `skills` items: `{ name }`. `memory` items: `{ path }`, the file's full path.
+  - Every item also has `tokens`.
+- **How it's worked out:**
+  - What was there before the first message is the first request's input count minus the
+    first prompt (at 4 characters a token).
+  - That gives a characters-per-token ratio for the text of each fixed part (system prompt,
+    tool definitions, MCP servers, skills, memory files), so each part is its text length at
+    that ratio. A part added later counts at the same ratio.
+  - `messages` is the rest of the total. Each request's growth over the one before is split
+    among the prompts, replies, and tool calls and results since then, by text length. After a
+    compaction, the next request's growth over the fixed parts is the summary.
+- **When it falls back:** if the transcript began mid-session (no first prompt before the first
+  request, or a compaction summary first), or the fixed count comes out at or below zero or
+  above the total, there are only two parts: `system` is the fixed text at 4 characters a
+  token, and `messages` the rest. With no fixed text known either, it's `null`. A transcript
+  with no record of what was sent has `messages` and `system` only, `system` being the whole
+  fixed count.
+- **Where the fixed text comes from:** only the files the readers already open; no config file
+  is read.
+  - Claude Code: its transcript's own records of each request (`api-request-shape` and the
+    `instructions`, `skill_listing`, `deferred_tools_delta`, `mcp_instructions_delta`, and
+    `agent_listing_delta` attachments; see [HARNESS-NOTES.md](HARNESS-NOTES.md)).
+  - Codex: the rollout's base instructions and developer messages, its AGENTS.md messages, and
+    its `additional_tools` items. Its built-in tool definitions aren't written, so they're in
+    `system`.
+- **Read only for an open thread,** by the same second reader as thoughts and replies. It keeps
+  numbers and names, never the text.
+
+### Tool kinds
+
+Every call and every tool total has a `kind`, so an app can draw one icon per kind instead of
+one per tool. The kinds are ACP's tool kinds plus Gemini CLI's `agent`, `plan`, and
+`communicate`: `read`, `search`, `edit`, `delete`, `move`, `execute`, `think`, `fetch`, `agent`,
+`plan`, `communicate`, `switch_mode`, and `other`.
+- **By name:** `../lib/tool-kinds.mjs` keeps one table of every harness's tool names, compared
+  without case, spaces, or dashes. A name it doesn't know is `other`.
+- **MCP tools** (`mcp__<server>__<tool>`) are `other`, with `server` set to the server's name.
+  `server` is `null` for every other tool.
+- **Shell calls:** a call whose tool is `execute` takes `read`, `search`, `delete`, or `move`
+  when every step of its command does only that. Anything else stays `execute`: a step the
+  table doesn't know, mixed kinds, a redirect into a file, command substitution, a background
+  `&`, or a pipe into anything but a filter such as `head` or `sort`.
+  - A known command with an option that writes a file or runs one stays `execute` too:
+    `find -exec`, `-delete`, or `-fprint`; `fd -x`; `rg --pre`; `tree -o`; `less -o`;
+    `sort -o`; and `uniq` with an output file.
+  - `sed` is `read` only when its script just prints, such as `10,20p`.
+  - `git` skips `-C <dir>` and `--no-pager` before its subcommand.
+  - A command cut short to fit `input` is `execute`, because the part that was cut could
+    write. An open call reads its command whole.
+- `startCall` sets both fields, so a reader gets them by passing the call's name and input.
+
 | Harness | Where its details come from | `null` |
 | --- | --- | --- |
-| Claude Code | The transcript the scan already reads, collected as it goes (`transcriptReader({ detail: true })`), plus every subagent transcript and its `.meta.json`. Hunks come from each edit's `structuredPatch`, and a failed call's error text from its tool result | — |
-| Codex | The rollout state: calls and their exit codes, per-file lines and hunks from patches, and each `token_count`. Subagents are the child rollouts. A failed command's error text is its output | `compactions`. Hunks have no line numbers |
-| Cursor | The transcript state. A call's start is when it was first read | `history`, `models`, `files`, `compactions`. A call has no end time or error |
-| Antigravity CLI | Transcript steps, each ended by the next, with prompts from `history.jsonl` | `history`, `models`, `files`, `subagents`, `compactions`. A call has no input or file |
-| Hermes | One query for the compression chain: tool calls joined to their results, user messages, and child sessions | `history`, `files`, `compactions`. A call has no error |
-| OpenCode, Kilo Code | One query for the session's messages and tool parts. Files are the 1.x per-turn diffs; a failed call's error text is its `state.error` | `compactions`; `files` on 2.x and when Kilo kept no diffs; `hunks` always |
+| Claude Code | The transcript the scan already reads, collected as it goes (`transcriptReader({ detail: true })`), plus every subagent transcript and its `.meta.json`. Hunks come from each edit's `structuredPatch`, and a failed call's error text from its tool result. Thoughts and replies come from a second reader of the transcript, kept for the last three sessions opened | — |
+| Codex | The rollout state: calls and their exit codes, per-file lines and hunks from patches, and each `token_count`. Subagents are the child rollouts. A failed command's error text is its output. Thoughts are reasoning summaries and replies are assistant messages, from a second reader kept for the last three sessions opened | `compactions`. Hunks have no line numbers |
+| Cursor | The transcript state. A call's start is when it was first read. Replies come from a second reader kept for the last three sessions opened; Cursor writes no time on them, so each takes its prompt's time, and it writes the agent's thinking into the same text | `thoughts`, `history`, `models`, `files`, `compactions`. A call has no end time or error |
+| Antigravity CLI | Transcript steps, each ended by the next, with prompts from `history.jsonl`. Thoughts and replies are planner steps' `thinking` and `content`, from a second reader kept for the last three sessions opened | `history`, `models`, `files`, `subagents`, `compactions`. A call has no input or file |
+| Hermes | One query for the compression chain: tool calls joined to their results, user and assistant messages, and child sessions. Thoughts are the `reasoning` column, or `reasoning_content` | `history`, `files`, `compactions`; `thoughts` when the database has neither column. A call has no error |
+| OpenCode, Kilo Code | One query for the session's messages and tool parts. Files are the 1.x per-turn diffs; a failed call's error text is its `state.error`. Thoughts and replies are the reasoning and text parts of each reply. On 2.x a reply's parts (calls, plan, thoughts, and text) are its part rows when OpenCode writes them (`experimental.part_rows`, off by default), and otherwise the message's own content | `compactions`; `files` on 2.x and when Kilo kept no diffs; `hunks` always |
 
 ## What each harness records
 
+[HARNESS-NOTES.md](HARNESS-NOTES.md) has what each harness saves of its reasoning and replies,
+the hooks it offers, and how much of its context it keeps free for compacting, with the version
+and date each was checked.
+
 Only Claude Code was checked against a real install. The others were written from each
 harness's source code, or, for the closed ones, from what other open-source tools parse, and
 tested against fake installs. Recheck them when a harness changes its format.
@@ -122,7 +248,7 @@ tested against fake installs. Recheck them when a harness changes its format.
 | Harness | What the reader takes, and from where | Not on disk, so `null` |
 | --- | --- | --- |
 | Claude Code | Transcripts, the live session records, the model catalog cache, and the Claude app's own record of each thread, for whether you've read it, whether its turn is waiting on you, and whether it's archived (`../lib/claude-desktop.mjs`). Spend is every reply's usage priced at Anthropic's list prices (`../lib/anthropic-prices.mjs`), the way Claude Code's own `/usage` total is computed, subagents included. Lines are counted from Edit and Write results and the files shell commands changed. The `cost-state` records Claude Code writes are a fallback only, for a model with no list price: they're written now and then, and they cover a whole process, which can span several sessions | — |
-| Codex | Rollouts, plus the writer lock each loaded thread holds. Tokens and context come from `token_count`. Lines are counted from patches that applied. Renames come from `session_index.jsonl` and the state database, which also says what's archived and what you've read | Spend. An open approval prompt can't be told apart from a running command; only a question to you (`request_user_input`) shows as needing you |
+| Codex | Rollouts, plus the writer lock each loaded thread holds. Tokens, context, and usage limits come from `token_count`. Lines are counted from patches that applied. Renames come from `session_index.jsonl` and the state database, which also says what's archived and what you've read | Spend. An open approval prompt can't be told apart from a running command; only a question to you (`request_user_input`) shows as needing you |
 | Cursor | Agent transcripts: status from `turn_ended`, the tool last called, the todo list, and subagents | Tokens, context, model, spend, lines, and tool start times (the start is when the record appeared) |
 | Antigravity CLI | The transcript, written after each turn ends; the prompt history, whose newer prompt shows a turn underway; and the `task.md` checklist | Tokens, context, model, spend, lines, the current tool, and subagents. They're only in the protobuf conversation database, which isn't read |
 | Hermes | `state.db`: token and spend columns added up across compaction segments, turn leases, the newest todo list, and the tool calls with no result yet. Context limits come from `context_length_cache.yaml` | Lines. Needing you shows only through the activity label, which Hermes updates at most once a minute |

package/telemetry/antigravity.mjs

@@ -2,19 +2,22 @@ import fsp from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
 import { exists, jsonLines, listDirs } from '../lib/fsutil.mjs'
-import { jsonlFollower } from '../lib/jsonl-follower.mjs'
+import { jsonlFollower, recentReaders } from '../lib/jsonl-follower.mjs'
 import {
   DETAIL_LIMITS,
   RECENT_MS,
   activityDetail,
+  askOf,
   clip,
   clipBlock,
   emptyActivity,
   keepNewest,
+  keepText,
   planItems,
   planSummary,
   startCall,
   text,
+  textList,
   titleFromPrompt,
 } from '../lib/telemetry-fields.mjs'
 
@@ -25,6 +28,7 @@ const TRANSCRIPTS = [
   ['.system_generated', 'logs', 'transcript.jsonl'],
   ['transcript.jsonl'],
 ]
+const WORDS_KEPT = 3
 const CHECKLIST = /^\s*[-*]\s+\[([ xX/])\]\s+(.+?)\s*$/
 const CHECK_STATUS = { ' ': 'pending', '/': 'in_progress', x: 'completed', X: 'completed' }
 
@@ -105,6 +109,15 @@ function applyRecord(state, record) {
   if (record.status) state.failed = record.status === 'ERROR' || record.type === 'ERROR_MESSAGE'
 }
 
+const emptyWords = () => ({ thoughts: [], replies: [] })
+
+function applyWords(state, record) {
+  if (record?.type !== 'PLANNER_RESPONSE') return
+  const at = epochMs(record.created_at)
+  keepText(state.thoughts, 'thoughts', { at, text: text(record.thinking) })
+  keepText(state.replies, 'replies', { at, text: contentText(record.content) })
+}
+
 export function parseChecklist(markdown) {
   const steps = []
   for (const line of text(markdown).split(/\r?\n/)) {
@@ -121,6 +134,7 @@ export function antigravity({
   const brainDir = path.join(home, 'brain')
   const historyFile = path.join(home, 'history.jsonl')
   const transcripts = jsonlFollower({ empty: emptyTranscript, apply: applyRecord })
+  const wordsFor = recentReaders(() => jsonlFollower({ empty: emptyWords, apply: applyWords }), WORDS_KEPT)
   const plans = new Map()
   let history = { mtime: -1, byId: new Map() }
   let known = new Set()
@@ -195,9 +209,10 @@ export function antigravity({
       const plan = await readPlan(sessionDir)
       const open = Boolean(typed) && typed.lastAt > transcriptAt && at - typed.lastAt < ACTIVE_WINDOW_MS
       let status
-      if (open) status = 'working'
-      else if (state.failed) status = 'error'
-      else status = at - lastActivityAt < ACTIVE_WINDOW_MS ? 'done' : 'idle'
+      let statusReason
+      if (open) [status, statusReason] = ['working', 'new-prompt']
+      else if (state.failed) [status, statusReason] = ['error', 'turn-failed']
+      else [status, statusReason] = at - lastActivityAt < ACTIVE_WINDOW_MS ? ['done', 'recent'] : ['idle', 'quiet']
       const cwd = state.cwd || typed?.workspace || ''
       const prompt = state.firstPrompt || typed?.first || ''
       sessions.push({
@@ -218,11 +233,17 @@ export function antigravity({
         tool: null,
         tokens: null,
         context: null,
+        contextHistory: null,
         costUsd: null,
         lines: null,
         plan: planSummary(plan),
         subagents: 0,
+        workingSubagents: null,
         prompts: Math.max(state.prompts, typed?.prompts || 0),
+        turnStartedAt: open ? typed.lastAt : null,
+        statusReason,
+        ask: askOf(status, { errorText: state.errors.at(-1)?.message }),
+        usageLimits: null,
       })
     }
     transcripts.sweep()
@@ -237,6 +258,7 @@ export function antigravity({
     const sessionDir = path.join(brainDir, id)
     const found = await transcriptOf(sessionDir)
     const state = (found && (await transcripts.read(found.file, found.stat).catch(() => null))) || emptyTranscript()
+    const said = found ? await wordsFor(found.file).read(found.file, found.stat).catch(() => null) : null
     const typed = (await readHistory()).get(id)
     return {
       id: `antigravity:${id}`,
@@ -251,6 +273,9 @@ export function antigravity({
       subagents: null,
       files: null,
       prompts: (typed?.list.length ? typed.list : state.promptList).map((p) => ({ ...p })),
+      thoughts: found ? textList(said?.thoughts) : [],
+      replies: found ? textList(said?.replies) : [],
+      contextBreakdown: null,
       errors: state.errors.map((e) => ({ ...e })),
     }
   }

package/telemetry/claude-code.mjs

@@ -4,7 +4,9 @@ import path from 'node:path'
 import { claudeDesktopStores, desktopRecordReader, projectOf } from '../lib/claude-desktop.mjs'
 import { awaitedPeers, readLiveSessions, transcriptDetail, transcriptReader, turnEnding } from '../lib/claude-transcript.mjs'
 import { exists, listDirs, listFiles, num } from '../lib/fsutil.mjs'
-import { DETAIL_LIMITS, RECENT_MS, number, planSummary, text, titleFromPrompt } from '../lib/telemetry-fields.mjs'
+import { contextBreakdown } from '../lib/context-breakdown.mjs'
+import { recentReaders } from '../lib/jsonl-follower.mjs'
+import { DETAIL_LIMITS, RECENT_MS, askOf, number, planSummary, sampleList, text, titleFromPrompt, toolNow } from '../lib/telemetry-fields.mjs'
 
 export { nextPlan } from '../lib/telemetry-fields.mjs'
 
@@ -12,6 +14,8 @@ const STALE_TURN_MS = 2 * 60 * 1000
 const ACTIVE_WINDOW_MS = 30 * 60 * 1000
 const SUBAGENT_WINDOW_MS = 10 * 60 * 1000
 const OLDER_KEPT = 3
+const OPENED_KEPT = 3
+const RESERVED_TOKENS = 33_000
 const SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
 
 export function claudeCode({
@@ -25,7 +29,8 @@ export function claudeCode({
   const catalogDir = path.join(home, 'cache', 'model-catalog')
   const transcripts = transcriptReader({ detail: true })
   const subagentFiles = transcriptReader()
-  const subagentDetails = transcriptReader({ detail: true })
+  const subagentDetails = transcriptReader({ detail: true, words: true })
+  const openedFor = recentReaders(() => transcriptReader({ words: true, sizes: true }), OPENED_KEPT)
   const desktopRecords = desktopRecordReader()
   const olderReaders = new Map()
   const metas = new Map()
@@ -77,7 +82,7 @@ export function claudeCode({
 
   async function subagentTotals(file, sessionId) {
     const cutoff = now() - SUBAGENT_WINDOW_MS
-    const totals = { running: 0, spend: 0, unpriced: false, added: 0, removed: 0 }
+    const totals = { running: 0, working: [], spend: 0, unpriced: false, added: 0, removed: 0 }
     for (const sub of await listFiles(subagentDir(file, sessionId), (n) => n.endsWith('.jsonl'))) {
       const stat = await fsp.stat(sub).catch(() => null)
       if (!stat) continue
@@ -87,8 +92,12 @@ export function claudeCode({
       totals.unpriced ||= state.unpriced
       totals.added += state.lines.added
       totals.removed += state.lines.removed
-      if (stat.mtimeMs >= cutoff && !turnEnding(state).handedBack) totals.running++
+      if (stat.mtimeMs < cutoff || turnEnding(state).handedBack) continue
+      totals.running++
+      const meta = await readMeta(sub.replace(/\.jsonl$/, '.meta.json'))
+      totals.working.push({ id: path.basename(sub, '.jsonl').replace(/^agent-/, ''), name: subagentName(meta, state), startedAt: state.startedAt })
     }
+    totals.working = totals.working.sort((a, b) => a.startedAt - b.startedAt).map(({ id, name }) => ({ id, name }))
     return totals
   }
 
@@ -131,7 +140,7 @@ export function claudeCode({
       const status = ending.failed ? 'error' : !open ? 'done' : now() - lastActivityAt < SUBAGENT_WINDOW_MS ? 'working' : 'idle'
       list.push({
         id: path.basename(sub, '.jsonl').replace(/^agent-/, ''),
-        name: text(meta?.description) || titleFromPrompt(state.firstPrompt) || 'Subagent',
+        name: subagentName(meta, state),
         type: text(meta?.agentType),
         status,
         model: state.model,
@@ -168,7 +177,7 @@ export function claudeCode({
       if (!running && now() - (state.lastAt || stat.mtimeMs) > RECENT_MS) continue
       const totals = await subagentTotals(file, id)
       const awaiting = running ? awaitedPeers(state, live, handedBackAt) : []
-      sessions.push(toSession({ id, state, stat, running, subagents: running ? totals.running : 0, awaiting, totals, limits, mark: marks.get(id), now: now() }))
+      sessions.push(toSession({ id, state, stat, running, subagents: running ? totals.running : 0, workingSubagents: running ? totals.working : [], awaiting, totals, limits, mark: marks.get(id), now: now() }))
     }
     known = files
     listed = new Map(sessions.map((s) => [s.id, s]))
@@ -189,6 +198,7 @@ export function claudeCode({
       agentId,
       source: sub,
       ...transcriptDetail(state),
+      contextBreakdown: null,
       subagents: null,
     }
   }
@@ -205,6 +215,13 @@ export function claudeCode({
     return newest?.file || null
   }
 
+  async function opened(file, stat, state, limits) {
+    const read = await openedFor(file).read(file, stat).catch(() => null)
+    const limit = contextLimit(limits, state.model)
+    const reserved = limit ? Math.min(RESERVED_TOKENS, limit) : RESERVED_TOKENS
+    return { words: read?.words ?? null, contextBreakdown: contextBreakdown(read?.sizes, { total: state.context, limit, reserved }) }
+  }
+
   function olderReader(file) {
     const reader = olderReaders.get(file) || transcriptReader({ detail: true })
     olderReaders.delete(file)
@@ -220,17 +237,18 @@ export function claudeCode({
     if (!stat) return null
     const state = await (known.get(id) === file ? transcripts : olderReader(file)).read(file, stat)
     const [live, limits, marks] = await Promise.all([readLiveSessions(liveDir, isAlive), contextLimits(), desktopRecords(desktop).then(desktopMarks)])
+    const said = await opened(file, stat, state, limits)
     if (marks.get(id)?.archived) return null
     const running = live.get(id)
     const totals = await subagentTotals(file, id)
     const awaiting = running ? awaitedPeers(state, live) : []
     const session =
       listed.get(`claude-code:${id}`) ||
-      toSession({ id, state, stat, running, subagents: running ? totals.running : 0, awaiting, totals, limits, mark: marks.get(id), now: now() })
+      toSession({ id, state, stat, running, subagents: running ? totals.running : 0, workingSubagents: running ? totals.working : [], awaiting, totals, limits, mark: marks.get(id), now: now() })
     if (subagent != null) return { session, detail: await subagentDetail(file, id, String(subagent)) }
     return {
       session,
-      detail: { id: `claude-code:${id}`, sessionId: id, source: file, ...transcriptDetail(state), subagents: await subagentList(file, id) },
+      detail: { id: `claude-code:${id}`, sessionId: id, source: file, ...transcriptDetail(state, said.words), contextBreakdown: said.contextBreakdown, subagents: await subagentList(file, id) },
     }
   }
 
@@ -241,11 +259,13 @@ export function claudeCode({
     if (!stat) return null
     if (subagent != null) return subagentDetail(file, id, String(subagent))
     const state = await transcripts.read(file, stat)
+    const said = await opened(file, stat, state, await contextLimits())
     return {
       id: `claude-code:${id}`,
       sessionId: id,
       source: file,
-      ...transcriptDetail(state),
+      ...transcriptDetail(state, said.words),
+      contextBreakdown: said.contextBreakdown,
       subagents: await subagentList(file, id),
     }
   }
@@ -284,6 +304,7 @@ function desktopMarks({ records, deleted }) {
       activeAt: num(r.lastActivityAt) || num(r.lastFocusedAt) || num(r.createdAt),
       outcome: r.turnOutcome || '',
       failed: Boolean(r.error) || r.turnOutcome === 'failed',
+      errorText: typeof r.error === 'string' ? r.error : text(r.error?.message),
     }
     const seen = marks.get(r.cliSessionId)
     marks.set(
@@ -297,6 +318,7 @@ function desktopMarks({ records, deleted }) {
             activeAt: Math.max(seen.activeAt, next.activeAt),
             outcome: seen.outcome || next.outcome,
             failed: seen.failed || next.failed,
+            errorText: seen.errorText || next.errorText,
           }
         : next
     )
@@ -305,38 +327,46 @@ function desktopMarks({ records, deleted }) {
   return marks
 }
 
-function statusOf({ running, state, subagents, awaiting, lastAt, mark, unread, now }) {
+function statusOf({ running, state, calls, subagents, awaiting, lastAt, mark, unread, now }) {
   const midTurn = Boolean(state.ending && !state.ending.handedBack)
   const { failed, onAgents: onlyAgents } = turnEnding(state)
   const blocked = mark?.outcome === 'blocked'
   const failedTurn = failed || Boolean(mark?.failed)
+  const quiet = () => (unread ? ['done', 'unread'] : ['idle', mark ? 'read' : 'quiet'])
   if (running) {
-    if (running.status === 'waiting') return 'asking'
+    if (running.status === 'waiting') return ['asking', calls.some((c) => c.questions) ? 'question' : calls.length ? 'approval' : 'waiting']
     const busy = running.status ? running.status === 'busy' : midTurn
-    if (busy) return onlyAgents ? 'delegating' : 'working'
-    if (subagents || awaiting.length) return 'delegating'
-    if (blocked) return 'asking'
-    if (failedTurn) return 'error'
-    return unread || now - lastAt < ACTIVE_WINDOW_MS ? 'done' : 'idle'
+    if (busy) return onlyAgents ? ['delegating', 'subagents'] : ['working', running.status ? 'process-busy' : 'turn-open']
+    if (subagents || awaiting.length) return ['delegating', subagents ? 'subagents' : 'awaiting']
+    if (blocked) return ['asking', 'marked-blocked']
+    if (failedTurn) return ['error', 'turn-failed']
+    if (!unread && now - lastAt < ACTIVE_WINDOW_MS) return ['done', 'recent']
+    return quiet()
   }
-  if (midTurn && now - lastAt < STALE_TURN_MS) return onlyAgents ? 'delegating' : 'working'
-  if (blocked) return 'asking'
-  if (failedTurn) return 'error'
-  return unread ? 'done' : 'idle'
+  if (midTurn && now - lastAt < STALE_TURN_MS) return onlyAgents ? ['delegating', 'subagents'] : ['working', 'turn-open']
+  if (blocked) return ['asking', 'marked-blocked']
+  if (failedTurn) return ['error', 'turn-failed']
+  return quiet()
 }
 
+const subagentName = (meta, state) => text(meta?.description) || titleFromPrompt(state.firstPrompt) || 'Subagent'
+
 function currentTool(open) {
   let latest = null
   for (const call of open.values()) {
     if (!latest || call.startedAt >= latest.startedAt) latest = call
   }
-  return latest ? { name: latest.name, startedAt: latest.startedAt } : null
+  return toolNow(latest)
 }
 
-function toSession({ id, state, stat, running, subagents, awaiting, totals, limits, mark, now }) {
+function toSession({ id, state, stat, running, subagents, workingSubagents, awaiting, totals, limits, mark, now }) {
   const lastActivityAt = state.lastAt || Math.floor(stat.mtimeMs)
   const unread = Boolean(mark) && (state.handedBackAt || mark.activeAt) > mark.focusedAt
-  const status = statusOf({ running, state, subagents, awaiting, lastAt: lastActivityAt, mark, unread, now })
+  const calls = [...state.open.values()].sort((a, b) => a.startedAt - b.startedAt)
+  const [status, statusReason] = statusOf({ running, state, calls, subagents, awaiting, lastAt: lastActivityAt, mark, unread, now })
+  const errorText = state.detail?.errors.at(-1)?.message || mark?.errorText || ''
+  const midTurn = Boolean(state.ending && !state.ending.handedBack)
+  const turnOpen = midTurn && (status === 'working' || status === 'delegating' || status === 'asking')
   const { projectPath, project, worktree } = projectOf(mark?.cwd || state.firstCwd || state.cwd, mark?.originCwd)
   const limit = contextLimit(limits, state.model)
   const promptTitle = state.firstPrompt ? titleFromPrompt(state.firstPrompt) : ''
@@ -358,12 +388,18 @@ function toSession({ id, state, stat, running, subagents, awaiting, totals, limi
     tool: status === 'working' || status === 'delegating' ? currentTool(state.open) : null,
     tokens: { ...state.tokens },
     context: state.context ? { used: state.context, limit } : null,
+    contextHistory: sampleList(state.contextSample, state.context),
     costUsd: state.unpriced || totals.unpriced ? (state.cost ? state.cost.usd : null) : state.spend + totals.spend,
     lines: { added: state.lines.added + totals.added, removed: state.lines.removed + totals.removed },
     plan: planSummary(state.plan),
     subagents,
+    workingSubagents,
     awaiting: awaiting.map((p) => ({ id: `claude-code:${p.sessionId}`, title: p.name })),
     prompts: state.prompts,
+    turnStartedAt: turnOpen ? state.turnStartedAt || null : null,
+    statusReason,
+    ask: askOf(status, { calls, errorText }),
+    usageLimits: null,
   }
 }