zidane-ui/chat/transcript

One line of terminal output, already parsed (an output line's spans).

Terminal output in the theme's colors, a line per line; parsed only when it holds an escape (else the text as is), once per text.

An attachment's icon, or its short badge (e.g. TS) for icon-less kinds, in its tone.

Renders a sign-in failure as a card with its fixes; see the module comment for the rules.

Provides the badge menu to the badges below it and renders it (and its notice) when one opens.

A hover card's body as compact Markdown (see the module comment).

The disclosure caret of a collapsible header: points right, turns down while open.

The one hover card every chip opens (see the module comment for its layout).

A chip with its card: opens on hover / focus, under the chip.

A codemode script with its line numbers and, while it streams its progress, the state of each line.

A command chip's card.

Supporting output from a / command, in the ToolRow idiom: the info Dot in the gutter (drawn by TranscriptRow), a capitalized label, a trailing caret; COLLAPSED by default like tool results. The expanded body renders through the Markdown slot — command emits are markdown text (prose, fenced code the app may highlight), not raw terminal output, so a capped monospace <pre> would misrender them as a wall of mono.

A / command's receipt: what it recorded for the model, one muted line beside its check dot. Its commits, PRs, branches, links and `code` are whatever the InlineText slot draws (the desktop app: the badges a message shows).

A sha chip's card.

Renders a compaction boundary: how many turns were compacted, the model, cost, and tokens, with the summary text behind a toggle.

Renders a transcript row that is always mounted, such as a row inside an open fold or a subagent block.

Renders the text as is. The default InlineText slot.

The kit's Markdown, its fences drawn by the CodeBlock slot in effect. The default Markdown slot.

The prompt's text as typed, a block per line (PromptLines).

The session's id as a link that opens it (TranscriptActions.openSession; without it, plain text). A link inside the tool row's header button: the click is stopped before the button toggles the row, and role=link + Enter keeps it reachable without a nested <button>, which HTML forbids.

Tight diff rendering: green/red tints, gutter glyph (+ / − / space), whitespace-pre so leading indentation survives. Consecutive lines with the same op paint as one block (one tint, one gutter, one text node): a 500-line hunk would otherwise be 1,500 elements to build, style and lay out every time its row scrolled into a long transcript.

Renders the status dot that leads a transcript row, centered on the row's first text line. Nothing in a transcript without row icons (RowIconsContext).

Per-hunk diff renderer with approval-outcome badges. When edit.outcomes is set (per-edit approval landed live, or replay re-parsed it off the tool result body), each hunk gets its own card with a ✓/✕/⊘/⚠/⋯ badge; the header summarizes via canonical summarizeOutcomes. Single-hunk edits with all-applied outcomes collapse back to the flat layout so the common case doesn't grow extra chrome.

Renders an error line in the transcript's error tone.

Renders a folded exchange: one header line summarizing the work, a live stack of the latest steps while it runs, and the full step list when expanded.

A failed step's mark in its own line, in a transcript without row icons: the red cross its icon would have shown.

How a run that ended early reads: one quiet line (Stopped, then the reason in muted text, for a failure; Stopped by you for a stop), and on the transcript's last word a small button that picks the work back up: Continue when the run had done something, Retry (the same prompt) when it had not. Both hand their prompt to onResume (the desktop app: the composer's send); without it there is no button. A run stopped by a failed sign-in (detail.auth) shows the sign-in's card instead (AuthFailureCard).

A file's type icon (or its language's two letters), as the badge's leading icon. The letters are drawn by CSS, so the badge's text is the name alone (what a copy or a screen reader gets).

A fold's header line (the exchange's work, a group of earlier messages): a toggle with its caret when opening shows something more, otherwise the same line, inert. Same box, tone and spacing either way.

Renders a generate_image call's loader while it runs and its images once they land.

Renders a plain informational line from the harness, in muted text.

A receipt line with its chips (see the module comment).

Inline code in prose, as what it names (see above).

The expanded body of a present_plan, ask_user or todowrite call (see the module comment); null for any other.

Renders a transcript row that mounts its content only when it nears the viewport. Until then it is an empty box at its estimated height; once mounted it stays mounted.

A link as a badge: the site's icon and the short address; the whole URL on hover. Opens externally.

The site's icon before a link in prose; nothing until (or unless) the site has one.

A live output window.

Explicit scrollback at the top of the timeline, drawn as one of its rows: the rail's quiet ring (an arrow up, the running arc while a page loads) and a muted line on the conversation's text size, with the hover pill the fold's action lines use. Scroll-to-load needs an overflowing viewport; this works regardless, and by keyboard. Without row icons (showIcon, the Row icons setting) the ring goes too, so its text lines up with the rows'.

"Load full output" under a clipped result.

Renders markdown in the .zg-md prose box. Long texts (a pasted 60 KB prompt, a long report) render in chunks (splitMarkdown): each is its own memoised parse, so a streaming reply re-parses only its tail, and a long text mounting ahead of the view (useBackgroundMount) parses a couple of chunks per frame instead of all of it in one. Chunks are siblings in the one box, so block spacing, the first/last-child rules and the streaming caret are unchanged. While a transcript search runs, everything renders at once (it walks the DOM). A fence still open at the end of a streaming reply skips the parse: the code block draws its text until it closes.

Sets whether the Markdown below draws ```mermaid fences as diagrams. Without one they do. Transcript sets it from its renderDiagrams option.

Draws a Mermaid source as a themed SVG diagram, with zoom and a toggle to its source. Falls back to the highlighted source when Pele cannot draw it.

Renders a group of an exchange's messages: earlier messages stacked behind the latest one, which shows in full. Expands to list every message.

The decision model's verdict on the call. A denial reads "auto-denied" with the model and its confidence as chips; an approval is only a sparkle (most calls of a model-approved session are), its verdict in the tooltip.

The calls a tool made (a codemode script's tools.*, its row's children), one step in under its row, open or not: they are the call's children, not its body. Each one is a regular ToolRow with its own state.

Structured notice: the headline as a severity-toned badge, facts beneath. GUI counterpart of the TUI's NoticeRow (which keeps the glyph + label, this surface has color). Rendered for info events that carry notice (run-end stop reasons, model fallback, repeat guard, …); plain info events keep the quiet InfoRow.

A sent prompt with the composer's badges (see above).

A prompt's content as the composer lays it out: every typed line its own block (.zg-prompt-line), so a sent prompt keeps the rhythm it had while being written (.zg-prompt-bubble, transcript.css). items is the text and its inline badges, in order; a badge never spans a line break.

Markdown prose with chips: inline code as file / ref chips, links as reference and PR badges, extension references parsed in.

The highlighted file a read_file call returned, its language from the path it read.

A #N or sha chip: a GitHub issue or PR with its state and card when the repo is on GitHub, else the plain chip.

An extension reference as its badge (and hover card) once its view names something; the text until then.

text with its references as badges; plain text when there are none.

Lays out one transcript row: a flex line that holds the row's dot and its content.

A shell block with its run controls and its last run under it. A block with nothing to run, or an app that offers neither way to run, draws the plain block.

The run receipt as a row of small chips (model, time, round trips, cost, tokens, speed), each tinted by meaning and explained on hover. The hairline chips (.zg-meta-chip) keep the values apart.

Standalone receipt row — only for a run whose closing turn has no assistant row to dock onto.

The ::highlight() color rules, resolved once per mount. ::highlight() pseudos can't reliably resolve CSS custom properties in all Chromium versions, so the accent is resolved to a concrete color and interpolated into the injected rules. Theme changes mid-search show the old accent until reopen — acceptable for a transient surface. Render exactly one instance while search is active (overlay OR composer mode).

Renders the select-turn highlight behind the transcript rows marked data-sel, and scrolls the selection into view.

The mode's exit key, as a button.

The mode's key list (or its notice); null unless the mode is on in sessionId.

Holds select-turn mode for the surfaces below it (one mode for the whole app).

A #chat chip's card; its title opens the chat (OpenSessionContext).

Orchestration: a worker session reported an outcome. Drawn as a session thread draws its steps (the fold head / ToolRow idiom): a flat .zg-disclosure row, the title in the content voice, the receipt in .zg-meta, and a muted two-line excerpt of the worker's last word. No card, tint or line: status lives on the timeline dot and the verb's color. The whole row is a button that jumps to the reporting session (onOpenSession; without it the row is inert); needs-attention is the loud one, since it is the one status a human, not the main, has to act on. Falls back to a plain, non-clickable text row when sessionEvent is absent (malformed signal).

Lets the shell blocks of the reply below run (RunnableCodeBlock).

A skill chip's card.

The worker's end: a sentence, then what it cost and used as chips (describeSpawnEnd, shared with the TUI).

Spawn lifecycle markers — rendered INSIDE the SubagentBlock (every spawn row carries a childId, so clusterByOwner always folds them into a cluster). The block header already carries the identity + outcome, so these stay quiet: a plain "Task" / "Finished" lead-in and the marker text in normal (non-mono) type — task previews and outcome summaries are prose, not code. The raw child label survives as a tooltip for debugging.

Renders an assistant reply as markdown through the Markdown renderer slot. While streaming it marks the reply as still arriving.

Chained-thoughts group — mirrors ToolBatchRow's affordance exactly: one quiet header ("Thought 4 times", then the summed time as inline ToolTiming like a tool batch's) that expands to the individual ThinkingRow entries, each still individually collapsible. The duration only shows when at least one segment carried timing (live-session groups); replayed groups render a bare count.

Claude-Code-style batch header — collapsed by default, expands to reveal each child ToolRow. Mirrors the chevron / press-soft pattern the rest of the transcript already uses so the user reads it as "the same affordance" even though the underlying row is synthetic.

A tool call's payload: the command and its output, the diff, the file read, or input and output.

Renders the icon for a tool: a glyph by tool name, a puzzle piece for MCP tools, and a wrench otherwise.

A tool call's input panel, syntax-highlighted: the code it runs (a Codemode script line by line, CodemodeScript; a shell command, via toolInputCode), or else its JSON input.

Renders a tool result's media inline: images as thumbnails that open the lightbox, video and audio with native controls. An item that fails to load shows its stand-in text.

Renders a tool call as a collapsible row: glyph, name and target, timing, and, when opened, its input, output, diff, or media.

Live elapsed while the call runs, the final duration once it lands, both from the host's timing (the row's startedAt / durationMs). Same data the TUI shows for running work; muted mono so it reads as a receipt cell. No spinner: the ticking number is the progress cue, and the tool glyph already anchors the row's left edge.

Provides the transcript's actions to every row below it.

Overrides any subset of the slots; the rest keep the enclosing (or default) renderers.

Renders one transcript row by switching on its kind: prompts, replies, thinking, tool calls, notices, folds, and groups.

One root transcript row in its lazy wrapper, memoised on the row's own inputs.

The ⌘F overlay: the query, the match counter, ▲▼ and Esc (see the module comment). Needs the app's ModalProvider.

Dedicated row for user-initiated ! shell runs: ! <command> header with a stop button while running / an exit-code badge after, and a monospace tail window of the merged output (last 10 lines by default, full when showFull is on). Live streaming and reloaded transcripts render identically — both read the same persisted result text.

A sent prompt's attachments, above its bubble: images as 64px thumbnails, PDFs and text files as chips, all opening the lightbox (one gallery over them) when the transcript has their bytes or an address for them; other files as plain chips (the transcript has their name, not their bytes).

The prompt row: its dot, its attachments, its bubble. The bubble's pointer handlers are the app's (the desktop app opens the turn's actions on right-click).

A worker, opened: what it was asked (the Task step, closed by default), then its own progress folded like an exchange (foldWorkerRows): its calls behind one "Working" row, earlier messages stacked behind one group, its last message in full. No second "Agent" block: the fold line above already is the agent.

Inline code that is exactly an issue or PR number or a SHA becomes a ref chip too.

Copying from a bubble: the selected lines as typed, one line break between them and blank lines kept. The browser's own copy would drop the blank lines (an empty block has no text) and add breaks of its own.

Creates the turn commands over a session host's stored turns.

Returns a generic file icon and the file name. The default attachmentLabel slot.

True when the row draws images: it made image requests, itself or through a script.

A file badge's name: long names end in an ellipsis rather than crowding the line.

A file badge as an editor node renders it (the composer has no React inside its nodes).

The #123s and SHAs in a plain text, in order (outside markdown: receipts, titles).

The tools this body knows how to render.

Every lazy row mounts while held (and stays mounted after release). Returns the release.

The image requests a row draws: its own generate_image call, or the ones a script (a row with nested calls) made. Empty for anything else, a model listing, and a nested call (its script's row draws it).

Reasoning rows render nothing while showThinking is off (and get no wrapper).

The LineState a row icon stands for, or undefined when the row's line says its state already (a reply, a note, an error in its own tone).

A link badge's glyph: the site's icon once loaded (set --zg-site-icon), the globe until then or without one.

Mount a lazy row's content now, wherever it is: a view putting its place back (useStickToBottom's restorePosition) lands on rows it never came near. A row already mounted, or not a lazy row, is left alone. Call it outside React's render and effects: it commits synchronously.

The number of a text that is exactly #N (an issue or PR), else null.

The extension reference a zg-ref:ext: link names; null for any other URL.

The ref a zg-ref: link names; null for any other URL.

The zg-ref:ext: URL for an extension reference (what the remark plugin writes).

Where a ref leads on the repo's site (a PR or issue, a commit); null without a web base.

The remark plugin: the providers' matches in prose become zg-ref:ext: links.

The remark plugin: #123 and commit SHAs in prose become zg-ref: links (see the module comment).

The saved paths, from the result's Saved: <path> (<size>) lines.

The --zg-site-icon value for a loaded icon's data URL.

True inside a row mounted ahead of the view, where content may render over a few frames.

Opens the badge menu for a badge. Outside the provider (a test, a detached surface) the event is left alone, so the surrounding menu still opens.

Current answer for text in cwd, refreshed when stale.

The command a chip's text names, in a folder on a host (hostId null: this one).

A sha's commit in cwd's repository.

The composer's ? search: its query, the engine over the transcript, and a change another window made (remoteApply) for the composer to show.

Fill a viewport that cannot scroll. On a long live run the tail page is all one exchange, folded into a single Working row: nothing overflows, no scroll event ever fires, and the history above stays unreachable. Load pages until the content overflows (slackPx past the viewport) and holds FILL_MIN_PROMPTS of the user's prompts (rows marked data-prompt), capped per activation so a 10k-turn fold doesn't drag the whole run over IPC. Past the cap, LoadEarlierRow takes over.

Returns whether every lazy row must be mounted now, for example while a search needle is active.

The whole text of a clipped tool result, fetched on demand through TranscriptActions.toolOutput. full: null = not fetched, a string = the full text (replaces the clipped preview), 'loading' while the roundtrip runs. available is false when the app cannot fetch outputs: the row then offers no button.

How the transcript names a model: the app's modelName, else from the id.

The chat a #token names, and its context gauge.

The references in text for surface; empty until the providers are known.

The providers for cwd ('': user-level), asked for on first use. peek: only if the host already built that folder's registry.

A reference's view: undefined while unknown, null when it names nothing (no badge). Asked for on first use.

Asks again now, bypassing the cache (a click: the file may exist since). null without a host's paths.

Whether the rows of the transcript around draw their icons (RowIconsContext).

Select-turn stops (computeSelectStops): which turns the cursor walks and which rows light up. Derived per transcript change while the mode is on, never per keypress, and not at all outside it. registerStops hands the app a function that answers from the rows painted right now (it asks before the mode is on, and on every arrow), cached per input so a burst of arrows computes once.

The select-turn mode. K: the app's session id type. Throws outside a SelectTurnProvider.

Drives select-turn mode for the session on show.

Whether the thread is still veiled (see the module comment).

The reply whose blocks can run here, or null (a streaming reply, a thought, a tool's input).

The site icon of url once loaded; null until then, for a site without one, or without a host's icons.

The skill a chip's text names in cwd.

Keeps a transcript's scroller on the bottom while it grows, and its reader's line in place once they leave it (the contract above).

The media a result shows inline, with the text left around it; null when it shows none.

Returns the TranscriptActions from the nearest TranscriptActionsProvider. Without one it returns an object with no session and no actions.

The find in the conversation: ⌘F opens it on the session on show (keeping a query already there), a switch to another session closes it.

Routes ⌘F / ⌘⇧F to the tab scope in reach, else to the conversation. The listener attaches once.

Returns the renderer slots in effect: the defaults merged with every enclosing TranscriptRenderersProvider, and the extensions' language and tool renderers routed in.

Runs the headless pipeline over a transcript's events, one useMemo per pass, and returns the rows to paint.

The transcript's scroll: stick-to-bottom, where a conversation opens, the from-top signal and lazy scrollback (see the module comment).

revision is any value whose identity changes when the transcript re-renders (the host's events array) — it triggers a match recompute without moving the viewport, so streaming deltas don't yank the user away from the match they're reading. Only a needle CHANGE scrolls.

The turn commands over the session host's turns (stable while they are); null when the host has none.

The transcript's turn menu: onContextMenu for a row, prefetch on hover (the send time), and the menu element to render once (memoized).

Pauses hover effects while the wheel scrolls the transcript, so rows passing under the pointer don't light up.

Pages auto-loaded per activation before the explicit row takes over.

Literal classes (UnoCSS scans this file): the ::before glyph of each badge kind.

The hover card's width, px.

Tool input / output panels: set into the row on the code tone (quiet text, the code panel's inset edge).

The gutter line height of a command-detail row's Dot: a text-sm × 1.6 line (22.4px) plus the header button's py-0.5. A body-less detail has no button but keeps the same padding, so both share it.

The transcript's command scope (its container provides the session's).

The default renderer slots: safe markdown, highlighted code, plain inline text, and a generic attachment icon. Used when no TranscriptRenderersProvider is present.

Prompts the opened conversation should show: fewer, and the fill keeps loading.

Horizontal distance in pixels from one nesting level of the transcript's glyph column to the next: a 16px glyph slot plus a 12px gap.

Inline code in running prose: the code tone, no outline. A path or identifier longer than the line breaks instead of running past the column.

The chips' session facts (no session: nothing resolves, nothing links).

Range cap — a short query ("e") over a long transcript can produce tens of thousands of matches; building Ranges + a Highlight for all of them stalls the frame for no navigational benefit. The counter shows "500+" when the cap is hit.

Shows a chat by its id (a #chat card's title). The app provides it once; absent, the title is plain.

Whether the transcript draws its row icons: the Dot that leads each row (you, the agent, how a step went). Transcript provides it from its showRowIcons option. Without them the icon column goes and the rows take its room.

True while the transcript is first painting a conversation (switching to it, or its history landing). Rows mounted then were already there: they must not play their enter animation.

Props for AnsiSpans.

Props for AnsiText.

Props for AttachmentIcon.

What a non-image attachment shows: an icon (or a short badge) and its name.

Props for AuthFailureCard.

What applyBadgeEffect applies an effect with.

Where web links open: the default browser, and the app's own browser pane.

Where "Add to prompt" and an action's insert go: the focused composer.

Props for BadgeMenuProvider.

Opens and reveals paths (open / reveal effects); each resolves false when the path is unavailable.

Props for CardMarkdown.

Props for Caret.

Props for ChipCard.

Props for ChipHover.

Props of the CodeBlock renderer slot.

Props for CodemodeScript.

Props for CommandCard.

Props for CommandDetailRow.

Props for CommandNoteRow.

Where a session's commands come from: its folder, on this computer or a server.

Props for CommitCard.

Props for CompactSummaryRow.

Props for CvRow.

Props for DefaultMarkdown: the MarkdownSlotProps plus the root's style.

Props for DiffLines.

Props for Dot.

Props for EditDiffBlock.

Props for ErrorRow.

Props for ExchangeFoldRow.

Props for FailedMark.

Props for FailureRow.

Props for FileBadgeIcon.

Props for FoldHeader.

Props for ImageGenerationBlock.

Props for InfoRow.

Props for InlineChipText.

Props for InlineCode.

Props of the InlineText renderer slot.

The call an InteractionToolBody draws.

Props for InteractionToolBody.

Props for LazyRow.

Props for LinkBadge.

Props for LinkIcon.

Props for LiveOutput.

Props for LoadEarlierRow.

Props for LoadFullOutputButton.

Session-scoped facts prose chips need. cwd and repoWebBase are null outside a session. host: the server a server session's files are on; its file chips are inert (this machine's disk is not that server's), with a tooltip saying so.

Props of MarkdownDiagrams.

Props of a MarkdownProps.Link.

Props of Markdown.

Props of the Markdown renderer slot.

Props of MermaidDiagram.

Props for MessageGroupRow.

Props for ModelVerdict.

Props for NestedToolCalls: the display props every nested ToolRow gets, plus the child calls.

Props for NoticeRow.

A ref a zg-ref: link or inline code names.

An extension reference a zg-ref:ext: link names.

A submitted prompt as typed: its lines as the composer lays them out (PromptLines, the bubble keeps whitespace), with the composer's badges around its references (files, skills, links, and a command invocation's /name), so a prompt reads the same sent as typed. Badges are atomic inline boxes, so wrapping leaves them whole. An app's transcript Prompt slot.

Props for PromptLines.

Props of the Prompt renderer slot.

Props for ProseMarkdown.

Props for ReadFileBlock.

Props for RefChip.

Props for ReferenceChip.

Props for ReferenceText.

A #123 or SHA found in plain text.

What every row reads besides its own data: one memoized object per transcript.

Props for RowFrame.

A row of a ScrollPosition, and where it was on screen.

Props for RunnableCodeBlock.

Props for RunReceiptInline.

Props for RunSummaryRow.

Props for SelectCursor.

The turn commands an app implements for the mode (open the details, copy, fork).

Props for SelectTurnHintKeys.

Options for useSelectTurnKeys.

Props for SelectTurnProvider.

The mode's cursor: the session that owns it and the selected stop.

What useSelectTurn returns: the mode's state and its actions.

Props for SessionCard.

Props for SessionEventRow.

Props of the SessionTitle renderer slot.

Props for ShellBlockProvider.

The reply a block is in.

Props for SkillCard.

A cached root row element and the inputs it was built from. The transcript reuses the element while the inputs are unchanged.

Props for SpawnEndRow.

Props for SpawnStartRow.

Options of useStickToBottom.

Props for SubagentBlock.

Props of the TextPreview renderer slot: a text attachment opened in the lightbox.

Props for TextRow.

Props for ThinkingBatchRow.

Props for ThinkingRow.

Props for ToolBatchRow.

Props of the ToolBody renderer slot.

Props for ToolDetails.

Props for ToolGlyph.

Props for ToolInput.

Props for ToolMedia.

Props for ToolRow.

Props for ToolTiming.

The accounts of the host that holds a session's credentials, for the card a run stopped by a failed sign-in shows (AuthFailureCard). Each member is optional, and the card's button that needs it hides without it.

What a transcript row can ask of the app that hosts it. Every action but sessionId is optional, and its control is hidden when the app leaves it out.

Props for TranscriptActionsProvider.

What useTranscriptFind returns: hand open, query and close to your TranscriptSearch.

Options for useTranscriptFindKey.

Options for useTranscriptFind.

Where the find is open, and with what.

The set of renderer slots a transcript draws through. Each is a component or function an app can replace with TranscriptRenderersProvider.

Props for TranscriptRenderersProvider.

Props for TranscriptRow.

The rows a Transcript paints and what it derives from them.

The display options that shape the rows.

Props for TranscriptRowSlot: the TranscriptRowProps of its row, plus its lazy wrapper's.

What useTranscriptScroll reads from its container.

Opt-ins of a search opened from a palette match (see the module comment).

Props for TranscriptSearch.

What useTranscriptSearch returns: the match count and cursor, and the hop.

A turn's actions on its prompt bubble and settled replies (the app's turn menu).

What createTurnCommands returns.

Options of createTurnCommands.

What the turn menu's items do, for one transcript. Memoize it: the items rebuild when it changes.

What a turn-menu right-click landed on.

Props for UserBashRow.

Props for UserPromptAttachments.

Props for UserPromptRow.

Props for WorkerDetails.

How a file chip opens what it names: a file at at (1-based) when the text gave a line (schema.ts:258).

What useComposerSearch returns.

Props for DefaultInlineText: the InlineTextSlotProps.

Props for DefaultPrompt: the PromptSlotProps.

Props for DefaultSessionTitle: the SessionTitleSlotProps.

A step's state that only its row icon shows: a call or a worker still running, or one that failed. Without the icons the row's own line says it: a light sweep over its name while it runs, a FailedMark once it failed.

Opens the badge menu for a badge at the event's point.

Where a transcript's view is (useStickToBottom's readPosition): following the bottom, or the row under the reader's line and then each row around it, out to the transcript's own.