@workerdeck/protocol 0.23.0 → 1.0.0

package/build/index.mjs

@@ -18,47 +18,9 @@ function sessionState(info) {
 	if (runningSubagents(info).length > 0) return "working";
 	return "idle";
 }
-/**
-* The sub-agents a list row draws as live.
-*
-* `sessionState` deliberately does **not** grow a `subagents` bucket — a fifth
-* state would split `working` in two for every client that filters by it,
-* including the ones that have not shipped this yet. Instead `working` *counts*
-* them: a synchronous `Task` keeps the turn in flight so the status already
-* says `working`, and a **background** agent — which outlives its turn on
-* purpose — is the carve-out the extra arm in `sessionState` exists for.
-* That is what makes "sub-agents are an annotation on a working row" true
-* rather than assumed: the row is in the working bucket whichever kind is
-* running, and this list only says more about it.
-*/
 function runningSubagents(info) {
 	return (info.subagents ?? []).filter((sub) => sub.status === "running");
 }
-/**
-* A sub-agent's identity on one line: `Explore · find the auth check`.
-*
-* The same two fields `taskLabel` builds its transcript row from, minus the
-* `Task(…)` wrapper — a list row is already inside a session, so naming the tool
-* spends the width that the description needs. Falls back to the bare agent type,
-* then to a generic word: a row with no label at all reads as a rendering bug,
-* and an engine is free to send neither field.
-*/
-/**
-* Does this record name an **agent**, as opposed to a task the model merely
-* described?
-*
-* The tracker opens a record for every spawner call and for any nested event
-* whose parent it has not seen, so the list holds two different things wearing
-* one shape. One carries a `subagent_type` — a delegated agent with an identity
-* (`Explore`), whose own work is worth a surface of its own. The other carries
-* only a description, and there is no agent there to open: a row that offered a
-* screen and then showed a frame with nothing in it would be worse than a row
-* that offered nothing.
-*
-* Here rather than in a client because it decides two things a list must not
-* disagree about across surfaces — what is pressable, and what wears the
-* sub-agent colour.
-*/
 function isAgentRecord(sub) {
 	return (sub.agentType?.trim() ?? "") !== "";
 }
@@ -78,22 +40,9 @@ const DEFAULT_VIEW_CONFIG = {
 	groupBy: "state",
 	sortBy: "recent"
 };
-/** The adapters actually present, for the filter chips — derived rather than
-* enumerated, so a new engine needs no change here. */
 function adaptersOf(rows) {
 	return [...new Set(rows.map((r) => r.adapter))].sort();
 }
-/**
-* The projects actually present, as `{ key, label }` for a filter control —
-* derived like {@link adaptersOf}, and paired because the two halves differ:
-* the *key* is what {@link ViewConfig.projects} holds (gateway-qualified root,
-* so a rename regroups nothing) and the *label* is what a person picks by.
-*
-* Sorted by label, deduped by key. Two projects with the same name on two
-* gateways therefore stay two entries wearing one word — which is honest: they
-* really are two different directories, and the alternative is a filter that
-* silently selects both.
-*/
 function projectsOf(rows) {
 	const byKey = /* @__PURE__ */ new Map();
 	for (const row of rows) byKey.set(projectKey(row), projectLabel(row));
@@ -105,77 +54,24 @@ function projectsOf(rows) {
 function sessionLabel(info) {
 	return info.title ?? info.id.slice(0, 8);
 }
-/**
-* The project facet's grouping key: gateway id + the project root, falling
-* back to the session's cwd when no project is declared.
-*
-* The root and not the name, because a name is not a key (two repos can both
-* be called "api", and a rename must regroup nothing); qualified by gateway,
-* because a remote gateway's identical-looking path is another machine's
-* directory — the same rule `ScopeRoot` states. The cwd fallback is what makes
-* grouping by project useful before anyone has written a `.workerdeck.json`:
-* undeclared sessions group by their folder, declared ones by their root, and
-* a session in `packages/ui` joins its repo's group the moment the file
-* exists. Sessions with no cwd at all (a filesystem-less engine) share one
-* per-gateway bucket — see {@link projectLabel}.
-*/
 function projectKey(row) {
 	return `${row.hostId}:${normalizePath(row.info.project?.root ?? row.info.cwd)}`;
 }
-/**
-* What a project group (or a row's project slot) is called: the declared name,
-* else the cwd's basename — the exact string clients rendered before this
-* feature existed, so an undeclared project looks like today. 'No project' is
-* only ever the no-cwd case (a sandboxed provider session), where there is no
-* folder to name.
-*
-* Takes only the `info` it reads, so a surface holding a bare `SessionInfo` —
-* a row component, an iOS cell — can call it without inventing the rest of a
-* `SessionRow`. That matters more than it looks: this string is what a client
-* renders *in place of* the cwd basename it used to draw, and two spellings of
-* it would put the list and its group headers on different names.
-*/
 function projectLabel(row) {
 	const name = row.info.project?.name;
 	if (name) return name;
 	const dir = normalizePath(row.info.cwd);
 	return dir.slice(dir.lastIndexOf("/") + 1) || "No project";
 }
-/**
-* Where inside its project a session actually sits — the cwd with the project
-* root taken off the front, or `undefined` when it sits at the root, has no
-* declared project, or has no cwd at all.
-*
-* The companion to {@link projectLabel}, and it exists for one situation: a list
-* **grouped by project**. There the header has already said the project's name,
-* so repeating it on every row spends the row's most valuable line on the one
-* fact the reader already has. What the header cannot say is which *part* of the
-* project a session is working in, and two sessions in the same repo are told
-* apart by exactly that.
-*
-* Undefined is the honest answer for a session at the project root, and callers
-* must render nothing rather than a `.` or a repeated name — the slot simply
-* goes away, which is the point.
-*/
 function projectSubpath(row) {
 	const root = row.info.project?.root;
-	if (root === void 0 || !row.info.cwd) return void 0;
+	if (root === void 0 || !row.info.cwd) return;
 	const base = normalizePath(root);
 	const dir = normalizePath(row.info.cwd);
-	if (dir === base) return void 0;
-	if (!dir.startsWith(`${base}/`)) return void 0;
+	if (dir === base) return;
+	if (!dir.startsWith(`${base}/`)) return;
 	return dir.slice(base.length + 1) || void 0;
 }
-/**
-* This session is a job run — the queue created it, and `JobInfo.sessionId`
-* points at it.
-*
-* A job run is an ordinary registry session in every other respect, which is
-* what makes this worth spelling once: a client that renders jobs on their own
-* surface should not list them again among the sessions, and a client with no
-* jobs surface (the extension, the phone) should, or they would be invisible.
-* The queue stamps `meta.jobId`; nothing else may write that key.
-*/
 function isJobRun(info) {
 	return typeof info.meta?.jobId === "string";
 }
@@ -183,8 +79,6 @@ function matchesSearch(row, needle) {
 	if (!needle) return true;
 	return sessionLabel(row.info).toLowerCase().includes(needle) || row.info.cwd.toLowerCase().includes(needle) || (row.info.project?.name.toLowerCase().includes(needle) ?? false) || row.hostName.toLowerCase().includes(needle) || row.adapter.toLowerCase().includes(needle) || row.info.id.startsWith(needle);
 }
-/** Trailing separators dropped and separators unified, so containment is a
-* plain prefix test on both a posix and a Windows gateway. */
 function normalizePath(path) {
 	return path.replace(/\\/g, "/").replace(/\/+$/, "");
 }
@@ -193,17 +87,9 @@ function isWithin(root, path) {
 	const dir = normalizePath(path);
 	return dir === base || dir.startsWith(`${base}/`);
 }
-/**
-* Is this session inside one of the host's folders? A gateway-tagged root only
-* ever matches its own gateway; an untagged one only matches a loopback gateway,
-* because a remote gateway's identical-looking path is a different machine's
-* directory.
-*/
 function inScope(row, scope) {
 	return scope.roots.some((root) => (root.hostId ? root.hostId.toLowerCase() === row.hostId.toLowerCase() : row.local) && isWithin(root.path, row.info.cwd));
 }
-/** Whether the scope filter is actually hiding anything — it is inert with no
-* folder open, and that is the difference between a default and a filter. */
 function scopeActive(config, scope) {
 	return config.scoped && scope !== void 0;
 }
@@ -218,24 +104,18 @@ function facetKey(row, facet) {
 function facetLabel(row, facet) {
 	return facet === "gateway" ? row.hostName : facet === "adapter" ? row.adapter : facet === "project" ? projectLabel(row) : STATE_LABELS[row.state];
 }
-/** Comparable rank for a facet: states run worst-first (attention before ended),
-* the rest alphabetically by their visible label. */
 function facetRank(row, facet) {
 	if (facet === "state") return String(STATE_ORDER.indexOf(row.state));
 	return facetLabel(row, facet).toLowerCase();
 }
-const byRecency = (a, b) => (b.info.lastActivityAt ?? b.info.createdAt) - (a.info.lastActivityAt ?? a.info.createdAt);
+function byRecency(a, b) {
+	return (b.info.lastActivityAt ?? b.info.createdAt) - (a.info.lastActivityAt ?? a.info.createdAt);
+}
 function compare(a, b, sortBy) {
 	if (sortBy === "recent") return byRecency(a, b);
 	if (sortBy === "name") return sessionLabel(a.info).localeCompare(sessionLabel(b.info), void 0, { sensitivity: "base" }) || byRecency(a, b);
 	return facetRank(a, sortBy).localeCompare(facetRank(b, sortBy)) || byRecency(a, b);
 }
-/**
-* The list as rendered: filtered, grouped, and sorted within each group. Groups
-* themselves come out in the sort's own order — grouping by state and sorting by
-* name should still put "Needs attention" first, so groups are ordered by their
-* facet rank, never by the row sort.
-*/
 function groupRows(rows, config) {
 	const sorted = [...rows].sort((a, b) => compare(a, b, config.sortBy));
 	if (config.groupBy === "none") return sorted.length ? [{
@@ -258,7 +138,7 @@ function groupRows(rows, config) {
 	return [...groups.values()].sort((a, b) => a.rank.localeCompare(b.rank));
 }
 function subsetSummary(config, scope, shown, total) {
-	if (shown >= total) return void 0;
+	if (shown >= total) return;
 	const causes = [];
 	if (scope && scopeActive(config, scope)) causes.push(scope.label);
 	const facets = (config.gateways.length ? 1 : 0) + (config.adapters.length ? 1 : 0) + (config.states.length ? 1 : 0) + (config.projects?.length ? 1 : 0);
@@ -270,19 +150,9 @@ function subsetSummary(config, scope, shown, total) {
 		causes
 	};
 }
-/**
-* Is anything OTHER than the workspace scope narrowing the list?
-*
-* The distinction an empty list turns on: "this project has no sessions" wants a
-* different sentence, and a different way out, from "your filters match none".
-* Scope is excluded because it is on by default — it is the state, not a choice
-* someone made.
-*/
 function hasFacetFilter(config) {
 	return config.search.trim().length > 0 || config.gateways.length > 0 || config.adapters.length > 0 || config.states.length > 0 || (config.projects?.length ?? 0) > 0;
 }
-/** "Show me everything": every filter off, including scope. The group/sort
-* choices are a layout preference and survive. */
 function clearFilters(config) {
 	return {
 		...DEFAULT_VIEW_CONFIG,
@@ -293,28 +163,6 @@ function clearFilters(config) {
 }
 //#endregion
 //#region src/usage.ts
-/**
-* The usage a client should render: the gateway's per-profile state where it has
-* the window, this session's own reading where it does not.
-*
-* Why the profile wins outright rather than by comparing timestamps: the
-* gateway's `ProfileUsageTracker` is fed from **every** session on the profile —
-* including this one, from seq 0 — and keeps the newest reading per window by
-* the event's own `ts`. So for any window it holds, it holds a reading at least
-* as new as the one in this transcript, and a timestamp comparison could only
-* ever go wrong: the reducer keeps a *single* `updatedAt` for the whole map, so
-* a `five_hour` reading from this morning is dated with the afternoon's
-* `seven_day` event and would beat a genuinely fresher profile entry.
-*
-* The session half is not a fallback for correctness but for *coverage*: the
-* profile map is in-memory, so a restarted gateway serves nothing until a
-* session reports again, and a session with no profile has no account state at
-* all. In both cases the transcript's reading is the only one there is, and it
-* is dated honestly (see {@link SessionUsage.updatedAt}) rather than as now.
-*
-* Absent stays absent throughout: a window nobody has reported is **unknown,
-* never 0%**, and this returns an empty map rather than inventing entries.
-*/
 function mergeUsage(session, profile) {
 	const out = {};
 	for (const [key, info] of Object.entries(session.rateLimits ?? {})) out[key] = {
@@ -324,21 +172,6 @@ function mergeUsage(session, profile) {
 	for (const [key, window] of Object.entries(profile ?? {})) out[key] = window;
 	return out;
 }
-/**
-* The windows in reading order: the session window, the weekly one, then the
-* per-model weeklies alphabetically.
-*
-* Discovered rather than hardcoded — the engine's set of windows is an open
-* union and has grown before — but ordered, so the first two always mean the
-* same thing wherever they are drawn. A window with no `utilization` is
-* **unknown, not zero**, and is dropped entirely rather than rendered as an
-* empty bar that reads as "plenty left".
-*
-* Here rather than in a client because two surfaces now render the same windows
-* from different sources — the session panel from its merged state, the
-* dashboard's profile page straight off `ProfileInfo.usage` — and a list that
-* ordered or filtered differently would be the same account described two ways.
-*/
 function orderUsageWindows(usage) {
 	const all = Object.entries(usage ?? {}).filter(([, w]) => w.info.utilization !== void 0).map(([key, w]) => ({
 		key,
@@ -350,23 +183,19 @@ function orderUsageWindows(usage) {
 	const perModel = all.filter((w) => w.key.startsWith("seven_day_")).sort((a, b) => a.key.localeCompare(b.key));
 	return [...named, ...perModel];
 }
-/** The flat `rateLimitType → reading` map every existing renderer takes, out of
-* the dated form. Undefined in, undefined out — so a surface can keep telling
-* "no reading" apart from "an empty one". */
 function usageInfos(usage) {
-	if (!usage) return void 0;
+	if (!usage) return;
 	const out = {};
 	for (const [key, window] of Object.entries(usage)) out[key] = window.info;
 	return out;
 }
 //#endregion
 //#region src/watermarks.ts
-/** Entries older than this are dropped on write — a session deleted months ago
-* should not keep a row in storage forever. */
 const MAX_AGE_MS = 720 * 60 * 60 * 1e3;
-/** How stale "last here" is allowed to get before a write happens anyway. */
 const TOUCH_MS = 6e4;
-const watermarkKey = (hostId, sessionId) => `${hostId}:${sessionId}`;
+function watermarkKey(hostId, sessionId) {
+	return `${hostId}:${sessionId}`;
+}
 var Watermarks = class {
 	#store;
 	#cache;
@@ -377,35 +206,24 @@ var Watermarks = class {
 	get(hostId, sessionId) {
 		return this.#cache[watermarkKey(hostId, sessionId)];
 	}
-	/** Every mark, for a caller deriving unread counts over a whole list. */
 	all() {
 		return this.#cache;
 	}
-	/**
-	* Record what is on screen now. Monotonic on purpose: a transcript that
-	* *shrank* (a compaction, a fresh attach mid-replay) must not walk the mark
-	* backwards and resurrect rows the user already read.
-	*
-	* Returns whether the mark actually moved, because an unread badge is computed
-	* from it and nothing else will say so: rows read in a panel do not touch the
-	* sessions poll, so a caller that doesn't hear about this has no other way to
-	* learn the count is now wrong.
-	*/
 	mark(hostId, sessionId, seen, now = Date.now()) {
 		const id = watermarkKey(hostId, sessionId);
 		const previous = this.#cache[id];
 		const next = {
 			itemCount: Math.max(previous?.itemCount ?? 0, seen.itemCount ?? 0),
 			activity: Math.max(previous?.activity ?? 0, seen.activity ?? 0),
+			prose: seen.prose === void 0 ? previous?.prose : Math.max(previous?.prose ?? 0, seen.prose),
 			turns: Math.max(previous?.turns ?? 0, seen.turns ?? 0),
 			seenAt: now
 		};
-		if (previous && previous.itemCount === next.itemCount && previous.activity === next.activity && previous.turns === next.turns && next.seenAt - previous.seenAt < TOUCH_MS) return false;
+		if (previous && previous.itemCount === next.itemCount && previous.activity === next.activity && previous.prose === next.prose && previous.turns === next.turns && next.seenAt - previous.seenAt < TOUCH_MS) return false;
 		this.#cache[id] = next;
 		this.#store.write(this.#prune(now));
 		return true;
 	}
-	/** Forget a session — it was deleted, and its mark is now noise. */
 	forget(hostId, sessionId) {
 		const id = watermarkKey(hostId, sessionId);
 		if (!(id in this.#cache)) return;
@@ -419,78 +237,28 @@ var Watermarks = class {
 	}
 };
 /**
-* Rows this client has not seen, from the rollup alone.
-*
-* `activityCount` is the unit that makes an honest badge: turns undercount badly
-* (five tool calls in one turn is one turn) and a stream sequence overcounts
-* absurdly (every delta). Turns stay the fallback for a gateway too old to
-* report it.
-*
-* A session never visited returns 0 — "never opened" is not "unread", and a
-* badge that counted every session's whole history on first launch would be
-* noise on the one day it should be quiet.
+* The badge's number, in the best unit the pair can agree on: prose the human has not
+* read, else rows, else turns. The ladder is what keeps an older gateway (no `proseCount`
+* on the wire) badging exactly as it did before rather than going silent.
 */
 function unseenCount(mark, info) {
 	if (!mark) return 0;
+	if (info.proseCount !== void 0) return Math.max(0, info.proseCount - (mark.prose ?? info.proseCount));
 	if (info.activityCount !== void 0) return Math.max(0, info.activityCount - mark.activity);
 	return Math.max(0, (info.turns ?? 0) - mark.turns);
 }
 //#endregion
 //#region src/index.ts
-/**
-* @workerdeck/protocol — the wire protocol between a workerdeck server and its clients.
-*
-* One session = one ordered stream of {@link SessionEvent}s (each stamped with a monotonically
-* increasing `seq`) plus a small command set ({@link SessionCommand}). Clients attach over
-* WebSocket, optionally replaying from a known `seq`, and drive the session with commands.
-*
-* This package is dependency-free and browser-safe. Anthropic API message content is modeled
-* structurally (see {@link ApiMessage}) so clients don't need the Agent SDK to render transcripts.
-*/
-/** Bumped on any breaking change to events, commands, or REST shapes. */
-const PROTOCOL_VERSION = 7;
-/**
-* How much of a tool result a truncating replay keeps.
-*
-* Chosen against the two clients' *own* budgets, and the relationship is the
-* whole point: the terminal theme shows ~400 characters collapsed and ~2,000
-* open, so at 8,000 the collapsed and open states are **byte-identical to an
-* untruncated attach** and only the uncapped "show everything" press ever
-* fetches. That collapses the entire feature to one press, and it is asserted
-* in a test rather than trusted — lowered below the open budget, this would
-* silently clip the open state with no marker, which is the one failure this
-* design must not have.
-*
-* Measured justification: on one 1,270-row session three `tool_result` frames
-* were 641 / 463 / 396 KB, 68% of a 3.1 MB attach. The cut is *structural* —
-* proportional to the thing that is actually large, wherever in the log it sits
-* — which a row window is not.
-*/
+const PROTOCOL_VERSION = 1;
 const TOOL_RESULT_HEAD_CHARS = 8e3;
-/** How many bytes a base64 payload decodes to, without decoding it. */
 function base64Bytes(data) {
 	const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
 	return Math.max(0, Math.floor(data.length * 3 / 4) - padding);
 }
-/**
-* Project one `tool_result` content part onto its {@link ImageRefPart}, or
-* `undefined` when the part is not a base64 image and must be delivered as it
-* stands.
-*
-* The rule's **one spelling**, shared by the transform that replaces parts
-* (core), the route that serves them back (server) and the property test that
-* proves the fold is otherwise unchanged (react) — the same reason every other
-* member of this family lives here rather than in whichever package applies it.
-*
-* Deliberately narrow. The corpus holds exactly two non-text part kinds: this
-* one, and the CLI's `tool_reference`, of which every instance across 214
-* sessions totals 122 KB. A "drop non-text parts" rule would sweep those in for
-* no measurable gain, and narrowness is this family's standing habit.
-*/
 function imagePartRef(part, index) {
-	if (part.type !== "image") return void 0;
+	if (part.type !== "image") return;
 	const source = part.source;
-	if (!source || source.type !== "base64" || typeof source.data !== "string") return void 0;
+	if (!source || source.type !== "base64" || typeof source.data !== "string") return;
 	return {
 		type: "image_ref",
 		media_type: typeof source.media_type === "string" ? source.media_type : "application/octet-stream",
@@ -498,14 +266,6 @@ function imagePartRef(part, index) {
 		part_index: index
 	};
 }
-/**
-* The static capability record of each engine — the browser-safe default for
-* `ProfileInfo.capabilities` / `SessionInfo.capabilities`, and the single place
-* the values are written down. Core's adapters *reference* this record and a
-* conformance test compares runner behaviour against it, so it cannot silently
-* diverge from the code. When both a wire copy and this default exist, the wire
-* copy wins.
-*/
 const ENGINE_CAPABILITIES = {
 	claude: {
 		interactiveApprovals: true,
@@ -612,40 +372,12 @@ const ENGINE_CAPABILITIES = {
 		streaming: "token"
 	}
 };
-/**
-* Permission modes the model-agnostic provider engine understands.
-* @deprecated Read `ENGINE_CAPABILITIES.provider.permissionModes` (this is an
-* alias of it, kept for protocol-5 consumers).
-*/
-const PROVIDER_PERMISSION_MODES = ENGINE_CAPABILITIES.provider.permissionModes;
-/**
-* Whether a profile's engine can run a permission mode. The single source of
-* truth for the restriction: create forms filter what they offer with it, the
-* gateway rejects with it. An absent `engine` means 'claude' (every mode).
-*/
 function supportsPermissionMode(engine, mode) {
 	return ENGINE_CAPABILITIES[engine ?? "claude"].permissionModes.includes(mode);
 }
-/**
-* How many *settled* sub-agents {@link SessionInfo.subagents} keeps behind the
-* running ones. Small on purpose: the point of the tail is that a list row does
-* not go blank the instant a run finishes, not that it is a history.
-*/
 const SUBAGENT_HISTORY = 8;
-/**
-* The list-sized context reading an event carries, or `undefined` for the events
-* that carry none — the rule behind {@link SessionInfo.contextUsage}.
-*
-* Here rather than in each runner for the same reason {@link transcriptActivity}
-* is: it is one rule both sides have to agree on, and three copies of "which
-* events move the reading" is three chances to disagree. Runners fold it in
-* their emit path; **clearing on `conversation_reset` is the caller's half** —
-* this function answers "what does this event say the reading is", and a reset
-* says nothing about the window, it retires the conversation the window
-* described.
-*/
 function contextReading(body) {
-	if (body.type !== "context_usage") return void 0;
+	if (body.type !== "context_usage") return;
 	const { totalTokens, maxTokens, percentage } = body.usage;
 	return {
 		totalTokens,
@@ -653,21 +385,6 @@ function contextReading(body) {
 		percentage
 	};
 }
-/**
-* How many transcript rows an event materializes — the unit behind
-* {@link SessionInfo.activityCount}.
-*
-* Deliberately the *reducer's* rule (`@workerdeck/react`'s `transcript.ts`), not
-* a server-side approximation: one row per content block of an assistant
-* message (a text, a thought, each tool call), one for a user message, one per
-* turn result, delivered file or error. Everything else — status changes, usage
-* readings, stream deltas, permission bookkeeping — is state, not a row, and
-* counts zero.
-*
-* It lives in `protocol` because both sides need it and neither may import the
-* other: the runners count with it, and any client compares the totals. If the
-* reducer's row rule changes, change this with it.
-*/
 function transcriptActivity(body) {
 	if ("parentToolUseId" in body && body.parentToolUseId != null) return 0;
 	switch (body.type) {
@@ -684,33 +401,40 @@ function transcriptActivity(body) {
 	}
 }
 /**
-* Whether an event is **transcript content** — whether the reducer
-* (`@workerdeck/react`'s `transcript.ts`, and its Swift mirror) mutates
-* `items` when it applies it. The rule behind `conversation_reset`'s replay
-* semantics: the runner keeps its whole event log, but `subscribe()` skips
-* content below the latest reset so an attaching client does not resurrect a
-* cleared conversation — while every *state-bearing* event (`system_init`,
-* `capabilities`, `skills`, `status_changed`, usage and rate-limit readings,
-* `file_produced`, permission bookkeeping) still replays, because a fresh
-* attacher with no model list and no cwd is broken, not cleared.
-*
-* Deliberately **broader than `transcriptActivity() > 0`**: stream deltas,
-* tool results (synthetic user messages) and execution lifecycle events count
-* zero rows but still mutate items — replaying them across a reset would leave
-* orphaned deltas and results with no parent message.
-*
-* `conversation_reset` itself is content under this rule, and that is load-
-* bearing twice: a *superseded* reset (below a newer one) is skipped with the
-* conversation it cleared, while the latest reset always replays (the skip is
-* strictly-below), which is what clears a reconnecting client that still holds
-* pre-reset rows.
-*
-* Lives here beside {@link transcriptActivity} for the same reason: the
-* reducer owns the rule and the runners filter with it, and the two sides may
-* not import each other. If the reducer's items-mutating set changes, change
-* this with it. Unknown/future event types are NOT content — the safe failure
-* is replaying a stale row, never withholding state.
+* The unread badge's unit: output **addressed to the human**, not evidence of work.
+*
+* `transcriptActivity` counts a tool call and a paragraph alike, which is honest as
+* "how much has happened" and wrong as "how much is there to read" — a session that
+* tool-loops for a minute ticks 6, 7, 8 with nothing said yet. This scores the same
+* events through a narrower door:
+*
+* - assistant `text` blocks only — `thinking` is not addressed to anyone and `tool_use`
+*   is the noise being filtered out;
+* - the **sub-agent carve-out is inherited** (`parentToolUseId != null` scores 0): prose a
+*   sub-agent wrote to its parent is not addressed to the human either;
+* - a `turn_result` counts only when it **failed**, an interrupt or an error being a thing
+*   the human is owed; a successful turn already carried its own prose and would otherwise
+*   double-count every answer;
+* - `session_error` and `file_delivered` count — both are output, not work;
+* - `stream_delta` scores 0, exactly as in `transcriptActivity`. The badge is therefore
+*   correct within one poll of a message *completing*, never mid-stream, which is the
+*   deliberate price of leaving the streaming path alone.
 */
+function transcriptProse(body) {
+	if ("parentToolUseId" in body && body.parentToolUseId != null) return 0;
+	switch (body.type) {
+		case "assistant_message": {
+			const content = body.message.content;
+			if (typeof content === "string") return content.trim() === "" ? 0 : 1;
+			return content.filter((block) => block.type === "text" && typeof block.text === "string" && block.text.trim() !== "").length;
+		}
+		case "user_message": return body.synthetic ? 0 : 1;
+		case "turn_result": return body.isError ? 1 : 0;
+		case "file_delivered":
+		case "session_error": return 1;
+		default: return 0;
+	}
+}
 function transcriptContent(body) {
 	switch (body.type) {
 		case "user_message":
@@ -727,50 +451,6 @@ function transcriptContent(body) {
 		default: return false;
 	}
 }
-/**
-* The dedupe key for an event that is **last-write-wins** on replay, or
-* `undefined` for one that must always be delivered.
-*
-* The problem: the runner polls context usage and the plan's rate limits after
-* every turn, so a fifty-turn session's log holds fifty context readings and
-* fifty per rate-limit window. Replaying all of them is not merely wasteful —
-* it is *visible*. A client applies each in turn, so opening a session shows
-* the usage meters counting up from the session's first reading to its last
-* over the length of the replay, announcing history as if it were news.
-*
-* The fix is a backwards scan over the buffered log keeping the first
-* occurrence of each key, which is `staleReplaySeqs` in `@workerdeck/core`.
-* The key is per *window* for rate limits, not per event type: the reducer
-* stores them keyed by window ("so five_hour and seven_day updates don't
-* clobber each other"), so a single key would keep only the most recently
-* polled window and silently drop the others.
-*
-* **This is a claim about the reducer**, which is why it lives here rather
-* than in core: only the server coalesces, but only `@workerdeck/react` can
-* prove the rule correct, and neither package may import the other. The
-* property that must hold is that coalescing is *unobservable* — folding the
-* full log and the coalesced log through `applyEvent` yields identical state.
-* `packages/react/test/replay-coalesce.test.ts` asserts exactly that, over
-* every event kind. Extend the rule only with a case that test still passes.
-*
-* Three kinds are deliberately **excluded** despite looking eligible:
-*
-* - `capabilities` — `defaultModel: event.defaultModel ?? base.defaultModel`
-*   is a fallback *merge*, so a later event without one would erase an earlier
-*   event's. (It is also emitted once per session, so there is nothing to win.)
-* - `model_changed` — `undefined` means "reset to the server default" and the
-*   reducer *keeps* the last known model, so the last event alone is not the
-*   same as the fold.
-* - `system_init` — pure replace for the reducer, but the server's
-*   `watchAuthSource` reads the **first** one to decide an auth policy, and
-*   parking treats each as a resume point.
-*
-* Coalescing never drops the highest-seq event, and that is load-bearing
-* rather than incidental: the globally-last event is by definition the last of
-* its own key, so it always survives. `useClaudeSession`'s replay hold waits
-* for `state.lastSeq` to reach the attach's `session.lastSeq`, and would hang
-* on a blank panel forever if a coalescer could swallow the final event.
-*/
 function replayCoalesceKey(body) {
 	switch (body.type) {
 		case "context_usage": return "context_usage";
@@ -780,101 +460,16 @@ function replayCoalesceKey(body) {
 		default: return;
 	}
 }
-/**
-* Does a **replay** have to deliver this event, or may it be dropped outright?
-*
-* The fifth of the family, and the closest relative of {@link snapshotRetains} —
-* the same claim ("no client can tell") pointed at the wire instead of at a
-* store. The difference from {@link replayCoalesceKey} is that this is not
-* last-write-wins: there is nothing to keep. These are events the reducer reads
-* and *discards*, so a replay that sends them is spending the reader's network
-* on frames whose whole effect is `return base`.
-*
-* Today that is exactly one thing, and it is the second-largest item in a real
-* attach: the `stream_delta`s the reducer does not model. Measured over one
-* 1,270-row session, the delta run was 774 KB, and **~85% of it was frames the
-* reducer throws away** — `input_json_delta` (a tool call's arguments, streamed
-* character by character, 383 KB), `signature_delta` (encrypted-thinking
-* signatures, 153 KB) and the `message_start`/`content_block_start`/`_stop`
-* scaffolding (244 KB). The reducer models two delta kinds, `text_delta` and
-* `thinking_delta`; everything else falls through its switch untouched.
-*
-* What is deliberately **not** dropped, though the arithmetic would allow it:
-*
-* - `thinking_delta` — the Claude SDK delivers thinking blocks whose `thinking`
-*   is `''`, and the reducer backfills them from the accumulated streamed text
-*   (`streamedThinking`). Dropping these erases every thought from a replayed
-*   transcript. This is the same carve-out `snapshotRetains` documents, and it
-*   is the reason that rule is provider-engine-only.
-* - `text_delta` — superseded by the `assistant_message` that follows it, which
-*   filters the streaming id and rebuilds from the full content blocks. It could
-*   go, but only with a lookahead proving the message arrived, and at 24 KB in
-*   the measured session it is not worth a rule that has to be right about
-*   supersession. A merge is likewise not worth it: a *drop* needs no synthesized
-*   event and therefore no invented seq.
-*
-* A live event is never affected — this is about the buffered replay alone — and
-* the caller must never drop the log's highest-seq event whatever this says, for
-* the reason {@link replayCoalesceKey} gives: the replay hold waits for
-* `state.lastSeq` to reach the attach's `session.lastSeq` and would hang on a
-* blank panel forever.
-*
-* The property is the family's usual one and is a test rather than an argument:
-* folding the full log and the retained log through `applyEvent` yields
-* identical state (`packages/react/test/replay-retain.test.ts`).
-*/
 function replayRetains(body) {
 	if (body.type !== "stream_delta") return true;
 	const delta = body.event;
 	if (delta.type !== "content_block_delta") return false;
 	return delta.delta?.type === "text_delta" || delta.delta?.type === "thinking_delta";
 }
-/**
-* Does a `RunnerSnapshot` keep this event in its persisted log?
-*
-* The fourth of the same family, and the same shape of claim as
-* {@link replayCoalesceKey}: which events a *store* may drop without any client
-* being able to tell. It exists because a snapshot embeds the whole event log,
-* and a log is mostly stream deltas — a four-character token rides a ~180-byte
-* JSON envelope, so the delta run is tens of times the size of the text it
-* spells, sitting on disk *beside* the `assistant_message` that respells it in
-* full. That was affordable while a snapshot was written once, at a park. It is
-* not affordable written after every turn, which is what restart-survival needs.
-*
-* So: everything is retained except `stream_delta`. The reason that is safe is
-* not that deltas are unimportant but that they are **superseded by
-* construction**. The reducer upserts them under one constant id and the
-* following `assistant_message` filters exactly that id out and rebuilds from
-* the full content blocks — and a snapshot may only be taken at a rest point,
-* where the stream loop has exited and flushed. Both exits flush, including the
-* error path: an interrupted turn pushes its half-finished buffers into a
-* durable `assistant_message` before it emits the failed `turn_result`. There is
-* no rest state in which a delta is the only record of anything.
-*
-* **Provider engine only**, and this is the carve-out that must not be lost:
-* against a *Claude* log the rule would be wrong. The Claude SDK delivers
-* thinking blocks whose text is `''`, with the human-readable summary existing
-* only in the delta stream, and the reducer carries the streamed text over to
-* fill them (`transcript.ts`, the `streamedThinking` backfill). Dropping deltas
-* there would silently erase every thought from a restored transcript. Today
-* that is unreachable rather than merely avoided — only the provider engine
-* implements `park()`/`snapshot()` at all, and `#restore` refuses a snapshot
-* from another engine — but an engine that gains one inherits this obligation.
-*
-* Two properties hold it up, both of which are tests rather than arguments:
-* folding the full log and the retained log through `applyEvent` yields
-* identical state (`packages/react/test/snapshot-retain.test.ts`, the same
-* property `replay-coalesce.test.ts` asserts), and the retained log's last event
-* still carries the snapshot's own `seq`. The second matters more than it looks:
-* `transcriptActivity(stream_delta)` is 0, so the count `#restore` recomputes
-* from the log is bit-identical — a client's unread cursor cannot move — and the
-* replay hold waits for `state.lastSeq` to reach the attach's `lastSeq`, which a
-* rule that could drop the final event would hang forever.
-*/
 function snapshotRetains(body) {
 	return body.type !== "stream_delta";
 }
 //#endregion
-export { DEFAULT_VIEW_CONFIG, ENGINE_CAPABILITIES, PROTOCOL_VERSION, PROVIDER_PERMISSION_MODES, STATE_LABELS, STATE_ORDER, SUBAGENT_HISTORY, TOOL_RESULT_HEAD_CHARS, Watermarks, adaptersOf, clearFilters, contextReading, filterRows, groupRows, hasFacetFilter, imagePartRef, inScope, isAgentRecord, isJobRun, mergeUsage, orderUsageWindows, projectKey, projectLabel, projectSubpath, projectsOf, replayCoalesceKey, replayRetains, runningSubagents, scopeActive, sessionLabel, sessionState, snapshotRetains, subagentLabel, subsetSummary, supportsPermissionMode, transcriptActivity, transcriptContent, unseenCount, usageInfos, watermarkKey };
+export { DEFAULT_VIEW_CONFIG, ENGINE_CAPABILITIES, PROTOCOL_VERSION, STATE_LABELS, STATE_ORDER, SUBAGENT_HISTORY, TOOL_RESULT_HEAD_CHARS, Watermarks, adaptersOf, clearFilters, contextReading, filterRows, groupRows, hasFacetFilter, imagePartRef, inScope, isAgentRecord, isJobRun, mergeUsage, orderUsageWindows, projectKey, projectLabel, projectSubpath, projectsOf, replayCoalesceKey, replayRetains, runningSubagents, scopeActive, sessionLabel, sessionState, snapshotRetains, subagentLabel, subsetSummary, supportsPermissionMode, transcriptActivity, transcriptContent, transcriptProse, unseenCount, usageInfos, watermarkKey };
 
 //# sourceMappingURL=index.mjs.map