@workerdeck/protocol 0.23.0 → 1.0.0

package/build/index.d.mts

@@ -1,120 +1,46 @@
 //#region src/session-list.d.ts
-/**
- * How a sessions list is filtered, grouped and sorted — the whole of the view
- * config, kept pure and separate from the components so every surface renders
- * one derived list and nothing else decides what is visible.
- *
- * Framework-free like `transcript.ts`, and for the same reason: more than one
- * party has to agree. In the VS Code extension the webview renders the list and
- * the extension host counts the activity-bar badge over the same rows (a badge
- * that ignored the filter would announce work in sessions the list is
- * deliberately hiding); in the dashboard the list and its subset line derive
- * from it; on iOS it is mirrored to Swift the way the reducer is.
- *
- * Sessions are shown across ALL gateways by default; the gateway is a facet like
- * any other, not the frame the list lives in.
- */
-/** Coarse lifecycle bucket — what a person actually filters on. Raw statuses are
- * too many and too engine-shaped ('starting' vs 'running' is not a decision). */
 type SessionState = 'attention' | 'working' | 'idle' | 'ended';
 declare const STATE_ORDER: readonly SessionState[];
 declare const STATE_LABELS: Record<SessionState, string>;
 declare function sessionState(info: SessionInfo): SessionState;
-/**
- * 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.
- */
 declare function runningSubagents(info: SessionInfo): SubagentInfo[];
-/**
- * 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.
- */
 declare function isAgentRecord(sub: SubagentInfo): boolean;
 declare function subagentLabel(sub: SubagentInfo): string;
-/** The facets a session can be grouped or sorted by. */
 type Facet = 'gateway' | 'adapter' | 'state' | 'project';
 type GroupBy = 'none' | Facet;
 type SortBy = 'recent' | 'name' | Facet;
 type ViewConfig = {
-  search: string; /** Empty = no filter. Ids, not names: names are editable. */
+  search: string;
   gateways: string[];
   adapters: string[];
   states: SessionState[];
-  /**
-   * Empty = no filter. Keys are {@link projectKey} output — never names, which
-   * are neither unique (two repos both called "api") nor stable (editing
-   * `.workerdeck.json` renames every session at once and must not empty a
-   * saved filter). Optional, unlike its three siblings, because stored view
-   * configs predate it: a config restored from `localStorage`/`globalState`
-   * without the key must keep filtering, so absent and empty mean the same
-   * thing.
-   */
   projects?: string[];
-  /** Show only sessions inside the host's own folders. Inert where there is no
-   * such notion (no folder open, a dashboard with no workspace), which is why it
-   * can default on. */
   scoped: boolean;
   groupBy: GroupBy;
   sortBy: SortBy;
 };
 declare const DEFAULT_VIEW_CONFIG: ViewConfig;
-/**
- * One folder the surrounding host has open, as a place sessions can live in.
- *
- * `hostId` present = the folder belongs to exactly that gateway. Absent = a real
- * local folder, which only a loopback gateway's cwds can be inside: a remote
- * gateway's paths are on another machine, where an identical-looking path means
- * nothing.
- */
 type ScopeRoot = {
   hostId?: string;
   path: string;
 };
-/** The host's own folders — the sessions list's intrinsic scope. */
 type WorkspaceScope = {
   label: string;
   roots: ScopeRoot[];
 };
-/** A session with everything the list needs to filter, group and label it. */
 type SessionRow = {
   hostId: string;
-  hostName: string; /** Its gateway is loopback — its cwds are paths on this machine. */
+  hostName: string;
   local: boolean;
   adapter: string;
   state: SessionState;
   info: SessionInfo;
-  /** Transcript rows since this session was last on screen. 0 = nothing new (or
-   * never visited, which is not the same as unread). */
+  /**
+   * Messages this client has not read — `unseenCount` against its watermark, so the
+   * unit is prose (`SessionInfo.proseCount`) wherever the gateway reports it. A session
+   * that is only running tools contributes 0: the badge answers "is there something to
+   * read", not "is anything happening", which is what `state` is for.
+   */
   unseen: number;
 };
 type SessionGroup = {
@@ -122,300 +48,88 @@ type SessionGroup = {
   label?: string;
   rows: SessionRow[];
 };
-/** The adapters actually present, for the filter chips — derived rather than
- * enumerated, so a new engine needs no change here. */
 declare function adaptersOf(rows: readonly SessionRow[]): string[];
-/**
- * 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.
- */
 declare function projectsOf(rows: readonly SessionRow[]): {
   key: string;
   label: string;
 }[];
 declare function sessionLabel(info: SessionInfo): string;
-/**
- * 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}.
- */
 declare function projectKey(row: SessionRow): string;
-/**
- * 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.
- */
 declare function projectLabel(row: Pick<SessionRow, 'info'>): string;
-/**
- * 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.
- */
 declare function projectSubpath(row: Pick<SessionRow, 'info'>): string | undefined;
-/**
- * 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.
- */
 declare function isJobRun(info: SessionInfo): boolean;
-/**
- * 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.
- */
 declare function inScope(row: SessionRow, scope: WorkspaceScope): boolean;
-/** 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. */
 declare function scopeActive(config: ViewConfig, scope: WorkspaceScope | undefined): boolean;
 declare function filterRows(rows: readonly SessionRow[], config: ViewConfig, scope?: WorkspaceScope): SessionRow[];
-/**
- * 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.
- */
 declare function groupRows(rows: readonly SessionRow[], config: ViewConfig): SessionGroup[];
-/**
- * What the list is hiding, and why — the one "you are seeing a subset" signal.
- *
- * There used to be two: a dot on the funnel and a scope line above the list.
- * They competed (the scope line said one thing, the dot counted a superset of
- * it) and neither said how much was missing. This is the single rule both the
- * count and the wording come from: absent when nothing is hidden, and otherwise
- * naming every cause, so the line is never "12 of 30" with no way to guess why.
- *
- * Search is a cause like any other. Its box is visible, but the *consequence*
- * of it — rows gone from the list — is the thing being reported, and leaving it
- * out would make the arithmetic wrong.
- */
 type SubsetSummary = {
   shown: number;
   total: number;
   causes: string[];
 };
 declare function subsetSummary(config: ViewConfig, scope: WorkspaceScope | undefined, shown: number, total: number): SubsetSummary | undefined;
-/**
- * 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.
- */
 declare function hasFacetFilter(config: ViewConfig): boolean;
-/** "Show me everything": every filter off, including scope. The group/sort
- * choices are a layout preference and survive. */
 declare function clearFilters(config: ViewConfig): ViewConfig;
 //#endregion
 //#region src/usage.d.ts
-/**
- * What one session was last told about the plan's windows: the transcript's own
- * rate-limit state, and the event clock of the newest reading in it.
- *
- * Deliberately structural rather than `TranscriptState` — protocol may not
- * import a client — and it is exactly the two fields the reducer keeps.
- */
 type SessionUsage = {
-  /** Keyed by `rateLimitType`, as the reducer stores it. */rateLimits?: Record<string, RateLimitInfo>;
-  /** Epoch ms of the newest `rate_limit` event this session saw — one clock for
-   * the whole map, which is all the reducer records. */
+  rateLimits?: Record<string, RateLimitInfo>;
   updatedAt?: number;
 };
-/**
- * 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.
- */
 declare function mergeUsage(session: SessionUsage, profile: ProfileUsage | undefined): ProfileUsage;
-/** One window as a surface draws it: the reading, its own date, and whether the
- * gateway is the one that zeroed it. */
 type UsageWindowRow = {
   key: string;
-  info: RateLimitInfo; /** Epoch ms of the reading. Absent only for a hand-built state with no clock. */
+  info: RateLimitInfo;
   updatedAt?: number;
   inferredReset?: boolean;
 };
-/**
- * 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.
- */
 declare function orderUsageWindows(usage: ProfileUsage | undefined): UsageWindowRow[];
-/** 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". */
 declare function usageInfos(usage: ProfileUsage | undefined): Record<string, RateLimitInfo> | undefined;
 //#endregion
 //#region src/watermarks.d.ts
-/**
- * "What had you seen, and when" — per session, across reloads.
- *
- * Two numbers because two surfaces ask different questions. A session list has
- * only the REST rollup for sessions it isn't showing, so it compares **rows the
- * gateway counted**; a panel has the whole transcript, so it compares **rows it
- * rendered** and can put the mark in the right place. Keeping both means neither
- * surface has to attach to something it isn't rendering.
- *
- * A watermark is only written while a session is genuinely on screen. A surface
- * nobody can see is not being read, and marking it read is how an unread badge
- * silently stops working.
- *
- * Storage is a seam (`WatermarkStore`) rather than a dependency: the VS Code
- * extension backs it with `globalState`, the dashboard with `localStorage`, and
- * neither belongs in this package.
- */
 type Watermark = {
-  /** Transcript rows seen (`SessionVitals.itemCount`). */itemCount: number;
-  /** Rows the gateway had counted (`SessionInfo.activityCount`) — the same unit
-   * as `itemCount`, but from the rollup, so it is knowable for a session this
-   * client is not showing. */
+  itemCount: number;
   activity: number;
-  /** Completed turns seen. The fallback unit for a gateway too old to report
-   * `activityCount`; five tool calls in one turn count as one. */
-  turns: number; /** When this was last true. */
+  /**
+   * Prose rows read (`SessionInfo.proseCount`). Optional because a mark stored before
+   * prose counting existed cannot say — see `unseenCount`, which reads that absence as
+   * "caught up" rather than badging a whole history the operator has already seen.
+   */
+  prose?: number;
+  turns: number;
   seenAt: number;
 };
-/** Where the marks are kept. Reads happen once at construction; writes are
- * whole-map and may be async — nothing here awaits them. */
 type WatermarkStore = {
   read(): Record<string, Watermark> | undefined;
   write(marks: Record<string, Watermark>): void;
 };
-declare const watermarkKey: (hostId: string, sessionId: string) => string;
+declare function watermarkKey(hostId: string, sessionId: string): string;
 declare class Watermarks {
   #private;
   constructor(store: WatermarkStore);
   get(hostId: string, sessionId: string): Watermark | undefined;
-  /** Every mark, for a caller deriving unread counts over a whole list. */
   all(): Readonly<Record<string, Watermark>>;
-  /**
-   * 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: string, sessionId: string, seen: {
     itemCount?: number;
     activity?: number;
+    prose?: number;
     turns?: number;
   }, now?: number): boolean;
-  /** Forget a session — it was deleted, and its mark is now noise. */
   forget(hostId: string, sessionId: string): void;
 }
 /**
- * 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.
  */
 declare function unseenCount(mark: Watermark | undefined, info: {
+  proseCount?: number;
   activityCount?: number;
   turns?: number;
 }): number;
 //#endregion
 //#region src/index.d.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. */
-declare const PROTOCOL_VERSION = 7;
-/**
- * - `starting` — runner spawned, waiting for the SDK init handshake
- * - `running` — a turn is in progress
- * - `awaiting_approval` — blocked on at least one pending permission request
- * - `idle` — between turns; accepting user messages
- * - `parked` — waiting on a deferred tool execution. The live runner has been torn
- *   down and the session's state persisted; delivering the execution's result
- *   (`POST {basePath}/executions/:executionId/result`) rehydrates it under the same
- *   id and the run continues. Not terminal.
- * - `failed` — the underlying query errored; terminal
- * - `closed` — closed by a client or the host; terminal
- */
+declare const PROTOCOL_VERSION = 1;
 type SessionStatus = 'starting' | 'running' | 'awaiting_approval' | 'idle' | 'parked' | 'failed' | 'closed';
 type PermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan' | 'dontAsk' | 'auto';
 type TextBlock = {
@@ -441,192 +155,41 @@ type ToolResultBlock = {
     [key: string]: unknown;
   }>;
   is_error?: boolean;
-  /**
-   * This block carries only the **head** of the result: the replay truncated it
-   * (see {@link TOOL_RESULT_HEAD_CHARS}), and the whole thing is one fetch away
-   * at `GET /sessions/:id/events/:seq/result?toolUseId=`.
-   *
-   * On the **block**, never the event, and that is the same argument
-   * `user_message.patch` has to make in reverse: the patch sits on the event and
-   * its doc must therefore caveat "only when the message carries exactly one
-   * `tool_result` block — with two, nothing says which one it belongs to". A
-   * message answering three calls truncates whichever of them is large, so
-   * paying that caveat a second time would make the marker unusable exactly
-   * when it matters. {@link FilePatch.truncated} is the shipped precedent.
-   *
-   * Only ever set on a **replay** a client asked for (`truncateResults`), so a
-   * client that has never heard of this field cannot receive one — which is why
-   * this is additive at protocol 7 rather than a bump. Absent means the block is
-   * whole.
-   */
   truncated?: boolean;
-  /** How many characters the untruncated result had. Set iff `truncated`.
-   *
-   * A client cannot compute it — it holds the head — and the number is not
-   * cosmetic: a collapsed row spells "… +N chars", and `height.ts` sizes the row
-   * by wrapping **that exact string**, so a count derived from the head would be
-   * both a lie and a different pixel height. */
   total_chars?: number;
 };
-/**
- * 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.
- */
 declare const TOOL_RESULT_HEAD_CHARS = 8000;
-/**
- * A base64 image part, delivered as an address instead of its bytes.
- *
- * The **seventh** rule of the family, and the first written *after* its
- * measurement rather than before it. Across 214 local sessions, 91% of all
- * tool-result payload is base64 image data — 489 MB against 44 MB of text — and
- * **no client renders a byte of it**: `blockText` in the reducer and
- * `joinedText` on iOS both fold a `tool_result` to its text parts, and both
- * clients draw a tool's picture from a host *path* (`savedPath` → `/produced`,
- * `/fs/read`), never from block content. So it is `replayRetains`' argument at
- * nine times the size of the case that rule was written for: bytes whose entire
- * effect on the reader is `return base`.
- *
- * A **new part type rather than a hollowed-out `image`**, and that is the one
- * judgement here worth stating. `headOf`'s shape-preservation rule — "a
- * truncation is a shorter result, never a different kind of one" — cuts the
- * other way for pixels: a head *is* a valid shorter text, but an image with no
- * bytes is not a smaller image, and spelling it `{ type: 'image', source }` with
- * no `data` invites precisely the failure shape-preservation exists to prevent,
- * a renderer that trusts `source.data` drawing `data:;base64,undefined`. An
- * unfamiliar type instead falls through every fold that already exists, exactly
- * as the CLI's own `tool_reference` part does: no `text`, so it contributes
- * nothing, and an unaware consumer renders what it renders today, which is
- * nothing. That is this family's safe failure.
- *
- * Only ever produced for a socket that asked (`imageRefs`), so a client that has
- * never heard of this type cannot receive one — which is why this is additive at
- * protocol 7, the same argument {@link ToolResultBlock.truncated} makes. Unlike
- * truncation it applies to **live events as well as replays**: the client's one
- * render path is ref-then-fetch, so bytes on a live event would either be
- * discarded (335 KB median, once per attached watcher) or need a second
- * decode-from-event path pinning megabytes inside the transcript cache — the
- * disease relocated rather than cured.
- */
 type ImageRefPart = {
   type: 'image_ref';
-  /** The stored part's own media type (`image/png`, `image/jpeg` and
-   * `image/webp` are the three observed), or `application/octet-stream` when it
-   * had none. Never the membership test — that is `image` plus a base64 source. */
   media_type: string;
-  /** Decoded size, which a client cannot compute from an address it has not
-   * fetched yet. Not cosmetic: the placeholder spells it, and in the terminal
-   * theme a rendered string *is* a row height. */
   bytes: number;
-  /**
-   * Index of this part in the **stored** block's content array, and the address
-   * a fetch is made with.
-   *
-   * A stamped field rather than the position it arrives at, because that
-   * position is not stable: `headOf` builds a truncated head by keeping text
-   * parts up to budget and dropping every other part, so a block that is both
-   * over the text budget and image-bearing has its parts renumbered the moment
-   * the two rules compose. Stamped, the address survives any later reshaping —
-   * and the route verifies it against the stored block rather than trusting it.
-   */
   part_index: number;
 };
-/**
- * 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.
- */
 declare function imagePartRef(part: {
   type?: string;
   [key: string]: unknown;
 }, index: number): ImageRefPart | undefined;
-/** Forward-compatible fallback for block types this protocol version doesn't model. */
 type UnknownBlock = {
   type: string;
   [key: string]: unknown;
 };
-/**
- * One hunk of a file edit, in unified-diff terms.
- *
- * The numbers are the engine's own, not the client's: `newStart` is where this
- * hunk begins in the file *after* the edit, which is what a reader needs to jump
- * to the change. A client cannot compute them — it has never seen the file — so
- * a diff rendered without this is a diff with no line numbers.
- */
 type PatchHunk = {
   oldStart: number;
   oldLines: number;
   newStart: number;
   newLines: number;
-  /** Body lines, each prefixed ' ' (context), '-' (removed) or '+' (added), as
-   * unified diff spells them. The prefix is part of the string. */
   lines: string[];
 };
-/**
- * What a file-editing tool changed — the renderable half of an engine's edit
- * output, and deliberately only that half.
- *
- * Both engines can say far more: the Claude SDK's `FileEditOutput` carries
- * `originalFile`, the **entire** contents of the file before the edit. That must
- * not travel here. This log is replayed to every attaching client and captured
- * into parking snapshots, so a whole file on every edit is paid for again on
- * every attach, forever — the same reason attachment bytes are references (see
- * {@link MessageAttachment}) rather than inline base64.
- *
- * So the runner projects the engine's output down to the hunks, which is exactly
- * what a diff renders and nothing more.
- */
 type FilePatch = {
-  /** Absolute path the engine reported, when it named one. */path?: string; /** `create` when the file did not exist before this edit. */
+  path?: string;
   kind?: 'create' | 'update';
   hunks: PatchHunk[];
-  /** Hunks were dropped to keep the event small. A renderer must say so rather
-   * than present a partial diff as the whole change. */
   truncated?: boolean;
 };
 type ContentBlock = TextBlock | ThinkingBlock | ToolUseBlock | ToolResultBlock | UnknownBlock;
-/**
- * A file the user attached to a message — a photo, a screenshot, a document.
- *
- * The bytes never travel on this protocol. An attachment is uploaded first
- * (`POST {basePath}/sessions/:id/attachments`), and the command that sends the
- * message names it by id; what lands in the seq-numbered event log is this
- * reference. That is deliberate: the log is replayed to every attaching client
- * and captured into parking snapshots, so a few phone photos inlined as base64
- * would be paid for on every attach, forever. Clients render a thumbnail by
- * fetching `GET {basePath}/sessions/:id/attachments/:attachmentId`.
- *
- * Lifetime is the session's, like `/files` — the store is in-memory and an
- * attachment 404s after a server restart. The message itself is unaffected: the
- * model saw the bytes at send time.
- */
 type MessageAttachment = {
-  /** Server-assigned; the path segment of the download URL. */id: string; /** Display name from the file the user picked. A leaf name, never a path. */
+  id: string;
   name: string;
-  /** IANA media type, e.g. 'image/jpeg'. The server decides how it reaches the
-   * model (image block, document block, or inlined text) from this. */
   mediaType: string;
   bytes: number;
 };
@@ -635,8 +198,6 @@ type ApiMessage = {
   content: string | ContentBlock[];
   model?: string;
   stop_reason?: string | null;
-  /** Per-API-call token usage when the message carries it (assistant messages do).
-   * Enables mid-run token accounting; result-message usage stays authoritative. */
   usage?: {
     input_tokens?: number;
     output_tokens?: number;
@@ -644,181 +205,80 @@ type ApiMessage = {
     cache_read_input_tokens?: number;
   };
 };
-/** A tool call promoted into a pending approval by the runner's canUseTool hook
- * (Claude), or an engine ask-channel request surfaced by its runner (codex).
- * The two do not share a tense: Claude asks BEFORE a tool runs; codex's command
- * approval is usually an escalation AFTER its sandbox already ran and refused
- * the command ("command failed; retry without sandbox?"). The runner authors
- * `title`/`description`/`decisionReason` to say which — clients should render
- * those fields rather than composing their own "X wants to run Y" sentence. */
 type PermissionRequest = {
-  /** Server-assigned id; used by the `permission_decision` command. */id: string;
+  id: string;
   toolName: string;
   input: Record<string, unknown>;
-  toolUseId: string; /** Full prompt sentence from the SDK, e.g. "Claude wants to read foo.txt". */
-  title?: string; /** Short noun phrase for the tool action, e.g. "Read file". */
-  displayName?: string; /** Human-readable subtitle, e.g. "Claude will have read access to ~/x". */
-  description?: string; /** Why this permission request was triggered. */
-  decisionReason?: string; /** If raised from within a subagent, that subagent's id. */
-  agentId?: string; /** Epoch ms after which the server resolves it via its timeout policy. */
+  toolUseId: string;
+  title?: string;
+  displayName?: string;
+  description?: string;
+  decisionReason?: string;
+  agentId?: string;
   expiresAt?: number;
 };
 type PermissionDecisionSource = 'client' | 'timeout' | 'policy';
-/** One choice of an AskUserQuestion question (SDK tool-input mirror). */
 type UserQuestionOption = {
   label: string;
   description?: string;
-  /** Optional preview content (markdown unless the session configures html)
-   * rendered when the option is focused. */
   preview?: string;
 };
-/** One question from the AskUserQuestion tool's input. By the tool's convention the
- * first option is the model's recommended choice. */
 type UserQuestion = {
-  question: string; /** Short chip/tag label (max ~12 chars), e.g. "Auth method". */
+  question: string;
   header: string;
   options: UserQuestionOption[];
   multiSelect?: boolean;
 };
-/** How a session treats the AskUserQuestion tool:
- * - 'ask' (default) — a pending permission like any other: interactive UIs render the
- *   question form; job webhooks carry the full request so a remote controller can
- *   answer over REST (POST /sessions/:id/permissions/:requestId).
- * - 'auto' — resolved immediately with each question's first (recommended) option.
- * - 'deny' — the tool is refused with guidance to decide autonomously (unattended runs).
- * Answers ride a permission allow as `updatedInput.answers`: question text → chosen
- * option label(s), multi-select labels comma-joined — the shape the CLI's own UI uses. */
 type QuestionBehavior = 'ask' | 'auto' | 'deny';
-/** A model the session can switch to (SDK ModelInfo mirror; fields it may grow stay unknown). */
 type ModelOption = {
-  /** Model id for createSession.model / set_model. */value: string;
-  /** Wire model id this row resolves to ('sonnet' → 'claude-sonnet-5'). What a
-   * session actually reports as its model is the resolved form, so this is how a
-   * client matches the running model back to the row that names it. */
+  value: string;
   resolvedModel?: string;
   displayName: string;
   description?: string;
-  /** Whether this belongs in a picker's main list rather than behind a "more
-   * models" step: the newest model of each family. Derived server-side — the CLI
-   * reports one flat list — so that every client groups it the same way. */
   primary?: boolean;
-  /** Reasoning efforts this model supports at create time (codex catalogs carry
-   * them, from the binary's own per-model list). Absent = the engine's default
-   * set ({@link EngineCapabilities.reasoningEfforts}) applies. Open strings —
-   * the binary's vocabulary outruns its SDK's union. */
   reasoningEfforts?: readonly string[];
 };
-/**
- * A skill the engine can decide to use — **not** a command.
- *
- * The distinction is the whole point of this type existing beside
- * {@link SlashCommandInfo}. A slash command is wire syntax: the CLI parses
- * `/wrapup` out of the message and runs it. A skill is a capability the model
- * *chooses* from its description; there is no `/skillname` the engine would
- * recognise, and sending one reaches the model as literal text.
- *
- * So a client may list these, and may offer them as a **typing aid** that
- * inserts ordinary editable prose ({@link SkillInfo.defaultPrompt}) — but it
- * must never render them as command chips, and must never put them in
- * `capabilities.commands`, which means "the CLI accepts these as commands".
- */
 type SkillInfo = {
-  /** Directory name under the skills root — the identity the model refers to. */name: string;
-  /** What the skill is for, as its own manifest states it. This is the text the
-   * MODEL selects on, so it is also the most honest thing to show a human. */
+  name: string;
   description?: string;
-  /** A one-liner where the skill declares one, for a list row too narrow for
-   * `description`. */
   shortDescription?: string;
-  /** Human-facing name from the skill's own interface block, when it differs
-   * from `name`. */
   displayName?: string;
-  /**
-   * The engine's own suggested opening message for this skill. A client that
-   * offers a picker INSERTS this as plain editable text for the user to finish
-   * and send; it is a draft, never something submitted on selection.
-   */
   defaultPrompt?: string;
-  /** Where the skill came from: 'user' | 'repo' | 'system' | 'admin' — kept as
-   * a string, the engine's set may grow. */
   scope?: string;
-  /** False when the operator has this skill switched off: still listed, because
-   * "installed but off" is a different answer from "not installed". */
   enabled: boolean;
 };
-/** A slash command the CLI accepts as user-message text (SDK SlashCommand mirror). */
 type SlashCommandInfo = {
-  /** Command name without the leading slash. */name: string;
-  description?: string; /** Hint for arguments, e.g. "<file>". */
-  argumentHint?: string; /** Alternate names resolving to this command. */
+  name: string;
+  description?: string;
+  argumentHint?: string;
   aliases?: string[];
 };
-/** One category row from the CLI's context-usage breakdown (system prompt, tools, ...). */
 type ContextUsageCategory = {
   name: string;
   tokens: number;
-  /** Color the CLI assigns the category. Often a CLI theme token name ('inactive',
-   * 'promptBorder', ...), not a CSS color — validate before styling with it. */
   color: string;
 };
-/** Context-window usage snapshot (SDK getContextUsage mirror), polled after each turn. */
 type ContextUsage = {
   categories: ContextUsageCategory[];
   totalTokens: number;
-  maxTokens: number; /** Used share of the window, 0–100. */
-  percentage: number; /** Model the window sizing applies to. */
+  maxTokens: number;
+  percentage: number;
   model?: string;
 };
-/**
- * The context-window reading that rides the **sessions list**, as opposed to the
- * full {@link ContextUsage} that rides the event stream.
- *
- * Three numbers, and the omission is the design: `categories` is a breakdown for
- * a dialog that has a live session behind it, and this field is on every row of
- * `GET /sessions`, which a busy client polls at 1.2s. Same attachment-bytes
- * discipline as {@link SessionInfo.subagents}. `percentage` alone would size a
- * ring, but the token pair is what lets a row *say* `142k / 200k` on hover or
- * long-press without a second round trip, and it is two numbers.
- *
- * **Absent is a real state and is not zero.** A parked session, one that has
- * never run a turn, or an engine that reports no window has no reading — render
- * nothing, never an empty ring, which claims "context is empty" rather than "no
- * answer". Also absent on an older server.
- */
 type ContextReading = {
   totalTokens: number;
-  maxTokens: number; /** Used share of the window, 0–100. */
+  maxTokens: number;
   percentage: number;
 };
-/**
- * One rate-limit window snapshot (SDK SDKRateLimitInfo mirror). Emitted only for
- * claude.ai subscription sessions — API-key sessions may never produce one, so
- * clients must render nothing (not 0%) until data arrives.
- */
 type RateLimitInfo = {
-  /** 'allowed' | 'allowed_warning' | 'rejected' — kept as string, the SDK union may grow. */status: string;
-  /** Which window: 'five_hour' (session), 'seven_day' (weekly), 'seven_day_opus',
-   * 'seven_day_sonnet', 'overage', ... — kept as string, the SDK union may grow. */
+  status: string;
   rateLimitType?: string;
-  /** Used share of the window, 0–100. The CLI omits it on some updates — treat
-   * absent as unknown, not 0. */
-  utilization?: number; /** Epoch **seconds** when the window resets (render countdowns client-side). */
+  utilization?: number;
   resetsAt?: number;
   isUsingOverage?: boolean;
 };
-/**
- * Lifecycle of one tool execution, correlated by `executionId` end to end.
- *
- * - `pending` — dispatched, result not in yet (bridged to a client, or queued).
- * - `deferred` — parked beyond this turn/process; may outlive the session's
- *   liveness and be applied on rehydration.
- * - `settled` / `failed` — terminal. Results are applied idempotently by id, so
- *   a duplicate delivery is a no-op rather than a second application.
- */
 type ToolExecutionStatus = 'pending' | 'deferred' | 'settled' | 'failed';
-/** Where a tool execution ran (or is running). Advisory: for display and routing. */
 type ToolExecutionBackend = 'server' | 'browser' | 'managed' | 'remote';
-/** Result payload of a tool execution, by value — never a live host reference. */
 type ToolExecutionOutput = {
   type: 'text';
   value: string;
@@ -826,14 +286,11 @@ type ToolExecutionOutput = {
   type: 'json';
   value: unknown;
 };
-type SessionEventBody = /** SDK init handshake: what this session actually is. */{
+type SessionEventBody = {
   type: 'system_init';
   sdkSessionId: string;
   model: string;
   cwd: string;
-  /** Where the session's Anthropic auth came from: 'oauth' means a claude.ai
-   * subscription login; other values ('user' | 'project' | 'org' | 'temporary')
-   * are API-key provenance. Kept as string — the SDK union may grow. */
   apiKeySource: string;
   tools: string[];
   skills: string[];
@@ -848,136 +305,55 @@ type SessionEventBody = /** SDK init handshake: what this session actually is. *
   type: 'status_changed';
   status: SessionStatus;
   detail?: string;
-}
-/** Models and slash commands available to this session; fetched from the CLI after
- * init. Late attachers get it via replay like any other event. */
-| {
+} | {
   type: 'capabilities';
   models: ModelOption[];
   commands: SlashCommandInfo[];
-  /** Wire id the session's *default* resolves to, from the CLI's own `default`
-   * row. Answers "what will this session answer as" before it has answered
-   * anything — `system_init` carries the model, but a promptless session gets
-   * no `system_init` until its first message. */
   defaultModel?: string;
-}
-/**
- * The skills this session's engine can reach ({@link SkillInfo}) — a full
- * replacement each time, not a delta, so a late attacher's replay of several
- * of these converges on the last one. Emitted once the session's engine has
- * enumerated them, and again whenever the engine reports the set changed
- * (a skill added or edited on disk).
- *
- * Deliberately NOT folded into `capabilities.commands`: skills are not
- * commands (see {@link SkillInfo}). Only engines whose record sets
- * {@link EngineCapabilities.skillsList} ever emit it.
- */
-| {
+} | {
   type: 'skills';
   skills: SkillInfo[];
-}
-/**
- * The engine wrote a file on the **host filesystem** and handed over its path
- * — codex's `image_gen` saving a PNG is the case that motivated it. The
- * host-filesystem sibling of `file_delivered` (which is the scratch-VFS one).
- *
- * Fetch it at `GET {basePath}/sessions/:id/produced/:fileId` for as long as
- * the session lives. That route has no root allowlist and no size cap, and
- * that is sound *because of where the path came from*: this event is authored
- * by the runner about a file the engine itself just wrote, not by the agent
- * about a path it chose. `/fs/*` gates the second kind and must keep doing so
- * — a file the agent merely *read* is not a produced file and does not belong
- * here.
- *
- * Re-emitting the same file is a no-op: `fileId` is derived from the path, so
- * a runner that learns the path twice (codex reports `savedPath` on both the
- * progress and completed item) registers it once.
- */
-| {
-  type: 'file_produced'; /** Opaque, stable per session+path. The route's path segment. */
+} | {
+  type: 'file_produced';
   fileId: string;
-  /** Absolute host path, as the engine reported it. Shown to the operator,
-   * and what a client matches against a tool card's own `savedPath`. */
   path: string;
-  /** Media type when the runner could determine one (usually from the
-   * extension). Absent = let the route's own sniffing decide. */
-  mediaType?: string; /** Size at the time it was reported, when the runner knew it. */
-  bytes?: number; /** The tool call that produced it, when one did. */
+  mediaType?: string;
+  bytes?: number;
   toolUseId?: string;
-} /** The session's model changed via `set_model`. `model` undefined = back to default. */ | {
+} | {
   type: 'model_changed';
   model?: string;
-} /** The session's permission mode changed via `set_permission_mode`. */ | {
+} | {
   type: 'permission_mode_changed';
   mode: PermissionMode;
-} /** Context-window usage snapshot; the runner polls it after each turn. */ | {
+} | {
   type: 'context_usage';
   usage: ContextUsage;
-} /** Subscription rate-limit update for one window (see {@link RateLimitInfo}). */ | {
+} | {
   type: 'rate_limit';
   info: RateLimitInfo;
-}
-/** Which claude.ai plan the rate-limit windows belong to: 'pro' | 'max' | 'team' |
- * 'enterprise' — kept as string, the set may grow. Emitted from the same poll as
- * `rate_limit`, once per change, and never for an API-key session (which has no
- * plan). It names the windows; it does not size them — the tier suffix a
- * subscription page shows ("Max 20x") is not in the data. */
-| {
+} | {
   type: 'plan_info';
   subscriptionType: string;
-}
-/**
- * The engine started a **fresh conversation inside the same session** — the
- * CLI's `/clear`, a plan-mode exit, and whatever fresh-conversation flows the
- * SDK grows. The session id, registry row, workspace and scope are all
- * unchanged; only the conversation is new. Clients empty the transcript and
- * keep every session-scoped fact (models, commands, skills, produced files,
- * rate limits, cwd, permission mode).
- *
- * The server's replay honours it too: an attach after a reset does not
- * resurrect the cleared rows, because the runner skips *transcript content*
- * below the latest reset (see {@link transcriptContent}) while still
- * replaying every state-bearing event. `SessionInfo.activityCount` stays
- * monotonic across a reset on purpose — it is an unread cursor, not an item
- * count, and winding it back would kill every stored watermark above it.
- */
-| {
+} | {
   type: 'conversation_reset';
-  /** The engine session id the fresh conversation runs under (the SDK's
-   * `new_conversation_id`), when the engine reported one. The follow-up
-   * `system_init` remains authoritative. */
   sdkSessionId?: string;
 } | {
   type: 'assistant_message';
-  message: ApiMessage; /** Set when the message was produced inside a subagent (Task tool). */
-  parentToolUseId: string | null; /** True when backfilled from a resumed session's history. */
+  message: ApiMessage;
+  parentToolUseId: string | null;
   replay?: boolean;
   uuid: string;
 } | {
   type: 'user_message';
   message: ApiMessage;
-  parentToolUseId: string | null; /** True when replayed from a resumed session's history. */
-  replay?: boolean; /** True for tool results and other synthetic user-role messages. */
+  parentToolUseId: string | null;
+  replay?: boolean;
   synthetic?: boolean;
-  /** Files sent with this message, by reference (see {@link MessageAttachment}).
-   * `message.content` carries the typed text only — the attachment bytes went
-   * to the model, not into this log. */
   attachments?: MessageAttachment[];
-  /**
-   * What a file-editing tool changed, when this message carries that tool's
-   * result (see {@link FilePatch}). Set by the runner from the engine's own
-   * structured output — never derived by a client from the result text.
-   *
-   * Only when the message carries exactly one `tool_result` block, which is
-   * what both engines send: with two, there is nothing that says which one
-   * the patch belongs to, and guessing would attach a diff to the wrong call.
-   */
   patch?: FilePatch;
   uuid?: string;
-}
-/** Raw Anthropic streaming event (message_start/content_block_delta/...); emitted only
- * when the session was created with `includePartialMessages`. */
-| {
+} | {
   type: 'stream_delta';
   event: {
     type: string;
@@ -991,7 +367,7 @@ type SessionEventBody = /** SDK init handshake: what this session actually is. *
   isError: boolean;
   durationMs: number;
   numTurns: number;
-  totalCostUsd: number; /** Final text of the turn (success only). */
+  totalCostUsd: number;
   result?: string;
   errors?: string[];
   usage?: unknown;
@@ -1002,48 +378,34 @@ type SessionEventBody = /** SDK init handshake: what this session actually is. *
   type: 'permission_resolved';
   requestId: string;
   behavior: 'allow' | 'deny';
-  resolvedBy: PermissionDecisionSource; /** Denial message, when denied. */
+  resolvedBy: PermissionDecisionSource;
   message?: string;
-}
-/** A tool execution was dispatched to a backend. For bridged executions this
- * precedes the `tool_call_request` frame; for deferred ones it is the record
- * that survives a teardown. */
-| {
+} | {
   type: 'execution_dispatched';
   executionId: string;
   toolName: string;
-  backend: ToolExecutionBackend; /** True when the execution may outlive this turn or process. */
-  deferred?: boolean; /** Epoch ms after which the server applies its timeout policy. */
+  backend: ToolExecutionBackend;
+  deferred?: boolean;
   expiresAt?: number;
-} /** A dispatched execution produced a result. Applied idempotently by `executionId`. */ | {
+} | {
   type: 'execution_result';
   executionId: string;
-  output: ToolExecutionOutput; /** Guest/agent-visible logs, if the backend captured any. */
+  output: ToolExecutionOutput;
   logs?: string[];
   durationMs?: number;
-}
-/** A dispatched execution failed, timed out, or was orphaned. The failure is fed
- * back into the loop as tool output so the agent can adapt — it is not a session error. */
-| {
+} | {
   type: 'execution_failed';
-  executionId: string; /** Machine-readable cause: 'timeout' | 'oom' | 'exception' | 'orphaned' | backend-specific. */
+  executionId: string;
   reason: string;
   error: string;
   logs?: string[];
   durationMs?: number;
-}
-/** The agent handed over a file from its session scratch filesystem (the
- * `deliver_file` tool). Download it via `GET {basePath}/sessions/:id/files/<path>`
- * for as long as the session lives (the VFS is in-memory). */
-| {
+} | {
   type: 'file_delivered';
   path: string;
   bytes: number;
   description?: string;
-}
-/** Any SDKMessage this protocol version doesn't model first-class (task progress,
- * compaction boundaries, auth status, ...). Payload is the raw SDK message. */
-| {
+} | {
   type: 'sdk_event';
   payload: {
     type: string;
@@ -1057,68 +419,36 @@ type SessionEventBody = /** SDK init handshake: what this session actually is. *
   reason: 'client' | 'server' | 'error';
 };
 type SessionEvent = SessionEventBody & {
-  /** Monotonic per-session sequence number, starting at 1. */seq: number; /** Epoch ms when the server emitted the event. */
+  seq: number;
   ts: number;
 };
 type SessionCommand = {
   type: 'user_message';
   text: string;
-  /** Ids from `POST {basePath}/sessions/:id/attachments`, in the order they
-   * should reach the model. Unknown ids fail the command rather than sending
-   * a message that quietly lost its picture. */
   attachmentIds?: string[];
 } | {
   type: 'permission_decision';
   requestId: string;
-  behavior: 'allow' | 'deny'; /** allow only: modified tool input to run instead of the original. */
-  updatedInput?: Record<string, unknown>; /** deny only: reason surfaced to the model. */
-  message?: string; /** deny only: also interrupt the running turn. */
+  behavior: 'allow' | 'deny';
+  updatedInput?: Record<string, unknown>;
+  message?: string;
   interrupt?: boolean;
 } | {
   type: 'interrupt';
-}
-/**
- * Reset the conversation in place — same session id, same watermarks, same
- * row in the list, empty context. The server answers with a
- * `conversation_reset` event, whose replay rules are what stop a later attach
- * from resurrecting the cleared transcript.
- *
- * Send only where {@link EngineCapabilities.clearContext} says so: a server
- * that predates this command rejects it as unknown, and an engine that cannot
- * do it errors rather than quietly doing nothing.
- *
- * Sent while a turn is running, it **queues** behind that turn rather than
- * cutting it short — a clear is not an interrupt, and one that landed in the
- * middle of the turn it was clearing would be neither. Interrupt first if the
- * intent was to stop the work as well as forget it.
- */
-| {
+} | {
   type: 'clear_context';
 } | {
   type: 'set_permission_mode';
   mode: PermissionMode;
-} /** Switch the model for subsequent responses; omit `model` for the default. */ | {
+} | {
   type: 'set_model';
   model?: string;
-}
-/**
- * Result of a tool execution the server bridged to this client (see
- * {@link ToolCallRequestFrame}). Unknown or already-settled `executionId`s are
- * ignored — delivery is idempotent, and a late result after a timeout must not
- * re-open a settled call.
- *
- * Browser-returned results are UNTRUSTED input: acceptable for the user's own
- * data, never a source for server-authoritative state.
- */
-| {
+} | {
   type: 'tool_call_result';
   executionId: string;
   output: ToolExecutionOutput;
   logs?: string[];
-}
-/** The client could not execute a bridged call (unsupported tool, guest error,
- * tab closing). Fed back to the agent as tool output. */
-| {
+} | {
   type: 'tool_call_error';
   executionId: string;
   reason: string;
@@ -1127,40 +457,28 @@ type SessionCommand = {
 } | {
   type: 'close';
 };
-/** First frame the server sends after a successful attach. */
 type AttachedFrame = {
   type: 'attached';
   protocolVersion: number;
-  session: SessionInfo; /** Events with seq > the client's `afterSeq` follow as `event` frames. */
+  session: SessionInfo;
   replayingFrom: number;
 };
-/**
- * Ask the attached client to execute a tool call in its own sandbox (browser
- * bridge). The client answers with `tool_call_result` or `tool_call_error`
- * carrying the same `executionId`.
- *
- * Only sandbox-benefiting tools are ever bridged. Authenticated/authoritative
- * tools (MCP, secret-bearing APIs) execute server-side and never appear here.
- */
 type ToolCallRequestFrame = {
   type: 'tool_call_request';
   executionId: string;
   toolName: string;
-  input: unknown; /** Files to seed the client's scratch VFS with, path → contents. */
+  input: unknown;
   vfsSeed?: Record<string, string>;
   limits?: {
     timeoutMs?: number;
     memoryLimitBytes?: number;
-  }; /** Epoch ms after which the server gives up and fails the execution. */
+  };
   expiresAt?: number;
 };
 type ServerFrame = AttachedFrame | {
   type: 'event';
   event: SessionEvent;
-} | ToolCallRequestFrame
-/** A bridged execution no longer needs an answer (turn interrupted, timed out,
- * or the session closed) — the client should abandon it. */
-| {
+} | ToolCallRequestFrame | {
   type: 'tool_call_canceled';
   executionId: string;
   reason: string;
@@ -1169,283 +487,87 @@ type ServerFrame = AttachedFrame | {
   message: string;
 };
 type ClientFrame = SessionCommand;
-/** Per-profile fallbacks filled into session/job requests that leave the field
- * unset. Defaults, not enforced caps — an explicit request value always wins. */
 type ProfileDefaults = {
   model?: string;
   permissionMode?: PermissionMode;
 };
-/**
- * A named Claude Code config directory sessions can run under: the session's CLI
- * process gets it as CLAUDE_CONFIG_DIR, so the profile carries that directory's
- * settings, memory, skills, and whatever credentials the SDK/CLI resolves from it.
- * Profiles are declared in server options at startup (or a 'default' one is
- * auto-created from the operator's own config dir) — the API only reads them.
- */
-/**
- * Which engine a profile runs on. A **closed union, deliberately**: both clients
- * switch exhaustively, the Swift mirror ships in lockstep, and a closed set is
- * what lets this package carry per-engine capability defaults
- * ({@link ENGINE_CAPABILITIES}) browser-safe, with no server round-trip. Adding a
- * member is a versioned protocol event.
- *
- * - `claude` (default) — Claude Code via the Agent SDK, configured by a config dir.
- * - `codex` — OpenAI Codex over the codex CLI binary's `app-server` JSON-RPC
- *   surface, configured by a CODEX_HOME (auth resolved by the binary itself,
- *   like claude).
- * - `provider` — a model-agnostic provider over the AI SDK, assembled by the
- *   host's `createEngineRunner` hook.
- */
 type ProfileEngine = 'claude' | 'codex' | 'provider';
-/**
- * What an engine does and does not do — one axis per real difference, each field
- * answering a concrete UI or gateway question. Clients render from this record
- * instead of switching on the engine name: an absent capability means the
- * affordance is *hidden*, never a control that silently does nothing.
- *
- * Reaches clients in two places, same shape: `ProfileInfo.capabilities` (stamped
- * by the server; the create form's source) and `SessionInfo.capabilities`
- * (reported by the runner; the session surface's source). When the field is
- * absent — an older server — {@link ENGINE_CAPABILITIES} keyed by the engine
- * name is the browser-safe default.
- */
 type EngineCapabilities = {
-  /** PermissionRequest / permission_resolved can occur; approval UI is live.
-   * False: hide approval affordances entirely (and `questionBehavior` on jobs). */
   interactiveApprovals: boolean;
-  /** Modes this engine can honor. A stored choice outside the set is coerced to
-   * {@link EngineCapabilities.defaultPermissionMode}, not submitted. */
-  permissionModes: readonly PermissionMode[]; /** Coercion target for a stored/unsupported mode choice (always ∈ permissionModes). */
-  defaultPermissionMode: PermissionMode; /** CreateSessionRequest.resume works (an engine session id continues). */
+  permissionModes: readonly PermissionMode[];
+  defaultPermissionMode: PermissionMode;
   resume: boolean;
-  /** Resume replays prior history into the transcript (Claude's backfill).
-   * False + resume: show a "history predates this attach" notice instead of
-   * treating an empty transcript as a bug. */
-  resumeBackfill: boolean; /** GET /sdk-sessions offers a resume picker for this engine. */
-  listSessions: boolean; /** context_usage events can occur. False: render nothing — never a 0% ring. */
-  contextUsage: boolean; /** rate_limit / plan_info events can occur. False: render nothing. */
+  resumeBackfill: boolean;
+  listSessions: boolean;
+  contextUsage: boolean;
   rateLimits: boolean;
-  /** GET /sessions/:id/mcp works (else 501) — the engine can *list* its MCP
-   * servers. Gates the MCP panel's existence. */
   mcpStatus: boolean;
-  /**
-   * POST /sessions/:id/mcp/:name works — the engine can reconnect, enable and
-   * disable a server. Separate from {@link EngineCapabilities.mcpStatus}
-   * because listing and acting are genuinely different powers: codex reports
-   * rich status but exposes no per-server action on this transport, and a panel
-   * that rendered the buttons anyway would present three controls that do
-   * nothing and then report success. False: render the panel read-only.
-   */
-  mcpServerActions: boolean; /** A session request may bring its own mcpServers. */
-  sessionMcpServers: boolean; /** capabilities events carry slash commands (composer popover). */
+  mcpServerActions: boolean;
+  sessionMcpServers: boolean;
   slashCommands: boolean;
-  /**
-   * The `clear_context` command works — the engine can reset the conversation
-   * *in place*, keeping the session id, its watermarks and its place in the
-   * list, and announce it with {@link SessionEventBody} `conversation_reset`.
-   *
-   * Separate from {@link EngineCapabilities.slashCommands} because the two
-   * answer different questions and only one engine has both: Claude reaches a
-   * clear through the `/clear` its CLI already lists, codex has no command
-   * surface at all and needs the explicit operation, and a client that gated
-   * the control on `slashCommands` would offer it exactly where it was already
-   * offered and hide it where it is the only route.
-   *
-   * Absent = false, so an older gateway hides the control rather than
-   * presenting one that 501s.
-   */
   clearContext?: boolean;
-  /** `skills` events can occur — the engine can enumerate its skills. False:
-   * hide the skills panel entirely rather than showing an empty one. Orthogonal
-   * to `slashCommands`: an engine can have skills and no commands (codex), or
-   * commands and no skill listing (claude, whose skills reach clients only as
-   * `system_init.skills` names). */
-  skillsList: boolean; /** settingSources / allowDangerouslySkipPermissions-style CLI options apply. */
-  settingSources: boolean; /** maxTurns / maxBudgetUsd are honored (else the gateway 400s them). */
+  skillsList: boolean;
+  settingSources: boolean;
   budgets: boolean;
-  /** Attachment kinds sendMessage can deliver to the model. Filter the attach
-   * menu by kind; refuse locally before the server's 415. */
   attachments: ReadonlyArray<'image' | 'pdf' | 'text'>;
-  /** Efforts offerable at create time; absent = not settable (hide the control).
-   * Open strings — Codex's own binary already outruns its SDK's union. */
-  reasoningEfforts?: readonly string[]; /** Sessions expose a scratch VFS (GET /sessions/:id/files, deliverables panel). */
+  reasoningEfforts?: readonly string[];
   vfs: boolean;
-  /**
-   * The engine runs against a host directory, so `CreateSessionRequest.cwd` is
-   * required and meaningful (and a create form should ask for it). False: the
-   * engine has no host filesystem — the gateway accepts a session with no
-   * `cwd`, `SessionInfo.cwd` reports `''`, and there is no path to validate.
-   *
-   * Absent = true, so a wire copy from an older gateway keeps the old
-   * always-required behaviour rather than silently relaxing it.
-   */
   hostCwd?: boolean;
-  /** stream_delta granularity: per-token, coarse item updates (no typing
-   * cursor), or none. */
   streaming: 'token' | 'item' | 'none';
 };
-/**
- * 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.
- */
 declare const ENGINE_CAPABILITIES: Record<ProfileEngine, EngineCapabilities>;
-/**
- * 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).
- */
-declare const PROVIDER_PERMISSION_MODES: readonly PermissionMode[];
-/**
- * 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).
- */
 declare function supportsPermissionMode(engine: ProfileEngine | undefined, mode: PermissionMode): boolean;
-/**
- * A model provider a `provider` profile can run on. Credentials are ALWAYS
- * resolved from the operator's environment — never carried on the wire, never
- * stored here. `apiKeyEnv` names the variable to read, it does not hold a key.
- */
 type ProviderConfig = {
-  /** Provider adapter to use, e.g. 'anthropic' | 'openai' | 'moonshotai' |
-   * 'openai-compatible'. Kept as a string: the set is host-extensible. */
-  id: string; /** Default model id, e.g. 'kimi-k3'. Overridable per session. */
+  id: string;
   model?: string;
-  /** Model ids this profile offers, for the dashboard's picker. Operator-declared
-   * rather than discovered: provider engines have no equivalent of the CLI's
-   * `supportedModels()`, and only the operator knows which ids their endpoint and
-   * key actually serve. Unset → the picker offers {@link ProviderConfig.model} alone. */
-  models?: string[]; /** Base URL for OpenAI-compatible providers. */
-  baseUrl?: string; /** Environment variable the operator put the key in. Never the key itself. */
+  models?: string[];
+  baseUrl?: string;
   apiKeyEnv?: string;
 };
-/**
- * A grantable capability of the model-agnostic engine, named after the tool it
- * yields. The always-present tools (`fs_*`, `eval_script`) are not listed: they
- * are the engine's scratch filesystem and sandbox, not a grant.
- */
 type SessionCapability = 'web_search' | 'download' | 'web_fetch' | 'deliver_file';
-/**
- * What sessions under a `provider` profile get, declared by the operator. Meaning-
- * less for `claude` profiles, whose equivalents live in the config directory.
- *
- * MCP servers are named, never configured, here: a server's transport config can
- * carry credentials in its headers, and this type is served by `GET /profiles`.
- * The names refer to servers the host connected in `createEngineRunner`, which is
- * where the configs (and the credentials) stay.
- */
 type ProfileSessionDefaults = {
-  /** Capabilities granted to sessions under this profile. Absent = no
-   * declaration, so a session gets whatever backends the host wired. A session
-   * request may narrow this set, never widen it. */
   capabilities?: SessionCapability[];
-  /** MCP servers, by name, whose tools sessions under this profile may use.
-   * Absent = no declaration (every server the host connected). */
-  mcpServers?: string[]; /** Prepended to the session's system prompt. */
+  mcpServers?: string[];
   instructions?: string;
 };
-/**
- * One rate-limit window of a profile's plan, as the *gateway* last saw it — the
- * newest {@link RateLimitInfo} any session on the profile reported, across every
- * session, live or since closed. The profile is the account boundary (one config
- * dir / codex home / provider key = one plan), so this is the single usage state
- * per account, where a session's own transcript only knows what *it* was last
- * told.
- *
- * Two rules a client must keep:
- * - An absent window (or an absent {@link ProfileInfo.usage} entirely) is
- *   **unknown, not 0%** — render nothing, exactly as for session-level readings.
- *   The map is in-memory and starts empty on a cold server.
- * - `inferredReset` marks a reading the server zeroed at serve time because the
- *   reading's own `resetsAt` passed with nothing newer: the pre-reset number is
- *   then provably wrong, and 0 is the truthful *floor* (the account may have
- *   been used outside this gateway since). Distinguishable on the wire from an
- *   engine-reported 0, which carries no flag.
- */
 type ProfileUsageWindow = {
-  /** The reading, exactly as the session event carried it — except after an
-   * elapsed reset, when `utilization` is 0 and `resetsAt` is dropped (the old
-   * one names the *previous* window; a countdown from it would be nonsense). */
   info: RateLimitInfo;
-  /** Epoch ms of the event that carried the reading — honest for "Updated …"
-   * lines even when the served utilization is inferred. */
-  updatedAt: number; /** Present (true) only on the served-as-0 inference described above. */
+  updatedAt: number;
   inferredReset?: boolean;
 };
-/** Per-window plan usage, keyed by `rateLimitType` ('five_hour', 'seven_day',
- * ...) — the same keying as a transcript's rate-limit state. */
 type ProfileUsage = Record<string, ProfileUsageWindow>;
 type ProfileInfo = {
-  /** Unique name, used as {@link CreateSessionRequest.profile}. */name: string;
-  /** Engine this profile runs on. Defaults to 'claude' when absent, so profiles
-   * written before provider support keep working unchanged. */
+  name: string;
   engine?: ProfileEngine;
-  /** Absolute path set as CLAUDE_CONFIG_DIR for the session's CLI process.
-   * Required for 'claude' profiles; meaningless for the other engines. */
   configDir?: string;
-  /** Codex profiles: absolute path set as CODEX_HOME for the session's codex
-   * process (auth, config.toml, thread storage) — the `configDir` analogue,
-   * request-writable like it. Unset = the binary's own `~/.codex`. */
-  codexHome?: string; /** Provider wiring for 'provider' profiles. */
+  codexHome?: string;
   provider?: ProviderConfig;
   description?: string;
-  defaults?: ProfileDefaults; /** Provider-engine session grants (capabilities, MCP servers, instructions). */
+  defaults?: ProfileDefaults;
   session?: ProfileSessionDefaults;
-  /** Response-only: the engine's model catalog, shipped with the release and
-   * served from the first request (no process spawned, no warm-up session).
-   * For provider profiles the ids come from `provider.models` instead. Never
-   * contains a 'default' sentinel row — forms add their own "Profile default"
-   * row mapping to an unset model. Ignored on the way in. */
   models?: ModelOption[];
-  /** Response-only: what this profile's default model resolves to. For claude
-   * profiles this is the operator's CLI config — unknowable statically — so it
-   * is absent until a session on this profile reports it. */
   defaultModel?: string;
-  /** Response-only: the engine's capability record (see {@link EngineCapabilities}).
-   * Absent = use ENGINE_CAPABILITIES[engine]. Ignored on the way in. */
   capabilities?: EngineCapabilities;
-  /** Response-only: whether the profile's credentials probe as usable right now.
-   * Absent = unknown/unchecked — treat as available. **Display-only**: create
-   * against an unavailable profile still proceeds and fails with the engine's
-   * own error (the probe can be stale in both directions). */
   available?: boolean;
-  /** Response-only: one operator-actionable line, present only when
-   * `available === false`. */
   unavailableReason?: string;
-  /** Response-only: the plan's rate-limit windows as last reported by any
-   * session on this profile (see {@link ProfileUsageWindow}). Absent = unknown
-   * — no session has reported yet (API-key sessions never do), or the server
-   * restarted. **Display-only**, like `available`: never a gate. */
   usage?: ProfileUsage;
-  /** Response-only, computed by the server: this profile came from the profile
-   * store and can be edited or deleted through the API. Profiles declared in
-   * server options are absent/false — they are code. Ignored on the way in. */
   managed?: boolean;
 };
-/**
- * Curated, read-only snapshot of what a profile's config directory contains —
- * the parts relevant to running worker sessions. Values that could carry secrets
- * (env var values) never leave the server; only names are listed.
- */
 type ProfileConfigSnapshot = {
-  /** From the config dir's settings.json; absent when missing or unparseable. */settings?: {
-    /** Configured default model. */model?: string; /** permissions.defaultMode — the CLI's default permission mode. */
-    defaultPermissionMode?: string; /** Rule counts from permissions.allow / ask / deny. */
+  settings?: {
+    model?: string;
+    defaultPermissionMode?: string;
     permissionRules?: {
       allow: number;
       ask: number;
       deny: number;
-    }; /** Env var NAMES declared in settings.json env (values never included). */
-    envKeys?: string[]; /** Hook event names with at least one hook configured. */
+    };
+    envKeys?: string[];
     hooks?: string[];
-  }; /** CLAUDE.md (user memory) present in the config dir. */
-  hasUserMemory: boolean; /** Skill names (skills/<name>/). */
-  skills: string[]; /** Agent names (agents/<name>.md). */
-  agents: string[]; /** Custom slash-command names (commands/<name>.md). */
+  };
+  hasUserMemory: boolean;
+  skills: string[];
+  agents: string[];
   commands: string[];
 };
 type McpServerConfigWire = {
@@ -1462,9 +584,6 @@ type McpServerConfigWire = {
   url: string;
   headers?: Record<string, string>;
 };
-/** One tool an MCP server exposes, as the session's engine reports it.
- * Parameters are deliberately absent: the CLI's status payload names and
- * describes each tool but does not carry its input schema. */
 type McpServerToolInfo = {
   name: string;
   description?: string;
@@ -1473,224 +592,64 @@ type McpServerToolInfo = {
     destructive?: boolean;
     openWorld?: boolean;
   };
-  /**
-   * The tool's JSON Schema, where the engine reports one. **Engine-dependent,
-   * and that is not an oversight**: the Agent SDK's `McpServerStatus` names and
-   * describes each tool but carries no schema at all, while codex's
-   * `mcpServerStatus/list` returns the full one. So a client renders parameters
-   * where they exist and says they are unavailable where they don't — rather
-   * than either leaving a silent gap or claiming the absence is universal.
-   *
-   * Opaque on purpose: this is a JSON Schema document, not a shape this
-   * protocol models.
-   */
   inputSchema?: unknown;
 };
-/**
- * Live status of one MCP server on a session — what `GET
- * {basePath}/sessions/:id/mcp` answers with, and what the `/mcp` screens render.
- *
- * The connection *identity* is here (transport, command, url, scope) but never
- * its secrets: the engine's config carries `env` for stdio servers and `headers`
- * for HTTP/SSE ones, and both are dropped on the way out. A client that can read
- * this is not thereby entitled to the tokens the operator configured.
- */
 type McpServerStatusInfo = {
   name: string;
-  /** 'connected' | 'failed' | 'needs-auth' | 'pending' | 'disabled' — kept open,
-   * the engine's set may grow. */
-  status: string; /** Where the server was configured: 'project' | 'user' | 'local' | 'dynamic' | … */
-  scope?: string; /** Present when `status` is 'failed'. */
-  error?: string; /** Name and version the server announced on connect. */
+  status: string;
+  scope?: string;
+  error?: string;
   serverInfo?: {
     name: string;
     version: string;
   };
-  transport?: 'stdio' | 'http' | 'sse' | 'sdk'; /** stdio only. */
+  transport?: 'stdio' | 'http' | 'sse' | 'sdk';
   command?: string;
-  /** stdio only. Secrets do occasionally ride argv; the operator's own client
-   * shows them, and hiding them here would only mislead. `env` is not exposed. */
-  args?: string[]; /** http/sse only. */
-  url?: string; /** Present when connected. */
+  args?: string[];
+  url?: string;
   tools?: McpServerToolInfo[];
 };
 type McpServersResponse = {
   servers: McpServerStatusInfo[];
 };
-/** `POST {basePath}/sessions/:id/mcp/:name` — answers with the refreshed status. */
 type McpServerActionRequest = {
   action: 'reconnect' | 'enable' | 'disable';
 };
-/** `POST {basePath}/sessions/:id/attachments?name=<name>` — the body is the raw
- * file, the `content-type` header its media type. Answers with the reference to
- * name on the next `user_message`. */
 type UploadAttachmentResponse = {
   attachment: MessageAttachment;
 };
 type CreateSessionRequest = {
-  /** Directory the session is rooted at. Required for any engine whose
-   * capability record declares {@link EngineCapabilities.hostCwd} — `cwd` is
-   * per-query in the SDK and the server re-pins it on every call. Omittable for
-   * an engine that has no host filesystem at all (the provider engine, whose
-   * tools run against the in-memory VFS): there the field would be a required
-   * lie, and `allowedCwdRoots` would look like a sandbox boundary it is not. */
   cwd?: string;
-  /** Profile (named Claude Code config dir) to run under. Required when the server
-   * declares more than one profile; implicit when exactly one exists. */
-  profile?: string; /** Optional initial prompt (may be a skill invocation like "/verify-content 123"). */
+  profile?: string;
   prompt?: string;
   permissionMode?: PermissionMode;
-  /** Pre-authorize 'bypassPermissions' (the CLI's --dangerously-skip-permissions
-   * capability) so the mode can be switched on mid-session. Without it the CLI
-   * rejects `set_permission_mode: 'bypassPermissions'` on a running session.
-   * Implied when `permissionMode` is already 'bypassPermissions'. */
   allowDangerouslySkipPermissions?: boolean;
   allowedTools?: string[];
   disallowedTools?: string[];
   mcpServers?: Record<string, McpServerConfigWire>;
-  /** Which filesystem settings the session loads. Include 'project' to pick up the
-   * target repo's skills and CLAUDE.md ("close-to-real" fidelity). */
   settingSources?: Array<'user' | 'project' | 'local'>;
   model?: string;
   maxTurns?: number;
-  maxBudgetUsd?: number; /** Resume an existing SDK session by id. */
-  resume?: string; /** With `resume`: fork to a new session id instead of continuing. */
+  maxBudgetUsd?: number;
+  resume?: string;
   forkSession?: boolean;
-  /** Reasoning effort for the session's model (codex engine). Open string —
-   * offerable values come from the profile's catalog/capability record. The
-   * gateway 400s it when the engine's record declares no `reasoningEfforts`. */
-  reasoningEffort?: string; /** Emit `stream_delta` events for token-by-token rendering. Default true. */
-  includePartialMessages?: boolean; /** Per-session override of the server's permission-request timeout (ms). */
-  approvalTimeoutMs?: number; /** AskUserQuestion handling (see {@link QuestionBehavior}). Default 'ask'. */
+  reasoningEffort?: string;
+  includePartialMessages?: boolean;
+  approvalTimeoutMs?: number;
   questionBehavior?: QuestionBehavior;
-  /** Provider engine only: run with fewer capabilities than the profile grants
-   * (see {@link ProfileSessionDefaults.capabilities}). Narrowing only — naming a
-   * capability the profile does not grant is a 400, not a silent upgrade. */
-  capabilities?: SessionCapability[]; /** Free-form metadata echoed back on SessionInfo (host app bookkeeping). */
+  capabilities?: SessionCapability[];
   meta?: Record<string, unknown>;
-  /**
-   * Opaque string tags naming what this session *belongs to* — the gateway's
-   * only intra-deployment scoping primitive. Assigned at create, **immutable
-   * afterwards** (no route writes it), echoed on {@link SessionInfo}, and
-   * carried through parking/dormancy so a restart cannot un-scope a session.
-   *
-   * WorkerDeck never interprets a key: an embedder writes `{ space, user }` or
-   * `{ tenant }` or nothing at all. What the tags *mean* is the host's
-   * `authorizeSession` predicate; absent one, the default rule is that every
-   * key the authenticated principal pins must match here (an unset principal
-   * scope is unrestricted — the same "unset means all" rule `allowedProfiles`
-   * uses, so an operator's dashboard keeps working unchanged).
-   *
-   * NOT `meta`: `meta` is free-form, client-settable and echoed, and an
-   * enforcement rule whose input the caller supplies is not an enforcement
-   * rule. Values are visible to any principal the policy admits a session to,
-   * so use opaque ids rather than names you would not show that audience.
-   */
   scope?: Record<string, string>;
 };
-/**
- * One sub-agent (a `Task` call and the sidechain it spawned), as a *list* surface
- * sees it — without attaching.
- *
- * Sub-agent work is otherwise attach-only: it exists on the wire as
- * `parentToolUseId` on three event bodies, and is reconstructed into rows by the
- * react reducer and grouped per-Task by `terminalBlocks`. A sessions list never
- * attaches (one live attach per session, owned by the panel), so it reads
- * `SessionInfo` over REST and would otherwise have no way to know a session has
- * six agents running inside one turn.
- *
- * This is a **runner-owned rollup computed at read time**, exactly like
- * {@link SessionInfo.pendingPermissionCount}: it is not an event, it is not
- * persisted separately, and it therefore rides the REST list, the WS attach
- * snapshot and parking snapshots for free.
- *
- * **The claude and codex engines both produce it; the provider engine's absence
- * is the truth.** The AI SDK has no multi-agent primitive and no tool that runs
- * a nested agent loop, so `parentToolUseId: null` on every provider event is
- * honest. Codex's spawn signal is the `subAgentActivity` item, whose own `id` is
- * the model's `spawn_agent` call id — a genuine tool-use id — so `toolUseId`
- * keeps its documented meaning there: the codex runner authors the anchor
- * `tool_use` itself and keys every event of the agent's *thread* to it
- * (`engines/codex/subagents.ts`). The earlier version of this comment asserted
- * codex had no sidechains; that was true of the exec era and has not been true
- * for a while.
- *
- * It is deliberately **not** the input to `taskSummary`. That string is spelled
- * from the absorbed transcript items and must stay that way, so a transcript
- * replayed tomorrow spells the same line from the same items it holds today.
- */
 type SubagentInfo = {
-  /** The `tool_use` id of the `Task` call that spawned it — the same id its
-   * nested events carry as `parentToolUseId`, and therefore the handle a client
-   * uses to jump to that Task's row. */
-  toolUseId: string; /** The Task input's `subagent_type` (e.g. "Explore"), when it named one. */
+  toolUseId: string;
   agentType?: string;
-  /** The Task input's short `description`, clipped by the runner. Together with
-   * `agentType` this is what makes two parallel sub-agents tell apart in a list;
-   * a row reading only `Task` answers nothing. */
   description?: string;
-  /**
-   * `running` until the Task's own `tool_result` arrives, then `done`/`failed`
-   * from that result's `is_error`. A turn that ends without that result — an
-   * interrupt, a session error, a turn or budget cap — settles what is still
-   * running as `failed`: the report never came, which is the one thing `done`
-   * could have claimed, and a `running` badge on an idle session would be a
-   * lie a list re-renders at every poll.
-   *
-   * Deliberately **narrower than `taskFailed`** in `@workerdeck/ui`'s
-   * `tool-run.ts`, which reddens a Task row when *any child call* failed. That is
-   * right for a transcript row the reader can expand — the failure is one press
-   * away and hiding it would be worse. It is wrong for a list: a grep that
-   * matched nothing inside an otherwise successful Explore agent would put
-   * `failed` beside the session's name with nothing to open. So this reports the
-   * sub-agent's own outcome. If you are here to "fix" the inconsistency, this is
-   * the reason it exists.
-   */
-  status: 'running' | 'done' | 'failed'; /** Epoch ms the `Task` call was emitted. */
+  status: 'running' | 'done' | 'failed';
   startedAt: number;
-  /** Tool calls the sub-agent has made so far — its progress reading while
-   * running, counted from nested `tool_use` blocks. */
   toolCount: number;
 };
-/**
- * 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.
- */
 declare const SUBAGENT_HISTORY = 8;
-/**
- * A project's icon, as declared by its `.workerdeck.json` — either a named
- * glyph or a reference to an image the gateway serves.
- *
- * A discriminated union rather than one stringly field, because the two arms
- * have opposite render paths: a glyph is looked up in the client's own icon
- * set with no I/O, an image is a fetch. Collapsing them would put "is this a
- * name or an address" back on every renderer, which is the inference this
- * family keeps refusing (`ImageRefPart` is a new part type, never a
- * hollowed-out `image`, for the same reason).
- *
- * `glyph.name` is a lucide icon name, validated by the gateway for *shape*
- * only (lowercase kebab-case): the gateway has no lucide catalog and must not
- * grow one — icon sets version independently of this protocol. A client whose
- * set lacks the name renders its no-project fallback rather than erroring;
- * an unknown name is a stale row, never withheld state.
- *
- * `image` carries an **address, never bytes** — the attachment-bytes rule.
- * `SessionInfo` rides every row of `GET /sessions`, which clients poll at 1.2s
- * while anything is working, so an inlined base64 icon would be paid for on
- * every poll of every session forever (the same argument that keeps
- * `originalFile` off {@link FilePatch} and message bytes off events). The
- * bytes come from `GET {basePath}/sessions/:id/project/icon` — session-scoped
- * on purpose, so the fetch rides the same `canSee` gate as every other
- * `/sessions/:id/*` route and a scoped principal's miss is the uniform 404. A
- * project-keyed route would need the project root in the URL, and a route
- * addressed by host paths is an existence oracle for the gateway's
- * filesystem. `hash` (sha256 hex of the bytes) is the cross-session cache
- * key: two sessions in one project serve identical bytes, so a client caches
- * by hash rather than by URL and fetches once per project, not once per
- * session. The route answers with `ETag: "<hash>"` and honors
- * `If-None-Match`.
- */
 type ProjectIcon = {
   type: 'glyph';
   name: string;
@@ -1699,381 +658,74 @@ type ProjectIcon = {
   mediaType: 'image/png' | 'image/svg+xml';
   hash: string;
 };
-/**
- * Project identity for a session — what a `.workerdeck.json` in the session's
- * ancestry declares, resolved by the **gateway** and shipped on
- * {@link SessionInfo.project}.
- *
- * The gateway reads the file, not each client: the iOS app and a browser
- * pointed at a remote gateway have no access to that filesystem, so a
- * per-client reader would make the feature exist on exactly one client.
- * Discovery is an ancestor walk from the session's `cwd` upward — nearest
- * `.workerdeck.json` wins, so a session started in `packages/ui` still says
- * "WorkerDeck" — over the *realpath'd* cwd, which is what makes `root`
- * canonical below.
- *
- * The file's schema, stated here because this type is its wire projection
- * (clients never read the file; the gateway is its only parser):
- *
- * ```json
- * { "name": "WorkerDeck", "icon": "layers" }
- * { "name": "WorkerDeck", "icon": "./docs/assets/icon.png" }
- * ```
- *
- * Both keys optional, unknown keys ignored (forward compatibility). An empty
- * `{}` still marks its directory as the project root — grouping is the point,
- * and the name falls back to the root's basename. `icon` is one string with a
- * total classification rule: a value ending in `.png`/`.svg`
- * (case-insensitive) is a repo-relative image path — relative only, since the
- * file is checked into a repo that clones onto other machines, where an
- * absolute path is wrong by construction — and anything else must be a
- * lucide-shaped glyph name (`^[a-z0-9]+(-[a-z0-9]+)*$`) or it is ignored. The
- * two shapes cannot collide (a glyph name contains no dot), so the rule is a
- * classification, not a guess. Every degradation degrades *fieldwise and
- * silently*: a malformed or oversized file is skipped and the walk continues
- * to an ancestor (a broken nested file must not shadow the repo root's valid
- * one), a junk name falls back to the basename, a junk or escaping icon is
- * dropped — a session must never fail, or even warn, because of a display
- * declaration.
- *
- * `root` — the canonical (realpath'd) absolute directory holding the file, on
- * the **gateway's** filesystem — is the grouping key: two sessions are in the
- * same project iff same root *on the same gateway* (a remote gateway's
- * identical-looking path is another machine's directory — the `ScopeRoot`
- * argument). A *name* is not a key: two repos can both be called "api".
- * Canonicalizing at discovery is what makes two differently-spelled cwds of
- * one project agree on it.
- *
- * Resolved at **serve time** from a TTL cache, never persisted — the same
- * placement argument as the profile tracker's 0%-after-reset inference: it is
- * a function of the gateway's current filesystem, and a copy captured into a
- * parking record would replay a stale name forever. Editing the file shows up
- * on every session in the project within the TTL, with no migration and no
- * event.
- *
- * Additive at protocol **7**: an optional field on `SessionInfo`, where
- * absent means exactly what today's wire means (no project declared — render
- * the folder basename), an old client ignores it, and a new client against an
- * old gateway sees absent. The icon route is likewise unreachable by
- * accident: a client only fetches it when this gateway told it an image
- * exists.
- */
 type ProjectInfo = {
-  /** Display name — the file's `name`, else the root's basename. Never empty. */name: string;
-  /** Canonical absolute path of the directory holding `.workerdeck.json`, on
-   * the gateway's filesystem. The grouping key (per gateway); an opaque string
-   * to clients beyond equality and display. */
+  name: string;
   root: string;
-  /** Absent = the file declared none (or declared one the gateway refused —
-   * malformed, escaping, oversized — which a client cannot and must not
-   * distinguish). */
   icon?: ProjectIcon;
 };
 type SessionInfo = {
-  /** Server-assigned id (stable across SDK session forks/resumes). */id: string; /** Underlying Agent SDK session id, once known; use for `resume`. */
+  id: string;
   sdkSessionId?: string;
   status: SessionStatus;
-  /** Empty string for a session whose engine has no host filesystem (see
-   * {@link CreateSessionRequest.cwd}). Deliberately not optional: every client
-   * renders and searches it, and a synthetic path would send the workspace and
-   * `@file` search probing a directory that does not exist. */
-  cwd: string; /** Profile the session runs under (resolved name, present even when implicit). */
+  cwd: string;
   profile?: string;
-  /** Engine actually running this session, reported by the runner itself. Lets a
-   * session surface gate CLI-only affordances (permission modes, context usage,
-   * rate limits) without looking the profile back up. Absent = 'claude'. */
   engine?: ProfileEngine;
-  /** The engine's capability record, reported by the runner like `engine`. The
-   * attach snapshot is the session-level source (no event carries it). Absent =
-   * ENGINE_CAPABILITIES[engine]. */
   capabilities?: EngineCapabilities;
   model?: string;
   permissionMode?: PermissionMode;
-  /** Whether this session may be switched into `bypassPermissions`. The CLI only
-   * allows it when the process was spawned for it, so it is decided at creation
-   * and never changes: a session that did not ask for bypass up front cannot
-   * gain it later. Lets a picker disable the mode instead of offering a switch
-   * the engine will refuse. Absent = unknown (an older server). */
-  canBypassPermissions?: boolean; /** See the `system_init` event; 'oauth' = claude.ai subscription credentials. */
+  canBypassPermissions?: boolean;
   apiKeySource?: string;
-  createdAt: number; /** Highest event seq emitted so far; attach with `afterSeq` to catch up. */
+  createdAt: number;
   lastSeq: number;
   pendingPermissionCount: number;
-  /**
-   * Sub-agents this session has running, plus a short tail of settled ones — see
-   * {@link SubagentInfo}. Absent on an engine that has no sidechains and on an
-   * older server; **absent and empty mean the same thing to a client**, so render
-   * nothing rather than "0 sub-agents".
-   *
-   * Bounded on purpose. This rides every row of `GET /sessions`, which a busy
-   * client polls at 1.2s, and it is captured into parking snapshots — the same
-   * attachment-bytes rule that keeps whole files off {@link FilePatch}. Every
-   * *running* sub-agent is always present (they are the live reading and there
-   * are never many at once); settled ones are kept newest-first to
-   * {@link SUBAGENT_HISTORY} and then dropped, so a day-long session with two
-   * hundred Tasks does not grow an unbounded field. A client must therefore not
-   * treat this as the session's full Task history — the transcript is that.
-   */
   subagents?: SubagentInfo[];
-  meta?: Record<string, unknown>; /** Display title: `meta.title` if the host set one, else derived (e.g. first prompt). */
-  title?: string; /** Cumulative cost across all turns so far (sum of turn_result totals). */
-  totalCostUsd?: number; /** Cumulative turn count across the session. */
+  meta?: Record<string, unknown>;
+  title?: string;
+  totalCostUsd?: number;
   numTurns?: number;
+  activityCount?: number;
   /**
-   * How many transcript rows this session has produced (see
-   * {@link transcriptActivity}) — a monotonic counter a client can diff against
-   * a remembered value to answer "how much happened while I wasn't looking",
-   * without attaching.
-   *
-   * `numTurns` cannot answer it: five tool calls inside one turn are one turn.
-   * `lastSeq` cannot either — it counts every event, and with token streaming on
-   * that is hundreds per reply. Absent on an older server; a client should fall
-   * back to `numTurns` rather than showing nothing.
-   *
-   * Monotonic for the session's whole life, **including across a
-   * `conversation_reset`**: after a `/clear` this deliberately exceeds the
-   * number of rows a fresh attach renders. It is an unread *cursor* diffed
-   * against stored monotonic watermarks (see `watermarks.ts`) — resetting it to
-   * the new row count would leave every stored mark above it, and that
-   * session's badge dead until the count caught back up.
+   * Rows of the kind a person is actually waiting to read — see `transcriptProse`.
+   * Absent from a gateway that predates it — additive, so no `PROTOCOL_VERSION` bump —
+   * which is why every reader falls back to `activityCount`. This is the badge's number; `activityCount` stays the "has
+   * anything happened at all" measure that sorting and dormancy read.
    */
-  activityCount?: number; /** Epoch ms of the most recent emitted event. */
+  proseCount?: number;
   lastActivityAt?: number;
-  /**
-   * The session's latest context-window reading — see {@link ContextReading}.
-   *
-   * The same number the session screen draws, served on the list so a row can
-   * show where a session is bloating **without attaching to it**. That is the
-   * whole reason it is here: context fill is the one session metric you want
-   * across *all* sessions at once, and until now it existed only as an event on
-   * an attached socket.
-   *
-   * Retained by the runner from the last `context_usage` it emitted, so it is
-   * exactly what the transcript last showed — never recomputed on the serve
-   * path, which would be a second answer to a question that already has one.
-   * Absent until the first reading (a promptless session has none), and cleared
-   * by a `conversation_reset` for the same reason the transcript state clears
-   * it: the old window is not this conversation's.
-   */
   contextUsage?: ContextReading;
-  /** Opaque scope tags this session was created with — see
-   * {@link CreateSessionRequest.scope}. Echoed by the runner, re-stamped by the
-   * gateway, and never editable. */
   scope?: Record<string, string>;
-  /**
-   * Project identity discovered from the session's `cwd` — see
-   * {@link ProjectInfo}. Stamped by the **gateway at serve time** (runners
-   * never set it; a runner-echoed value would be persisted into parking
-   * records and replay a stale name forever). Absent = no `.workerdeck.json`
-   * in the cwd's ancestry, and also = an older gateway: both mean "render the
-   * folder basename", which is exactly today's behaviour.
-   */
   project?: ProjectInfo;
 };
-/**
- * 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.
- */
 declare function contextReading(body: SessionEventBody): ContextReading | undefined;
-/**
- * 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.
- */
 declare function transcriptActivity(body: SessionEventBody): number;
 /**
- * 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.
+ */
+declare function transcriptProse(body: SessionEventBody): number;
 declare function transcriptContent(body: SessionEventBody): boolean;
-/**
- * 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.
- */
 declare function replayCoalesceKey(body: SessionEventBody): string | undefined;
-/**
- * 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`).
- */
 declare function replayRetains(body: SessionEventBody): boolean;
-/**
- * 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.
- */
 declare function snapshotRetains(body: SessionEventBody): boolean;
-/**
- * A session in an engine's on-disk store (independent of this server's registry):
- * the Agent SDK's session files, or a codex profile's CODEX_HOME threads. Listed
- * so hosts can offer "resume" across server restarts: feed `sessionId` to
- * CreateSessionRequest.resume — under a profile of the SAME engine, since the id
- * only means something to the store it came from. `GET {basePath}/sdk-sessions`
- * takes an optional `profile` query parameter naming whose store to list; absent,
- * the profile is resolved implicitly when the server declares exactly one, else
- * the Claude engine's store is listed (the pre-engine-aware behavior). Mirrors
- * the SDK's SDKSessionInfo shape, kept browser-safe.
- */
 type SdkSessionSummary = {
-  sessionId: string; /** Custom title, auto summary, or first prompt — whichever the SDK has. */
-  summary: string; /** Epoch ms of last modification. */
+  sessionId: string;
+  summary: string;
   lastModified: number;
   createdAt?: number;
   customTitle?: string;
@@ -2081,14 +733,10 @@ type SdkSessionSummary = {
   gitBranch?: string;
   cwd?: string;
 };
-/** One deliverable in the session's scratch filesystem (see the `file_delivered` event). */
 type SessionFileInfo = {
   path: string;
   bytes: number;
 };
-/** `GET {basePath}/sessions/:id/files` — every file currently in the session's VFS.
- * `GET {basePath}/sessions/:id/files/<path>` downloads one (attachment disposition).
- * 404 when the session's engine exposes no VFS (Claude-engine sessions). */
 type ListSessionFilesResponse = {
   files: SessionFileInfo[];
 };
@@ -2101,26 +749,12 @@ type CreateSessionResponse = {
 type GetSessionResponse = {
   session: SessionInfo;
 };
-/**
- * Body of `PATCH {basePath}/sessions/:id` — the host-facing edits to a live
- * session. Today that is only its display name: `title` writes `meta.title`,
- * which {@link SessionInfo.title} prefers over the derived one, and `null` (or
- * an empty string) clears the override so the derived title comes back. Nothing
- * here reaches the engine — renaming does not speak to the model.
- *
- * 409 when the session is parked: a parked session has no runner to carry the
- * change, and its snapshot is the host's to rewrite, not this route's.
- */
 type UpdateSessionRequest = {
   title?: string | null;
 };
 type UpdateSessionResponse = {
   session: SessionInfo;
 };
-/** Body of `POST {basePath}/sessions/:id/permissions/:requestId` — the REST counterpart
- * of the WS `permission_decision` command, for remote controllers without a socket
- * (e.g. answering a job's AskUserQuestion from a webhook consumer). 404 = the request
- * is unknown, already resolved, or expired. */
 type ResolvePermissionRequest = {
   behavior: 'allow';
   updatedInput?: Record<string, unknown>;
@@ -2132,17 +766,6 @@ type ResolvePermissionRequest = {
 type ResolvePermissionResponse = {
   resolved: true;
 };
-/**
- * Body of `POST {basePath}/executions/:executionId/result` — the way a deferred
- * executor (a remote worker, a batch job, a human) delivers the outcome of an
- * execution the session parked on. The session is rehydrated if its runner was
- * torn down, and the result is folded back into the agent loop; a `failed` result
- * is ordinary tool output the agent adapts to, not a session error.
- *
- * Applied **idempotently by `executionId`**: a duplicate or late delivery (one
- * racing the execution watchdog) answers 200 with `applied: false` rather than
- * erroring or applying twice. 404 means no session is parked on that id.
- */
 type SubmitExecutionResultRequest = {
   status: 'ok';
   output: ToolExecutionOutput;
@@ -2154,129 +777,70 @@ type SubmitExecutionResultRequest = {
   logs?: string[];
 };
 type SubmitExecutionResultResponse = {
-  /** False when the id was already settled — the delivery was a no-op. */applied: boolean; /** Session the execution belonged to. */
+  applied: boolean;
   sessionId: string;
 };
 type ListSdkSessionsResponse = {
   sdkSessions: SdkSessionSummary[];
 };
-/** `GET {basePath}/profiles` — filtered to the profiles the caller may use. */
 type ListProfilesResponse = {
   profiles: ProfileInfo[];
-  /** Whether this caller may create profiles here — true only when the server has
-   * a profile store AND the principal carries `canManageProfiles`. Lets a UI hide
-   * controls that would always be refused. */
   canManage?: boolean;
 };
-/**
- * `POST {basePath}/profiles` — create a managed profile. Available only when the
- * server was given a profile store, and only to a principal with
- * `canManageProfiles`. Profiles declared in server options are code, not data:
- * they cannot be created, edited, or deleted through these routes.
- */
 type CreateProfileRequest = ProfileInfo;
-/** `PATCH {basePath}/profiles/:name` — merge into a managed profile. The name is
- * the route, not the body; pass `null` to clear an optional field. */
 type UpdateProfileRequest = Omit<Partial<ProfileInfo>, 'name'>;
-/**
- * The **host's real project tree**, not a session's in-memory VFS — the two are
- * unrelated despite both being "files". {@link SessionFileInfo} is a deliverable
- * the agent produced inside a session; these routes read and write the operator's
- * actual disk.
- *
- * That makes them **operator-privileged**: they are authorized by the server's auth
- * key alone and deliberately sit outside the agent permission flow, because the
- * caller *is* the operator, not the model. A client holding the key can already
- * start a session with any allowed cwd; browsing that same tree grants it nothing
- * new. Writing does, which is why writes are separately enabled server-side.
- *
- * The whole surface is opt-in and root-scoped: with no roots configured every route
- * below 404s. There is no "unset means anything" default here — a phone on a tailnet
- * must never be one request away from `~/.ssh`.
- */
 type HostFileRoot = {
-  /** Absolute, canonical (symlinks resolved) path of the root. */path: string; /** Last path segment, for display — roots are not named by the operator. */
+  path: string;
   name: string;
 };
-/** `GET {basePath}/fs/roots` — where a client may start browsing. Empty `roots`
- * never happens: the routes are absent entirely when none are configured. */
 type ListHostRootsResponse = {
-  roots: HostFileRoot[]; /** Whether `PUT /fs/write` is enabled here; lets a UI hide an editor it can't save from. */
+  roots: HostFileRoot[];
   canWrite: boolean;
 };
-/** One entry in a host directory listing. Classified with `lstat` semantics, so a
- * `symlink` is reported as itself and never silently resolved — following it is the
- * *next* request's problem, and that request is refused if it escapes the roots. */
 type HostDirEntry = {
-  name: string; /** Absolute path, ready to pass back as `?path=`. */
+  name: string;
   path: string;
-  type: 'file' | 'dir' | 'symlink' | 'other'; /** Regular files only. */
-  bytes?: number; /** Epoch ms mtime. */
+  type: 'file' | 'dir' | 'symlink' | 'other';
+  bytes?: number;
   modifiedAt?: number;
 };
-/** `GET {basePath}/fs/list?path=<abs>` — one directory, not recursive. */
 type ListHostDirResponse = {
-  /** Canonical path actually listed (the request's path after symlink resolution). */path: string; /** Directories first, then files, each alphabetical. */
-  entries: HostDirEntry[]; /** Set when the directory held more entries than the server will return. */
+  path: string;
+  entries: HostDirEntry[];
   truncated?: boolean;
 };
-/** One hit from `GET {basePath}/fs/find`. */
 type HostFileMatch = {
-  /** Absolute path, for a follow-up read. */path: string; /** Path relative to the searched directory — what a picker shows and inserts. */
+  path: string;
   relative: string;
 };
-/**
- * `GET {basePath}/fs/find?path=<dir>&q=<query>&limit=<n>` — recursive fuzzy file
- * search under one directory, which is what an `@file` picker needs and
- * `/fs/list` is not: listing answers "what is in this directory", this answers
- * "which file in this tree did you mean".
- *
- * Subsequence matching (`seslist` finds `SessionListView.swift`), filename hits
- * ranked above path hits, shallow files above deep ones. An empty `q` returns the
- * shallowest files. Build directories (`.git`, `node_modules`, …) are skipped, as
- * is anything behind a symlink — so every path returned is one `/fs/read` will
- * accept.
- */
 type FindHostFilesResponse = {
-  /** Canonical directory the search ran under; `relative` paths are relative to it. */base: string;
-  matches: HostFileMatch[]; /** More matched, or the tree was larger than the server would walk. */
+  base: string;
+  matches: HostFileMatch[];
   truncated: boolean;
 };
-/** `GET {basePath}/fs/read?path=<abs>` — one file's contents. Binary files come back
- * base64; 413 rather than a truncated read when the file exceeds the server's cap. */
 type ReadHostFileResponse = {
   path: string;
   content: string;
   encoding: 'utf8' | 'base64';
-  bytes: number; /** sha256 (hex) of the bytes on disk. Pass it back as `expectedHash` to write. */
+  bytes: number;
   hash: string;
   modifiedAt: number;
 };
-/**
- * `PUT {basePath}/fs/write` — replace or create one file.
- *
- * The agent is editing this same tree, so a write is **conditional, always**:
- * `expectedHash` must be the hash from the read this edit is based on, and the
- * server 409s if the file has changed since. Omitting it means "create" and 409s
- * if the path already exists — there is no unconditional overwrite, by design.
- * Directories are never created implicitly: writing under a missing parent is a 404.
- */
 type WriteHostFileRequest = {
   path: string;
-  content: string; /** Default 'utf8'. */
-  encoding?: 'utf8' | 'base64'; /** Required to overwrite; omit only to create a new file. */
+  content: string;
+  encoding?: 'utf8' | 'base64';
   expectedHash?: string;
 };
 type WriteHostFileResponse = {
   path: string;
-  bytes: number; /** Hash of what was just written — carry it into the next edit. */
+  bytes: number;
   hash: string;
   modifiedAt: number;
 };
 type SaveProfileResponse = {
   profile: ProfileInfo;
 };
-/** `GET {basePath}/profiles/:name` — the profile plus a fresh config snapshot. */
 type GetProfileResponse = {
   profile: ProfileInfo;
   config: ProfileConfigSnapshot;
@@ -2284,95 +848,53 @@ type GetProfileResponse = {
 type ErrorResponse = {
   error: string;
 };
-/**
- * The moments in an *interactive* session a person needs to hear about when they
- * are not watching it — the whole point being that a phone cannot hold a
- * WebSocket open in the background, so the server has to reach out.
- *
- * Deliberately four: this is a human-attention channel, not an event mirror. The
- * event log stays on the session WS (attach with `afterSeq` to catch up); if you
- * want every assistant message, subscribe there instead.
- */
-type SessionNotificationType = /** The agent is blocked on an approval — the one that matters most. */'permission_requested' /** A turn finished; the session is idle and waiting for the human. */ | 'turn_completed' /** The session failed (`session_error`). */ | 'session_error' /** The session ended (`session_closed`), whoever ended it. */ | 'session_closed';
-/** One delivery on the session-notification channel (JSON body of a webhook POST). */
+type SessionNotificationType = 'permission_requested' | 'turn_completed' | 'session_error' | 'session_closed';
 type SessionNotification = {
   type: SessionNotificationType;
-  sessionId: string; /** Snapshot at notification time — status, title, cwd, cost, `lastSeq`. */
+  sessionId: string;
   session: SessionInfo;
-  /** Seq of the event behind this notification; attach with `afterSeq: seq - 1` to
-   * land on it. */
   seq: number;
   ts: number;
-  /** One line fit for a notification body: the permission title, the turn's final
-   * text, the error message. */
   preview?: string;
-  /** `permission_requested` only: the full request, so a consumer can answer it via
-   * `POST {basePath}/sessions/:id/permissions/:requestId` — which is what makes an
-   * Approve/Deny action on a lock-screen notification possible. */
-  request?: PermissionRequest; /** `turn_completed` only. */
+  request?: PermissionRequest;
   result?: {
     isError: boolean;
     durationMs: number;
     numTurns: number;
     totalCostUsd: number;
-  }; /** `session_closed` only. */
+  };
   reason?: 'client' | 'server' | 'error';
 };
-/** Where session notifications are POSTed (JSON body = {@link SessionNotification}).
- * Server-wide, not per session: the point is to hear about sessions you did not
- * create yourself and are not attached to. */
 type SessionWebhookConfig = {
-  url: string; /** Extra headers sent with every delivery (auth tokens etc.). */
-  headers?: Record<string, string>; /** Types to deliver. Default: all of them. */
+  url: string;
+  headers?: Record<string, string>;
   events?: SessionNotificationType[];
 };
-/**
- * - `queued` — accepted, waiting for a concurrency slot (or the daily token budget)
- * - `running` — a session is executing the prompt
- * - `parked` — waiting on an external event (a deferred tool execution). Not
- *   terminal and not consuming a concurrency slot; resumes to `running` when the
- *   result arrives, or fails via the execution watchdog if it never does.
- * - `succeeded` / `failed` — terminal; `result` (and `error` on failure) are set
- * - `canceled` — terminal; canceled by a client before or during the run
- */
 type JobStatus = 'queued' | 'running' | 'parked' | 'succeeded' | 'failed' | 'canceled';
-/** Where job progress/completion deliveries are POSTed (JSON body = {@link JobEvent}). */
 type WebhookConfig = {
-  url: string; /** Extra headers sent with every delivery (auth tokens etc.). */
+  url: string;
   headers?: Record<string, string>;
-  /** Delivery granularity: 'messages' also POSTs job_progress per assistant message /
-   * permission request; 'completion' only job_started + job_completed. Default 'messages'. */
   progress?: 'messages' | 'completion';
 };
-/**
- * Schedule a one-shot run: the session executes `prompt` unattended and the job
- * completes with that run's result. `session.prompt` is the task and is required;
- * `resume`/`forkSession` are not supported for queued jobs.
- */
 type CreateJobRequest = {
   session: CreateSessionRequest & {
     prompt: string;
   };
-  webhook?: WebhookConfig; /** Per-job token cap; the effective cap is min(this, the server's sessionTokenLimit). */
-  maxTokens?: number; /** Per-job wall-clock cap; the effective cap is min(this, the server's maxJobDurationMs). */
+  webhook?: WebhookConfig;
+  maxTokens?: number;
   maxDurationMs?: number;
-  /** Total run attempts: failed (not canceled) runs re-queue until this many attempts
-   * have been made. Default 1 (no retries). */
-  attempts?: number; /** Delay before the first retry, doubled for each subsequent one. Default 5000. */
-  retryDelayMs?: number; /** Host bookkeeping echoed back on JobInfo. */
+  attempts?: number;
+  retryDelayMs?: number;
   meta?: Record<string, unknown>;
 };
-/** Cumulative resource usage of a job's run. `tokens` counts input + output +
- * cache-creation + cache-read tokens across all turns. */
 type JobUsage = {
   tokens: number;
   totalCostUsd: number;
   numTurns: number;
 };
-/** Terminal outcome of the job's run (mirrors the final turn_result). */
 type JobResult = {
   subtype: string;
-  isError: boolean; /** Final text of the run (success only). */
+  isError: boolean;
   result?: string;
   errors?: string[];
   durationMs: number;
@@ -2380,45 +902,30 @@ type JobResult = {
 type JobInfo = {
   id: string;
   status: JobStatus;
-  /** `''` when the run's engine has no host filesystem (see
-   * {@link CreateSessionRequest.cwd}). */
-  cwd: string; /** Profile the run executes under (resolved name, present even when implicit). */
+  cwd: string;
   profile?: string;
-  prompt: string; /** Server session id once started — attach via the sessions WS to watch the run live. */
+  prompt: string;
   sessionId?: string;
   sdkSessionId?: string;
   createdAt: number;
   startedAt?: number;
-  finishedAt?: number; /** 1-based run attempt this info reflects. */
-  attempt?: number; /** Total attempts configured on the request (see CreateJobRequest.attempts). */
-  maxAttempts?: number; /** For a job re-queued by retry backoff: earliest time the next attempt may start. */
+  finishedAt?: number;
+  attempt?: number;
+  maxAttempts?: number;
   nextRunAt?: number;
-  /** Set while `status` is 'parked': when the run parked, and the execution it is
-   * waiting on — the id to POST a result to. Cleared when it resumes. */
   parkedAt?: number;
-  parkedExecutionId?: string; /** Cumulative across attempts. */
+  parkedExecutionId?: string;
   usage: JobUsage;
-  result?: JobResult; /** Failure or cancellation reason (for a queued retry: the previous attempt's error). */
+  result?: JobResult;
   error?: string;
   meta?: Record<string, unknown>;
-  /** Scope tags of the session this job runs (see
-   * {@link CreateSessionRequest.scope}) — copied from the request at submit so
-   * the job routes can be gated by the same rule as the session routes. Without
-   * it the queue would be a side door into an unscoped session. */
   scope?: Record<string, string>;
 };
-/** Latest mid-run activity, carried on job_progress deliveries. */
 type JobProgress = {
-  kind: 'assistant_text' | 'tool_use' | 'permission_requested' | 'permission_resolved'; /** Short human-readable preview (message excerpt, tool name, permission title). */
+  kind: 'assistant_text' | 'tool_use' | 'permission_requested' | 'permission_resolved';
   preview?: string;
-  /** 'permission_requested' only: the full request (including AskUserQuestion input) so
-   * webhook consumers can answer via POST /sessions/:sessionId/permissions/:requestId. */
   request?: PermissionRequest;
 };
-/** Webhook delivery payload (also the queue's local event shape). `job_submitted` goes
- * to local observers and the queue WS only — the submitter already has the POST
- * response, so webhooks start at `job_started`. `job_retrying` marks a failed run that
- * was re-queued (`job.nextRunAt` says when); `job_completed` is always terminal. */
 type JobEvent = {
   type: 'job_submitted';
   job: JobInfo;
@@ -2432,17 +939,12 @@ type JobEvent = {
   job: JobInfo;
   progress: JobProgress;
   ts: number;
-}
-/** The run parked on a deferred execution; `executionId` says what it waits on —
- * the id to POST a result to. The *work itself* (tool name, input, VFS seed) went
- * to the executor's own dispatch hook, not over this channel: a webhook consumer
- * learns that a run is waiting, the worker learns what to do. */
-| {
+} | {
   type: 'job_parked';
   job: JobInfo;
   executionId: string;
   ts: number;
-} /** A parked run resumed because its execution result arrived. */ | {
+} | {
   type: 'job_resumed';
   job: JobInfo;
   executionId: string;
@@ -2460,17 +962,12 @@ type QueueStats = {
   maxConcurrency: number;
   running: number;
   queued: number;
-  /** Jobs waiting on a deferred execution. They hold no concurrency slot and
-   * their wall-clock budget is not ticking. */
   parked: number;
   sessionTokenLimit?: number;
-  dailyTokenLimit?: number; /** Tokens consumed by queue jobs in the current UTC day. */
-  dailyTokensUsed: number; /** True when the daily budget is exhausted and queued jobs are being held. */
+  dailyTokenLimit?: number;
+  dailyTokensUsed: number;
   paused: boolean;
 };
-/** Frames sent on the queue WS (`{basePath}/queue/ws`). The stream is one-way
- * (server→client): every job's lifecycle as it happens, plus refreshed stats after
- * lifecycle changes. Clients send nothing; job mutations stay on REST. */
 type QueueServerFrame = {
   type: 'queue_attached';
   protocolVersion: number;
@@ -2495,5 +992,5 @@ type QueueStatsResponse = {
   stats: QueueStats;
 };
 //#endregion
-export { ApiMessage, AttachedFrame, ClientFrame, ContentBlock, ContextReading, ContextUsage, ContextUsageCategory, CreateJobRequest, CreateJobResponse, CreateProfileRequest, CreateSessionRequest, CreateSessionResponse, DEFAULT_VIEW_CONFIG, ENGINE_CAPABILITIES, EngineCapabilities, ErrorResponse, Facet, FilePatch, FindHostFilesResponse, GetJobResponse, GetProfileResponse, GetSessionResponse, GroupBy, HostDirEntry, HostFileMatch, HostFileRoot, ImageRefPart, JobEvent, JobInfo, JobProgress, JobResult, JobStatus, JobUsage, ListHostDirResponse, ListHostRootsResponse, ListJobsResponse, ListProfilesResponse, ListSdkSessionsResponse, ListSessionFilesResponse, ListSessionsResponse, McpServerActionRequest, McpServerConfigWire, McpServerStatusInfo, McpServerToolInfo, McpServersResponse, MessageAttachment, ModelOption, PROTOCOL_VERSION, PROVIDER_PERMISSION_MODES, PatchHunk, PermissionDecisionSource, PermissionMode, PermissionRequest, ProfileConfigSnapshot, ProfileDefaults, ProfileEngine, ProfileInfo, ProfileSessionDefaults, ProfileUsage, ProfileUsageWindow, ProjectIcon, ProjectInfo, ProviderConfig, QuestionBehavior, QueueServerFrame, QueueStats, QueueStatsResponse, RateLimitInfo, ReadHostFileResponse, ResolvePermissionRequest, ResolvePermissionResponse, STATE_LABELS, STATE_ORDER, SUBAGENT_HISTORY, SaveProfileResponse, ScopeRoot, SdkSessionSummary, ServerFrame, SessionCapability, SessionCommand, SessionEvent, SessionEventBody, SessionFileInfo, SessionGroup, SessionInfo, SessionNotification, SessionNotificationType, SessionRow, SessionState, SessionStatus, SessionUsage, SessionWebhookConfig, SkillInfo, SlashCommandInfo, SortBy, SubagentInfo, SubmitExecutionResultRequest, SubmitExecutionResultResponse, SubsetSummary, TOOL_RESULT_HEAD_CHARS, TextBlock, ThinkingBlock, ToolCallRequestFrame, ToolExecutionBackend, ToolExecutionOutput, ToolExecutionStatus, ToolResultBlock, ToolUseBlock, UnknownBlock, UpdateProfileRequest, UpdateSessionRequest, UpdateSessionResponse, UploadAttachmentResponse, UsageWindowRow, UserQuestion, UserQuestionOption, ViewConfig, Watermark, WatermarkStore, Watermarks, WebhookConfig, WorkspaceScope, WriteHostFileRequest, WriteHostFileResponse, 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 { ApiMessage, AttachedFrame, ClientFrame, ContentBlock, ContextReading, ContextUsage, ContextUsageCategory, CreateJobRequest, CreateJobResponse, CreateProfileRequest, CreateSessionRequest, CreateSessionResponse, DEFAULT_VIEW_CONFIG, ENGINE_CAPABILITIES, EngineCapabilities, ErrorResponse, Facet, FilePatch, FindHostFilesResponse, GetJobResponse, GetProfileResponse, GetSessionResponse, GroupBy, HostDirEntry, HostFileMatch, HostFileRoot, ImageRefPart, JobEvent, JobInfo, JobProgress, JobResult, JobStatus, JobUsage, ListHostDirResponse, ListHostRootsResponse, ListJobsResponse, ListProfilesResponse, ListSdkSessionsResponse, ListSessionFilesResponse, ListSessionsResponse, McpServerActionRequest, McpServerConfigWire, McpServerStatusInfo, McpServerToolInfo, McpServersResponse, MessageAttachment, ModelOption, PROTOCOL_VERSION, PatchHunk, PermissionDecisionSource, PermissionMode, PermissionRequest, ProfileConfigSnapshot, ProfileDefaults, ProfileEngine, ProfileInfo, ProfileSessionDefaults, ProfileUsage, ProfileUsageWindow, ProjectIcon, ProjectInfo, ProviderConfig, QuestionBehavior, QueueServerFrame, QueueStats, QueueStatsResponse, RateLimitInfo, ReadHostFileResponse, ResolvePermissionRequest, ResolvePermissionResponse, STATE_LABELS, STATE_ORDER, SUBAGENT_HISTORY, SaveProfileResponse, ScopeRoot, SdkSessionSummary, ServerFrame, SessionCapability, SessionCommand, SessionEvent, SessionEventBody, SessionFileInfo, SessionGroup, SessionInfo, SessionNotification, SessionNotificationType, SessionRow, SessionState, SessionStatus, SessionUsage, SessionWebhookConfig, SkillInfo, SlashCommandInfo, SortBy, SubagentInfo, SubmitExecutionResultRequest, SubmitExecutionResultResponse, SubsetSummary, TOOL_RESULT_HEAD_CHARS, TextBlock, ThinkingBlock, ToolCallRequestFrame, ToolExecutionBackend, ToolExecutionOutput, ToolExecutionStatus, ToolResultBlock, ToolUseBlock, UnknownBlock, UpdateProfileRequest, UpdateSessionRequest, UpdateSessionResponse, UploadAttachmentResponse, UsageWindowRow, UserQuestion, UserQuestionOption, ViewConfig, Watermark, WatermarkStore, Watermarks, WebhookConfig, WorkspaceScope, WriteHostFileRequest, WriteHostFileResponse, 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.d.mts.map