zidane-ui/chat/headless

The row's words for an activity: the newest running tool, else the phase.

What the card's Copy details writes: the headline, the reason, and the provider's own words when the reason rephrased them.

Every project the sessions belong to, by folder name, sorted.

Mark one lookup as started; call the returned function once when it ends (success or not).

The sidebar's rows over every host. Per host: This computer's section first, then each saved server's, each host's sessions grouped per folder under its header. Any other view lists every host in one list, a server's folder headers naming the server, and a repository's sessions on every machine under one header (repoGroups). Sessions of a server no longer saved are not listed.

The sidebar's rows under a query grouping (a space's, an extension's, the agents'): favorites first, then one group per value in the grouping's order, the items of each group leading it. A session whose value is a list is in each of its groups. The sessions come sorted.

Builds the flat row list for a session list: favorites first, then groups with headers, collapse state, and "show more" caps for project groups. Pure: the same input gives the same rows.

The sidebar's rows over the kit's session-list model: favorites, git repositories and the project of each session.

The chip of a path known to be a file or folder (a mention): never plain code.

Whether any lookup is in flight.

Each item with its child sessions (a session goes to the first item that claims it), and the sessions no item claims.

What inline code names, read from its text alone: a file or folder chip, or null for plain code.

The patch that turns every filter of a view off (viewFiltersOn), keeping its grouping, sort and the contributed grouping and sort picked.

Group contiguous rows with the same childId so the renderer can wrap a subagent's output in a single bordered card — and nest the card of a worker a worker started inside its spawner's (spawner from the markers' spawn.parentChildId). A row's block chain is its worker's ancestry; the open chain is reused as far as it matches, so a grandchild's rows land inside the spawner's block that is still open, and the spawner's later rows close the grandchild's block. A row of another lane (main rows, an unrelated sibling) closes the chain: a later grandchild row then reopens its spawner's block around itself.

Turns transcript events into rows: pairs tool calls with their results, merges streamed text, reconciles edits and spawns. Rows are cached per source event, so appending an event keeps every earlier row identical.

The command a chip names (/fix conflicts → fix).

The command an invocation starts with: its /name, plus the leading argument when that is one of the command's fixed values (args, which may be several words): /fix conflicts now reads /fix conflicts. The longest value wins, and it must end at a space or the end of the text.

A command chip's card: the description and the aliases.

Commits a picked chain, the ONE path every model picker takes: the session's model (when there is one), then the app's default (the next chat's model and lastModelChain) when this computer can run it. A draft whose pick only a server can run still launches under it: held for this window, not remembered. remember: false (a side chat's pick) only sets the session's model.

A sha chip's card: the short sha, the subject as its title, the author, the change size and the age.

The order a sort puts two sessions in (negative: a first), as buildSessionRows sorts them.

The cost pill's figure while a run is in flight (see the header).

Final submit text for the active mode, or null when the submit is a no-op. Shell re-attaches the consumed bang (TUI submit in src/tui/prompt/use-composer-actions.ts); a blank shell command never submits, even with attachments staged. Search mode never submits — Enter navigates matches instead.

Works out the stops of select-turn mode from the painted rows. Result-only turns join the turn that made the call, and work-only turns join the next answer in the same exchange.

A store that never changes.

The badges to show, in their default order (the kit's orderComposerBadges applies the user's).

Creates an empty AuthFixes.

A ChatBlockRuns over transport: each session's runs read on first ask, again on each change.

The compaction store over subscribe, the app's feed of every session's stream signals (an Electron bus, a server connection's ipc.signal).

The lists over a host's completions. onCommands: the command list changed (a typed /name may become, or stop being, a badge).

Creates the draft's scope store.

Creates the remembered knobs over a host's prefs.

Creates the names over a catalog and, optionally, the sign-in report's providers. Both are read for the store's life once a reader subscribes.

Creates the preferences over a Storage, read on first use.

An empty notification store.

Creates the chip answers over a host's paths.

Creates the reference cache over a host's references.

The store over subscribe, the app's feed of every session's stream signals (an Electron bus, a server connection's ipc.signal).

Creates an empty RunMeter.

The activity store over subscribe, the app's feed of every session's stream signals (an Electron bus, a server connection's ipc.signal).

The badges store over source.

The directory over the app's ports; nothing runs until start().

The history store: in memory, persisted through store once SessionHistory.load has read it.

Binds the writes of streams (and its store) into one stable object.

The session stream store: every session's live transcript and run state, reduced from zidane's host signals, with per-session subscriptions, smooth-stream pacing, lazy scrollback and run-end compaction. React-free.

The views store: Storage first, the host's copy merged in once (SidebarViews.sync).

Creates the site icon cache over a fetcher.

Today, Yesterday, a weekday within the week, Mon D this year, Mon YYYY before.

Decode a recalled history entry: !-prefixed entries recall INTO shell mode with the bang stripped (applyRecalledPrompt, src/tui/prompt/use-prompt-history.ts); everything else recalls as a normal prompt.

The prefs patch that remembers pick as the next new chat's model.

The delete confirmation: the question, and a warning when the session's sandbox goes with it.

The dot state. Presence follows the TUI: awaiting input (◉) beats running (▶) beats attached (○). This window's own pending ask sits on top; a finished run's notification (completed / error) outranks attached.

Picks the status dot a row shows.

The conversation's folder: null while the draft has none picked (the folder gate shows), '' for none (a server's draft has none on this computer), else the folder.

The draft's folder when it is a folder on this computer, the only kind that makes a draft scope (a server's or machine's draft, or a folderless one, has none).

The scope of a draft state, null while it has none.

Pop the head off bucket.pending using the surrogate-safe slice. Convenience over a raw safeSurrogateSlice call when the caller doesn't need the remainder.

What the effort picker offers for a session, null when its model has nothing to set (no dead-end dialog).

Encode the in-progress draft for the prompt-history stash so a shell-mode draft survives the cycle round trip with its bang (usePromptHistory, src/tui/prompt/use-prompt-history.ts). Search-mode drafts are never stashed (history cycling is disabled in search mode).

An environment kind's display name: a built-in kind's name, a machine's kind as Local @ laptop, else the id.

Where a session runs, in one line: tooltips and screen readers.

An extension's space as the sidebar lists it: read-only, its newSession defaults as the space's.

The failure row's tooltip: the line, then what it leaves out (when the limit resets, the provider's own words). Never inline: the row stays one quiet line.

The sessions the list shows: the space's (a remote session without a space shows in every space), then the project and activity filters. The same array when nothing filters.

The query one contributed filter applies at the value the user picked, or null (off, or an option no longer offered). A multi filter keeps a session one of its picked options matches.

Sessions whose title contains every word of query (case-insensitive).

The contributed filters a space offers: those for every space and those naming it.

The command token (a name or an alias, without the slash) names in commands, or undefined.

The streaming reply that carries the caret, looking inside message groups.

First grapheme cluster of the input — Intl.Segmenter so ZWJ-joined emoji (👨‍💻, 🏳️‍🌈) survive as one unit instead of splitting at the first code point.

A block's first row in paint order (its own or a nested block's): a stable key.

Every action of an exchange, in order (core planFold, shared with the TUI): tool calls (batches seen through, the calls a call made nested under it), consecutive thoughts merged, each worker one item holding its rows and merged with the spawn call that started it. Rows that say nothing on their own (plain notes) are skipped.

A worker's (subagent's) own rows folded like an exchange of the main transcript: its tool calls, thoughts and the workers it started behind one "Working" row, its earlier messages behind one group, its last message in full. Its own rows are re-based to depth 0 (same row objects per input, so folds keep their identity across stream ticks); rows of workers it started keep their lane and fold as worker lines. Its lifecycle markers are left out: the line or header showing the worker already carries them.

A running session's elapsed time: 42s, 12m, 1h 5m.

Shared with the TUI (formatCostLabel in src/chat/format.ts).

Views whose groups are folders: Per directory, and each host's section in Per host.

Whether sessions on a host can be driven: This computer always, a server only while connected. A host no longer saved (undefined) is not.

One word for a host's status, for dots and labels, as the TUI words it.

Hands the row identity of the prompts next dropped to their copies in it. A store swaps a prompt on show for an updated copy when it learns its turn (the host's binding, or the persisted copy a page read brings): the copy's rows keep their keys, so they update in place instead of remounting and playing their entrance again. A copy is the same prompt by its words, as reconcileEvents matches prompts; the newest pair first, so an older prompt with the same words keeps its own rows.

Whether a failure's sign-in was fixed since.

Whether a stored entry is a well-formed icon.

Whether session is listed under a project header: a local session in its folder, or, for a header that names a repoKey, a server session of that repository.

An item's row and its child sessions' rows (none while it is collapsed).

The items listed in a space: those naming it, where the space allows items (the default space and user spaces always; an extension's when it says so).

The prefs' lastModelChain entries for a chain (core ModelChainEntry shape, account included).

Returns rows itself when no run failed, so memoised consumers stay put. The rules are core's (createRunStopMarker), shared with the TUI; an exchange whose rows did not change keeps its previous output rows.

Fill dataUrl on image and PDF attachments that lack one, from previews: same media type and name first, then the next unused preview of that media type. With no incoming metadata at all (a local append that knew nothing of the attachments) the previews are the attachments.

The spaces the sidebar knows: the user's in their order (a saved view's query kept), then the extensions' by order. A space the host already lists under an extension's id takes the extension's base and keeps its place; one with an extension space's id (<extension>/<id>) whose extension contributes it no more is dropped, as core and the terminal app drop it.

True when some image or PDF attachment has no bytes to show.

Mode entered by typing char into the composer, or null when the keystroke should be handled as ordinary input. Requires an empty buffer and no active mode — matches the TUI's exactly-! / exactly-? on lastSynced === '' checks (useSyncBuffer, src/tui/prompt/use-sync-buffer.ts).

The one ModelKnobsStore over a host's prefs (one shared in-memory store when it has none).

The one ModelNamesStore over a host's models (this computer's catalog, and its providers when listed). Without models, every model keeps its readable id.

A namer reading catalog: the entry of that provider first, then any provider listing the id.

Whether a nested call's events show: core's nestedCallShown (a subagent, a plan or a question always; the rest only with Settings.codemodeShowCalls), the rule isVisible applies too.

The flat rows as nested sections: a host's section holds its groups, a group's holds its rows. Rows before any header (a flat view) stay at the top level, and so do a flat view's rows after its Favorites.

Moves every tool row whose parentId names a call in rows (same owner) into that call's children. A nested row whose parent is absent stays where it is. Returns rows itself when nothing nests.

The session a first send creates from the draft: on a server, its folder (or its first root), never one of this computer's; on a machine, the machine's folder; otherwise the draft's folder, if any. The model pick goes only when both halves are set.

The first saved-view name no space has yet: nameOf(1), nameOf(2)…

The fence a streaming chunk ends inside, when it opened at column 0 (an indented one may belong to a list item, which only the parse can tell). The open fence is the whole tail of the chunk, so parsing it again on every delta re-parses a growing code block for nothing: the code block can draw the text as is, and the chunk parses normally once the fence closes.

Matches each tool event with its tool-result or error event. Pairs by callId when events carry one, and by position within the turn and tool name otherwise.

Parse the exit metadata the shell contract embeds in the persisted result text (see runBashCommand in the TUI / startShellRun in main): (exit 0, Nms) footer on success, Exit code N (Nms) / Killed (Nms) header on failure, (cancelled by user after Nms) footer on abort. Live and reloaded transcripts render identically because both read the same text. Returns null when nothing matches (still streaming, or a clipped tail dropped the footer).

Parses stored preferences; undefined when they are not JSON.

Reads a stored pin map, dropping anything malformed and duplicate paths.

Reads a stored icon map, keeping only well-formed entries.

A stored history, checked: entries are session keys (non-empty strings) or null, the cursor one of them. Anything malformed reads as no history.

A stored view, every axis checked; what is missing or unknown takes the default.

Stored switcher prefs, checked; anything malformed reads as none.

Orchestration on: the main session is pulled out (pinned above the list). Off: the main is not a chat; it is hidden, not regrouped.

The estimate a row shows: the session's own run (depth 0), or the subagent named label (child-3). undefined when there is none.

The sessions pinned now (each once, however many pins).

Keep key's transcript cached until the returned unpin runs.

Plans the card of a failed sign-in: the provider's label, the stored credential that failed (by its id, else its account name, else the one in use when the failure names none), another OAuth account to switch to, and the Settings target.

How a chip writes its position after the name: :12, :12:5, :12-20. Empty without one.

The project filter's key for a session: its folder's name, as a query's projectName reads it (projectNameOf: / and `` both separate), so a view saved from the filter matches the same sessions.

The project a session is listed under: its repository's root, else its folder ('': none).

Staged attachments as the wire's: the data:<mime>;base64, prefix stripped. One that is not a base64 data URL is dropped: the model still gets the text.

The prompt of a turn: a turn with several text blocks shows several prompts (joined back with a blank line); their attachments ride along.

The prompt's chips, for its echo: /<skill> tokens naming an activated skill, @<path> mentions (zidane's inferPromptRefs, so every window shows the same chips) and #<chat> tokens. Half-open spans, sorted.

The views the Storage holds: the per-space map, else the legacy per-axis keys as the default space's view.

A saved server's recent folders (its sessions' folders there), most recent first, each once.

This computer's recent folders, most recent first (the rows' order), each once.

The next activity after signal; the same object when nothing a row shows changed, null once the run ended.

The progress after signal: null once the compaction ended, prev for any other signal.

A spawn the cap refused, as older recordings carry it: plain result text, not a failed call.

How long ago, as short as it can say it: now, 5m, 3h, 2d, Mar 4, Mar 2024. Only a duration reads with "ago" in a sentence (core ageStep says which).

The chain to remember, null for nothing (no primary, or a primary only the server runs).

The model remembered as the next new chat's, null when there is none. The account comes as remembered: check the catalog still serves it.

rememberableChain for a pick made on hostId (a server, or null for this computer).

The group each repository's sessions share across machines, by repoKey. A repository with one local folder groups under that folder: its sessions on servers join it. A repository only on servers groups under its first server folder, in key order. A repository with several local folders (two clones) is left out: each folder keeps its own group, and so does each server folder.

Test seam.

The panel an extension badge names, among the conversation's panels: the extension's own (a bare id), a full <extension>/<id>, or a built-in. null when it names none of them.

Absolute path for opening: relative chips resolve against cwd.

The grouping that applies: a contributed one the user picked, else the space's own (unless the user picked a built-in one, VIEW_CHOICE), else the view's groupBy ('agent' as a query grouping).

The sort that applies: a contributed one the user picked, else the space's own (unless the user picked a built-in one, VIEW_CHOICE). null: the view's sortBy.

Every turn a painted row stands for (batches and folds see through to their members).

Whether the session runs in a sandbox on a provider's machines, deleted with the session.

When a saved secret goes, in words.

The time left until expiresAt, rounded to the unit a person reads: minutes under an hour, hours under two days, then days.

secretTimeLeft for an ISO expiry, as a SecretReference carries it.

The events that carry a file edit, in order.

Sends one prompt from the composer. Rejects (the composer keeps the text) when no provider is connected, /side is refused, or the session could not be created; a refused send or enqueue shows its error in the transcript.

The chat a #token names: the one session whose id starts with it.

Each session's SessionRef, by id.

A #chat chip's card: the title, the project, the model and context gauge, prompts and turns, the age.

The first settled value of a resource (subscribing starts its read).

The command of a ! prompt (the TUI's parseBashInvocation), '' for any other prompt or a blank command.

https://www.github.com/a/b/ → github.com/a/b, ellipsized past max characters.

The six sidebar token stores of an extensions host as one store: a new snapshot whenever one of them changes.

The http(s) origin a link's icon belongs to, or null when it has none.

A skill's name in its chip text (/review, $review, review).

A skill chip's card: the description and the size in tokens.

Which sessions a space lists, or null while spaces are off (every session). A session tagged with the space is in it (an unknown tag reads as the default space); a space with a query also lists the sessions it matches. The orchestration Main is in every space.

Splits markdown into chunks that parse on their own, so a long or streaming reply can re-render only its last chunk. Text shorter than the threshold comes back as one chunk.

A selection that keeps returning the previous list while the new one holds the same items in the same order, so a reader re-renders only when an item changes.

The stop a painted row belongs to, or null for rows that are not selectable.

The switcher's spaces: the user's order first (ids it names), the rest in their own order, the hidden ones left out. The default space never hides, so the switcher always has one.

Compute how many chars to emit from bucket on this tick, at the pace its backlog sets. Mutates bucket.carry so caller can repeatedly tick without re-seeding. An empty bucket yields 0.

The overview item for one tool call: the shared words, plus what the details show.

A tool call that failed: its result says so, or it is a spawn the cap refused in plain text (older recordings do not mark that as failed).

A submit that was not sent (its chat could not be created) back as the draft it came from: the box is cleared on Enter, so a failure must not lose what was typed. The inverse of composeSubmitText.

The links in a text, as prompt spans (urls): where each starts and ends.

Subscribes a component to a Readable and returns its current value, re-rendering when it changes.

The view layer's own narrowing: the agent, the origin and the contributed filters the space offers. null when none applies.

Whether the view narrows the space's sessions: an archive axis other than active, a project, an activity window, an agent, an origin, or a contributed filter the space offers turned on. Grouping and sort don't count.

Resolves once no lookup is in flight, or after timeoutMs, whichever is first.

A sent prompt's attachments → staged ChatAttachments, for a draft that re-stages them (Edit message). Data URLs stage as they are; a zg-media: address (a PDF or text file served from the saved turn) is fetched and re-encoded under the attachment's own media type, since the send path only reads data URLs. Metadata-only chips (no address) and failed fetches drop.

A converted attachment's original as the wire carries it, or undefined when there is none (or its URL is not a base64 data URL).

Holds back a fence still arriving at the end of a streaming reply. Text reveals a few characters a frame, so a closing ``` lands as `, then ``: until the third, an open code block shows the partial marker as one more line of code, then drops it, and the reply shrinks by a line under a view following its bottom. A frame later the whole fence is there.

pins with fullPath pinned or unpinned in spaceId; the same object when nothing changes.

A plain value store: the building block for simple hosts and fixtures.

The agent grouping as a query grouping.

The directory-less bucket's label ("pure chat" sessions, no project).

Below this, one parse is cheap enough: no chunking at all.

Emoji grid — two dozen common project-marker choices. Ordered folders first (nearest to the default), then general dev/project glyphs.

The default English strings of the chat layer, merged over the design system's labels. Override any of them through ChatProvider.

The strings of the chrome around the editor (run chip, pickers, dock, badges). Merged into DEFAULT_COMPOSER_LABELS.

The default English composer strings.

The preferences before any change.

The default English strings of the session sidebar, merged over the chat layer's.

A view nobody changed yet.

No arrangement yet: the spaces' own order, nothing hidden.

The browser's frames and timers, looked up on every call (so a test that stubs requestAnimationFrame or fakes timers after the store exists is still heard). Without requestAnimationFrame (a worker, Node) frame returns null and the store paces on timers.

The counters of a session with no run seen.

Lines a live run keeps for its window.

Storage key for the orchestration Main session's icon. Not a path — the main is directory-less and one per store — but it lives in the same localStorage map so the picker, persistence and reset are shared.

How many badges one extension shows in one composer (zidane's MAX_COMPOSER_BADGES).

The most chips a row shows, whatever the decorations add.

The Storage key the preferences live under.

The thrown text when no provider can answer: the composer puts the prompt back.

Nothing contributed.

Where the pins persist.

Default number of sessions a project group shows before its "show more" row.

Where the icon map persists.

Where the caches persist.

From this many days relativeTime shows a date (Mar 4), not a duration: pass it to core ageStep to know whether the label takes "ago".

The most entries a history keeps by default.

Where the shown space persists.

Where the switcher's own order and hidden spaces persist.

Where the views persist: one map of space id → view.

Tick interval (ms). Matches one frame at 60fps.

In SidebarExtensionView: the view's own axis (groupBy, sortBy) in a space that has a grouping or sort of its own (an extension space, a saved view), where that one applies by default.

What the card offers for one failure, given the host's providers.

The sign-ins fixed from a card, per session: every card for the same sign-in says so.

Where the card's Settings button lands: the provider (or MCP server, integration) and the stored credential that failed.

Exit details of a shell command, parsed from its result text by parseBashExitMeta.

Options of buildQuerySidebarRows.

Which calendar day labels are read in. Default: the runtime's zone and locale. Pin both when the same list renders on a server and in browsers (a prerendered page), or the two disagree about "Yesterday" and hydration fails.

An attachment on a prompt, as the components can show it.

The file a composer converted before sending (ChatAttachment.original).

The badge menu's extension actions (badges:actions). Absent: the built-in actions only.

How a run reports and stops.

Run here on a reply's shell blocks. Absent: blocks have no Run button.

What an adapter's transport offers for createChatBlockRuns.

What chip hover cards read when they open. Each method left out leaves its card with the chip's own text.

A command, as a command chip's hover card shows it.

One commit, for a sha chip's hover card.

A session's context gauge, as a #chat card shows it.

The seam between the chat components and whatever runs the agent: readable stores plus optional actions. A component hides the control for any capability the host leaves out.

A request from the agent that waits for the user: a question, a plan, or an approval.

A model a session can run.

A provider and the models it offers, as the model picker groups them.

What prose chips name on the session's disk.

Extension text references (ctx.registerReferences): the providers' patterns per folder and the views of the keys found.

The transcript search of one session, as its windows share it.

The transcript search a session's windows share (the composer's ? mode).

A session as the list shows it.

A session as a #chat chip's hover card shows it.

Site icons for link badges: one ask per origin, shared by every badge of the site.

A skill, as a skill chip's hover card shows it.

Wire-safe projection of canonical CommandArgSuggestion.

Wire-safe summary of an extension-contributed / command — the projection of canonical Command (src/chat/commands.ts) minus its function-valued fields (steps, completeArgs).

A compaction's live progress.

Every session's compaction in progress, outside React.

An agent profile a folder offers.

The agent profiles. Absent: the agent picker hides.

An attachment staged in a composer: always read into a data: URL, keyed for removal.

Inline ghost-text autocomplete. Absent: no ghost text.

The commands' fixed argument values, shared by everything that reads a /command (the composer's badge, the transcript's prompt rows): what the / popover learns is noted here. The app keeps one; the rich composer takes it as a prop.

The catalogs behind the composer's completions. Each one left out empties its popover.

A session's meters. Each one left out hides what reads it.

A session's context gauge and what its model offers.

The pickers' writes on a session. Each one left out hides the control that needs it.

A session's total cost as last settled.

The per-session draft every window of the app shares. Absent: each window keeps its own.

One item an extension's completion offers.

An extension's completion trigger (a character that opens its popover).

Where a folder sits: its checkout and the project it belongs to.

The folder a new session opens in, remembered across launches.

The rich composer's host. Every member is optional.

The composer's lazily read completion lists, for one scope at a time.

Where the composer reads: its folder ('': folderless, rooted at HOME), the session's file root, its server.

A catalog row with the options its model declares: what ComposerModels.catalog lists.

A feature toggle a model declares (fast mode, …).

The model catalogs, kept current.

Where picks are remembered. Absent: they last for the page's life.

The picks remembered across apps (the TUI's state.json).

A next prompt the host suggests once a run ends.

A model chain entry as remembered (state.json's lastModelChain).

A run joined midway, as its host counts it.

The current run's counters per session. Absent: no run chip.

Where a completion list comes from: the composer's folder and the host it runs on (null: this computer).

What the pickers read of a session (the desktop app's session rows fit it as they are).

A ghost text another window resolved for a session's draft.

Next-prompt suggestions. Absent: none are shown.

A badge and what a click opens: a panel, the Running work dialog, or nothing (panel: null).

One badge of the strip, as data (the kit's ComposerBadge without its click).

What the strip is built from.

One owner's streamed text waiting to reveal.

A remote host as the directory follows it.

The settings the directory reads.

What deriveDotState reads.

A session row as recentLocalFolders reads it.

What draftFolderPath and draftLocalFolder read.

A draft's scope: where its terminals and layout attach.

The draft's state, as DraftScopeStore holds it.

The draft's scope, readable (get returns the same state until it changes).

What createDraftScopeStore asks the app.

Streamed markdown released from a smooth-stream bucket, applied by SessionStreamStore.applyDrainPlan.

What the effort picker sets for a session's model.

Counts shown on the summary line of a folded exchange.

A path in prose, as a chip shows it: its kind, name, icon or language letters, and tone.

One row in the project file catalog. path is forward-slashed + relative to cwd.

One overview line of a folded exchange: a tool call, a run of thoughts, a worker, or a note.

Frames and timers for the session stream store (see defaultFrameScheduler).

One host, as the kit's host parts show it.

One image model, as the host lists it.

What the Inbox badge reads of the conversation's pending requests.

A list read on demand.

The minimal session shape the list model needs. ChatSession satisfies it.

A run this window started: running, or one that could not run.

The cost pill's figure: settled, accrued and streaming.

The streaming turn's live counters (stream:progress).

What SessionStreams.loadEarlier reports back.

One row of the catalog.

An effort and the enabled options.

What the store holds.

The remembered knobs.

How models and providers are named.

A provider as the sign-in report lists it.

The live names.

The model picker's preferences.

The live preferences.

A model pick: provider, model and, when the provider has several, the stored account it runs on.

What a new session starts with when its draft picks nothing else.

The session newSessionRequest asks the app to create.

A streaming chunk's fence that has not closed yet, apart from the text before it.

A signal of a kind the store does not reduce (compaction pings, cache breaks …): ignored.

Every row carries the optional ownership metadata from its source StreamEvent. childId + depth drive the subagent block grouping; turnId drives select-turn mode highlighting.

The outcome of pairToolEvents.

The chip answers of one host.

Options for createPathResolver.

A project as one space lists it: its path (projectPathOf), the host it is on, the space.

A prompt's origin, as the transcript reads it. Mirrors zidane's TextOrigin (src/text-origin.ts), without its messageId.

The shape every chat host exposes its data in: read the current value and subscribe to changes.

The reference cache of one host.

Options for createReferenceStore.

A view as cached: null names nothing; at is when it was resolved (0: stale).

What the store reads of a session row (noteRows).

Every session's run estimates, outside React.

The run counters of every session.

A session row's word on its run (the session list's runStartedAt).

One session's run counters.

The turns select-turn mode can stop on, and how any turn id maps to its stop.

An attachment as the composer staged it: dataUrl is the paste, drop or picker URL.

Where the new-chat draft runs, as newSessionRequest reads it.

What the send flow sends through and writes to.

What the composer sends to ChatHost.send.

A prompt attachment on the wire: raw base64, no data: prefix.

One send from the composer.

What a session's run is doing, as its row says it.

Every session's activity, outside React.

One session's badges as a row shows them.

Where the badges come from.

Every session's badges, outside React.

The session directory: its state, notifications and views, and the actions on them.

Options of createSessionDirectory: the ports it reads and acts through.

The sessions transport the directory reads and acts through (ChatHost.sessions).

The directory's state as one snapshot: a new object whenever any field changes.

The slice of the session stream store the directory keeps in step.

The model serving a run after it fell back from the one picked.

The window's page history, outside React.

Options of createSessionHistory.

The history as it is kept: its pages, oldest first, and the cursor.

Where the history persists (the desktop app: main's database).

Options for buildSessionRows.

The notifications by session, subscribed to per session.

Lazy-scrollback bookkeeping for one session: where the hydrated window starts (firstSeq — the beforeSeq for the previous page), whether older turns exist, and an in-flight guard so wheel spam near the top can't stack duplicate page fetches.

How a reference names a session: its title, and its folder's name when it has one.

A provider stream being retried.

A conversation whose content matched a search.

The bound writes of a SessionStreams, from createSessionStreamActions.

One page of a session's persisted transcript (the tail, or the page before a sequence number).

The session stream store with pacing, scrollback and compaction. Created by createSessionStreams.

Options for createSessionStreams.

Options for SessionStreamStore.

One write to a session's window, see SessionStreamStore.write.

A session's shared draft, as another window left it.

The staged files of a draft written in another window.

A draft written in another window.

What the extensions contribute to the sidebar, per token.

The commands of the environment a session runs in (push the branch, open a pull request).

The user's layer over what extensions contribute to the filter menu, kept per space with the rest of the view. Ids are the published ones (<extension>/<id>); an id no extension offers now is ignored.

The sidebar's platform capabilities. Every member is optional.

Extension items grouped with their child sessions, as the rows place them.

One session as the sidebar lists it: the chat session plus where it runs (folder, host, space). An app's own row type extends it.

The query layer of the space shown, as the sidebar's parts read it: the space, the view, the grouping and sort that apply, and what the extensions contribute to this space.

A chip a decoration puts on a row, its template rendered.

What the decorations matching one session put on its row.

A space as the sidebar lists it: a user space, or an extension's (extensionId, read-only), with the base query, grouping and sort a query space carries.

The filter axes, kept per space.

The sidebar's views and shown space, outside React.

The views the host keeps for this user, next to the device's Storage.

Options of createSidebarViews.

A parsed skill: its frontmatter fields, instructions and origin.

The user's arrangement of the space switcher, over the spaces' own order: extension spaces included, which Settings › Spaces doesn't list.

The result paired with one tool call.

A readable store of one session's TranscriptState.

The state a Transcript store holds for one session.

A sent prompt as a draft: its text and attachments.

A Readable you can also write to.

The list options buildSidebarRows passes through.

zidane's canonical transcript event, plus what a live client knows and a replay does not: attachment previews, arrival times, clipped outputs and thinking durations. Every extra is optional; a replayed StreamEvent list is a valid ChatEvent list.

The shape of the chat label dictionary: every key of DEFAULT_CHAT_LABELS. Some values are functions that build a string.

What made the host's references change.

What a name in prose points at: a file or folder on disk, a git branch of the repo, or nothing. candidates: everything a bare name matched when it matched several, best first (path is the first's).

Run state of a session: idle, running, completed, or error.

null: not known yet, or the folder can't be checked (sandboxes).

The labels the views read.

A transcript row, or a subagent block. A block's rows are the worker's OWN rows (its header reads its lifecycle off them); body is what the block paints in order — those rows as singles, plus the blocks of the workers it started, nested where they ran.

The stream signals a compaction's progress follows; any other kind is ignored.

What a switch would cost the session's prompt cache.

A switch a picker would make: what its cache estimate is asked for.

The chrome's strings.

What ContextBreakdown renders.

Hears another window's staged files for a draft.

A reasoning effort level.

Every composer string.

The status dot a row shows, chosen by dotVariantFor: a row kind, a tool state, or a session event status.

What a path in prose names: a folder or a file.

waiting: a spawn call that has not started yet, every slot being taken.

A subagent block: the group member of Cluster.

A host's connection. local: This computer, always reachable. The rest mirror the TUI's statuses (identity: a different server answers at the saved URL; version-mismatch: it speaks another protocol version).

Where the preferences are stored.

Pinned folder paths per space id, in pin order.

A folder's icon: an emoji, or a small image as a data URL.

Icons by folder path.

One row of the transcript model. The kind field says what it is: a prompt, assistant markdown, thinking, a tool call, a notice, a worker marker, or a synthetic group such as tool-batch or exchange-fold.

The stream signals the store follows; any other kind is ignored.

How a run ended early and how to pick it back up: cause (error or aborted), resume (continue or retry), and the prompt to resend on retry.

The stream signals the meter follows (the host's HostSignal variants, structurally).

How long a saved secret has left.

Only sessions touched within the last day, 3, 7 or 30 days.

The stream signals the activity follows; any other kind is ignored.

Which sessions the list reads: the archive axis is the one the host filters.

How the list groups sessions: none (flat), date, state, or project.

Which way to move.

A page of the history: a session, or null for the new-chat draft.

One row of the flat list buildSessionRows returns: a group header, a session, or a showMore row that ends a capped group.

What a finished run left on a session the user wasn't watching.

What deleting a session did with its environment.

How sessions are ordered inside a group: recency (last activity, newest first), createdTime (newest first), or alphabetical by title.

The live signals the session stream store reduces: zidane's host signals for one session (the desktop app's chat:stream channel, zidane-server's signals). Any other signal kind is ignored.

What a standalone window shows: the conversation with its panels, the conversation alone, or the panels alone.

Sets the app's default model (the next new chat's); persist: false holds it for this window only.

The token stores sidebarContributionsOf reads.

What a session's dot says (StatusDot draws it).

How the sidebar groups its rows: the session list's groupings, one section per host, or one group per agent.

How the rows group: one of the built-in groupings, or a query grouping (a space's, an extension's, the agents').

The sidebar's strings, as DEFAULT_SIDEBAR_LABELS has them.

The conversation last open per space id.

One row of the sidebar: a session-list row (a header may name its host) or a host's section header.

What the sidebar list renders: a session or "show more" row, or a section, a header and the rows under it, drawn as its own <ul> so the header sticks while they scroll by and the next section pushes it out.

The Origin filter: the sessions a reminder started (scheduleId set), or the others.

How the sidebar orders sessions inside a group.

Views per space id.

A space's record as stored: its view, plus the conversation last open in it (session, when one was).

The Storage the views persist in (localStorage in a browser).

Structured subagent lifecycle metadata, as carried on StreamEvent.spawn.

A paired tool call's row: what ToolRow, ToolDetails and the ToolBody slot read.