@workerdeck/ui 0.23.0 → 1.1.0

package/build/index.d.mts

@@ -1,79 +1,52 @@
-import { a as formatDuration, c as formatRelativeTime, d as rateLimitWindowSeconds, f as toolInputPreview, i as formatCountdown, l as formatTokens, n as formatBytes, o as formatRateLimitWindow, r as formatCost, s as formatRateLimitWindowLong, t as formatAgoPrecise, u as friendlyModel } from "./format-ljc3lKpA.mjs";
-import { C as permissionModeChoices, S as PermissionModeSelectProps, _ as useAffordances, a as SessionVitals, b as PermissionModeMeta, c as TranscriptDensityProvider, d as TranscriptVariantProvider, f as useTranscriptDensity, g as WithActions, h as TerminalAffordances, i as SessionSurfacePanel, l as TranscriptFont, m as CopyAction, n as SessionPanel, o as TerminalMetrics, p as useTranscriptVariant, r as SessionPanelProps, s as TranscriptDensity, t as SessionControls, u as TranscriptVariant, v as PERMISSION_MODES, w as permissionModeMeta, x as PermissionModeSelect, y as PermissionModeChoice } from "./SessionPanel-BobynUo4.mjs";
-import * as _$react from "react";
+import { a as formatDuration, c as formatRelativeTime, d as rateLimitWindowSeconds, f as toolInputPreview, i as formatCountdown, l as formatTokens, n as formatBytes, o as formatRateLimitWindow, r as formatCost, s as formatRateLimitWindowLong, t as formatAgoPrecise, u as friendlyModel } from "./format-C_lpFq0l.mjs";
+import { C as permissionModeChoices, S as PermissionModeSelectProps, _ as useAffordances, a as SessionVitals, b as PermissionModeMeta, c as TranscriptDensityProvider, d as TranscriptVariantProvider, f as useTranscriptDensity, g as WithActions, h as TerminalAffordances, i as SessionSurfacePanel, l as TranscriptFont, m as CopyAction, n as SessionPanel, o as TerminalMetrics, p as useTranscriptVariant, r as SessionPanelProps, s as TranscriptDensity, t as SessionControls, u as TranscriptVariant, v as PERMISSION_MODES, w as permissionModeMeta, x as PermissionModeSelect, y as PermissionModeChoice } from "./SessionPanel-yNO60Tzw.mjs";
 import { ButtonHTMLAttributes, FunctionComponent, HTMLAttributes, InputHTMLAttributes, ReactElement, ReactNode, Ref, RefObject, TextareaHTMLAttributes } from "react";
 import { VariantProps } from "class-variance-authority";
 import { ClassValue } from "clsx";
-import * as _$_base_ui_react_select0 from "@base-ui/react/select";
 import { Select as Select$1 } from "@base-ui/react/select";
 import { LucideIcon } from "lucide-react";
-import * as _$_base_ui_react_alert_dialog0 from "@base-ui/react/alert-dialog";
 import { AlertDialog as AlertDialog$1 } from "@base-ui/react/alert-dialog";
 import { Menu as Menu$1 } from "@base-ui/react/menu";
-import * as _$_base_ui_react_dialog0 from "@base-ui/react/dialog";
 import { Dialog as Dialog$1 } from "@base-ui/react/dialog";
-import * as _$_base_ui_react_tooltip0 from "@base-ui/react/tooltip";
 import { Tooltip } from "@base-ui/react/tooltip";
 import { toast } from "sonner";
 import { ContextReading, ContextUsage, FilePatch, ModelOption, PermissionRequest, ProfileEngine, ProjectIcon as ProjectIcon$1, QuestionBehavior, RateLimitInfo, SessionInfo, SessionRow, SessionStatus, SkillInfo, SlashCommandInfo, UsageWindowRow, UserQuestion, ViewConfig, WorkspaceScope } from "@workerdeck/protocol";
 import { ConnectionState, TranscriptItem, TranscriptState, UseAttachmentsResult } from "@workerdeck/react";
-import * as _$class_variance_authority_types0 from "class-variance-authority/types";
 import { WorkerDeckClient } from "@workerdeck/client";
-
 //#region src/components/ui/Button.d.ts
 declare const buttonVariants: (props?: ({
   variant?: "default" | "outline" | "secondary" | "ghost" | "destructive" | "link" | null | undefined;
   size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-sm" | null | undefined;
-} & _$class_variance_authority_types0.ClassProp) | undefined) => string;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
 interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {}
-declare const Button: _$react.ForwardRefExoticComponent<ButtonProps & _$react.RefAttributes<HTMLButtonElement>>;
+declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
 //#endregion
 //#region src/components/ui/Badge.d.ts
 declare const badgeVariants: (props?: ({
   variant?: "neutral" | "accent" | "success" | "warning" | "danger" | "info" | null | undefined;
   mono?: boolean | null | undefined;
-} & _$class_variance_authority_types0.ClassProp) | undefined) => string;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
 interface BadgeProps extends HTMLAttributes<HTMLSpanElement>, VariantProps<typeof badgeVariants> {
-  /** Render a leading status dot in the variant's color. */
   dot?: boolean;
 }
-declare function Badge({
-  className,
-  variant,
-  mono,
-  dot,
-  children,
-  ...props
-}: BadgeProps): _$react.JSX.Element;
+declare function Badge({ className, variant, mono, dot, children, ...props }: BadgeProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/ui/Card.d.ts
-declare function Card({
-  className,
-  ...props
-}: HTMLAttributes<HTMLDivElement>): _$react.JSX.Element;
-declare function CardHeader({
-  className,
-  ...props
-}: HTMLAttributes<HTMLDivElement>): _$react.JSX.Element;
-declare function CardTitle({
-  className,
-  ...props
-}: HTMLAttributes<HTMLHeadingElement>): _$react.JSX.Element;
-declare function CardContent({
-  className,
-  ...props
-}: HTMLAttributes<HTMLDivElement>): _$react.JSX.Element;
+declare function Card({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+declare function CardHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+declare function CardTitle({ className, ...props }: HTMLAttributes<HTMLHeadingElement>): import("react").JSX.Element;
+declare function CardContent({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
 //#endregion
 //#region src/components/ui/Input.d.ts
-declare const Input: _$react.ForwardRefExoticComponent<InputHTMLAttributes<HTMLInputElement> & _$react.RefAttributes<HTMLInputElement>>;
+declare const Input: import("react").ForwardRefExoticComponent<InputHTMLAttributes<HTMLInputElement> & import("react").RefAttributes<HTMLInputElement>>;
 //#endregion
 //#region src/components/ui/Textarea.d.ts
-declare const Textarea: _$react.ForwardRefExoticComponent<TextareaHTMLAttributes<HTMLTextAreaElement> & _$react.RefAttributes<HTMLTextAreaElement>>;
+declare const Textarea: import("react").ForwardRefExoticComponent<TextareaHTMLAttributes<HTMLTextAreaElement> & import("react").RefAttributes<HTMLTextAreaElement>>;
 //#endregion
 //#region src/components/ui/Select.d.ts
 declare const Select: typeof Select$1.Root;
-declare const SelectValue: _$react.ForwardRefExoticComponent<Omit<_$_base_ui_react_select0.SelectValueProps, "ref"> & _$react.RefAttributes<HTMLSpanElement>>;
-declare const SelectItemText: _$react.NamedExoticComponent<Omit<_$_base_ui_react_select0.SelectItemTextProps, "ref"> & _$react.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react/select").SelectValueProps, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+declare const SelectItemText: import("react").NamedExoticComponent<Omit<import("@base-ui/react/select").SelectItemTextProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
 declare const SelectTrigger: FunctionComponent<Select$1.Trigger.Props>;
 declare const SelectContent: FunctionComponent<Select$1.Popup.Props & Pick<Select$1.Positioner.Props, 'align' | 'alignItemWithTrigger' | 'side' | 'sideOffset'>>;
 declare const SelectItem: FunctionComponent<Select$1.Item.Props>;
@@ -81,13 +54,13 @@ declare const SelectItem: FunctionComponent<Select$1.Item.Props>;
 //#region src/components/ui/AlertDialog.d.ts
 declare const AlertDialog: typeof AlertDialog$1.Root;
 declare const AlertDialogTrigger: AlertDialog$1.Trigger;
-declare const AlertDialogClose: _$react.ForwardRefExoticComponent<Omit<_$_base_ui_react_alert_dialog0.AlertDialogCloseProps, "ref"> & _$react.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogClose: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react/alert-dialog").AlertDialogCloseProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
 declare const AlertDialogContent: FunctionComponent<AlertDialog$1.Popup.Props>;
 declare const AlertDialogTitle: FunctionComponent<AlertDialog$1.Title.Props>;
 declare const AlertDialogDescription: FunctionComponent<AlertDialog$1.Description.Props>;
 //#endregion
 //#region src/components/ui/Menu.d.ts
-declare const Menu: <Payload>(props: Menu$1.Root.Props<Payload>) => _$react.JSX.Element;
+declare const Menu: <Payload>(props: Menu$1.Root.Props<Payload>) => import("react").JSX.Element;
 declare const MenuTrigger: Menu$1.Trigger;
 declare const MenuContent: FunctionComponent<Menu$1.Popup.Props & Pick<Menu$1.Positioner.Props, 'align' | 'side' | 'sideOffset'>>;
 declare const MenuItem: FunctionComponent<Menu$1.Item.Props & {
@@ -98,26 +71,16 @@ declare const MenuSeparator: FunctionComponent<Menu$1.Separator.Props>;
 //#region src/components/ui/Dialog.d.ts
 declare const Dialog: typeof Dialog$1.Root;
 declare const DialogTrigger: Dialog$1.Trigger;
-declare const DialogClose: _$react.ForwardRefExoticComponent<Omit<_$_base_ui_react_dialog0.DialogCloseProps, "ref"> & _$react.RefAttributes<HTMLButtonElement>>;
-/**
- * A dismissible panel, sized for reading rather than confirming — the web
- * counterpart of the iOS app's detail sheets (context, usage, session info, MCP).
- *
- * Taller than {@link AlertDialogContent} and scrollable inside, because these
- * carry lists whose length is the engine's business, not the layout's.
- */
+declare const DialogClose: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react/dialog").DialogCloseProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
 declare const DialogContent: FunctionComponent<Dialog$1.Popup.Props & {
   size?: 'sm' | 'md' | 'lg';
 }>;
-/** Title row with the close button, pinned above the scrolling body. */
 declare const DialogHeader: FunctionComponent<{
   title: string;
-  description?: string; /** Rendered between the title and the close button. */
+  description?: string;
   actions?: React.ReactNode;
 }>;
-/** The scrolling region under the header. */
 declare const DialogBody: FunctionComponent<React.HTMLAttributes<HTMLDivElement>>;
-/** A label/value row — the shape every one of these panels is mostly made of. */
 declare const DialogRow: FunctionComponent<{
   label: string;
   children: React.ReactNode;
@@ -125,196 +88,75 @@ declare const DialogRow: FunctionComponent<{
 }>;
 //#endregion
 //#region src/components/ui/Tooltip.d.ts
-declare const TooltipProvider: _$react.FC<_$_base_ui_react_tooltip0.TooltipProviderProps>;
+declare const TooltipProvider: import("react").FC<import("@base-ui/react/tooltip").TooltipProviderProps>;
 declare const TooltipContent: FunctionComponent<Tooltip.Popup.Props & Pick<Tooltip.Positioner.Props, 'side' | 'sideOffset'>>;
-/**
- * Convenience wrapper: `<Tip content="..."><Button/></Tip>`.
- *
- * Pass `render` when the trigger must *be* an element you already have — a tab, a
- * row — rather than something wrapped in a span. The default span is fine beside
- * a button but would break any layout that styles its own children (a flex tab
- * strip gets an extra box between the container and its items).
- */
-declare function Tip({
-  content,
-  render,
-  side,
-  children
-}: {
+declare function Tip({ content, render, side, children }: {
   content: ReactNode;
   render?: ReactElement;
   side?: 'top' | 'right' | 'bottom' | 'left';
   children?: ReactNode;
-}): _$react.JSX.Element;
+}): import("react").JSX.Element;
 //#endregion
 //#region src/components/ui/Sonner.d.ts
-/** Token-themed toaster; relies on the [data-theme] swap, so no `theme` prop needed. */
-declare function Toaster(): _$react.JSX.Element;
+declare function Toaster(): import("react").JSX.Element;
 //#endregion
 //#region src/components/ui/CopyButton.d.ts
 interface CopyButtonProps extends Omit<ButtonProps, 'onClick' | 'children'> {
   value: string;
-  /** Draw the state as characters (`⧉` / `✓`) rather than line-art icons — for
-   * terminal-styled surfaces, where an SVG reads as another app's button. */
   glyph?: boolean;
 }
-declare function CopyButton({
-  value,
-  glyph,
-  className,
-  variant,
-  size,
-  ...props
-}: CopyButtonProps): _$react.JSX.Element;
+declare function CopyButton({ value, glyph, className, variant, size, ...props }: CopyButtonProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/ui/Spinner.d.ts
-declare function Spinner({
-  className
-}: {
+declare function Spinner({ className }: {
   className?: string;
-}): _$react.JSX.Element;
+}): import("react").JSX.Element;
 //#endregion
 //#region src/components/ui/CodeBlock.d.ts
 interface CodeBlockProps {
   code: string;
-  /** Header label, e.g. a language or "Parameters". */
   label?: ReactNode;
   copyable?: boolean;
-  /**
-   * `'panel'` (default) is the framed card: border, header strip, rounded.
-   * `'plain'` is the terminal treatment — the label is a dim line, the code a
-   * flat band, and copy is a character. For surfaces where a box around every
-   * payload is more chrome than content (the transcript's `lines` variant).
-   *
-   * A prop rather than a read of the transcript's variant context: this is a
-   * `ui/` primitive and has no business knowing what a transcript is. The agent
-   * component that renders it does.
-   */
   variant?: 'panel' | 'plain';
   className?: string;
 }
-/** Plain (unhighlighted) code panel for structured data like tool inputs. Markdown code
- * inside assistant responses is highlighted by <Response> instead. */
-declare function CodeBlock({
-  code,
-  label,
-  copyable,
-  variant,
-  className
-}: CodeBlockProps): _$react.JSX.Element;
+declare function CodeBlock({ code, label, copyable, variant, className }: CodeBlockProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/ui/Splitter.d.ts
 interface SplitterProps {
-  /**
-   * ARIA's sense of the word: a `vertical` splitter is a vertical bar between
-   * two side-by-side panes, and it resizes a **width**. A `horizontal` one sits
-   * between stacked panes and resizes a **height**.
-   */
   orientation: 'vertical' | 'horizontal';
-  /** Current size of the pane this splitter controls, in pixels. */
   value: number;
   onValueChange: (value: number) => void;
   min: number;
   max: number;
-  /** Keyboard step. */
   step?: number;
-  /**
-   * Size to snap back to on a double-click — the convention every pane divider
-   * that can be dragged is expected to honour. Omit and a double-click does
-   * nothing, which is the honest behaviour when there is no default to mean.
-   */
   defaultValue?: number;
-  /** Set when dragging the splitter *away* from the origin should shrink the
-   * controlled pane — i.e. the pane is on the right or the bottom. */
   inverted?: boolean;
-  /** Required: "Resize" alone does not say which of two splitters this is. */
   'aria-label': string;
   className?: string;
 }
-/**
- * A draggable pane divider.
- *
- * Hand-rolled rather than depended on: `@base-ui/react` ships no splitter, the
- * behaviour is a hundred lines of pointer events, and this repo's instinct at
- * this layer is to own it (the composer is vendored for the same reason).
- *
- * Pointer capture is what makes it survive a fast drag — without it the pointer
- * leaves the 5px bar within a frame and the moves go to whatever is underneath,
- * which for this layout is an iframe-free but still selection-happy code pane.
- * The drag origin is captured on pointerdown and every move is measured against
- * it, so the pane cannot drift relative to the cursor over a long drag the way
- * per-move deltas do once clamping is involved.
- *
- * Keyboard-operable and announced as a separator, because a pane you can only
- * size by dragging is a pane some people cannot size.
- */
-declare function Splitter({
-  orientation,
-  value,
-  onValueChange,
-  min,
-  max,
-  step,
-  defaultValue,
-  inverted,
-  'aria-label': label,
-  className
-}: SplitterProps): _$react.JSX.Element;
+declare function Splitter({ orientation, value, onValueChange, min, max, step, defaultValue, inverted, 'aria-label': label, className }: SplitterProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/ui/Empty.d.ts
-/**
- * A view with nothing in it: icon, title, description, and at most one action.
- *
- * Centered and given room, because an empty view is the first thing a new
- * install shows and a flush-left sentence in the top corner reads like a bug
- * report. It lives here rather than in one client because every panel that can
- * be empty should be empty the same way — the extension's views and the
- * dashboard's four sidebars are the same shape of thing.
- *
- * **At most one action, and never one the view header already offers.** Creating
- * a session and adding a gateway are the `+` in the native title bar, exclusively
- * — so those empty states point at it in words rather than growing a second
- * button that does the same thing two inches lower. A button here is for the way
- * out of a state the header has no answer to: clearing a filter, widening a
- * scope.
- */
-declare function Empty({
-  icon,
-  title,
-  description,
-  action,
-  onAction
-}: {
+declare function Empty({ icon, title, description, action, onAction }: {
   icon: ReactNode;
   title: string;
   description?: ReactNode;
   action?: string;
   onAction?: () => void;
-}): _$react.JSX.Element;
-/** A key or icon named inline in an empty state's description — "use the + above". */
-declare function EmptyKey({
-  children
-}: {
+}): import("react").JSX.Element;
+declare function EmptyKey({ children }: {
   children: ReactNode;
-}): _$react.JSX.Element;
+}): import("react").JSX.Element;
 //#endregion
 //#region src/components/ui/ProgressRing.d.ts
 interface ProgressRingProps {
-  /** Filled share, 0–100 (clamped). */
   value: number;
-  /** Outer diameter in px. */
   size?: number;
   strokeWidth?: number;
   className?: string;
 }
-/** Tiny SVG progress circle; stroke color comes from `currentColor` so callers set it
- * via text color classes (e.g. warning/danger past thresholds). */
-declare function ProgressRing({
-  value,
-  size,
-  strokeWidth,
-  className
-}: ProgressRingProps): _$react.JSX.Element;
+declare function ProgressRing({ value, size, strokeWidth, className }: ProgressRingProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/prompt-area/types.d.ts
 /**
@@ -325,20 +167,22 @@ declare function ProgressRing({
  * - Immutable chips for resolved mentions/commands
  * - Configurable trigger behavior (dropdown vs callback)
  * - Simple inline markdown rendering
- */
-/**
- * A segment of content within the editable text.
- * The document model is an ordered array of these segments.
+ *
+ * The document model is an ordered array of {@link TextSegment}/{@link ChipSegment}.
  */
 type TextSegment = {
   type: 'text';
   text: string;
 };
 type ChipSegment = {
-  type: 'chip'; /** The trigger character that created this chip (e.g., '@', '#') */
-  trigger: string; /** The resolved value/ID (e.g., user ID, file ID) */
-  value: string; /** The display text shown in the chip */
-  displayText: string; /** Optional data payload attached to the chip */
+  type: 'chip';
+  /** The trigger character that created this chip (e.g., '@', '#') */
+  trigger: string;
+  /** The resolved value/ID (e.g., user ID, file ID) */
+  value: string;
+  /** The display text shown in the chip */
+  displayText: string;
+  /** Optional data payload attached to the chip */
   data?: unknown;
   /**
    * True when this chip was auto-created by pressing space (resolveOnSpace).
@@ -372,18 +216,26 @@ type ChipStyle = 'pill' | 'inline';
  * A suggestion item shown in the trigger dropdown.
  */
 type TriggerSuggestion = {
-  /** Unique value/ID for this suggestion */value: string; /** Display label shown in the dropdown */
-  label: string; /** Optional description shown below the label */
-  description?: string; /** Optional icon element rendered before the label */
-  icon?: React.ReactNode; /** Optional arbitrary data passed through on selection */
+  /** Unique value/ID for this suggestion */
+  value: string;
+  /** Display label shown in the dropdown */
+  label: string;
+  /** Optional description shown below the label */
+  description?: string;
+  /** Optional icon element rendered before the label */
+  icon?: React.ReactNode;
+  /** Optional arbitrary data passed through on selection */
   data?: unknown;
 };
 /**
  * Configuration for a trigger character.
  */
 type TriggerConfig = {
-  /** The trigger character (e.g., '/', '@', '#') */char: string; /** Where this trigger is valid */
-  position: TriggerPosition; /** How this trigger behaves */
+  /** The trigger character (e.g., '/', '@', '#') */
+  char: string;
+  /** Where this trigger is valid */
+  position: TriggerPosition;
+  /** How this trigger behaves */
   mode: TriggerMode;
   /**
    * For 'dropdown' mode: called with the current query to fetch suggestions.
@@ -442,8 +294,10 @@ type TriggerConfig = {
    * - 'pill' (default): Button-like pill with background, padding, border-radius
    * - 'inline': Bold inline text without pill styling
    */
-  chipStyle?: ChipStyle; /** CSS class name(s) applied to chips created by this trigger */
-  chipClassName?: string; /** Label used for accessibility (e.g., "mention", "command") */
+  chipStyle?: ChipStyle;
+  /** CSS class name(s) applied to chips created by this trigger */
+  chipClassName?: string;
+  /** Label used for accessibility (e.g., "mention", "command") */
   accessibilityLabel?: string;
   /**
    * Debounce delay in milliseconds before calling `onSearch`.
@@ -466,8 +320,11 @@ type TriggerConfig = {
  * Context passed to callback-mode trigger handlers.
  */
 type TriggerActivateContext = {
-  /** The full plain text content at the time of activation */text: string; /** The cursor offset position */
-  cursorPosition: number; /** Function to insert a chip at the current cursor position */
+  /** The full plain text content at the time of activation */
+  text: string;
+  /** The cursor offset position */
+  cursorPosition: number;
+  /** Function to insert a chip at the current cursor position */
   insertChip: (chip: Omit<ChipSegment, 'type'>) => void;
 };
 /**
@@ -475,9 +332,13 @@ type TriggerActivateContext = {
  * State is managed externally by the parent component.
  */
 type PromptAreaImage = {
-  /** Unique identifier for this image */id: string; /** URL to display (CDN URL or temporary blob URL for preview) */
-  url: string; /** Optional alt text for accessibility */
-  alt?: string; /** When true, shows a loading indicator over the thumbnail */
+  /** Unique identifier for this image */
+  id: string;
+  /** URL to display (CDN URL or temporary blob URL for preview) */
+  url: string;
+  /** Optional alt text for accessibility */
+  alt?: string;
+  /** When true, shows a loading indicator over the thumbnail */
   loading?: boolean;
 };
 /**
@@ -485,22 +346,34 @@ type PromptAreaImage = {
  * State is managed externally by the parent component.
  */
 type PromptAreaFile = {
-  /** Unique identifier for this file */id: string; /** Display filename (e.g., "report.pdf") */
-  name: string; /** File size in bytes */
-  size?: number; /** MIME type (used for icon selection, e.g., "application/pdf") */
-  type?: string; /** When true, shows a loading indicator over the file card */
+  /** Unique identifier for this file */
+  id: string;
+  /** Display filename (e.g., "report.pdf") */
+  name: string;
+  /** File size in bytes */
+  size?: number;
+  /** MIME type (used for icon selection, e.g., "application/pdf") */
+  type?: string;
+  /** When true, shows a loading indicator over the file card */
   loading?: boolean;
 };
 /**
  * Props for the PromptArea component.
  */
 type PromptAreaProps = {
-  /** The document segments (controlled) */value: Segment[]; /** Called when the content changes */
-  onChange: (segments: Segment[]) => void; /** Trigger configurations */
-  triggers?: TriggerConfig[]; /** Placeholder text when empty. Pass an array of strings to animate between them. */
-  placeholder?: string | string[]; /** Additional CSS class for the container */
-  className?: string; /** Whether the input is disabled */
-  disabled?: boolean; /** Whether to render simple inline markdown (bold, italic, URLs, lists) */
+  /** The document segments (controlled) */
+  value: Segment[];
+  /** Called when the content changes */
+  onChange: (segments: Segment[]) => void;
+  /** Trigger configurations */
+  triggers?: TriggerConfig[];
+  /** Placeholder text when empty. Pass an array of strings to animate between them. */
+  placeholder?: string | string[];
+  /** Additional CSS class for the container */
+  className?: string;
+  /** Whether the input is disabled */
+  disabled?: boolean;
+  /** Whether to render simple inline markdown (bold, italic, URLs, lists) */
   markdown?: boolean;
   /**
    * When markdown is on, the editor rewrites typed list markers (`- ` / `* `)
@@ -508,20 +381,31 @@ type PromptAreaProps = {
    * marker in the value/`onChange` text — needed when a host renders the output
    * as real markdown, where `•` is not a valid list marker. Default `true`.
    */
-  normalizeBullets?: boolean; /** Called when Enter is pressed (without Shift) */
-  onSubmit?: (segments: Segment[]) => void; /** Called when Escape is pressed */
-  onEscape?: () => void; /** Called when a chip element is clicked. Receives the chip's segment data. */
-  onChipClick?: (chip: ChipSegment) => void; /** Called when a new chip is added (dropdown selection, auto-resolve, paste, or imperative insert) */
-  onChipAdd?: (chip: ChipSegment) => void; /** Called when a chip is deleted (backspace or forward delete) */
-  onChipDelete?: (chip: ChipSegment) => void; /** Called when a URL link is clicked. Receives the URL string. */
-  onLinkClick?: (url: string) => void; /** Called after content is pasted. Receives the resulting segments and the paste source. */
+  normalizeBullets?: boolean;
+  /** Called when Enter is pressed (without Shift) */
+  onSubmit?: (segments: Segment[]) => void;
+  /** Called when Escape is pressed */
+  onEscape?: () => void;
+  /** Called when a chip element is clicked. Receives the chip's segment data. */
+  onChipClick?: (chip: ChipSegment) => void;
+  /** Called when a new chip is added (dropdown selection, auto-resolve, paste, or imperative insert) */
+  onChipAdd?: (chip: ChipSegment) => void;
+  /** Called when a chip is deleted (backspace or forward delete) */
+  onChipDelete?: (chip: ChipSegment) => void;
+  /** Called when a URL link is clicked. Receives the URL string. */
+  onLinkClick?: (url: string) => void;
+  /** Called after content is pasted. Receives the resulting segments and the paste source. */
   onPaste?: (data: {
     segments: Segment[];
     source: 'internal' | 'external';
-  }) => void; /** Called after an undo operation. Receives the restored segments. */
-  onUndo?: (segments: Segment[]) => void; /** Called after a redo operation. Receives the restored segments. */
-  onRedo?: (segments: Segment[]) => void; /** Minimum height in pixels */
-  minHeight?: number; /** Maximum height in pixels */
+  }) => void;
+  /** Called after an undo operation. Receives the restored segments. */
+  onUndo?: (segments: Segment[]) => void;
+  /** Called after a redo operation. Receives the restored segments. */
+  onRedo?: (segments: Segment[]) => void;
+  /** Minimum height in pixels */
+  minHeight?: number;
+  /** Maximum height in pixels */
   maxHeight?: number;
   /**
    * Maximum number of plain-text characters allowed, enforced on typed input:
@@ -534,19 +418,32 @@ type PromptAreaProps = {
    * bypass it, so a programmatic write can exceed the cap until the next
    * keystroke truncates.
    */
-  maxLength?: number; /** Auto-focus on mount */
-  autoFocus?: boolean; /** When true, the area auto-grows to fit content on focus and shrinks on blur */
-  autoGrow?: boolean; /** Accessible label for the input */
-  'aria-label'?: string; /** data-test-id for e2e testing */
-  'data-test-id'?: string; /** Array of image attachments to display */
-  images?: PromptAreaImage[]; /** Where to render the image strip relative to the text area. Defaults to 'above'. */
-  imagePosition?: 'above' | 'below'; /** Called when the user pastes an image from clipboard. Receives the File object. */
-  onImagePaste?: (file: File) => void; /** Called when the user clicks the remove button on an image */
-  onImageRemove?: (image: PromptAreaImage) => void; /** Called when the user clicks an image thumbnail */
-  onImageClick?: (image: PromptAreaImage) => void; /** Array of file attachments to display */
-  files?: PromptAreaFile[]; /** Where to render the file strip relative to the text area. Defaults to 'above'. */
-  filePosition?: 'above' | 'below'; /** Called when the user clicks the remove button on a file */
-  onFileRemove?: (file: PromptAreaFile) => void; /** Called when the user clicks a file attachment */
+  maxLength?: number;
+  /** Auto-focus on mount */
+  autoFocus?: boolean;
+  /** When true, the area auto-grows to fit content on focus and shrinks on blur */
+  autoGrow?: boolean;
+  /** Accessible label for the input */
+  'aria-label'?: string;
+  /** data-test-id for e2e testing */
+  'data-test-id'?: string;
+  /** Array of image attachments to display */
+  images?: PromptAreaImage[];
+  /** Where to render the image strip relative to the text area. Defaults to 'above'. */
+  imagePosition?: 'above' | 'below';
+  /** Called when the user pastes an image from clipboard. Receives the File object. */
+  onImagePaste?: (file: File) => void;
+  /** Called when the user clicks the remove button on an image */
+  onImageRemove?: (image: PromptAreaImage) => void;
+  /** Called when the user clicks an image thumbnail */
+  onImageClick?: (image: PromptAreaImage) => void;
+  /** Array of file attachments to display */
+  files?: PromptAreaFile[];
+  /** Where to render the file strip relative to the text area. Defaults to 'above'. */
+  filePosition?: 'above' | 'below';
+  /** Called when the user clicks the remove button on a file */
+  onFileRemove?: (file: PromptAreaFile) => void;
+  /** Called when the user clicks a file attachment */
   onFileClick?: (file: PromptAreaFile) => void;
   /**
    * Called on keydown before PromptArea's own handling. Call `preventDefault()`
@@ -571,18 +468,25 @@ type PromptAreaProps = {
    * to make Enter insert a newline instead (e.g. on touch devices where submit
    * is a dedicated button).
    */
-  submitOnEnter?: boolean; /** Forwarded to the editable element. */
-  spellCheck?: boolean; /** Forwarded to the editable element as `aria-describedby`. */
+  submitOnEnter?: boolean;
+  /** Forwarded to the editable element. */
+  spellCheck?: boolean;
+  /** Forwarded to the editable element as `aria-describedby`. */
   'aria-describedby'?: string;
 };
 /**
  * Ref handle exposed by PromptArea via useImperativeHandle.
  */
 type PromptAreaHandle = {
-  /** Focus the editable area */focus: () => void; /** Blur the editable area */
-  blur: () => void; /** Insert a chip at the current cursor position */
-  insertChip: (chip: Omit<ChipSegment, 'type'>) => void; /** Get the current plain text (without chip markup) */
-  getPlainText: () => string; /** Clear all content */
+  /** Focus the editable area */
+  focus: () => void;
+  /** Blur the editable area */
+  blur: () => void;
+  /** Insert a chip at the current cursor position */
+  insertChip: (chip: Omit<ChipSegment, 'type'>) => void;
+  /** Get the current plain text (without chip markup) */
+  getPlainText: () => string;
+  /** Clear all content */
   clear: () => void;
   /**
    * Replace all content with plain text (chips dropped), caret moved to the
@@ -593,14 +497,19 @@ type PromptAreaHandle = {
    * Append plain text at the end (existing chips preserved), caret moved to the
    * end. Not capped by `maxLength` (see its docs); undoable.
    */
-  appendText: (text: string) => void; /** Caret offset in plain-text characters, or null when unavailable. */
-  getCursorPosition: () => number | null; /** Move the caret to a plain-text offset. */
-  setCursorPosition: (offset: number) => void; /** Move the caret to the end of the content. */
-  setCursorToEnd: () => void; /** Current selection as plain-text offsets, or null when there is none. */
+  appendText: (text: string) => void;
+  /** Caret offset in plain-text characters, or null when unavailable. */
+  getCursorPosition: () => number | null;
+  /** Move the caret to a plain-text offset. */
+  setCursorPosition: (offset: number) => void;
+  /** Move the caret to the end of the content. */
+  setCursorToEnd: () => void;
+  /** Current selection as plain-text offsets, or null when there is none. */
   getSelection: () => {
     start: number;
     end: number;
-  } | null; /** Set the selection between two plain-text offsets. */
+  } | null;
+  /** Set the selection between two plain-text offsets. */
   setSelection: (start: number, end: number) => void;
 };
 //#endregion
@@ -630,69 +539,41 @@ type PromptAreaHandle = {
  * />
  * ```
  */
-declare function PromptArea({
-  value,
-  onChange,
-  triggers,
-  placeholder,
-  className,
-  disabled,
-  markdown,
-  normalizeBullets,
-  onSubmit,
-  onEscape,
-  onChipClick,
-  onChipAdd,
-  onChipDelete,
-  onLinkClick,
-  onPaste,
-  onUndo,
-  onRedo,
-  minHeight,
-  maxHeight,
-  autoFocus,
-  autoGrow,
-  'aria-label': ariaLabel,
-  'data-test-id': dataTestId,
-  images,
-  imagePosition,
-  onImagePaste,
-  onImageRemove,
-  onImageClick,
-  files,
-  filePosition,
-  onFileRemove,
-  onFileClick,
-  onKeyDown,
-  onBlur,
-  onRawPaste,
-  submitOnEnter,
-  spellCheck,
-  maxLength,
-  'aria-describedby': ariaDescribedBy,
-  ref
-}: PromptAreaProps & {
+declare function PromptArea({ value, onChange, triggers, placeholder, className, disabled, markdown, normalizeBullets, onSubmit, onEscape, onChipClick, onChipAdd, onChipDelete, onLinkClick, onPaste, onUndo, onRedo, minHeight, maxHeight, autoFocus, autoGrow, 'aria-label': ariaLabel, 'data-test-id': dataTestId, images, imagePosition, onImagePaste, onImageRemove, onImageClick, files, filePosition, onFileRemove, onFileClick, onKeyDown, onBlur, onRawPaste, submitOnEnter, spellCheck, maxLength, 'aria-describedby': ariaDescribedBy, ref }: PromptAreaProps & {
   ref?: React.Ref<PromptAreaHandle>;
-}): _$react.JSX.Element;
+}): import("react").JSX.Element;
 //#endregion
 //#region src/components/prompt-area/use-prompt-area-state.d.ts
 type UsePromptAreaStateOptions = {
-  /** Initial segment value. Defaults to `[]`. */initialValue?: Segment[];
+  /** Initial segment value. Defaults to `[]`. */
+  initialValue?: Segment[];
 };
 type PromptAreaBind = {
-  /** Ref to attach to PromptArea — gives access to imperative methods. */ref: React.RefObject<PromptAreaHandle | null>; /** Current segment array — pass as `value` prop. */
-  value: Segment[]; /** Setter — pass as `onChange` prop. */
+  /** Ref to attach to PromptArea — gives access to imperative methods. */
+  ref: React.RefObject<PromptAreaHandle | null>;
+  /** Current segment array — pass as `value` prop. */
+  value: Segment[];
+  /** Setter — pass as `onChange` prop. */
   onChange: (segments: Segment[]) => void;
 };
 type PromptAreaState = {
-  /** Props to spread directly onto `<PromptArea {...bind} />`. Contains ref, value, and onChange. */bind: PromptAreaBind; /** Derived plain text representation of the current value. */
-  plainText: string; /** `true` when the value is empty or whitespace-only. */
-  isEmpty: boolean; /** `true` when the value contains at least one chip. */
-  hasChips: boolean; /** All chip segments in the current value. */
-  chips: ChipSegment[]; /** Clear all content (both state and the editor DOM). */
-  clear: () => void; /** Focus the editor. */
-  focus: () => void; /** Blur the editor. */
-  blur: () => void; /** Insert a chip at the current cursor position. */
+  /** Props to spread directly onto `<PromptArea {...bind} />`. Contains ref, value, and onChange. */
+  bind: PromptAreaBind;
+  /** Derived plain text representation of the current value. */
+  plainText: string;
+  /** `true` when the value is empty or whitespace-only. */
+  isEmpty: boolean;
+  /** `true` when the value contains at least one chip. */
+  hasChips: boolean;
+  /** All chip segments in the current value. */
+  chips: ChipSegment[];
+  /** Clear all content (both state and the editor DOM). */
+  clear: () => void;
+  /** Focus the editor. */
+  focus: () => void;
+  /** Blur the editor. */
+  blur: () => void;
+  /** Insert a chip at the current cursor position. */
   insertChip: (chip: Omit<ChipSegment, 'type'>) => void;
 };
 declare function usePromptAreaState(options?: UsePromptAreaStateOptions): PromptAreaState;
@@ -700,7 +581,8 @@ declare function usePromptAreaState(options?: UsePromptAreaStateOptions): Prompt
 //#region src/components/prompt-area/trigger-presets.d.ts
 type TriggerPresetOptions = Omit<Partial<TriggerConfig>, 'char' | 'position' | 'mode'>;
 type MentionTriggerOptions = TriggerPresetOptions & {
-  /** Override the trigger character. Defaults to `'@'`. */char?: string;
+  /** Override the trigger character. Defaults to `'@'`. */
+  char?: string;
 };
 /**
  * Creates a **mention** trigger (`@`).
@@ -710,7 +592,8 @@ type MentionTriggerOptions = TriggerPresetOptions & {
  */
 declare function mentionTrigger(opts?: MentionTriggerOptions): TriggerConfig;
 type CommandTriggerOptions = TriggerPresetOptions & {
-  /** Override the trigger character. Defaults to `'/'`. */char?: string;
+  /** Override the trigger character. Defaults to `'/'`. */
+  char?: string;
   /**
    * Where the command trigger is valid. Defaults to `'any'`, so commands fire
    * anywhere a `/` follows whitespace — not just at the start of a line.
@@ -730,7 +613,8 @@ type CommandTriggerOptions = TriggerPresetOptions & {
  */
 declare function commandTrigger(opts?: CommandTriggerOptions): TriggerConfig;
 type HashtagTriggerOptions = TriggerPresetOptions & {
-  /** Override the trigger character. Defaults to `'#'`. */char?: string;
+  /** Override the trigger character. Defaults to `'#'`. */
+  char?: string;
 };
 /**
  * Creates a **hashtag / tag** trigger (`#`).
@@ -763,591 +647,172 @@ type ToolCallItem$1 = Extract<TranscriptItem, {
   kind: 'tool_call';
 }>;
 //#endregion
-//#region src/components/terminal/row.d.ts
-/**
- * The primitives every terminal row is built from.
- *
- * There are three, and that is the whole vocabulary: a {@link Row} (a gutter
- * cell and a body cell), a {@link Blank} (one empty line), and a {@link Band} (a
- * run of rows carrying a full-bleed background). Anything the theme draws — a
- * message, a tool call, a diff hunk, an approval prompt — is some arrangement of
- * those, which is what keeps the grid a property of the renderer rather than a
- * thing each component re-derives.
- *
- * Geometry is in `styles/terminal.css`. These components choose a class, a
- * marker and a tone; they never carry a measurement.
- */
-/** The palette, as a name. See the `[data-tone]` rules in `terminal.css`. */
-type Tone = 'fg' | 'bright' | 'dim' | 'faint' | 'mark' | 'blue' | 'green' | 'red' | 'yellow' | 'magenta';
-interface RowProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
-  /**
-   * What sits in the gutter — `●`, `⎿`, `>`, a list bullet, or nothing. Kept to
-   * the width of the gutter (`--term-cell`, two columns by default): a wider
-   * marker would push its own body off the column every other row starts on.
-   * Omitted, the gutter is still drawn as empty space, so an unmarked row's
-   * text lines up with a marked one's.
-   */
-  glyph?: ReactNode;
-  /** The marker's colour. Defaults to dim — the marker is structure, not content. */
-  glyphTone?: Tone;
-  /** The body's colour. */
-  tone?: Tone;
-  bold?: boolean;
-  /** Indent levels, one character cell each. A child row's marker then sits
-   * exactly under its parent row's first letter. */
-  indent?: 0 | 1 | 2 | 3;
-  /**
-   * Gutter width in columns, when the marker needs other than two — an ordered
-   * list's `10.` is four, a prompt's `❯ 1.` is five, and a framed payload wants
-   * `0`. Changes only this row's split, so the body still starts on a whole
-   * column.
-   */
-  columns?: number;
-  children?: ReactNode;
-}
-declare function Row({
-  glyph,
-  glyphTone,
-  tone,
-  bold,
-  indent,
-  columns,
-  className,
-  children,
-  style,
-  ...props
-}: RowProps): _$react.JSX.Element;
-/**
- * One empty line — the theme's only vertical spacing.
- *
- * A terminal separates blocks with a blank line, not with padding, and saying it
- * that way has a practical payoff: spacing is part of the row list, so it can be
- * decided by whoever knows whether two blocks belong together (a tool call and
- * its output do not get one; two assistant turns do), instead of by a margin
- * rule that cannot tell them apart.
- */
-declare function Blank(): _$react.JSX.Element;
-/**
- * A run of rows under a background: a code block, a command's output, a diff
- * hunk. Full-bleed — the wash reaches the scroller's edges, because in a
- * terminal the line is the full width of the screen. See `--term-bleed` on
- * {@link TerminalSurface}.
- */
-declare function Band({
-  className,
-  ...props
-}: HTMLAttributes<HTMLDivElement>): _$react.JSX.Element;
-/** Inline colour/weight inside a row's body. */
-declare function Ink({
-  tone,
-  bold,
-  className,
-  ...props
-}: HTMLAttributes<HTMLSpanElement> & {
-  tone?: Tone;
-  bold?: boolean;
-}): _$react.JSX.Element;
-//#endregion
 //#region src/components/agent/Transcript.d.ts
 interface TranscriptProps {
   state: TranscriptState;
-  /** Builds the download URL for a delivered file (see FileCard). Typically
-   * `(path) => client.sessionFileUrl(sessionId, path)`. */
   fileUrl?: (path: string) => string;
-  /** Builds the URL for an uploaded attachment. Typically
-   * `(id) => client.attachmentUrl(sessionId, id)`. Same-origin and
-   * cookie-authenticated, which is what lets an `<img src>` render one. */
   attachmentUrl?: (attachmentId: string) => string;
-  /** Whether this gateway serves `@file` search here — the empty state must not
-   * advertise an affordance the composer doesn't have. */
   canBrowseFiles?: boolean;
-  /** Reads a host file as a data URL, for tool calls whose output is a picture
-   * on the host (codex's `image_gen`). Omit and those cards name the path. */
   hostImage?: (path: string) => Promise<string | undefined>;
-  /**
-   * How a turn is drawn: `cards` (default, the chat convention) or `terminal`,
-   * which is not a set of branches in these components but its own renderer.
-   * See {@link TranscriptVariant}.
-   */
   variant?: TranscriptVariant;
-  /**
-   * How much air each row gets: `comfortable` (default — a blank line between
-   * messages, as the Claude Code CLI does) or `compact`. Independent of
-   * {@link TranscriptVariant}. See {@link TranscriptDensity}.
-   */
   density?: TranscriptDensity;
-  /** Terminal theme only: the character cell, in whole pixels. See
-   * {@link TerminalSurface}. */
   fontSize?: number;
   lineHeight?: number;
-  /** Terminal theme only: the pointer affordances a real terminal cannot offer.
-   * `false` for none. See {@link TerminalAffordances}. */
   affordances?: TerminalAffordances | boolean;
-  /** Hold the prompt of the turn being read at the top of the scroller. Works
-   * in both variants: the terminal clips to one line, cards shows a frosted
-   * bar. The *real* row is pinned, not a copy — see `TranscriptRows`. */
   stickyPrompt?: boolean;
-  /**
-   * Mount the overview scrubber — a 12px rail of marks (your prompts, each
-   * turn's response and result as one mark, errors, the pending approval, the
-   * catch-up boundary) over the scroller's right edge. Two rails behind one
-   * prop: under `terminal` it is the pixel-exact ruler that replaces the
-   * native scrollbar (positions ride the height calculator; drag scrubs), and
-   * under `cards` it is the **proportional annotation rail** — positioned by
-   * `itemIndex / items.length`, because proportional text gives the
-   * calculator no claim there — where the native scrollbar stays and the rail
-   * only peeks and jumps. With `affordances={false}` either rail degrades to
-   * passive paint — no drag, peek or click.
-   */
   scrubber?: boolean;
-  /**
-   * Bookmarked item indices, painted as full-width marks on the rail. Paint
-   * only, deliberately: the store — and the affordance that writes it — is
-   * the client's, the way the unread watermarks are, not the panel's.
-   */
-  scrubberMarks?: readonly number[];
-  /**
-   * The attach replay is still landing (`useClaudeSession().replaying`): rows
-   * render, measure and pin exactly as normal but nothing paints, and a loading
-   * line shows in their place; when it flips false the settled tail appears in
-   * one frame. Hiding is by *visibility*, never by not mounting — see the
-   * comment at the render site. Optional: an embedder that never passes it
-   * gets today's behaviour, and a short or empty session holds for no visible
-   * time at all (the frame between attach and replay-complete).
-   */
+  bookmarks?: readonly string[];
   replaying?: boolean;
-  /**
-   * Catch-up: `from` is how many items had been seen last time, `since` when
-   * that was. A recap row is drawn at that boundary and everything above it is
-   * dimmed. Omit (or pass a boundary at/after the end) and the transcript
-   * renders exactly as before.
-   */
   catchUp?: {
     from: number;
     since?: number;
   };
-  /**
-   * Filled with a closure that scrolls the recap row into view — the seam the
-   * panel's catch-up strip presses. A ref rather than a DOM query because the
-   * rows are virtualized: when the recap row isn't mounted, only the
-   * virtualizer knows where it would be. Optional; embedders without a
-   * catch-up strip never touch it. `null` while no transcript is mounted.
-   */
   jumpToRecapRef?: RefObject<(() => void) | null>;
-  /**
-   * Filled with a closure that re-pins the transcript to the bottom, so a host
-   * can resume following after the reader has scrolled away. The panel presses
-   * it on send: choosing to say something is choosing to watch what happens
-   * next, and a transcript left parked where you were reading makes a sent
-   * message look like it did nothing at all.
-   */
   repinRef?: RefObject<(() => void) | null>;
-  /**
-   * Scroll a tool call into view — bump `nonce` to ask again for the same one.
-   *
-   * The seam a *list* needs: sub-agent work is nested inside the `Task` call
-   * that spawned it, so "open that sub-agent" can only ever mean "take me to its
-   * row". A `parentToolUseId` works here as well as the Task's own id, since the
-   * lookup resolves an absorbed child to the row that folded it.
-   *
-   * A prop rather than a ref (the shape `jumpToRecapRef` uses) because the asker
-   * is outside this webview entirely and the request travels as data; a ref
-   * would need a live closure at the other end of a postMessage bridge.
-   */
   reveal?: {
     toolUseId: string;
     nonce: number;
   };
-  /**
-   * Render **only** the work one sub-agent did, rather than the conversation —
-   * the sub-agent takeover's frame.
-   *
-   * Membership is `subagentItems` (`terminal/blocks.ts`), which is also the rule
-   * iOS will mirror: everything the agent produced, and not the spawning `Task`
-   * call itself, which *is* the frame rather than a row in it.
-   *
-   * Features are switched off internally whenever it is set, and the gate lives
-   * here rather than at the call site on purpose: each is keyed to a
-   * **full-transcript item index**, so a host that passed a frame and a catch-up
-   * boundary together would not be making a strange choice, it would be making
-   * an incoherent one. Those are the catch-up boundary and its recap row, the
-   * sticky prompt, `reveal`, and the scrubber's **bookmarks** (host indices in
-   * full-transcript space).
-   *
-   * The **scrubber itself stays**, and the distinction is the point: the rail
-   * derives every one of its inputs from the rows it is given, and inside a
-   * frame those are the sub-agent's own — so it marks that agent's prompts,
-   * answers and failures at that agent's offsets. It was originally gated with
-   * the marks, on the reasonable-looking argument that they are one feature;
-   * they are two, and a fifty-tool agent run is exactly where a rail earns its
-   * keep. What stays besides is everything that makes a long stream readable —
-   * virtualization, the height epoch, the follow spring, the replay hold.
-   */
   frame?: {
     parentToolUseId: string;
   };
-  /**
-   * Raise the takeover from a `Task` row. Absent draws no affordance, which is
-   * what the plain renderer and the cards variant get: cards folds nothing, so
-   * it has no task blocks to hang this on, and reaches the takeover from the
-   * sessions list instead.
-   */
   onOpenSubagent?: (toolUseId: string) => void;
-  /**
-   * Replaces the default empty state when the transcript has no items. Pass a
-   * `ReactNode` to show your product's own onboarding instead of WorkerDeck's
-   * generic "`>_` Tell the agent what to do." placeholder.
-   */
   emptyState?: ReactNode;
   className?: string;
 }
-declare function Transcript({
-  state,
-  fileUrl,
-  attachmentUrl,
-  canBrowseFiles,
-  hostImage,
-  variant,
-  density,
-  fontSize,
-  lineHeight,
-  affordances,
-  stickyPrompt,
-  scrubber,
-  scrubberMarks,
-  replaying,
-  catchUp,
-  jumpToRecapRef,
-  repinRef,
-  reveal,
-  frame,
-  onOpenSubagent,
-  emptyState,
-  className
-}: TranscriptProps): _$react.JSX.Element;
+declare function Transcript({ state, fileUrl, attachmentUrl, canBrowseFiles, hostImage, variant, density, fontSize, lineHeight, affordances, stickyPrompt, scrubber, bookmarks, replaying, catchUp, jumpToRecapRef, repinRef, reveal, frame, onOpenSubagent, emptyState, className }: TranscriptProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/terminal/surface.d.ts
-/**
- * The root of the terminal theme: the element that establishes the character
- * cell every row inside it lands on.
- *
- * It exists as a component rather than a class because the cell has to be *set*
- * somewhere — the font, the size and the line height together are what make
- * `1ch` mean one column and `--term-line` mean one row — and because that is the
- * one place a host is allowed to change the metrics. Everything below this
- * element measures itself in those two units and never in pixels.
- *
- * The geometry and the palette live in `styles/terminal.css`; this only names
- * the element and hands down the two numbers.
- */
 interface TerminalSurfaceProps extends HTMLAttributes<HTMLDivElement> {
-  /**
-   * Cell size in **whole pixels**. Fractional values put every other row on a
-   * half-pixel: text softens and the diff bands show a seam, which is exactly
-   * what a grid renderer must not do. Defaults (13/18) are the CLI's own.
-   */
   fontSize?: number;
   lineHeight?: number;
-  /**
-   * How far a full-bleed band reaches past the content edge — normally the
-   * scroller's own horizontal padding. A band cancels it with matched negative
-   * margin and padding, so a diff hunk's wash runs to the viewport edge the way
-   * a terminal's line does, instead of stopping at a gutter.
-   */
   bleed?: string;
-  /**
-   * The things a real terminal cannot do — the pointer hover fill, the
-   * hover-revealed copy actions. `false` turns them all off, an object picks.
-   * Default: all on. See {@link TerminalAffordances}; none of them costs layout,
-   * so switching them off changes no glyph's position.
-   */
   affordances?: TerminalAffordances | boolean;
 }
-declare function TerminalSurface({
-  fontSize,
-  lineHeight,
-  bleed,
-  affordances,
-  className,
-  style,
-  children,
-  ...props
-}: TerminalSurfaceProps): _$react.JSX.Element;
+declare function TerminalSurface({ fontSize, lineHeight, bleed, affordances, className, style, children, ...props }: TerminalSurfaceProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/terminal/TerminalTranscript.d.ts
-/**
- * The transcript, drawn as a terminal.
- *
- * The whole of the layout is here and it is four lines long, which is the point:
- * items become row blocks, a blank line goes between blocks that do not belong
- * together, and the working line is one more row at the end. There is no gap
- * scale, no density knob and no variant branch — a terminal has one line height
- * and one type size, and everything the theme can express is expressed in which
- * rows exist and what marker each carries.
- *
- * Not virtualized yet: the row blocks are the part that has to be right first,
- * and the existing `Transcript` already owns a hard-won virtualizer plus the
- * scroll-regime rules it needs. This renders into that shell when the rows are
- * settled, rather than growing a second copy of that logic.
- */
 interface TerminalTranscriptProps {
   state: TranscriptState;
-  /** Builds the download URL for a delivered file. */
   fileUrl?: (path: string) => string;
-  /** Cell metrics, in whole pixels. See {@link TerminalSurface}. */
   fontSize?: number;
   lineHeight?: number;
-  /** The pointer affordances a real terminal has no way to offer — hover fill,
-   * hover-revealed copy. `false` for none. See {@link TerminalAffordances}. */
   affordances?: TerminalAffordances | boolean;
   className?: string;
 }
-/**
- * One transcript item as terminal rows. Exported because the virtualized shell
- * in `agent/Transcript.tsx` renders rows through it: the theme owns how a row
- * looks, that component owns which rows are mounted, and neither needs a copy
- * of the other.
- */
-declare function TerminalItemView({
-  item,
-  fileUrl
-}: {
+declare function TerminalItemView({ item, fileUrl }: {
   item: TranscriptItem;
   fileUrl?: (path: string) => string;
-}): _$react.JSX.Element | null;
-declare function TerminalTranscript({
-  state,
-  fileUrl,
-  fontSize,
-  lineHeight,
-  affordances,
-  className
-}: TerminalTranscriptProps): _$react.JSX.Element;
+}): import("react").JSX.Element | null;
+declare function TerminalTranscript({ state, fileUrl, fontSize, lineHeight, affordances, className }: TerminalTranscriptProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/terminal/StatusLine.d.ts
 interface TerminalStatusLineProps {
   className?: string;
   state: TranscriptState;
-  /** Plan windows to read from, when they should not be the session's own — the
-   * gateway's per-profile state merged over this transcript's. See
-   * {@link StatusBarProps.rateLimits}. Absent = `state.rateLimits`. */
   rateLimits?: Record<string, RateLimitInfo>;
-  /** How the client is doing at reaching the gateway. Wins the status slot when
-   * the socket is down — see above. */
   connection?: ConnectionState;
-  /** Opens the panel that answers each reading's own question. Omit and the
-   * reading is text rather than something to press. */
   onOpenStatus?: () => void;
   onOpenContext?: () => void;
   onOpenUsage?: () => void;
 }
-declare function TerminalStatusLine({
-  className,
-  state,
-  rateLimits,
-  connection,
-  onOpenStatus,
-  onOpenContext,
-  onOpenUsage
-}: TerminalStatusLineProps): _$react.JSX.Element;
+declare function TerminalStatusLine({ className, state, rateLimits, connection, onOpenStatus, onOpenContext, onOpenUsage }: TerminalStatusLineProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/terminal/PermissionPrompt.d.ts
-/**
- * The approval, as the CLI draws it: a rule, what is being asked and about what,
- * the change itself, a dashed rule, the question, numbered answers, and the keys.
- *
- * Two things it does that the card version does not, both taken from the CLI:
- *
- * - **It shows the change, not the payload.** For a file edit, `old_string` and
- *   `new_string` are a diff — so it renders one, rather than the JSON input a
- *   reader would have to diff in their head. Without line numbers, necessarily:
- *   the edit has not happened and this client has never read the file (see
- *   {@link previewPatch}). Everything else falls back to the input.
- * - **The heading is the engine's own sentence.** `displayName` ("Edit file")
- *   over `title`, never "wants to use {tool}" composed here — for codex an
- *   approval is an *escalation after a sandbox refusal*, and the runner has
- *   already written the sentence that says so.
- */
 interface TerminalPermissionPromptProps {
   request: PermissionRequest;
   onApprove: (requestId: string) => void;
-  /** `message` is fed back to the agent, which can then try something else;
-   * `interrupt` also stops the turn. */
   onDeny: (requestId: string, message?: string, interrupt?: boolean) => void;
   className?: string;
 }
-declare function TerminalPermissionPrompt({
-  request,
-  onApprove,
-  onDeny,
-  className
-}: TerminalPermissionPromptProps): _$react.JSX.Element;
+declare function TerminalPermissionPrompt({ request, onApprove, onDeny, className }: TerminalPermissionPromptProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/terminal/QuestionPrompt.d.ts
 interface TerminalQuestionPromptProps {
-  /** A pending permission whose toolName is 'AskUserQuestion'. */
   request: PermissionRequest;
-  /** Allow the tool with `updatedInput` (the original input plus `answers`). */
   onAnswer: (requestId: string, updatedInput: Record<string, unknown>) => void;
-  /** Deny the tool — the model proceeds without an answer. */
   onDismiss: (requestId: string, message?: string) => void;
   className?: string;
 }
-declare function TerminalQuestionPrompt({
-  request,
-  onAnswer,
-  onDismiss,
-  className
-}: TerminalQuestionPromptProps): _$react.JSX.Element;
+declare function TerminalQuestionPrompt({ request, onAnswer, onDismiss, className }: TerminalQuestionPromptProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/terminal/diff.d.ts
-/**
- * A patch for a change that has **not happened yet** — an approval prompt's
- * `Edit`, where the input names the old and new text but no line numbers exist
- * because the edit has not been applied and this client has never read the file.
- *
- * `newStart: 0` is how it says so, and {@link TerminalDiff} reads that back: a
- * diff whose hunks all start at zero renders without a number column rather than
- * printing a column of zeroes or inventing an offset.
- */
 declare function previewPatch(input: unknown): FilePatch | undefined;
-declare function TerminalDiff({
-  patch
-}: {
+declare function TerminalDiff({ patch }: {
   patch: FilePatch;
-}): _$react.JSX.Element;
+}): import("react").JSX.Element;
 //#endregion
 //#region src/components/terminal/markdown.d.ts
 interface TerminalMarkdownProps {
   children: string;
-  /** Streaming text: tolerate half-written markdown (unclosed fences, half links). */
   streaming?: boolean;
   className?: string;
 }
-declare const TerminalMarkdown: _$react.MemoExoticComponent<({
-  children,
-  streaming,
-  className
-}: TerminalMarkdownProps) => _$react.JSX.Element>;
+declare const TerminalMarkdown: import("react").MemoExoticComponent<({ children, streaming, className }: TerminalMarkdownProps) => import("react").JSX.Element>;
+//#endregion
+//#region src/components/terminal/row.d.ts
+type Tone = 'fg' | 'bright' | 'dim' | 'faint' | 'mark' | 'blue' | 'green' | 'red' | 'yellow' | 'magenta';
+interface RowProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+  glyph?: ReactNode;
+  glyphTone?: Tone;
+  tone?: Tone;
+  bold?: boolean;
+  indent?: 0 | 1 | 2 | 3;
+  columns?: number;
+  children?: ReactNode;
+}
+declare function Row({ glyph, glyphTone, tone, bold, indent, columns, className, children, style, ...props }: RowProps): import("react").JSX.Element;
+declare function Blank(): import("react").JSX.Element;
+declare function Band({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+declare function Ink({ tone, bold, className, ...props }: HTMLAttributes<HTMLSpanElement> & {
+  tone?: Tone;
+  bold?: boolean;
+}): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/Conversation.d.ts
 interface ConversationProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
   children: ReactNode;
 }
-/** Scroll container that stays pinned to the bottom while streaming, unless the user
- * scrolls up — plus a floating scroll-to-bottom button.
- *
- * **Nothing here animates its scroll position.** `initial` and `resize` are both
- * `'instant'` and are no longer configurable: the follow spring's job is to
- * *stay* at the bottom, not to travel there, and every travel a reader has ever
- * complained about on this surface was an animation we asked for. The `resize`
- * prop used to exist so a caller could pick, which required the caller to know
- * whether the transcript was streaming or replaying — a latch's worth of
- * machinery to decide something that has one right answer. */
-declare function Conversation({
-  className,
-  children,
-  ...props
-}: ConversationProps): _$react.JSX.Element;
-declare function ConversationContent({
-  className,
-  children,
-  ...props
-}: HTMLAttributes<HTMLDivElement> & {
+declare function Conversation({ className, children, ...props }: ConversationProps): import("react").JSX.Element;
+declare function ConversationContent({ className, children, ...props }: HTMLAttributes<HTMLDivElement> & {
   children: ReactNode;
-}): _$react.JSX.Element;
-declare function ConversationScrollButton({
-  className
-}: {
+}): import("react").JSX.Element;
+declare function ConversationScrollButton({ className }: {
   className?: string;
-}): _$react.JSX.Element | null;
+}): import("react").JSX.Element | null;
 //#endregion
 //#region src/components/agent/Message.d.ts
 interface MessageProps extends HTMLAttributes<HTMLDivElement> {
   from: 'user' | 'assistant';
 }
-/**
- * One chat turn row.
- *
- * `cards`: user messages sit in a bubble, assistant content is flat and
- * full-width. Both are **left-aligned**: the transcript is a log read top to
- * bottom, and an editor-shaped host (a full-width session view beside a sessions
- * rail) has no right edge to anchor to — a bubble drifting right in a 1600px
- * column separates a prompt from the reply it produced. The bubble alone is
- * enough to say who spoke.
- *
- * The terminal theme draws none of this: it is its own renderer
- * (`components/terminal/`) and mounts instead of these rows.
- */
-declare function Message({
-  from,
-  className,
-  children,
-  ...props
-}: MessageProps): _$react.JSX.Element;
-declare function MessageContent({
-  className,
-  ...props
-}: HTMLAttributes<HTMLDivElement>): _$react.JSX.Element;
+declare function Message({ from, className, children, ...props }: MessageProps): import("react").JSX.Element;
+declare function MessageContent({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/Response.d.ts
 interface ResponseProps {
   children: string;
-  /** Streaming text: tolerate incomplete markdown (unclosed fences, half links). */
   streaming?: boolean;
   className?: string;
 }
-/** Markdown renderer for assistant output — streaming-safe via streamdown, code
- * highlighted with shiki (dual theme follows [data-theme] through the dark: variant). */
-declare const Response: _$react.MemoExoticComponent<({
-  children,
-  streaming,
-  className
-}: ResponseProps) => _$react.JSX.Element>;
+declare const Response: import("react").MemoExoticComponent<({ children, streaming, className }: ResponseProps) => import("react").JSX.Element>;
 //#endregion
 //#region src/components/agent/Reasoning.d.ts
 interface ReasoningProps {
   children: string;
-  /** Auto-opens while true, auto-closes shortly after it flips false. */
   isStreaming?: boolean;
   defaultOpen?: boolean;
   className?: string;
 }
-/** Collapsible extended-thinking block: open while the model is thinking, tucks itself
- * away once the thought is finished (unless the user toggled it manually). */
-declare function Reasoning({
-  children,
-  isStreaming,
-  defaultOpen,
-  className
-}: ReasoningProps): _$react.JSX.Element | null;
+declare function Reasoning({ children, isStreaming, defaultOpen, className }: ReasoningProps): import("react").JSX.Element | null;
 //#endregion
 //#region src/components/agent/Loader.d.ts
 interface LoaderProps {
-  /** Overrides the cycling verb — for a state that has one true name
-   * ("Starting session…"). */
   label?: string;
-  /** When the current run began, for the elapsed clock. Absent = no clock.
-   * Unused by the card treatment; kept so the `cards` and `terminal` loaders
-   * take the same call site in `Transcript`. */
   startedAt?: number;
-  /** Context tokens in play. Same story as `startedAt`. */
   tokens?: number;
   className?: string;
 }
-/**
- * "The agent is working and hasn't produced output yet."
- *
- * Three dots pulsing in CSS — the chat convention, for the `cards` variant. The
- * terminal theme has its own working line (`terminal/items.tsx`'s `WorkingRow`,
- * with the mark's pulse in the gutter and the run's readings beside the verb),
- * because there it is a *row of the transcript* rather than a spinner floating
- * over one.
- */
-declare function Loader({
-  label,
-  className
-}: LoaderProps): _$react.JSX.Element;
+declare function Loader({ label, className }: LoaderProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/ToolCallCard.d.ts
 type ToolCallItem = Extract<TranscriptItem, {
@@ -1355,21 +820,10 @@ type ToolCallItem = Extract<TranscriptItem, {
 }>;
 interface ToolCallCardProps {
   item: ToolCallItem;
-  /**
-   * Reads a host file as a data URL, for tools whose output is a picture on the
-   * host. Resolves `undefined` when the gateway won't serve that path — a
-   * generated image saved outside the allowed roots (codex's default
-   * `$CODEX_HOME/generated_images/`) is one, and the card then names the path
-   * instead of showing it.
-   */
   hostImage?: (path: string) => Promise<string | undefined>;
   className?: string;
 }
-declare function ToolCallCard({
-  item,
-  hostImage,
-  className
-}: ToolCallCardProps): _$react.JSX.Element;
+declare function ToolCallCard({ item, hostImage, className }: ToolCallCardProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/FileCard.d.ts
 type FileDeliveredItem = Extract<TranscriptItem, {
@@ -1377,47 +831,19 @@ type FileDeliveredItem = Extract<TranscriptItem, {
 }>;
 interface FileCardProps {
   item: FileDeliveredItem;
-  /** Download URL for the delivered path (the server's session file route).
-   * Without it the card renders informational only. */
   href?: string;
   className?: string;
 }
-/** A file the agent handed over (`file_delivered`): name, size, download link.
- * The file lives in the session's in-memory VFS — the link works while the
- * session lives. */
-declare function FileCard({
-  item,
-  href,
-  className
-}: FileCardProps): _$react.JSX.Element;
+declare function FileCard({ item, href, className }: FileCardProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/PermissionPrompt.d.ts
 interface PermissionPromptProps {
   request: PermissionRequest;
   onApprove: (requestId: string) => void;
-  /** `message` is fed back to the agent, which can then try something else;
-   * `interrupt` also stops the turn. */
   onDeny: (requestId: string, message?: string, interrupt?: boolean) => void;
   className?: string;
 }
-/**
- * Generic allow/deny prompt for a pending permission request.
- *
- * Three outcomes, not two: denying usually means "not that, try something else",
- * so plain Deny lets the turn continue (with an optional reason the agent reads)
- * while "Deny & stop" also interrupts.
- *
- * The heading is whatever the engine authored — `title`, else `displayName`.
- * Composing "wants to use {tool}" instead would be wrong for codex, where an
- * approval is usually an *escalation after a sandbox refusal* and the runner has
- * already written the sentence that says so.
- */
-declare function PermissionPrompt({
-  request,
-  onApprove,
-  onDeny,
-  className
-}: PermissionPromptProps): _$react.JSX.Element;
+declare function PermissionPrompt({ request, onApprove, onDeny, className }: PermissionPromptProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/QuestionPrompt.d.ts
 type QuestionBehaviorMeta = {
@@ -1425,233 +851,84 @@ type QuestionBehaviorMeta = {
   label: string;
   description: string;
 };
-/** The AskUserQuestion policies surfaced on job/session creation forms. */
 declare const QUESTION_BEHAVIORS: QuestionBehaviorMeta[];
-/** Extract well-formed questions from an AskUserQuestion permission request's input. */
 declare function parseUserQuestions(input: Record<string, unknown>): UserQuestion[];
 interface QuestionPromptProps {
-  /** A pending permission whose toolName is 'AskUserQuestion'. */
   request: PermissionRequest;
-  /** Allow the tool with `updatedInput` (the original input plus `answers`). */
   onAnswer: (requestId: string, updatedInput: Record<string, unknown>) => void;
-  /** Deny the tool — the model proceeds without an answer. */
   onDismiss: (requestId: string, message?: string) => void;
   className?: string;
 }
-/** Interactive form for the AskUserQuestion tool: option buttons per question
- * (multi-select where the question allows it), a free-text "Other" escape hatch,
- * and the focused option's preview. Falls back to nothing renderable → the caller
- * should show a generic PermissionPrompt if `parseUserQuestions` finds no questions. */
-declare function QuestionPrompt({
-  request,
-  onAnswer,
-  onDismiss,
-  className
-}: QuestionPromptProps): _$react.JSX.Element;
+declare function QuestionPrompt({ request, onAnswer, onDismiss, className }: QuestionPromptProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/Composer.d.ts
-/** Files matching an `@` query, for the composer's file trigger. Structural so
- * the ui package doesn't have to reach for the protocol's `HostFileMatch`. */
 type ComposerFileMatch = {
   path: string;
   relative: string;
 };
-/** Imperative surface for panels that draft a message the user then finishes —
- * the skills dialog's "Use this skill". Nothing here sends. */
 type ComposerHandle = {
-  /** Append plain text at the caret's end and focus, separating it from
-   * whatever is already there. */
-  insertText: (text: string) => void; /** Put the caret in the field, changing nothing. */
+  insertText: (text: string) => void;
   focus: () => void;
 };
 interface ComposerProps {
-  /** `attachmentIds` are the staged uploads, in the order they were picked. */
   onSend: (text: string, attachmentIds: string[]) => void;
   onInterrupt: () => void;
   busy: boolean;
-  /** Disable input entirely (session failed/closed). */
   disabled?: boolean;
   placeholder?: string;
-  /** Slash commands offered as autocomplete; picked ones render as chips. */
   commands?: SlashCommandInfo[];
-  /**
-   * Skills offered under a **`$`** popover of their own — codex's sigil, kept
-   * separate from `/` because the two behave differently. A skill is a typing
-   * aid, not a command: picking one inserts editable text (the skill's own
-   * `defaultPrompt` where it has one, else `$name`) and nothing is sent. No
-   * engine parses `$skillname` as syntax, which is exactly why these can never
-   * resolve to a chip the way `commands` do.
-   */
   skills?: SkillInfo[];
-  /** Host-file search behind the `@` trigger. Omit to leave `@` inert — a
-   * gateway without host files has nothing to complete. */
   onSearchFiles?: (query: string, options: {
     signal: AbortSignal;
   }) => Promise<ComposerFileMatch[]>;
-  /** Attachment staging (see `useAttachments`). Omit for a text-only composer. */
   attachments?: UseAttachmentsResult;
-  /** Left side of the toolbar row (mode selects, …). */
   toolbar?: ReactNode;
-  /**
-   * `'stacked'` (default) gives the buttons a row of their own under the field —
-   * right where a toolbar belongs. `'inline'` puts the field and the buttons on
-   * ONE line, growing from a single row as the message does: for a host whose
-   * session controls live in its own chrome (VS Code's status bar), where the
-   * empty composer would otherwise spend two rows saying nothing.
-   */
   layout?: 'stacked' | 'inline';
-  /**
-   * Terminal theme only: the cell the composer draws on. Passed straight
-   * through to its own {@link TerminalSurface}, and it has to be passed — the
-   * composer sits outside the transcript's scroller, so it establishes a second
-   * surface, and a surface handed no metrics falls back to the 13/18 default. A
-   * host running the transcript at its editor's size and the composer at the
-   * default would have the caret land on a different column from the text above
-   * it, which is the one thing this theme exists to prevent.
-   */
   fontSize?: number;
   lineHeight?: number;
-  /** Terminal theme only; see {@link TerminalAffordances}. */
   affordances?: TerminalAffordances | boolean;
+  /**
+   * Where unsent text is remembered between mounts. The composer is remounted on every session switch, so without
+   * this a half-written prompt dies with the switch. Omit to keep the composer stateless across mounts.
+   */
+  draft?: {
+    initialText: string;
+    save: (text: string) => void;
+    clear: () => void;
+  };
   className?: string;
   ref?: Ref<ComposerHandle>;
 }
-/**
- * What a picked skill types into the composer.
- *
- * The engine's own `defaultPrompt` when it declared one — it knows what its
- * skill wants to be asked — and otherwise `$name`, which is codex's native way
- * of referring to a skill in prompt text: its `skill-creator` documents the form
- * (`Use $skill-x at /path/to/skill-x to solve problem y`) and its own bundled
- * prompts are written that way ("Use $pdf to …"). Spelling it the way the engine
- * spells it beats paraphrasing into "Use the X skill to".
- *
- * Either way it ends in a space so the caret lands ready for the rest of the
- * sentence, and either way it is ordinary text: nothing here is submitted, and
- * nothing is parsed back out.
- */
 declare function skillPrompt(skill: SkillInfo): string;
-/**
- * Framed prompt input built on prompt-area's contentEditable.
- *
- * Three completions ride the same field and behave nothing alike. `/` is the
- * CLI's command list and `$` is the engine's skill list — both local, so they
- * filter completely and instantly; `@` is a search against the host filesystem,
- * debounced and abortable so a fast typist makes one request rather than eight.
- *
- * `/` and `$` are separate keys rather than one merged menu, and that mirrors
- * the engines themselves: codex completes skills on `$` and reserves `/` for
- * commands. The behaviours differ too — a command resolves to a **chip**,
- * because the CLI really does parse `/name` out of the message, while a skill
- * resolves to plain editable **text**, because no engine parses `$name` as
- * syntax; it is prose the model reads. Rendering them alike would promise
- * something that does not happen.
- *
- * Files can arrive three ways — the paperclip, a drop, or a paste — because on a
- * desktop all three are things people already do, and the upload starts the
- * moment one lands rather than at send time.
- */
-declare function Composer({
-  onSend,
-  onInterrupt,
-  busy,
-  disabled,
-  placeholder,
-  commands,
-  skills,
-  onSearchFiles,
-  attachments,
-  toolbar,
-  layout,
-  fontSize,
-  lineHeight,
-  affordances,
-  className,
-  ref
-}: ComposerProps): _$react.JSX.Element;
+declare function Composer({ onSend, onInterrupt, busy, disabled, placeholder, commands, skills, onSearchFiles, attachments, toolbar, layout, fontSize, lineHeight, affordances, draft, className, ref }: ComposerProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/ModelSelect.d.ts
 interface ModelSelectProps {
-  /** Models the session can switch to (TranscriptState.models). */
   models: ModelOption[];
-  /** The session's current model id (TranscriptState.model), possibly decorated
-   * (e.g. "claude-fable-5[1m]") — matched leniently against the options.
-   * `undefined` selects the list's default row, if it has one. */
   model?: string;
-  /** `undefined` = back to the CLI's default model. */
   onModelChange: (model?: string) => void;
-  /** 'toolbar' (default) is the composer's compact borderless trigger;
-   * 'form' is a standard field-sized Select for create/settings forms. */
   variant?: 'toolbar' | 'form';
   disabled?: boolean;
   className?: string;
 }
-/** Compact model switcher for the composer toolbar; fed by the `capabilities` event.
- * Rows render CLI-style: bold display name with the model's description beneath. */
-declare function ModelSelect({
-  models,
-  model,
-  onModelChange,
-  variant,
-  disabled,
-  className
-}: ModelSelectProps): _$react.JSX.Element;
+declare function ModelSelect({ models, model, onModelChange, variant, disabled, className }: ModelSelectProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/StatusBar.d.ts
 interface StatusBarProps {
   state: TranscriptState;
-  /**
-   * Plan windows to draw, when they should not be the session's own. The panel
-   * hands over the gateway's per-profile state merged over this transcript's
-   * reading (`mergeUsage`): a session's own `rate_limit` readings arrive only at
-   * a turn's edges, so one idle since yesterday would otherwise render
-   * yesterday's number as current. Absent = `state.rateLimits`, which is what a
-   * bar composed by hand outside the panel gets.
-   */
   rateLimits?: Record<string, RateLimitInfo>;
-  /** @deprecated Pass {@link StatusBarProps.connection}; kept so an embedder
-   * still handing over a boolean keeps working. */
+  /** @deprecated Pass {@link StatusBarProps.connection}. */
   connected?: boolean;
-  /** How the client is doing at reaching the gateway. A dropped socket wins the
-   * status slot: the session status held over a dead socket is a stale reading,
-   * and presenting it as a live one is the thing worth avoiding. */
   connection?: ConnectionState;
-  /**
-   * Where the gauges lead. Each one opens the panel that answers *its* question
-   * — the two meters measure different things, so sending both to one "details"
-   * list would be a detour every time. Omit a handler and that gauge stays a
-   * read-only tooltip.
-   */
   onOpenStatus?: () => void;
   onOpenContext?: () => void;
   onOpenUsage?: () => void;
-  /**
-   * The session's own controls (model, permission mode), for
-   * `controlsSurface: 'status'`. They sit at the end of the readings cluster —
-   * status, context, usage, then what you can *change* — rather than out by the
-   * actions menu, because they belong with the session facts they act on.
-   */
   controls?: ReactNode;
-  /** Trailing slot — the session-actions menu, at the bar's trailing edge. */
   actions?: ReactNode;
-  /** Which edge the bar sits on, so its separating rule goes on the other side.
-   * Placement is the panel's decision; this only styles it. */
   placement?: 'top' | 'bottom';
   className?: string;
 }
-declare function StatusBar({
-  state,
-  rateLimits,
-  connected,
-  connection,
-  onOpenStatus,
-  onOpenContext,
-  onOpenUsage,
-  controls,
-  actions,
-  placement,
-  className
-}: StatusBarProps): _$react.JSX.Element;
+declare function StatusBar({ state, rateLimits, connected, connection, onOpenStatus, onOpenContext, onOpenUsage, controls, actions, placement, className }: StatusBarProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/ContextDialog.d.ts
 interface ContextDialogProps {
@@ -1660,97 +937,28 @@ interface ContextDialogProps {
   onOpenChange: (open: boolean) => void;
   className?: string;
 }
-/**
- * What is in the model's context window right now, category by category.
- *
- * One of the three panels the status bar opens. Context, usage and session info
- * are different questions asked at different moments, so they are different
- * screens rather than one "details" list you scroll past two answers to reach.
- */
-declare function ContextDialog({
-  usage,
-  open,
-  onOpenChange,
-  className
-}: ContextDialogProps): _$react.JSX.Element;
+declare function ContextDialog({ usage, open, onOpenChange, className }: ContextDialogProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/UsageDialog.d.ts
 interface UsageDialogProps {
-  /**
-   * Windows in reading order — session, weekly, then per-model weeklies.
-   *
-   * `updatedAt`/`inferredReset` ride each window because the readings no longer
-   * share one clock: the panel merges the gateway's per-profile state over this
-   * session's, so a `five_hour` learned from a sibling session two minutes ago
-   * can sit beside a `seven_day` this session last heard about yesterday.
-   * `inferredReset` marks the ones the *gateway* zeroed because their own reset
-   * time passed with nothing newer — a floor, not a report.
-   */
   rateLimits: UsageWindowRow[];
-  /** claude.ai plan behind the windows ('max', 'pro', …), when there is one. */
   subscriptionType?: string;
   engine: ProfileEngine;
   totalCostUsd: number;
-  /** When the *freshest* of the windows was read, for the footer line. Readings
-   * arrive one per turn at best (and for an idle session, not at all), so a
-   * stale one is normal and worth saying out loud. */
   updatedAt?: number;
   open: boolean;
   onOpenChange: (open: boolean) => void;
   className?: string;
 }
-/**
- * The session's view of the plan: every window as a meter (see
- * {@link UsageMeters}), the plan tier, and what this session itself has cost.
- */
-declare function UsageDialog({
-  rateLimits,
-  subscriptionType,
-  engine,
-  totalCostUsd,
-  updatedAt,
-  open,
-  onOpenChange,
-  className
-}: UsageDialogProps): _$react.JSX.Element;
+declare function UsageDialog({ rateLimits, subscriptionType, engine, totalCostUsd, updatedAt, open, onOpenChange, className }: UsageDialogProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/UsageMeters.d.ts
-/**
- * Ticking clock — the countdowns and the pace markers both move with it, and a
- * minute is the finest resolution either of them prints.
- *
- * `active` is what a dialog passes its `open`: a closed panel's clock is a timer
- * re-rendering something nobody can see.
- */
 declare function useMinuteClock(active?: boolean): number;
-/**
- * The plan's rate-limit windows, spelled out: how much of each is used, how that
- * compares to the pace that would spend the window exactly, and when it resets.
- *
- * The pace marker is the point. A bar alone says "17% used", which is only
- * alarming or reassuring once you know how far into the week you are — so every
- * window draws a tick at the elapsed share of its duration. Left of the tick is
- * under budget, right of it is ahead of it. The duration comes from the window
- * key (5h, 7d) because the engine reports a reset time and a percentage and
- * never a duration; a window whose key doesn't say gets no marker rather than a
- * guessed one.
- *
- * Its own component rather than the Usage dialog's private helper because two
- * surfaces draw these now — the session panel's Usage panel, from the session's
- * readings merged with the gateway's, and the dashboard's profile page, straight
- * off `ProfileInfo.usage` with no session in sight. Same account, same bars.
- */
-declare function UsageMeters({
-  windows,
-  now,
-  className
-}: {
-  /** In reading order — protocol's `orderUsageWindows`. */windows: UsageWindowRow[];
-  /** A shared clock, when the caller already ticks one. Omitted, this ticks its
-   * own for as long as it is mounted. */
+declare function UsageMeters({ windows, now, className }: {
+  windows: UsageWindowRow[];
   now?: number;
   className?: string;
-}): _$react.JSX.Element;
+}): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/SessionInfoDialog.d.ts
 interface SessionInfoDialogProps {
@@ -1760,21 +968,7 @@ interface SessionInfoDialogProps {
   open: boolean;
   onOpenChange: (open: boolean) => void;
 }
-/**
- * What this session *is*: engine, profile, model, mode, where it runs, which
- * credentials it found, and the files it has handed over.
- *
- * The identity half of the session's facts. Context and usage have their own
- * panels — they change every turn and are consulted mid-run, while everything
- * here is fixed at creation and looked up once.
- */
-declare function SessionInfoDialog({
-  state,
-  client,
-  sessionId,
-  open,
-  onOpenChange
-}: SessionInfoDialogProps): _$react.JSX.Element;
+declare function SessionInfoDialog({ state, client, sessionId, open, onOpenChange }: SessionInfoDialogProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/McpDialog.d.ts
 interface McpDialogProps {
@@ -1782,90 +976,29 @@ interface McpDialogProps {
   sessionId: string | undefined;
   open: boolean;
   onOpenChange: (open: boolean) => void;
-  /**
-   * Whether this engine can reconnect/enable/disable a server
-   * (`EngineCapabilities.mcpServerActions`). False renders the panel read-only:
-   * codex reports rich status but exposes no per-server action, and buttons
-   * that 501 are worse than buttons that aren't there.
-   */
   canManageServers?: boolean;
   className?: string;
 }
-/**
- * The session's MCP servers, at the CLI's own `/mcp` depth: servers → one server
- * → its tools → one tool, with Reconnect / Enable / Disable where they apply.
- *
- * Two things vary by engine rather than being fixed here. **The actions** exist
- * only where the engine has them (`canManageServers`): codex reports rich status
- * but has no per-server reconnect or toggle, so its panel is read-only. And
- * **tool parameters** appear only where the engine reports a schema — codex
- * returns each tool's full JSON Schema, the Agent SDK returns none at all, so
- * the tool view either renders it or says why it can't, rather than leaving a
- * silent gap or claiming the absence is universal.
- */
-declare function McpDialog({
-  client,
-  sessionId,
-  open,
-  onOpenChange,
-  canManageServers,
-  className
-}: McpDialogProps): _$react.JSX.Element;
+declare function McpDialog({ client, sessionId, open, onOpenChange, canManageServers, className }: McpDialogProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/SkillsDialog.d.ts
 interface SkillsDialogProps {
   skills: SkillInfo[] | undefined;
   open: boolean;
   onOpenChange: (open: boolean) => void;
-  /** Insert a skill's opening message into the composer, if the host offers
-   * that. Omit and the dialog is read-only. */
   onUse?: (skill: SkillInfo) => void;
   className?: string;
 }
-/**
- * What this session's engine can do beyond its own tools: the skills it found,
- * grouped by where they came from, with one drilled-down view each.
- *
- * The framing matters more here than in most panels. A skill is **not** a
- * command — the model decides to use one by reading its description, and there
- * is no wire syntax that invokes it. So this screen is a *discovery* surface,
- * and the one action it offers ("Use this skill") is honest about being a
- * drafting aid: it types a message for the operator to edit and send.
- *
- * Fed from the session's `skills` event rather than a REST route, because that
- * is the channel the engine refreshes on its own when a skill changes on disk.
- */
-declare function SkillsDialog({
-  skills,
-  open,
-  onOpenChange,
-  onUse,
-  className
-}: SkillsDialogProps): _$react.JSX.Element;
+declare function SkillsDialog({ skills, open, onOpenChange, onUse, className }: SkillsDialogProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/HostFilesDialog.d.ts
 interface HostFilesDialogProps {
   client: WorkerDeckClient;
-  /** The session's working directory — the browser is rooted here. */
   cwd: string | undefined;
   open: boolean;
   onOpenChange: (open: boolean) => void;
 }
-/**
- * Browse the project the session is working in.
- *
- * Deliberately rooted at the session's cwd rather than at the server's
- * `hostFiles.roots`: the roots are the *security* boundary (the server enforces
- * them on every request), but what someone wants while watching an agent is this
- * project's tree. Read-only — writing is a separate server opt-in and not
- * something a session viewer should be doing behind the agent's back.
- */
-declare function HostFilesDialog({
-  client,
-  cwd,
-  open,
-  onOpenChange
-}: HostFilesDialogProps): _$react.JSX.Element;
+declare function HostFilesDialog({ client, cwd, open, onOpenChange }: HostFilesDialogProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/SessionList.d.ts
 interface SessionListItemProps {
@@ -1875,13 +1008,7 @@ interface SessionListItemProps {
   onDelete?: (id: string) => void;
   className?: string;
 }
-declare function SessionListItem({
-  session,
-  active,
-  onSelect,
-  onDelete,
-  className
-}: SessionListItemProps): _$react.JSX.Element;
+declare function SessionListItem({ session, active, onSelect, onDelete, className }: SessionListItemProps): import("react").JSX.Element;
 interface SessionListProps {
   sessions: SessionInfo[];
   activeId?: string;
@@ -1890,606 +1017,128 @@ interface SessionListProps {
   emptyText?: string;
   className?: string;
 }
-declare function SessionList({
-  sessions,
-  activeId,
-  onSelect,
-  onDelete,
-  emptyText,
-  className
-}: SessionListProps): _$react.JSX.Element;
+declare function SessionList({ sessions, activeId, onSelect, onDelete, emptyText, className }: SessionListProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/SessionStatusIcon.d.ts
-/**
- * State as one glyph — a ringing bell when it wants a human, a spinner while it
- * works, a moon when it is only sleeping. Replaces the text badge: in a sidebar
- * the word costs more room than it earns, and the states that matter are the two
- * you can recognise without reading.
- *
- * **It reads `row.state`, not `info.status`, and that distinction is the whole
- * point of the row model.** `sessionState` already folds in the arm this glyph
- * cannot see for itself: a *background* sub-agent outlives its turn by design,
- * so the turn ends, `status` comes to rest at `idle`, and the agent keeps
- * working. Reading the raw status drew a **moon on a row filed under the
- * "Working" header** — the list contradicting itself on one line, which is
- * exactly what a derived view model exists to prevent. The value was in scope
- * and unread.
- *
- * The terminal statuses still come off `info.status`, because `ended` collapses
- * `failed` and `closed` into one bucket and those are worth telling apart here.
- *
- * It lives in its own file rather than inside the dashboard's browser because
- * the extension's cards draw it too, and a second copy there is how the two
- * lists last disagreed about what a parked session looks like.
- */
-declare function SessionStatusIcon({
-  row,
-  className
-}: {
+declare function SessionStatusIcon({ row, className }: {
   row: SessionRow;
   className?: string;
-}): _$react.JSX.Element;
+}): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/SessionBrowser.d.ts
-/**
- * A sessions list with the affordances a list of thirty needs: search, facets,
- * grouping, sorting, unread counts, and one honest line about what is hidden.
- *
- * The *rules* are `@workerdeck/protocol`'s (`filterRows`/`groupRows`/
- * `subsetSummary`), not this component's — the VS Code sidebar renders the same
- * model with workbench chrome, its activity-bar badge counts the same rows this
- * would show, and iOS mirrors them in Swift. What lives here is the styled
- * rendering of that model, so a host that wants the dashboard's look gets it
- * without reimplementing the model behind it.
- *
- * `SessionList` remains beside this for the plain case (a fixed set of rows, no
- * controls); this is what you reach for when the list is the screen.
- */
 interface SessionBrowserProps {
   rows: SessionRow[];
   config: ViewConfig;
   onConfigChange: (config: ViewConfig) => void;
-  /** The host's own folders, if it has such a notion. Absent — a dashboard, a
-   * phone — makes the scope filter genuinely inert rather than empty. */
   scope?: WorkspaceScope;
   activeId?: string;
-  /**
-   * Which sub-agent the host currently has open, by tool-use id — the *finer*
-   * of the two selections. The card holding it drops to the secondary grey and
-   * that step takes the blue; see `SessionItem`. A host with no sub-agent
-   * surface leaves it undefined and nothing changes.
-   */
   activeSubagentId?: string;
   onSelect?: (row: SessionRow) => void;
   onDelete?: (row: SessionRow) => void;
-  /**
-   * Rename, from the row's pencil. Empty string restores the derived title. A
-   * gateway edit (`PATCH /sessions/:id`), never a local override — every client
-   * should see the same name. Omit to make titles read-only.
-   *
-   * A hover affordance rather than the extension's double-click-the-title,
-   * because here a single click on the row navigates: the *first* click of a
-   * double-click would have already left the page.
-   */
   onRename?: (row: SessionRow, title: string) => void;
-  /**
-   * Clear the conversation in place, from the row's eraser. Same session, empty
-   * context — **not** a delete: the engine keeps the old conversation and it
-   * stays resumable, which is why the row's copy never says "deleted".
-   *
-   * Rendered only where the session's own capability record allows it
-   * (`capabilities.clearContext`, absent = false), so a row that cannot be
-   * cleared has no eraser rather than one that errors. Omit the prop to have
-   * none at all — a host with no way to send a session command has nothing to
-   * hang it on (this is a WS command, not a REST route).
-   */
   onClearContext?: (row: SessionRow) => void;
-  /** Open a session *at* one of its sub-agents, when the host can scroll a
-   * transcript to a `Task` row. Absent, the sub-agent list still expands and a
-   * step just opens its session — see `SessionRowItemProps`. */
   onSelectSubagent?: (row: SessionRow, toolUseId: string) => void;
-  /** Open a session and travel to one of its **tasks** — see
-   * `SessionItem.onRevealStep`. A task has no agent behind it, so it is a place
-   * to go rather than a thing to open, and framing it as an agent drew an empty
-   * view. */
   onRevealStep?: (row: SessionRow, toolUseId: string) => void;
-  /** Rendered when nothing at all exists (as opposed to nothing matching). */
   emptyState?: React.ReactNode;
-  /**
-   * Whether the search + facet bar is shown. Defaults to `true` — a list that
-   * *is* the screen shows its controls.
-   *
-   * A host with somewhere better to put the toggle (a view title bar) passes
-   * `false` and owns the boolean itself, the way the VS Code extension does: the
-   * key lives where the commands do. Two rules come with it, and they are why
-   * this hides only the bar and nothing else — **closing the bar never clears
-   * the filters**, and the subset line below it renders either way, so a list
-   * filtered by a control you can't currently see still says so.
-   */
   showControls?: boolean;
-  /**
-   * Resolved project-icon bytes by content hash — `useProjectIcons`' output.
-   *
-   * Passed in rather than fetched here for the reason `ProjectIcon` states: the
-   * wire carries an *address*, and who can fetch it differs per client. Absent,
-   * or a hash not in it yet, simply draws no picture; the project's name is
-   * already there.
-   */
   projectIcons?: Record<string, string>;
   className?: string;
 }
-/**
- * How a list row is drawn, in one place, so `SidebarRow` in `web` matches this
- * exactly rather than approximating it — the dashboard's other three sidebars
- * are that component, and a sessions list that hovered differently from the
- * gateways list beside it would read as a different product.
- *
- * Two rules are load-bearing:
- *
- * - **Fill means hover, and only hover.** It stays on the row whether or not
- *   the row is selected, because a selected row still has to answer the
- *   pointer. Selection gets the gutter instead.
- * - **`ml-0` on the selected row is not cosmetic.** It hands the accent border
- *   the 4px the margin was holding, so the text does not shift sideways as a
- *   row becomes the selected one. The squared left corners are what let the bar
- *   sit flush against the sidebar edge.
- */
 declare function rowShapeClass(active: boolean): string;
-declare function SessionBrowser({
-  rows,
-  config,
-  onConfigChange,
-  scope,
-  activeId,
-  activeSubagentId,
-  onSelect,
-  onDelete,
-  onRename,
-  onClearContext,
-  onSelectSubagent,
-  onRevealStep,
-  emptyState,
-  showControls,
-  projectIcons,
-  className
-}: SessionBrowserProps): _$react.JSX.Element;
+declare function SessionBrowser({ rows, config, onConfigChange, scope, activeId, activeSubagentId, onSelect, onDelete, onRename, onClearContext, onSelectSubagent, onRevealStep, emptyState, showControls, projectIcons, className }: SessionBrowserProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/SessionItem.d.ts
-/**
- * One session in a list — the **card**, and the only drawing of it in the
- * product.
- *
- * The dashboard's `SessionBrowser` and the VS Code sidebar both render this;
- * before it existed they rendered two hand-kept copies that agreed on the model
- * and disagreed on every measurement, and the two lists read as two products.
- * iOS mirrors this file's geometry rather than either copy.
- *
- * ## The shape
- *
- * A 4px-padded, 4px-rounded card whose whole surface is the hit target, holding
- * two 20px lines and, when it is open, the work under them.
- *
- * **Line one is state and identity**: the status glyph leads, the title takes
- * the rest, and the line closes with the unread badge and the context ring. The
- * glyph leads because a sessions list is scanned for *state* first — which of
- * these is working, which is waiting on me — and the title is what you read once
- * the glyph has told you which row to read. The two readings that close the line
- * are the two that change while you are looking at them.
- *
- * **Line two is identity and cost**: the engine's mark and its model in the
- * vendor's own colour, then the project, then everything else the host wants
- * said, then the age — a `·`-joined run that ends in the one part of it that
- * keeps moving. The line's right edge belongs to the disclosure (which doubles
- * as the count of the work below, so the card says how much there is without
- * being opened) and to the host's own actions.
- *
- * **The gutter is one 16px cell, shared by both lines.** The two glyphs are
- * different sizes and laying them out as plain flex children starts the two
- * text columns at different x — two pixels, invisible as a measurement and
- * obvious as a misalignment. Centring inside a fixed cell fixes the text edges
- * and the ink centres at once. It is the terminal gutter's argument at card
- * scale.
- *
- * ## Selection
- *
- * **Selection is the card's own fill**, not a gutter bar: the card is an inset
- * shape with air around it, so filling it is unambiguous in a way a fill on a
- * full-bleed row is not, and it leaves the left edge to the state glyph.
- *
- * There are **two selections at two grains**, and the card and its steps split
- * them:
- *
- * | what is on screen | card | the step |
- * | --- | --- | --- |
- * | nothing | transparent, hovers | transparent, hovers |
- * | this session | `--row-selected` (blue) | transparent, hovers |
- * | one of its sub-agents | `--row-selected-weak` (grey) | `--row-selected` (blue) |
- *
- * **The blue always marks the finest thing selected.** Opening a sub-agent
- * selects its session too, so both claims are true at once and the blue can only
- * carry one; it goes to the agent, and the card steps back to grey — present,
- * holding what you are looking at, not itself the thing you are looking at.
- * Reversing that (blue card, blue row inside it) says nothing, which is what a
- * blue-on-blue card looked like.
- *
- * A filled card does **not** also answer hover: the fill is already spent, and a
- * selected row that lightened under the pointer read as a third state nobody
- * could name. Its steps still do, on `--row-active`, which is a tint and so
- * works on all three grounds.
- *
- * A **task** never takes the blue. It is a reference to a place inside a
- * session, so pressing one selects the session and travels to its marker — see
- * `StepRow`.
- */
 interface SessionItemProps {
   row: SessionRow;
-  /** This session is the one the host is showing. */
   active?: boolean;
-  /**
-   * Which sub-agent is open, by `Step.key` — the *finer* of the two selections.
-   * When it names one of this card's agents, that step takes the blue and the
-   * card drops to the secondary grey. A key belonging to some other card's
-   * agent, or to a task, changes nothing here.
-   */
   activeStepKey?: string;
-  /** Shown when the list is not already grouped by gateway. */
   showGateway?: boolean;
-  /**
-   * False when the list is already grouped by project — the header above has
-   * said the name, so the card must not spend its metadata line repeating it.
-   * What takes the slot is the *sub-path inside the project*
-   * (`projectSubpath`): `packages/ui`, `packages/server` — the one thing the
-   * header cannot say and the only thing that tells two sessions in one repo
-   * apart. A session at the project root has nothing to add and the slot
-   * disappears entirely. Exactly the rule `showGateway` follows one facet over.
-   */
   showProject?: boolean;
-  /** Resolved project-icon bytes by content hash. A hash this map has not got
-   * yet simply draws no icon. */
   projectIcons?: Record<string, string>;
-  /** Uncontrolled by default — pass both to drive expansion from the host. */
   expanded?: boolean;
   onExpandedChange?: (expanded: boolean) => void;
   onSelect?: () => void;
-  /** Open the session *at* one of its sub-agents — hand the panel body over to
-   * that agent's own work. Only ever called for an **agent** step. Absent is not
-   * a missing feature: without it a step just opens the session, which is all a
-   * host with no sub-agent surface can offer. */
   onSelectSubagent?: (toolUseId: string) => void;
-  /**
-   * Open the session and travel to a **task**'s row in the transcript — where
-   * the work was started, and where it finished.
-   *
-   * A separate seam from `onSelectSubagent` because the destinations are
-   * different, and conflating them is not a styling detail: a task has no agent
-   * behind it, so framing its tool-use id selects **no items at all** and the
-   * panel draws an empty agent view. That was the bug. A task is a reference,
-   * and the only honest thing to do with a reference is follow it.
-   */
   onRevealStep?: (toolUseId: string) => void;
-  /** Enables in-place rename. The trigger is the host's — see `renameOn`. */
   onRename?: (title: string) => void;
-  /**
-   * How a rename starts. `doubleClick` is the editor feel (a rename is a thing
-   * you do to the word you are looking at); `external` means the host opens it
-   * from its own affordance — a menu entry, a pencil in `actions` — and drives
-   * it through `editing`/`onEditingChange`.
-   */
   renameOn?: 'doubleClick' | 'external';
   editing?: boolean;
   onEditingChange?: (editing: boolean) => void;
-  /** The card's trailing controls, at the end of line two. A single overflow
-   * glyph is what the design draws; a host with three always-on actions can put
-   * them here instead. */
   actions?: ReactNode;
   className?: string;
 }
-declare function SessionItem({
-  row,
-  active,
-  activeStepKey,
-  showGateway,
-  showProject,
-  projectIcons,
-  expanded,
-  onExpandedChange,
-  onSelect,
-  onSelectSubagent,
-  onRevealStep,
-  onRename,
-  renameOn,
-  editing,
-  onEditingChange,
-  actions,
-  className
-}: SessionItemProps): _$react.JSX.Element;
+declare function SessionItem({ row, active, activeStepKey, showGateway, showProject, projectIcons, expanded, onExpandedChange, onSelect, onSelectSubagent, onRevealStep, onRename, renameOn, editing, onEditingChange, actions, className }: SessionItemProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/EngineIcon.d.ts
-/**
- * Which mark a session wears.
- *
- * The two first-party engines are named directly. A `provider` session is
- * whatever the host wired up, so its *model* is the only thing that says whose
- * it is — sniffed loosely on purpose (`gemini-2.5-pro`, `deepseek-chat`,
- * `kimi-k2`), and falling through to no mark rather than guessing wrong.
- */
 declare function engineMark(engine: string, model?: string): string | undefined;
-/** The colour a session's engine mark wears. Pass it to `EngineIcon`'s
- *  `className` rather than to a parent: the svg carries its own `text-fg-3`,
- *  and only a class on the element itself is merged over it. */
 declare function vendorMarkClass(engine: string, model?: string): string;
-/** The colour the model *name* wears beside that mark — muted unless the vendor
- *  is one whose accent survives at label size. See `VENDOR_TEXT`.
- *
- *  The fallback is `text-fg-3` rather than the metadata line's own `text-fg-4`,
- *  so an unbranded model still sits one step above the project and gateway
- *  beside it — the order the spec lists them in, held without a colour. */
 declare function vendorTextClass(engine: string, model?: string): string;
-declare function EngineIcon({
-  engine,
-  model,
-  className
-}: {
+declare function EngineIcon({ engine, model, className }: {
   engine: string;
   model?: string;
   className?: string;
-}): _$react.JSX.Element;
+}): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/SessionSteps.d.ts
-/**
- * The work *under* a session row, and the one row shape every client renders it
- * through.
- *
- * This lived inside the VS Code webview first, which is exactly why the
- * dashboard had none of it. Nothing in here is extension-specific: a session's
- * sub-agents are a protocol fact, and a disclosure over them is a list
- * affordance. It sits in `packages/ui` so the sidebar, the dashboard and (in its
- * own idiom) the phone are annotating rows the same way rather than three ways.
- *
- * Today the only source is `SessionInfo.subagents`. The other — the CLI's own
- * **task checklist**, the to-do list it keeps for the current turn — is what the
- * design was drawn from, and it is not built: nothing on the wire carries it yet
- * (see `_docs/features/sub-agent-handling.md`, second thread, which opens with
- * "check a capture" rather than "design a surface"). When it arrives it is a
- * *source*, not a second row component: checklist when the session has one, its
- * sub-agents otherwise.
- *
- * That is also why `state` has a `pending` arm no sub-agent can produce. A
- * sub-agent record exists only once dispatched, so it is never queued; a to-do
- * is queued for most of its life, and dropping the state would mean widening the
- * union later — the shape is cheaper to state now than to retrofit.
- */
 type Step = {
   key: string;
-  label: string; /** What one of these is called, for the disclosure's count. */
+  label: string;
   noun: string;
-  /**
-   * Both kinds press. The kind decides **where the press goes**, which is the
-   * whole of the distinction.
-   *
-   * An **agent** has an identity and work of its own, so it wears the sub-agent
-   * colour and opens that agent's own frame. A **task** is something the model
-   * described with no agent behind it (`isAgentRecord`), so there is no frame:
-   * framing its id selects no items and draws an empty screen. What it has
-   * instead is a *place* — the spawning call's row in the transcript — so it is
-   * muted, never selected, and travels there. See `StepRow` for why an inert
-   * row was the worse answer.
-   *
-   * Two values and not a boolean because the checklist source this shape was
-   * drawn for (see above) produces the second kind natively — a to-do is a task
-   * in exactly this sense, and it will slot in here rather than widening
-   * anything.
-   */
   kind: 'agent' | 'task';
-  state: 'done' | 'running' | 'pending' | 'failed'; /** A trailing reading — a sub-agent's tool count. Absent draws nothing. */
+  state: 'done' | 'running' | 'pending' | 'failed';
   detail?: string;
   title: string;
   onSelect: () => void;
 };
-/**
- * The steps under one session, **agents first**.
- *
- * The two kinds do different things when pressed and are worth different
- * amounts of attention: an agent has work of its own to go and read, a task is a
- * marker in a transcript. Interleaved in dispatch order they read as one
- * undifferentiated list, and the rows you can actually open are scattered
- * through it. Grouped, the openable ones are a block at the top and the markers
- * are a tail you can skip.
- *
- * Stable **within** each group, deliberately: dispatch order is the only order
- * these records have that means anything (it is the order the work was started
- * in), so the sort partitions and never reorders inside a partition.
- *
- * `onSelect` is handed the **kind** as well as the id, because the two kinds go
- * to different places — see `SessionItem`, which is what routes them. Passing
- * only the id is what let a task be opened as if it were an agent, and a framed
- * task id matches no items, so the panel drew an **empty agent view**.
- */
 declare function sessionSteps(info: SessionInfo, onSelect: (toolUseId: string, kind: Step['kind']) => void): Step[];
-/** How many of these are still going — the live half of the disclosure's count. */
 declare function runningSteps(steps: readonly Step[]): number;
-/**
- * The disclosure, which is also the reading: `3 agents` — or `2 of 3 agents`
- * while some have settled, because "how many are still going" is the live
- * question and a bare total answers it wrong the moment one finishes.
- *
- * Sub-agents are an annotation on a working row rather than a state of their own
- * (see `runningSubagents` in protocol's `session-list.ts`), so this never
- * competes with the row's status glyph: that still says what the *session* is
- * doing.
- */
-declare function StepToggle({
-  expanded,
-  running,
-  total,
-  noun,
-  onToggle
-}: {
+declare function StepToggle({ expanded, running, total, noun, onToggle }: {
   expanded: boolean;
   running: number;
   total: number;
   noun: string;
   onToggle: () => void;
-}): _$react.JSX.Element;
-/**
- * One step under its session — **pressable, all of them**, and what a press
- * means is what tells the two kinds apart.
- *
- * Pressing an **agent** hands the panel over to that agent's own work
- * (`SessionPanel.openSubagent`): it is not a session and never becomes one, but
- * it has a surface, so it can be the selected thing. Pressing a **task** selects
- * the *session* and travels to that task's marker inside it — a task is a
- * reference to a place in a transcript, not a thing with a screen, so it can be
- * followed but never held.
- *
- * That is a reversal, and a deliberate one. A task used to be inert markup on
- * the argument that "a disabled-looking button still announces itself as one" —
- * correct about the markup, wrong about the premise, because there *was* always
- * somewhere to go and the row simply swallowed the click on its way there. A row
- * that looks like a list item, sits in a list, and does nothing when pressed is
- * the worse lie. So every step answers the pointer and every step answers a
- * press; only what the press does differs.
- *
- * Divided from the card's header by **indentation and its own hit shape**, not
- * by a rule. The rules came first, on the argument that at 11px an indent is not
- * enough to say "list inside a row" — and they were right about the reading and
- * wrong about the cost: a stack of hairlines across every open card turned the
- * list into a ledger, and a rule cannot answer a pointer. A step that lights up
- * under the cursor and fills when it is the one on screen says *list* far more
- * plainly than a line between two of them, and it says it while doing the job
- * the rule could not.
- *
- * **Only an agent can wear the selection**, and `active` is guarded on that here
- * rather than trusted from the caller: a host that hands back a task's key is
- * describing where it navigated, not what it selected, and the row must not
- * paint itself blue for it.
- *
- * The hover is `--row-active` — **alpha, not a flat fill** — because this row
- * has to answer the pointer on three different grounds: a transparent card, a
- * blue one (its session is selected), and a grey one (a sibling agent is). A
- * flat value tuned for any of those is wrong on the other two; a tint darkens or
- * lifts whatever it lands on. It is the one place in the list where the alpha
- * token earns its keep.
- */
-declare function StepRow({
-  step,
-  active,
-  onSelect
-}: {
+}): import("react").JSX.Element;
+declare function StepRow({ step, active, onSelect }: {
   step: Step;
-  /** The panel is showing this step's own work. Ignored for tasks, which cannot
-   * be the selected thing — see above. */
   active?: boolean;
   onSelect: () => void;
-}): _$react.JSX.Element;
+}): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/SubagentStrip.d.ts
-/**
- * The one line above a sub-agent takeover: who this is, how it is doing, and the
- * way back.
- *
- * **It claims exactly what the `TaskRow` it was opened from claims** — the same
- * `taskBusy` / `taskFailed` / tool count over the same items — and deliberately
- * *not* `SubagentInfo.status`. Protocol documents those two as divergent on
- * purpose (`index.ts:1476-1487`), but that divergence is transcript-versus-*list*
- * and this surface **is** the transcript. The disagreement that must not exist
- * here is between a header and the rows directly beneath it.
- *
- * The rollup is still allowed one job — naming an agent whose `Task` call is not
- * in the transcript — because a label is not content, and `SessionInfo.subagents`
- * keeps only eight settled records (`SUBAGENT_HISTORY`), so it can never be the
- * source of what a frame *shows*.
- *
- * Both variants, because the panel has two and a strip that only existed in one
- * would make the takeover a terminal-theme feature rather than a session feature.
- */
-declare function SubagentStrip({
-  task,
-  items,
-  label,
-  onBack,
-  terminal,
-  fontSize,
-  lineHeight
-}: {
-  /** The spawning call. Absent when the transcript does not have it — the strip
-   *  still draws, because the way back must exist even when the content cannot. */
-  task: ToolCallItem$1 | undefined; /** The frame's items, for the busy reading and the tool count. */
-  items: readonly TranscriptItem[]; /** Fallback name when there is no task item. */
+declare function SubagentStrip({ task, items, label, onBack, terminal, fontSize, lineHeight }: {
+  task: ToolCallItem$1 | undefined;
+  items: readonly TranscriptItem[];
   label: string;
   onBack: () => void;
   terminal: boolean;
   fontSize?: number;
   lineHeight?: number;
-}): _$react.JSX.Element;
+}): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/ProjectIcon.d.ts
-declare function ProjectIcon({
-  icon,
-  src,
-  name,
-  className
-}: {
+declare function ProjectIcon({ icon, src, name, className }: {
   icon: ProjectIcon$1 | undefined;
-  /** Resolved bytes for the `image` arm — an object URL or a data URL. The
-   * caller fetches (see the note above); absent draws nothing. */
-  src?: string; /** The project's name, for the alt text. */
+  src?: string;
   name?: string;
   className?: string;
-}): _$react.JSX.Element | null;
+}): import("react").JSX.Element | null;
 //#endregion
 //#region src/components/agent/SessionEmptyState.d.ts
 interface SessionEmptyStateProps {
   cwd?: string;
-  /** Whether `/command` completion is live yet — the CLI reports its commands a
-   * beat after the session starts, and promising a feature that isn't wired up
-   * yet is worse than not mentioning it. */
   hasCommands?: boolean;
-  /** Whether the engine has reported skills the `/` popover can offer. Its own
-   * flag, not a variant of `hasCommands`: what `/` does differs — a command is
-   * submitted, a skill is typed for you to edit — and an engine can have one
-   * without the other. */
   hasSkills?: boolean;
-  /** Whether this gateway serves `@file` search for the session's directory. */
   canBrowseFiles?: boolean;
   className?: string;
 }
-/**
- * What a session shows before it has said anything: where the agent is sitting,
- * and what the composer accepts beyond prose.
- *
- * Every hint is conditional on the affordance actually existing — an engine
- * without slash commands, or a gateway without host files, is not told about
- * them. Deliberately no project name (the header already carries it) and no
- * brand mark (its geometry is inlined in several places already and they are
- * meant to stay identical).
- */
-declare function SessionEmptyState({
-  cwd,
-  hasCommands,
-  hasSkills,
-  canBrowseFiles,
-  className
-}: SessionEmptyStateProps): _$react.JSX.Element;
+declare function SessionEmptyState({ cwd, hasCommands, hasSkills, canBrowseFiles, className }: SessionEmptyStateProps): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/PromptTokenText.d.ts
-/**
- * A sent message, with its `@file` and `/command` tokens styled the way the CLI
- * writes them: monospace and tinted, no background — the bubble already has one,
- * and a second fill inside it reads as a button.
- *
- * Literal text, never markdown: what was typed is what was sent. The one pass
- * over it is this, so a message reads the same after sending as it did in the
- * composer. Two tokens, two meanings — a file is a reference, a command is an
- * action — so they are told apart by hue rather than by shape alone.
- */
-declare function PromptTokenText({
-  text,
-  className
-}: {
+declare function PromptTokenText({ text, className }: {
   text: string;
   className?: string;
-}): _$react.JSX.Element;
+}): import("react").JSX.Element;
 //#endregion
 //#region src/components/agent/status.d.ts
 declare const STATUS_META: Record<SessionStatus, {
@@ -2499,73 +1148,20 @@ declare const STATUS_META: Record<SessionStatus, {
 }>;
 //#endregion
 //#region src/components/agent/ContextRing.d.ts
-/**
- * How full a session's context window is, sized for a **list row**.
- *
- * The reading the session screen has always drawn, moved somewhere it answers a
- * question the session screen cannot: *which* of these thirty sessions is
- * bloating. That is also why it is a ring and not a number — across a list, a
- * ring is read at a glance and `71%` has to be read one row at a time.
- *
- * **Absent draws nothing, and absent is not zero.** A promptless session, a
- * parked one from before the field existed, or an engine that reports no window
- * has no reading; an empty ring would claim its context is empty rather than
- * unknown. The title carries the exact numbers for anyone who wants them.
- *
- * Shared rather than spelled per client: the dashboard's row and the VS Code
- * sidebar's card both draw it, and two copies would be two sets of thresholds
- * the day one of them is nudged.
- */
-declare function ContextRing({
-  usage,
-  size,
-  className
-}: {
+declare function ContextRing({ usage, size, className }: {
   usage: ContextReading | undefined;
   size?: number;
   className?: string;
-}): _$react.JSX.Element | null;
+}): import("react").JSX.Element | null;
 //#endregion
 //#region src/lib/utils.d.ts
 declare function cn(...inputs: ClassValue[]): string;
 //#endregion
 //#region src/lib/clipboard.d.ts
-/**
- * Copy text to the clipboard, on origins where the modern API does not exist.
- *
- * `navigator.clipboard` is gated on a **secure context**: HTTPS, or localhost.
- * A WorkerDeck dashboard reached the way it is meant to be reached — plain HTTP
- * on a LAN address, from a laptop or a phone — is neither, so `navigator.clipboard`
- * is `undefined` there and touching `.writeText` throws outright. That is the
- * normal deployment, not an edge case, which is why this falls back rather than
- * feature-detecting into a disabled button.
- *
- * The fallback is `document.execCommand('copy')` over an off-screen textarea.
- * It is deprecated and it is also the only thing that works here; every browser
- * still implements it. Returns whether the text actually landed, so a caller can
- * avoid claiming success it did not have.
- */
 declare function copyText(value: string): Promise<boolean>;
 //#endregion
 //#region src/lib/tool-icon.d.ts
-/**
- * An icon per tool, so a transcript can be skimmed by shape rather than read.
- *
- * The same mapping the iOS app makes, in lucide's vocabulary rather than SF
- * Symbols — the two clients should be recognisably showing the same thing. An
- * unknown tool falls back to a wrench, and an MCP tool (`mcp__server__name`) to
- * the puzzle piece the MCP screens use, because "which server is this from" is
- * the useful thing to see at a glance.
- */
 declare function toolIcon(toolName: string): LucideIcon;
-/**
- * Does this tool *change* the workspace?
- *
- * Worth its own colour in a transcript: skimming a run, "what did it edit" is a
- * different question from "what did it look at", and a write is the one you
- * might need to undo. Names from both first-party engines; an MCP tool is
- * unknowable from its name, so it reads as neutral rather than guessed.
- */
 declare function isMutatingTool(toolName: string): boolean;
 //#endregion
 export { AlertDialog, AlertDialogClose, AlertDialogContent, AlertDialogDescription, AlertDialogTitle, AlertDialogTrigger, Badge, type BadgeProps, Band, Blank, Button, type ButtonProps, Card, CardContent, CardHeader, CardTitle, type ChipSegment, CodeBlock, type CodeBlockProps, Composer, type ComposerFileMatch, type ComposerHandle, type ComposerProps, ContextDialog, type ContextDialogProps, ContextRing, Conversation, ConversationContent, type ConversationProps, ConversationScrollButton, CopyAction, CopyButton, type CopyButtonProps, Dialog, DialogBody, DialogClose, DialogContent, DialogHeader, DialogRow, DialogTrigger, Empty, EmptyKey, EngineIcon, FileCard, type FileCardProps, type FileDeliveredItem, HostFilesDialog, type HostFilesDialogProps, Ink, Input, Loader, McpDialog, type McpDialogProps, Menu, MenuContent, MenuItem, MenuSeparator, MenuTrigger, Message, MessageContent, type MessageProps, ModelSelect, type ModelSelectProps, PERMISSION_MODES, type PermissionModeChoice, type PermissionModeMeta, PermissionModeSelect, type PermissionModeSelectProps, PermissionPrompt, type PermissionPromptProps, ProgressRing, type ProgressRingProps, ProjectIcon, PromptArea, type PromptAreaHandle, type PromptAreaProps, PromptTokenText, QUESTION_BEHAVIORS, type QuestionBehaviorMeta, QuestionPrompt, type QuestionPromptProps, Reasoning, type ReasoningProps, Response, type ResponseProps, Row, type RowProps, STATUS_META, type Segment, Select, SelectContent, SelectItem, SelectItemText, SelectTrigger, SelectValue, SessionBrowser, type SessionBrowserProps, type SessionControls, SessionEmptyState, type SessionEmptyStateProps, SessionInfoDialog, type SessionInfoDialogProps, SessionItem, type SessionItemProps, SessionList, SessionListItem, type SessionListItemProps, type SessionListProps, SessionPanel, type SessionPanelProps, SessionStatusIcon, type SessionSurfacePanel, type SessionVitals, SkillsDialog, type SkillsDialogProps, Spinner, Splitter, type SplitterProps, StatusBar, type StatusBarProps, type Step, StepRow, StepToggle, SubagentStrip, type TerminalAffordances, TerminalDiff, TerminalItemView, TerminalMarkdown, type TerminalMarkdownProps, type TerminalMetrics, TerminalPermissionPrompt, type TerminalPermissionPromptProps, TerminalQuestionPrompt, type TerminalQuestionPromptProps, TerminalStatusLine, type TerminalStatusLineProps, TerminalSurface, type TerminalSurfaceProps, TerminalTranscript, type TerminalTranscriptProps, type TextSegment, Textarea, Tip, Toaster, type Tone, ToolCallCard, type ToolCallCardProps, type ToolCallItem, TooltipContent, TooltipProvider, Transcript, type TranscriptDensity, TranscriptDensityProvider, type TranscriptFont, type TranscriptProps, type TranscriptVariant, TranscriptVariantProvider, type TriggerConfig, type TriggerSuggestion, UsageDialog, type UsageDialogProps, UsageMeters, WithActions, badgeVariants, buttonVariants, cn, commandTrigger, copyText, engineMark, formatAgoPrecise, formatBytes, formatCost, formatCountdown, formatDuration, formatRateLimitWindow, formatRateLimitWindowLong, formatRelativeTime, formatTokens, friendlyModel, getChipsByTrigger, hashtagTrigger, isMutatingTool, isSegmentsEmpty, mentionTrigger, parseUserQuestions, permissionModeChoices, permissionModeMeta, plainTextToSegments, previewPatch, rateLimitWindowSeconds, rowShapeClass, runningSteps, segmentsToPlainText, sessionSteps, skillPrompt, toast, toolIcon, toolInputPreview, useAffordances, useMinuteClock, usePromptAreaState, useTranscriptDensity, useTranscriptVariant, vendorMarkClass, vendorTextClass };