@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/web-react/index.d.ts

@@ -1,2342 +1,77 @@
-import * as react from 'react';
-import { ReactNode, RefObject, ReactElement, CSSProperties } from 'react';
-import { ToolPart } from '@tangle-network/ui/types';
-import { C as ChatInteractionField, I as InteractionAnswers, a as ChatInteractionStatus, b as ChatInteraction, c as InteractionCancelData, d as ChatSelectField, e as InteractionRequestWire } from '../contract-OxG_jVMx.js';
-export { f as ChatFreeTextField, g as ComposerAnswerDelivery, h as INTERACTION_CANCEL_EVENT, i as INTERACTION_EVENT, j as INTERACTION_RESOLVED_EVENT, k as InteractionAnswerValue, l as InteractionPersistedPart, N as NoticeKind, m as NoticePersistedPart, P as ParseInteractionAnswersResult, n as ParseInteractionResult, o as canTransitionInteractionStatus, p as cancelStatusFor, q as composerAnswerData, r as composerAnswerDeliveries, s as dedupeQuestionInteractionsByContent, t as fieldAcceptsFreeText, u as interactionFromWireRequest, v as interactionPartKey, w as interactionToPersistedPart, x as isRenderableInteractionKind, y as isSafeInteractionFieldKey, z as isTerminalInteractionStatus, A as noticePart, B as noticePartKey, D as parseInteractionAnswers, E as parseInteractionCancel, F as parseInteractionRequest, G as persistedPartToInteraction, H as questionInteractionContentSignature, J as stampInteractionAnswers } from '../contract-OxG_jVMx.js';
-import { ChatPlan } from '../plans/index.js';
-import { InteractionData } from '@tangle-network/agent-interface';
-export { InteractionData, InteractionOutcome, InteractionRequest } from '@tangle-network/agent-interface';
-import { e as ChatMentionPart, a as ChatAttachmentPart } from '../parts-BqIHMdyu.js';
-export { s as attachmentInputToPart, t as attachmentKindForMime, u as attachmentPartsFromMessageParts, x as isChatAttachmentPart, H as mentionInputToPart, I as mentionPartsFromMessageParts } from '../parts-BqIHMdyu.js';
-import { E as EvidenceEntry, g as ExceptionEntry, b as WorkProductProvenance, P as ProfileBacktestSummary, Q as QualityCheck, W as WorkProductPersistedPart, h as WorkProductStatus } from '../types-CCeYywdS.js';
-export { a as AgentSessionControls, A as AgentSessionControlsProps, C as ComposerMentionProp, D as DEFAULT_EFFORT_LEVELS, b as DEFAULT_MENTION_EMPTY_TEXT, c as DEFAULT_MENTION_LIMIT, E as EFFORT_METER_SEGMENTS, d as EffortLevel, e as EffortMeter, f as EffortPicker, g as EffortPickerProps, I as INDEX_REFRESH_AFTER_MS, M as MentionItem, h as ModelPicker, i as ModelPickerProps, O as OVERLAY_SHADOW, P as POPOVER_SURFACE_ATTR, j as PopoverSurface, k as PopoverSurfaceProps, l as UseFileMentionsOptions, U as UseFileMentionsResult, m as effortLevelLabel, n as effortLevelsFromIds, o as effortMeterFill, r as rankFileMentions, p as reconcileEffortLevels, u as useFileMentions, q as usePending, s as usePopover } from '../agent-session-controls-CmlXwp_H.js';
-import { a as ChatAttachmentKind, b as ChatAttachmentInput } from '../wire-DOZ-O6hD.js';
-export { C as ChatMentionKind, e as ChatTurnFilePartInput, d as ChatTurnPartInput, c as ChatTurnRequestPayload, D as DISPATCH_MAX_MEDIA_PARTS, i as DISPATCH_MAX_PARTS, j as DISPATCH_REQUEST_MAX_BYTES, k as DISPATCH_STRUCTURAL_RESERVE_BYTES, F as FileMention, P as ProducerErrorEvent, m as ProducerNoticeEvent, n as ProducerPassthroughEvent, o as ProducerPassthroughEventType, p as ProducerReasoningEvent, q as ProducerTextEvent, r as ProducerToolCallEvent, s as ProducerToolResultEvent, t as ProducerUsageEvent, u as ProducerWireEvent, w as base64WireLen, x as buildMentionPromptBlock, y as chatTurnRequestInit, z as fileMentionsToParts, B as mediaTypeForMentionPath, E as mentionKindForPath } from '../wire-DOZ-O6hD.js';
-import { Harness } from '../harness/index.js';
-import { S as StepAgentActivity } from '../agent-activity-C8ZG0F0M.js';
-import { F as FlowTrace } from '../flow-types-CJxEmaRy.js';
-import { a as ReviewQueueItem, c as ReviewQueueState } from '../queue-VTBA5ONX.js';
-export { p as parseReviewQueueItem } from '../queue-VTBA5ONX.js';
-export { SandboxTerminalConnection, SandboxTerminalConnectionResponse, UseSandboxTerminalConnectionOptions, UseSandboxTerminalConnectionResult, tabTerminalConnectionId, useSandboxTerminalConnection } from './terminal.js';
-import { i as ProductSeatOffer } from '../billing-BuNlaKlE.js';
-import { SessionSort, SessionPage, SessionSummary, SessionRailAction } from '../session-shell/index.js';
-import { AsyncResourceState, AsyncEmptySpec } from './async/index.js';
-import { CatalogModel } from '../catalog/index.js';
-export { a as ATTACHMENT_ACCEPT, e as FileIndexReadyResponse, f as FileIndexResponse, g as FileIndexWarmingResponse } from '../attachment-validation-BfJDBU1g.js';
-export { a as attachmentPartKey } from '../stream-normalizer-DKRxyVlZ.js';
-import '../billing/index.js';
-
-/** Represent durable plan decisions as either approved or rejected */
-type DurablePlanDecision = 'approved' | 'rejected';
-/** Stable authority receipt for the follow-up turn dispatched by a plan
- * decision. Consumers must make `attachFollowUp` idempotent by `receiptId`;
- * reload and retry deliberately invoke it again. */
-interface DurablePlanFollowUpReceipt {
-    receiptId: string;
-    planId: string;
-    revision: number;
-    turnId: string;
-    state: string;
-}
-/** Describe the result of a durable plan decision including plan details and pending statuses */
-interface DurablePlanDecisionResult {
-    plan: ChatPlan;
-    followUp?: DurablePlanFollowUpReceipt;
-    idempotent: boolean;
-    projectionPending?: boolean;
-    effectPending?: boolean;
-}
-/** Define input parameters for making a durable plan decision including optional feedback */
-interface DurablePlanDecisionInput {
-    planId: string;
-    revision: number;
-    decision: DurablePlanDecision;
-    feedback?: string;
-}
-/** Define input parameters for retrieving the current durable plan including optional revision number */
-interface DurablePlanCurrentInput {
-    planId: string;
-    revision?: number;
-}
-/** Define methods to obtain and decide durable plan decisions asynchronously */
-interface DurablePlanDecisionClient {
-    current: (input: DurablePlanCurrentInput) => Promise<DurablePlanDecisionResult>;
-    decide: (input: DurablePlanDecisionInput) => Promise<DurablePlanDecisionResult>;
-}
-/** Represent errors from DurablePlanClient operations including status, code, and current plan details */
-declare class DurablePlanClientError extends Error {
-    readonly status: number;
-    readonly code?: string | undefined;
-    readonly currentPlan?: ChatPlan | undefined;
-    constructor(message: string, status: number, code?: string | undefined, currentPlan?: ChatPlan | undefined);
-}
-/** Define configuration options for creating a durable plan decision client */
-interface DurablePlanDecisionClientOptions {
-    url: string | ((input: DurablePlanCurrentInput | DurablePlanDecisionInput) => string);
-    body?: Record<string, unknown> | ((input: DurablePlanDecisionInput) => Record<string, unknown>);
-    fetchImpl?: typeof fetch;
-}
-/** Browser client for the shared durable-plan route. The route URL and all
- * product routing fields are injected; workspace/session identity is still
- * resolved and authorized on the server. */
-declare function createDurablePlanDecisionClient(options: DurablePlanDecisionClientOptions): DurablePlanDecisionClient;
-/** Define options to configure durable plan flow with plan, client, and optional callbacks */
-interface UseDurablePlanFlowOptions {
-    plan: ChatPlan;
-    client: DurablePlanDecisionClient;
-    /** Must be idempotent by receipt.receiptId. */
-    attachFollowUp?: (receipt: DurablePlanFollowUpReceipt) => Promise<void> | void;
-    onUpdated?: (plan: ChatPlan) => void;
-}
-/** Define the result and actions for managing a durable plan flow including decisions, restoration, and error handling */
-interface UseDurablePlanFlowResult {
-    plan: ChatPlan;
-    deciding: DurablePlanDecision | null;
-    restoring: boolean;
-    error: string | null;
-    decide: (decision: DurablePlanDecision, feedback?: string) => Promise<DurablePlanDecisionResult | null>;
-    restore: () => Promise<DurablePlanDecisionResult | null>;
-    clearError: () => void;
-}
-/** Shared plan decision controller. It coalesces only concurrent attachment
- * attempts; a later retry/restore calls the consumer's idempotent transport
- * again so a lost response cannot strand an already-dispatched follow-up. */
-declare function useDurablePlanFlow(options: UseDurablePlanFlowOptions): UseDurablePlanFlowResult;
-
-/**
- * Shared answer-building + submit plumbing for the interaction cards
- * (question, plan). Client-safe, no React: cards own their state, this owns
- * the wire. Lifted from the gtm-agent fork (the most fix-absorbed of the three
- * product copies), including the 30s submit timeout that keeps a dead route
- * from wedging a card in "Submitting…".
- */
-
-/** Status-badge labels for an interaction card. `cancelled`/`expired` read the
- *  same across cards; each card supplies its own verbs for the other states
- *  (a question is answered/declined; a plan is approved/rejected). */
-declare function interactionStatusLabels(labels: {
-    pending: string;
-    answered: string;
-    declined: string;
-}): Record<ChatInteractionStatus, string>;
-/** Terminal-state notes for an interaction card. The expiry/withdrawal lines
- *  share one shape around the card's noun ("question"/"plan"); any extra notes
- *  (e.g. a plan's `declined` revision line) merge on top. */
-declare function interactionTerminalNotes(noun: string, extra?: Partial<Record<ChatInteractionStatus, string>>): Partial<Record<ChatInteractionStatus, string>>;
-/** Define a record mapping field names to objects with optional selected, text, and custom string arrays or values */
-type FieldValues = Record<string, {
-    selected?: string[];
-    text?: string;
-    custom?: string;
-}>;
-/** Converts acknowledged, persisted answers back into the local field state
- * consumed by the shared cards. Persisted values are authoritative: this is
- * intentionally used only when an interaction carries `answers`, never to
- * guess an answer from the absence of an outstanding sidecar ask. */
-declare function fieldValuesFromAnswers(fields: ChatInteractionField[], answers: InteractionAnswers | undefined): FieldValues;
-/** The submitted value for one field, or null when it has no answer yet.
- *
- *  Returns `InteractionAnswers[string]`, not the wider `InteractionData[string]`:
- *  a card reads its value out of a rendered control, so every branch below
- *  yields a plain scalar or string array. `InteractionData` also admits a
- *  one-use `secret_handle` reference, which no control here can produce and
- *  which `onResolved` must never receive — that path persists into the visible
- *  transcript. Declaring the narrow type keeps the handle out by construction
- *  rather than by review. */
-declare function fieldAnswer(field: ChatInteractionField, values: FieldValues): InteractionAnswers[string] | null;
-/** All required fields answered → the respond payload; else null (not
- *  submittable yet). Optional unanswered fields are omitted. */
-declare function buildAnswerData(fields: ChatInteractionField[], values: FieldValues): InteractionAnswers | null;
-/** Determine if a status is late answerable by checking if it is expired or cancelled */
-declare function isLateAnswerableStatus(status: ChatInteractionStatus): boolean;
-/** Secrets must never leave the sidecar answer channel for the visible chat
- *  transcript, so a secret-bearing ask cannot be late-answered. */
-declare function hasSecretField(fields: ChatInteractionField[]): boolean;
-/** Renders the late answer as a self-contained chat message: the original
- *  question, its context, and the user's answer(s). */
-declare function lateAnswerMessage(interaction: ChatInteraction, data: InteractionData): string;
-/** Define the timeout duration in milliseconds for submitting an interaction */
-declare const INTERACTION_SUBMIT_TIMEOUT_MS = 30000;
-/** Provide the timeout message displayed when the agent cannot be reached during interaction submission */
-declare const INTERACTION_SUBMIT_TIMEOUT_MESSAGE = "Could not reach the agent. Try again.";
-/** One card submission: which ask, resolved how, with what answers. */
-interface InteractionAnswerSubmission {
-    id: string;
-    outcome: 'accepted' | 'declined';
-    data?: InteractionData;
-}
-/** Resolve the result of an interaction submission indicating success or failure with details */
-type InteractionSubmitResult = {
-    ok: true;
-} | {
-    ok: false;
-    expired: boolean;
-    message: string;
-};
-/** The cards' only side-effect seam: POST one resolution, report the normalized
- *  outcome. Products bind their route URL + routing fields (workspaceId,
- *  threadId, session path param) via `createInteractionAnswerSubmitter` or a
- *  hand-rolled implementation. */
-type SubmitInteractionAnswer = (submission: InteractionAnswerSubmission) => Promise<InteractionSubmitResult>;
-/** Extracts the most specific error message a route returned. */
-declare function responseErrorMessage(res: Response): Promise<{
-    code?: string;
-    message: string;
-}>;
-/** Define options for submitting interaction answers including URL, body, timeout, and fetch implementation */
-interface InteractionAnswerSubmitterOptions {
-    /** The product's answer route (the POST half of `createInteractionAnswerRoute`).
-     *  A function when the URL carries the session (e.g. `/api/sessions/${id}/interactions`). */
-    url: string | ((submission: InteractionAnswerSubmission) => string);
-    /** Extra routing fields merged into the POST body (e.g. workspaceId, threadId). */
-    body?: Record<string, unknown> | ((submission: InteractionAnswerSubmission) => Record<string, unknown>);
-    timeoutMs?: number;
-    fetchImpl?: typeof fetch;
-}
-/**
- * Runs a host-supplied submitter under the CARD's own deadline, and always
- * resolves.
- *
- * `createInteractionAnswerSubmitter` aborts its own fetch, but a product may
- * pass any `SubmitInteractionAnswer` — commonly one wrapping an untimed
- * `fetch`. The deadline cannot live only in the submitter, because what gets
- * stuck is the card: its in-flight guard is cleared by the awaited promise
- * settling, so a submitter that never settles leaves that guard set for the
- * life of the instance — "Submitting…" forever, and no answer can be sent
- * again. A submitter with its own shorter timeout simply wins the race.
- *
- * Rejection is normalized too: a submitter that throws would otherwise escape
- * the click handler as an unhandled rejection, leaving the user with a card
- * that silently did nothing. It becomes a visible, retryable message instead.
- */
-declare function settleInteractionSubmit(run: () => Promise<InteractionSubmitResult>, timeoutMs?: number): Promise<InteractionSubmitResult>;
-/**
- * Builds the `SubmitInteractionAnswer` the cards consume: POSTs
- * `{ ...routingFields, id, outcome, data? }` with an abortable timeout and
- * normalizes the outcome. `expired` is the 410 path — the ask is gone
- * (answered elsewhere, timed out, or the session moved on) and the card must
- * flip to the same dead state a cancel event produces.
- */
-declare function createInteractionAnswerSubmitter(options: InteractionAnswerSubmitterOptions): SubmitInteractionAnswer;
-
-type DurableChatCard = {
-    kind: 'plan';
-    key: string;
-    plan: ChatPlan;
-} | {
-    kind: 'interaction';
-    key: string;
-    interaction: ChatInteraction;
-};
-/** Converts persisted/live parts to canonical cards. Legacy interaction-plan
- * cards are suppressed only when their raw part carries an explicit planId and
- * revision matching a durable plan. Identical markdown alone is never proof. */
-declare function durableChatCardsFromParts(parts: Array<Record<string, unknown>>): DurableChatCard[];
-interface DurableChatCardsProps {
-    parts: Array<Record<string, unknown>>;
-    canWrite: boolean;
-    submitInteraction: SubmitInteractionAnswer;
-    decidePlan: (plan: ChatPlan, decision: DurablePlanDecision, feedback?: string) => Promise<DurablePlanDecisionResult | null>;
-    decidingPlan?: (plan: ChatPlan) => DurablePlanDecision | null;
-    planError?: (plan: ChatPlan) => string | null;
-    onInteractionResolved?: (id: string, status: Exclude<ChatInteraction['status'], 'pending'>, answers?: InteractionAnswers) => void;
-    onLateAnswer?: (message: string) => boolean | void | Promise<boolean | void>;
-    /** Fired when the user asks the agent to re-submit an expired/withdrawn
-     *  plan card as a new chat turn; receives that card's interaction. Omit to
-     *  hide the affordance entirely. */
-    onReRequest?: (interaction: ChatInteraction) => boolean | void | Promise<boolean | void>;
-    /** Overrides the default re-request button label. */
-    reRequestLabel?: string;
-    renderMarkdown?: (markdown: string) => ReactNode;
-    className?: string;
-}
-/** Ready-to-embed canonical question/plan card lane for persisted assistant
- * parts. Apps inject transport and styling callbacks instead of rebuilding the
- * lifecycle/render switch. */
-declare function DurableChatCards({ parts, canWrite, submitInteraction, decidePlan, decidingPlan, planError, onInteractionResolved, onLateAnswer, onReRequest, reRequestLabel, renderMarkdown, className, }: DurableChatCardsProps): react.JSX.Element | null;
-
-/**
- * Client-side chat-stream consumption — the NDJSON parse loop every agent
- * app's chat UI hand-rolls (and breaks). Normalizes the three line shapes the
- * agent-app chat routes emit:
- *
- *   {kind:'event', event:{type:'text'|'reasoning'|'tool_call'|'usage'|'notice'|'error', ...}}
- *   {kind:'tool_result', toolCallId, toolName, label, outcome}
- *   {type:'turn'|'metadata'|'error'|'turn_status', ...}          (route-level)
- *   {type:'interaction', data:{request}}                         (sidecar ask)
- *
- * Replayed lines carry an extra `seq` — transparently ignored. Works for
- * router-backed and sandbox-backed chats alike: anything producing these
- * lines (live pump, queued follow, resume replay) feeds the same callbacks.
- */
-
-/** Define the structure for a chat tool call including optional ID, name, and arguments object */
-interface ChatStreamToolCall {
-    toolCallId?: string;
-    toolName: string;
-    args: Record<string, unknown>;
-}
-/** Describe the result of a chat stream tool including its outcome and optional metadata fields */
-interface ChatStreamToolResult {
-    toolCallId?: string;
-    toolName?: string;
-    label?: string;
-    outcome: {
-        ok: boolean;
-        result?: unknown;
-        code?: string;
-        message?: string;
-    };
-}
-/** Define callbacks to handle events and data during a chat streaming session */
-interface ChatStreamCallbacks {
-    onTurnId?: (turnId: string) => void;
-    onText?: (delta: string) => void;
-    onReasoning?: (delta: string) => void;
-    onToolCall?: (call: ChatStreamToolCall) => void;
-    onToolResult?: (result: ChatStreamToolResult) => void;
-    onUsage?: (usage: {
-        promptTokens: number;
-        completionTokens: number;
-    }) => void;
-    onNotice?: (notice: {
-        id: string;
-        noticeKind: 'warning' | 'auto-declined';
-        text: string;
-    }) => void;
-    onMetadata?: (data: Record<string, unknown>) => void;
-    /** Structured detail from a loop-level error event. Fired alongside the
-     *  legacy string-only `onErrorEvent` callback. */
-    onErrorEventDetail?: (detail: {
-        message: string;
-        code?: string;
-        details?: Record<string, unknown>;
-    }) => void;
-    /** A loop-level error event (the turn failed server-side). Optional, but the
-     *  error never vanishes: when omitted, the message is synthesized into the
-     *  transcript via `onText` (rendered by ChatMessages as a text segment) and
-     *  logged with `console.error`. */
-    onErrorEvent?: (message: string) => void;
-    /** A sidecar interaction ask (kind: "question"/"plan"/…). The run is BLOCKED
-     *  in the broker until the user answers; a pending ask is "waiting on the
-     *  user", not "model working". Optional — a consumer that doesn't wire it
-     *  parses the same stream unchanged. */
-    onInteraction?: (interaction: ChatInteraction) => void;
-    /** A terminal withdrawal/timeout for a previously emitted interaction. */
-    onInteractionCancel?: (cancel: InteractionCancelData) => void;
-    /** A durable-plan snapshot from any plan lifecycle event. */
-    onPlan?: (plan: ChatPlan) => void;
-}
-/** Represent the result of consuming a chat stream including turn ID and content reception status */
-interface ConsumeChatStreamResult {
-    turnId: string | null;
-    /** True when any text/reasoning/tool activity was received. */
-    receivedContent: boolean;
-}
-/** Parse one NDJSON line into the callbacks. Exposed for tests. */
-declare function dispatchChatStreamLine(line: string, cb: ChatStreamCallbacks): {
-    turnId?: string;
-    receivedContent: boolean;
-};
-/** Drain one NDJSON body into the callbacks. Throws on transport failure
- *  (caller decides whether to resume). */
-declare function consumeChatStream(body: ReadableStream<Uint8Array>, cb: ChatStreamCallbacks): Promise<ConsumeChatStreamResult>;
-/** Define options for managing and resuming streaming chat interactions with callbacks */
-interface StreamChatOptions {
-    /** Start the turn (POST the chat request); must return a streaming Response. */
-    start: () => Promise<Response>;
-    /** Re-attach to a turn after a transport drop (GET the resume route). */
-    resume?: (turnId: string, fromSeq: number) => Promise<Response>;
-    callbacks: ChatStreamCallbacks;
-    /** Called before a resume replays from 0 so the UI can reset accumulated
-     *  turn state (text, reasoning, tool chips). */
-    onResetForResume?: () => void;
-}
-/**
- * Run one chat turn with automatic single-shot resume: if the transport drops
- * mid-turn and the server announced a turnId, reset and replay the buffered
- * turn. Server-side the turn keeps running either way (queued runner).
- */
-declare function streamChatTurn(opts: StreamChatOptions): Promise<ConsumeChatStreamResult>;
-
-/** Prompt-part descriptor an uploaded file carries (the upload route's
- *  `UploadedChatFile.part`), echoed back in the turn body on send. Mirrors
- *  `/chat-routes`' wire shape structurally — no server import here. */
-interface ComposerFilePart {
-    type: 'image' | 'file';
-    filename?: string;
-    mediaType?: string;
-    url?: string;
-    path?: string;
-    content?: string;
-}
-interface ComposerFile {
-    id: string;
-    name: string;
-    size?: number;
-    kind: 'file' | 'folder';
-    /** Number of files inside, for a folder chip. */
-    fileCount?: number;
-    status: 'pending' | 'uploading' | 'ready' | 'error';
-    /** Uploaded part descriptor; set once the upload route returns. Only
-     *  `status: 'ready'` files with a part travel on a parts-aware send. */
-    part?: ComposerFilePart;
-}
-/** A send the host refused. `error` is shown verbatim in the composer's notice;
- *  omit it for the generic copy. */
-interface ComposerSendRejected {
-    ok: false;
-    error?: string;
-}
-/**
- * What a send handler reports back. `void` — what every handler returned before
- * this existed — reads as accepted, so wiring stays unchanged; a thrown error, a
- * rejected promise, or `{ ok: false }` is the rejection that restores the draft.
- * A handler that resolves only when the whole turn finishes still reports
- * correctly: the input already cleared on dispatch, so the answer only decides
- * whether the draft comes back.
- */
-type ComposerSendOutcome = void | {
-    ok: true;
-} | ComposerSendRejected;
-type ComposerSendResult = ComposerSendOutcome | Promise<ComposerSendOutcome>;
-/**
- * A send handler, typed as a UNION with the legacy `=> void` signature rather
- * than as `(…) => ComposerSendResult` alone.
- *
- * TypeScript's return-type-`void` rule accepts a function returning ANYTHING
- * where a `=> void` is expected, and that rule fires only when the target's
- * return type is exactly `void` — not when it is a union that contains `void`.
- * So narrowing this prop to `ComposerSendResult` would reject handler shapes
- * that compiled against the shipped `onSend?: (message: string) => void`:
- * `onSend={(m) => rows.push(m)}` (returns `number`) and
- * `onSend={(m) => append({ role: 'user', content: m })}` (an ai-sdk append
- * returns `Promise<string | null | undefined>`) both stop compiling, on a
- * package whose pinned consumers must never need a source edit to take a minor.
- *
- * The union keeps both: a legacy handler lands on the first member, and a
- * handler that reports an outcome lands on the second. A call through it
- * resolves to `void | ComposerSendResult`, which IS `ComposerSendResult`, so
- * the composer reads the outcome exactly as before.
- */
-type ComposerSendHandler = ((message: string) => void) | ((message: string) => ComposerSendResult);
-/** @see ComposerSendHandler — the parts-aware arity, same union for the same reason. */
-type ComposerSendPartsHandler = ((message: string, parts: ComposerFilePart[]) => void) | ((message: string, parts: ComposerFilePart[]) => ComposerSendResult);
-/** The rejected send, handed to `onSendFailed` so the host can undo whatever it
- *  cleared optimistically — most importantly the staged attachments, which the
- *  composer does not own (`pendingFiles` is a prop). */
-interface ComposerSendFailure {
-    /** The reason as the composer renders it. */
-    message: string;
-    /** The user's exact draft, untrimmed. */
-    text: string;
-    /** The parts the rejected send carried. */
-    parts: ComposerFilePart[];
-    /** Whatever the handler threw / rejected with, or the `{ ok: false }` value. */
-    error: unknown;
-    /** True when the draft was put back in the textarea (the box was empty).
-     *  False means the user had typed a replacement, so the unsent text is held in
-     *  the notice instead. */
-    restored: boolean;
-}
-interface ChatComposerProps {
-    /** Send the trimmed, non-empty message. Attached files travel separately via
-     *  `onAttach` + `pendingFiles` (the host consumes and clears them on send).
-     *  Optional when `onSendParts` is wired.
-     *
-     *  Report a refused send by throwing, rejecting, or returning `{ ok: false }`
-     *  — the composer restores the draft rather than losing it. */
-    onSend?: ComposerSendHandler;
-    /** Parts-aware send: receives the trimmed message plus the `part`
-     *  descriptors of every `ready` pending file. Takes precedence over
-     *  `onSend`; enables file-only sends (empty text, ≥1 ready part).
-     *
-     *  Same rejection contract as `onSend`. */
-    onSendParts?: ComposerSendPartsHandler;
-    /** Notified when a send is rejected, after the composer has restored what it
-     *  owns. The host uses it to put back the `pendingFiles` it consumed. */
-    onSendFailed?: (failure: ComposerSendFailure) => void;
-    /** Notice copy when the handler names no reason of its own. */
-    sendFailureMessage?: string;
-    /** Stop the in-flight turn; shown in place of Send while `isStreaming`. */
-    onCancel?: () => void;
-    isStreaming?: boolean;
-    /** Block input + send (e.g. while restoring). Distinct from `isStreaming`,
-     *  which keeps the textarea editable so the next turn can be composed. */
-    disabled?: boolean;
-    placeholder?: string;
-    /** Controlled value. Omit for self-managed internal state (cleared on send). */
-    value?: string;
-    onValueChange?: (value: string) => void;
-    /** Initial text in uncontrolled mode; ignored when `value` is provided. */
-    initialValue?: string;
-    /** One-shot external prefill: when this becomes a non-null string the
-     *  composer adopts it as the draft (replacing any current draft), focuses the
-     *  input with the caret at the end, and reports consumption via
-     *  `onSeedApplied` so the host can clear its seed state. */
-    seed?: string | null;
-    onSeedApplied?: () => void;
-    /** Inline controls (e.g. `<ModelPicker/>` + `<EffortPicker/>` or
-     *  `<AgentSessionControls/>`). */
-    controls?: ReactNode;
-    /**
-     * Where {@link controls} sit. `inline` (default) puts them on the card's own
-     * action row, beside attach and Send — the model a turn will use reads as
-     * part of the input rather than as a separate widget floating above it.
-     * `above` keeps them outside the card, for a host that wants the input to be
-     * nothing but the input.
-     */
-    controlsPlacement?: 'above' | 'inline';
-    /** Attachments are opt-in: pass `onAttach` to show the attach button, accept
-     *  drag-and-drop onto the input, and render `pendingFiles` chips. */
-    onAttach?: (files: FileList) => void;
-    onAttachFolder?: (files: FileList) => void;
-    pendingFiles?: ComposerFile[];
-    onRemoveFile?: (id: string) => void;
-    accept?: string;
-    dropTitle?: string;
-    dropDescription?: string;
-    /** Cmd/Ctrl+L focuses the input and shows the hint. Default true. */
-    focusShortcut?: boolean;
-    /** Float the card on a soft two-layer foreground-tinted shadow (opt-in).
-     *  Elevation only — radius, ring, and control layout are unchanged. */
-    floating?: boolean;
-    /** Send button label. Default "Send". */
-    sendLabel?: string;
-    className?: string;
-}
-declare function ChatComposer({ onSend, onSendParts, onSendFailed, sendFailureMessage, onCancel, isStreaming, disabled, placeholder, value, onValueChange, initialValue, seed, onSeedApplied, controls, controlsPlacement, onAttach, onAttachFolder, pendingFiles, onRemoveFile, accept, dropTitle, dropDescription, focusShortcut, floating, sendLabel, className, }: ChatComposerProps): react.JSX.Element;
-
-type InteractionBadgeVariant = 'outline' | 'default' | 'destructive';
-declare function InteractionBadge({ variant, children }: {
-    variant: InteractionBadgeVariant;
-    children: string;
-}): react.JSX.Element;
-declare function InteractionActionButton({ variant, onClick, disabled, children, }: {
-    variant?: 'primary' | 'outline';
-    onClick: () => void;
-    disabled?: boolean;
-    children: string;
-}): react.JSX.Element;
-interface QuestionOptionListProps {
-    /** Radio/checkbox group name — unique per field so selection is isolated. */
-    groupName: string;
-    /** Stable prefix for per-option input ids (label htmlFor pairing). */
-    idPrefix: string;
-    options: ChatSelectField['options'];
-    /** Checkbox (multi-select) vs radio (single). */
-    multi: boolean;
-    selectedValues: string[];
-    disabled: boolean;
-    onToggle: (value: string) => void;
-    /** Terminal answered state: the selected rows highlight (primary edge, tint,
-     *  trailing check) so the card shows WHAT was answered, not just that it was. */
-    answered?: boolean;
-}
-/** The radio/checkbox option rows for a select field. Renders a fragment of
- *  option `<label>` rows so a card keeps its own wrapping layout and appends
- *  its own write-in input.
- *
- *  The rows arrive as a SEQUENCE (`.agent-arrive` + `--stagger-index`), which
- *  is the difference between reading a list and being shown one: the eye is
- *  told there are N choices and in what order before it has read any of them.
- *  The index is safe to take straight from the map because an option list does
- *  not re-sort under a mounted card — a different set of options is a
- *  different `key`, and a different ask resets the card wholesale. */
-declare function QuestionOptionList({ groupName, idPrefix, options, multi, selectedValues, disabled, onToggle, answered, }: QuestionOptionListProps): react.JSX.Element;
-interface InteractionQuestionCardProps {
-    interaction: ChatInteraction;
-    /** Viewer-vs-editor gate: false renders everything read-only. */
-    canWrite: boolean;
-    /** POST one resolution to the product's answer route (see
-     *  `createInteractionAnswerSubmitter`). Never called for late answers. */
-    submitAnswer: SubmitInteractionAnswer;
-    /** Fired when this card resolves locally (answered, or discovered expired
-     *  via a 410) so the stream/route state stays in sync. */
-    onResolved?: (id: string, status: Exclude<ChatInteractionStatus, 'pending'>, answers?: ChatInteraction['answers']) => void;
-    /** Delivers a late answer (the ask expired/was withdrawn) as a fresh chat
-     *  turn. Return/resolve `false` when the send was rejected so the card stays
-     *  retryable. Omit to hide the late-answer affordance entirely. */
-    onLateAnswer?: (message: string) => boolean | void | Promise<boolean | void>;
-    /** Overrides the kind badge ("Question"). */
-    kindLabel?: string;
-    /** What happens if nobody answers, rendered beside the submit action.
-     *
-     *  The caller owns both the clock and the copy: this card holds no timer, so a
-     *  deadline that counts down re-renders on the caller's cadence rather than
-     *  driving one of its own — and the consequence of silence ("the default is
-     *  taken", "the run fails") is the host's policy to state, not this card's to
-     *  infer. */
-    timeoutNote?: ReactNode;
-    /** Renders `body` as markdown. Omitted, `body` renders as plain text — so a
-     *  host that passes authored markdown without this shows its syntax raw.
-     *
-     *  `body` ONLY. `title` and every `field.label` stay plain strings: a label is
-     *  also the input's accessible name (`aria-label`), which has to be text, and
-     *  rendering one as nodes would either break that or silently disagree with
-     *  what a screen reader announces. Put prose in `body`.
-     *
-     *  `interaction.body` is untrusted: it arrives off the wire, written by an
-     *  agent or whoever authored the ask. This card never injects HTML, but a
-     *  renderer that does is an XSS sink — so return React elements, and sanitize
-     *  (DOMPurify or equivalent) if you must produce HTML. */
-    renderMarkdown?: (markdown: string) => ReactNode;
-    className?: string;
-}
-declare function InteractionQuestionCard({ interaction, canWrite, submitAnswer, onResolved, onLateAnswer, kindLabel, timeoutNote, renderMarkdown, className, }: InteractionQuestionCardProps): react.JSX.Element;
-
-interface InteractionPlanCardProps {
-    interaction: ChatInteraction;
-    /** Viewer-vs-editor gate: false renders everything read-only. */
-    canWrite: boolean;
-    /** POST one resolution to the product's answer route (see
-     *  `createInteractionAnswerSubmitter`). */
-    submitAnswer: SubmitInteractionAnswer;
-    /** Fired when this card resolves locally (approved/rejected, or discovered
-     *  expired via a 410) so the stream/route state stays in sync. */
-    onResolved?: (id: string, status: Exclude<ChatInteractionStatus, 'pending'>) => void;
-    /** Fired when the user asks the agent to re-submit an expired/withdrawn plan
-     *  as a new chat turn. Receives the interaction so a callback shared across
-     *  cards (e.g. via DurableChatCards) knows which plan fired. Return/resolve
-     *  `false` (or throw) to report the send failed and keep the affordance
-     *  retryable. Omit to hide it entirely. */
-    onReRequest?: (interaction: ChatInteraction) => boolean | void | Promise<boolean | void>;
-    /** Overrides the default re-request button label
-     *  ("Ask agent to re-submit the plan" — gtm's exact current copy). */
-    reRequestLabel?: string;
-    /** Renders the plan body (markdown). Falls back to pre-wrapped plain text. */
-    renderMarkdown?: (markdown: string) => ReactNode;
-    className?: string;
-}
-declare function InteractionPlanCard({ interaction, canWrite, submitAnswer, onResolved, onReRequest, reRequestLabel, renderMarkdown, className, }: InteractionPlanCardProps): react.JSX.Element;
-
-interface DurablePlanCardProps {
-    plan: ChatPlan;
-    canWrite: boolean;
-    decide: (decision: DurablePlanDecision, feedback?: string) => Promise<DurablePlanDecisionResult | null>;
-    deciding?: DurablePlanDecision | null;
-    error?: string | null;
-    renderMarkdown?: (markdown: string) => ReactNode;
-    className?: string;
-}
-declare function DurablePlanCard({ plan, canWrite, decide, deciding, error, renderMarkdown, className, }: DurablePlanCardProps): react.JSX.Element;
-
-/** Manage storage and retrieval of interaction attempt keys by interaction and submission identifiers */
-interface InteractionAttemptStore {
-    get(interactionId: string, submissionSignature: string): string | null;
-    set(interactionId: string, submissionSignature: string, attemptKey: string): void;
-    delete(interactionId: string, submissionSignature: string): void;
-}
-/** Create a session-based store to manage interaction attempts using provided storage and optional namespace */
-declare function createSessionInteractionAttemptStore(storage: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>, namespace?: string): InteractionAttemptStore;
-/** Create an in-memory store to manage interaction attempts keyed by ID and signature */
-declare function createMemoryInteractionAttemptStore(): InteractionAttemptStore;
-/** Generate a stable string signature from an interaction answer submission */
-declare function interactionSubmissionSignature(submission: InteractionAnswerSubmission): string;
-/** Define options for submitting durable interaction answers with attempt tracking and optional key creation */
-interface DurableInteractionAnswerSubmitterOptions extends InteractionAnswerSubmitterOptions {
-    attempts: InteractionAttemptStore;
-    createAttemptKey?: () => string;
-}
-/** Answer submitter for a durable interaction route. One opaque attempt key is
- * retained for an ambiguous transport/5xx result and reused after reload. A
- * changed answer has a different signature and therefore a new attempt. */
-declare function createDurableInteractionAnswerSubmitter(options: DurableInteractionAnswerSubmitterOptions): SubmitInteractionAnswer;
-
-/**
- * useChatInteractions — the interaction-state wiring every consumer of
- * `ChatStreamCallbacks.onInteraction` re-implements: an id-keyed,
- * insertion-ordered list with
- *
- *   - forward-only status transitions (a replayed/stale `pending` never
- *     resurrects a resolved card),
- *   - pending-question content dedupe (a re-emitted duplicate ask never renders
- *     a second card),
- *   - cancel-event application (`interaction.cancel` → cancelled/expired),
- *   - local resolution marking (the card's `onResolved`),
- *   - reload restore from the answer route's GET list (sidecar registry is the
- *     source of truth after a reload),
- *   - turn-end settling (client mirror of the server's finalize pass: a turn
- *     that completed without a cancel was answered; a failed turn can make no
- *     such claim).
- *
- * The reducer functions are pure and exported for non-React consumers/tests;
- * the hook is a thin `useState` shell over them.
- */
-
-/** Insert or update one interaction. A terminal existing entry wins over any
- *  incoming state for the same id; a new pending ask that duplicates another
- *  pending ask's content is dropped. Returns the same array when unchanged. */
-declare function upsertChatInteraction(list: ChatInteraction[], interaction: ChatInteraction): ChatInteraction[];
-/** Applies an `interaction.cancel` event: only a pending ask moves, to
- *  `expired` (reason:"timeout") or `cancelled`. */
-declare function cancelChatInteraction(list: ChatInteraction[], cancel: InteractionCancelData): ChatInteraction[];
-/** Marks one ask resolved locally (the card's `onResolved`). Forward-only. */
-declare function resolveChatInteraction(list: ChatInteraction[], id: string, status: Exclude<ChatInteractionStatus, 'pending'>, answers?: InteractionAnswers): ChatInteraction[];
-/** Settles every still-pending ask when the turn ends: `answered` for a turn
- *  that completed cleanly, `expired` for one that failed. */
-declare function terminalizePendingChatInteractions(list: ChatInteraction[], status: Extract<ChatInteractionStatus, 'answered' | 'expired'>): ChatInteraction[];
-/** Define modes for restoring chat interactions with legacy or durable strategies */
-type ChatInteractionRestoreMode = 'legacy' | 'durable';
-/** Define options to control how chat interactions are restored during the restore process */
-interface RestoreChatInteractionsOptions {
-    /**
-     * `legacy` settles pending asks absent from the sidecar list as answered,
-     * preserving the pre-durable restore contract. `durable` leaves them
-     * pending because absence is ambiguous until `hydrateChatInteractions`
-     * applies the durable projection.
-     */
-    mode?: ChatInteractionRestoreMode;
-}
-/** Reload restore from the answer route's GET list. Legacy consumers retain
- * the historical absence→answered behavior; durable consumers opt into the
- * ambiguity-preserving mode and apply terminal parts through `hydrate`. */
-declare function restoreChatInteractions(list: ChatInteraction[], outstanding: InteractionRequestWire[], options?: RestoreChatInteractionsOptions): ChatInteraction[];
-/** Applies transcript/state-store projections after reload. Terminal state and
- * acknowledged answer values enrich an existing pending card without relying
- * on the sidecar's outstanding-list absence. */
-declare function hydrateChatInteractions(list: ChatInteraction[], persisted: ChatInteraction[]): ChatInteraction[];
-/** Resolve and manage chat interactions with methods to update, cancel, mark resolved, and restore state */
-interface UseChatInteractionsResult {
-    /** All known interactions, insertion-ordered. */
-    interactions: ChatInteraction[];
-    /** The asks currently blocking the run (waiting on the user). */
-    pending: ChatInteraction[];
-    /** Wire to `ChatStreamCallbacks.onInteraction` (and persisted-part replay). */
-    upsert: (interaction: ChatInteraction) => void;
-    /** Wire to `interaction.cancel` events. */
-    applyCancel: (cancel: InteractionCancelData) => void;
-    /** Wire to the cards' `onResolved`. */
-    markResolved: (id: string, status: Exclude<ChatInteractionStatus, 'pending'>, answers?: InteractionAnswers) => void;
-    /** Wire to the answer route's GET list after a reload/reconnect. */
-    restore: (outstanding: InteractionRequestWire[], options?: RestoreChatInteractionsOptions) => void;
-    /** Apply durable transcript/state projections after a reload. */
-    hydrate: (persisted: ChatInteraction[]) => void;
-    /** Settle still-pending asks when the turn ends. */
-    terminalizePending: (status: Extract<ChatInteractionStatus, 'answered' | 'expired'>) => void;
-    /** Drop everything (thread switch). */
-    reset: () => void;
-}
-/** Resolve options for restoring chat interactions from previous sessions */
-type UseChatInteractionsOptions = RestoreChatInteractionsOptions;
-/** Manage chat interactions state with upsert, cancel, resolve, and restore capabilities */
-declare function useChatInteractions(options?: UseChatInteractionsOptions): UseChatInteractionsResult;
-
-/**
- * Transcript-side counterpart to the composer's `@`-mention primitive
- * (sandbox-ui#184). The composer serializes a picked file into the message
- * text as `@<path>`; this module is the exact inverse — it finds those tokens
- * again in a PERSISTED message and splits the text so a renderer can draw a
- * pill where the user typed one and leave the rest as prose.
- *
- * Pure and product-agnostic: no React, no fetch, no DOM. The only input beyond
- * the text is the message's OWN mention parts, so one message can never render
- * a pill for a path another message mentioned.
- *
- * `ChatMentionPart` and the runtime helpers `mentionInputToPart` /
- * `mentionPartsFromMessageParts` are re-exported here from `../chat-store/parts`
- * directly (not the `/chat-store` barrel), so a browser bundle gets the mention
- * vocabulary and its converters without importing `/chat-store`, whose barrel
- * pulls the drizzle peer.
- */
-
-/** One run of a segmented message: literal prose, or a matched mention with
- *  the part that produced it. `text` for a mention segment is the token as it
- *  appears in the message (`@<path>`), so a renderer that ignores `part` still
- *  reproduces the original string exactly. */
-interface MentionTextSegment {
-    type: 'text' | 'mention';
-    text: string;
-    part?: ChatMentionPart;
-}
-/**
- * Split a message's text into plain-text and mention segments by matching
- * `@<path>` runs against that message's own mention parts.
- *
- * Only a part whose exact `@<path>` token appears in `content`, at a token
- * boundary on both sides, counts as a match; everything else — including
- * unrelated `@` text — passes through as plain text untouched. When two parts'
- * tokens both match at the same position (one path a prefix of another), the
- * LONGEST token wins, so nested-looking paths split at the right boundary.
- *
- * Returns the matched parts alongside the segments: a caller that also renders
- * a fallback chip row can drop the chip for anything now shown inline and keep
- * it only for mentions the text does not actually contain (a restored draft, a
- * queued message whose text was edited).
- */
-declare function segmentMentionContent(content: string, parts: ReadonlyArray<ChatMentionPart>): {
-    segments: MentionTextSegment[];
-    matched: Set<ChatMentionPart>;
-};
-
-/**
- * Renders a message's attachment parts (images + files) as thumbnails and
- * download chips — the transcript-side counterpart to `ChatComposer`'s
- * staged-upload chips. Ported from gtm-agent's `chat-attachment-parts.tsx`
- * onto agent-app's RAW-BYTES download contract: the host supplies
- * `resolveFileUrl(part)`, a URL that serves the attachment's raw bytes
- * directly, so this module never parses a JSON `{file:{blobUrl,body}}`
- * envelope or decodes a `[base64]` marker the way gtm's vault route did.
- *
- * No icon-library or primitives dependency (`ChatComposer`'s house style):
- * the loading skeleton is an inline `animate-pulse` span and the few glyphs
- * are inline SVGs.
- */
-
-/** Typed outcome of fetching one attachment's raw bytes. Callers must check
- *  `ok` before touching `blob` — a failed fetch never produces a blank
- *  render, it produces a visible error state. */
-type AttachmentFileResult = {
-    ok: true;
-    blob: Blob;
-} | {
-    ok: false;
-    message: string;
-};
-declare function __resetAttachmentFileCacheForTests(): void;
-/** Fetches (and caches) the raw bytes behind one attachment url. Concurrent
- *  callers for the SAME url dedupe to one in-flight fetch. Only a successful
- *  settlement stays cached — evicting failures means a remount or click-retry
- *  after a transient error issues a fresh fetch. */
-declare function loadAttachmentFile(url: string, fetchFile?: (url: string) => Promise<Response>): Promise<AttachmentFileResult>;
-/** Drives an anchor-click download from an already-resolved blob. Returns a
- *  typed outcome rather than throwing — a chip that fails to synthesize the
- *  download must show the failure, not silently no-op. */
-declare function triggerAttachmentDownload(name: string, blob: Blob): {
-    ok: true;
-} | {
-    ok: false;
-    message: string;
-};
-interface MessageAttachmentsProps {
-    parts: ChatAttachmentPart[];
-    /** URL serving the attachment's RAW bytes. */
-    resolveFileUrl: (part: ChatAttachmentPart) => string;
-    /** Row alignment — a user-bubble attachment row is right-aligned by
-     *  default; pass `"start"` for an assistant-turn attachment, which sits
-     *  inline with the rest of the transcript. */
-    justify?: 'start' | 'end';
-    /** Override the fetch used to load an attachment's bytes. Default:
-     *  `fetch(url, { credentials: 'same-origin' })`. */
-    fetchFile?: (url: string) => Promise<Response>;
-}
-/** Renders a message's attachment parts as a row of image thumbnails and file
- *  chips. `null` when there are none, so callers can render unconditionally
- *  without an extra length check. */
-declare function MessageAttachments({ parts, resolveFileUrl, justify, fetchFile }: MessageAttachmentsProps): ReactNode;
-
-/**
- * `useComposerAttachments` — the composer's staged-upload lifecycle: validate
- * selected/dropped/pasted files against the shared limits (the SAME
- * `sniffBinary`/`checkAttachmentType`/size-cap vocabulary the store-backed
- * upload route enforces server-side, `../chat-routes/attachment-validation`
- * + `../chat-routes/binary-sniff`), upload each accepted file with one POST
- * request per file (so a single failure never poisons the batch), and track
- * every file's status so a host composer can render chips and gate sending.
- *
- * Ported from gtm-agent's `src/components/composer-attachments.tsx`
- * (gtm#584/#592/#593 hardened the sniff gate and batch semantics this leans
- * on), de-gtm-ified:
- *   - the hardcoded `/api/vault/upload?workspaceId=` URL becomes
- *     `uploadUrl`/`buildUploadRequest` (the latter wins — it hands back both
- *     the URL and a `RequestInit` override, e.g. an auth header);
- *   - `sonner` toasts become `onReject` (client pre-validation, never hits the
- *     network) and `onError` (a request that reached the server and failed);
- *   - the sandbox-ui `validateComposerFiles` import becomes a small
- *     accept-list matcher re-implemented locally (`isAcceptedFileType`,
- *     mirroring its `accept`-string matching byte-for-byte) — this module
- *     stays free of the sandbox-ui peer;
- *   - the response is expected to be `{ files: ChatAttachmentInput[] }` (full
- *     server-authoritative descriptors — size/mediaType/kind — not gtm's
- *     `{path, name}`), so `references` is a verbatim pass-through with no
- *     client recompute;
- *   - `workspaceId`'s truthiness gate becomes `enabled` (default `true`).
- *
- * Import-free beyond React + the browser-safe `/chat-routes` validation core:
- * this module ships through `/web-react` into client bundles
- * (`tests/browser-safe-subpaths.test.ts` walks the graph), so nothing here
- * may reach a Node builtin, `sandbox-ui`, or an engine package.
- */
-
-/** Define options for configuring file upload behavior and handling in a composer component */
-interface UseComposerAttachmentsOptions {
-    /** Simple upload target: every file POSTs here. Ignored when
-     *  `buildUploadRequest` is provided. */
-    uploadUrl?: string;
-    /** Full request-building seam (auth headers, per-file routing, …) — wins
-     *  over `uploadUrl` when both are set. */
-    buildUploadRequest?: (args: {
-        file: File;
-        name: string;
-        form: FormData;
-    }) => {
-        url: string;
-        init?: Omit<RequestInit, 'body' | 'signal'>;
-    };
-    /** Client pre-validation rejections — a file that never reaches the
-     *  network (bad type, over a size cap, over count, disallowed kind). */
-    onReject?: (reason: string, file?: File) => void;
-    /** A file that reached the upload endpoint and failed (HTTP error,
-     *  transport error, malformed response). */
-    onError?: (reason: string) => void;
-    limits?: {
-        maxCount?: number;
-        maxBinaryBytes?: number;
-        maxTextBytes?: number;
-        maxTotalBytes?: number;
-    };
-    /** Attachment kinds accepted, checked against the sniffed content's
-     *  mime. Default: both (`['image', 'file']` — i.e. no restriction). */
-    allowedKinds?: ChatAttachmentKind[];
-    /** `<input accept>`-style gate for the file picker/drop/paste path.
-     *  Default {@link ATTACHMENT_ACCEPT}. */
-    accept?: string;
-    /** When `false`, `addFiles` rejects every call via `onReject` (and
-     *  `blockReason` explains why) instead of staging anything — the
-     *  replacement for gtm's `workspaceId`-truthiness gate (e.g. no workspace
-     *  loaded yet). Default `true`. */
-    enabled?: boolean;
-}
-/** Provide staged file chips, ready attachments, and methods to add, retry, or drop composer files */
-interface UseComposerAttachmentsResult {
-    /** Chip models for `ChatComposer`'s `pendingFiles` prop, one per staged
-     *  file — `kind` is always `'file'` (agent-app's `ComposerFile.kind`
-     *  discriminates file-vs-folder chips, not attachment media type). */
-    composerFiles: ComposerFile[];
-    /** Ready-to-send attachment descriptors — only files whose upload
-     *  succeeded, straight from the server's response (no recompute). Feed
-     *  this into `ChatTurnRequestPayload.attachments`. */
-    references: ChatAttachmentInput[];
-    /** Validate + stage + upload the given files, one request per file. */
-    addFiles: (files: File[] | FileList) => Promise<void>;
-    /** Re-upload a failed entry using its retained `File`. */
-    retry: (id: string) => void;
-    /** Drop one staged entry, aborting its upload and revoking its preview. */
-    removeAttachment: (id: string) => void;
-    /** Forget every staged entry (call after a successful send). */
-    clear: () => void;
-    /** True while any file is still pending or uploading. */
-    hasPending: boolean;
-    /** True while any file failed to upload. */
-    hasError: boolean;
-    /** Why a send is blocked, or `null` when the queue is clean. */
-    blockReason: string | null;
-}
-/**
- * Owns the composer's attachment lifecycle: validate selected/dropped/pasted
- * files against the shared limits, upload each accepted file to the
- * product's store (one request per file), and track every file's status so
- * the composer can render chips and gate sending.
- *
- * Failures surface loud — a rejected file calls `onReject` and is never
- * uploaded; a failed upload calls `onError` and leaves an error chip the user
- * can retry or remove. `references` only ever contains files whose upload the
- * server actually confirmed.
- */
-declare function useComposerAttachments(options: UseComposerAttachmentsOptions): UseComposerAttachmentsResult;
-
-/**
- * Provider brand marks — real logo path data (simple-icons / SVG Logos, both
- * CC0) inlined so the picker shows actual provider identity instead of
- * colored-initial monograms. Providers without a usable mark fall back to a
- * tinted monogram chip. Aliases (z-ai/zai, moonshot/moonshotai, deepseek_ai)
- * normalize to one entry.
- */
-
-interface ProviderLogoProps {
-    provider?: string;
-    size?: number;
-}
-/** Real brand mark when we have one; tinted monogram otherwise. */
-declare function ProviderLogo({ provider, size }: ProviderLogoProps): ReactNode;
-
-/**
- * Per-harness brand marks for the canonical pickers — the same marks the
- * legacy sandbox-ui harness picker (`dashboard/harness-logo.tsx`) shipped,
- * vendored as inline SVG so `/web-react` stays dependency-free beyond React:
- * sandbox-ui (and its `@lobehub/icons-static-svg` bundle) is an OPTIONAL peer
- * the canonical pickers must not force on a consumer. Geometry is the lobehub
- * single-color artwork, rendered in `currentColor` exactly as the legacy
- * component painted it (a foreground-filled CSS mask), so every mark tracks
- * the theme. Harnesses with no published brand mark get an honest inline
- * lucide glyph — bot / plug / terminal, the same fallbacks the legacy picker
- * used — and an unknown id falls back to the neutral bot. Data-record
- * structure mirrors `./provider-logo`.
- */
-
-interface HarnessGlyphProps {
-    /** Harness to mark. Typed as the canonical union; an out-of-union runtime
-     *  value still renders — it gets the neutral fallback glyph. */
-    harness: Harness;
-    className?: string;
-}
-/**
- * Brand mark for a harness — size it from the call site (`className="h-4
- * w-4"`). Unknown ids render the neutral bot, never an invented logo.
- * `data-glyph` names the resolved mark so tests and stories can assert
- * brand-vs-fallback without snapshotting path data.
- */
-declare function HarnessGlyph({ harness, className }: HarnessGlyphProps): ReactNode;
-
-/**
- * Smooth text reveal — turns chunky network deltas into a continuous
- * typewriter paint. Streamed turns arrive in 100-500ms slabs (model burst,
- * flush windows, replay polls); revealing characters at an adaptive rate
- * makes the same bytes read as top-tier streaming. The rate scales with the
- * backlog so the reveal never falls behind the stream — it crawls when caught
- * up and sprints when a burst lands (e.g. a reasoning summary arriving all at
- * once still *types out* instead of popping in).
- */
-/** Define configuration options for controlling smooth text reveal animation rates */
-interface SmoothRevealOptions {
-    /** Baseline reveal rate when nearly caught up. Default 90 chars/s. */
-    baseCharsPerSecond?: number;
-    /** Extra chars/s per backlog character — the catch-up pressure. Default 5. */
-    catchUpPerChar?: number;
-    /** Hard ceiling so giant bursts still animate. Default 2400 chars/s. */
-    maxCharsPerSecond?: number;
-}
-/** Pure reveal step: how many characters should be visible after `dtMs`.
- *  Exposed for tests; the hook is a thin rAF wrapper around it. */
-declare function nextRevealCount(shown: number, targetLength: number, dtMs: number, opts?: SmoothRevealOptions): number;
-/**
- * Animate `target` text into view. While `enabled`, the returned string grows
- * smoothly toward `target` (which may itself keep growing); when `enabled` is
- * false the full text returns immediately (history, completed turns). A
- * target that is not an extension of the revealed prefix (new message) resets
- * the reveal.
- */
-declare function useSmoothText(target: string, enabled: boolean, opts?: SmoothRevealOptions): string;
-
-type ActivityTone = 'live' | 'ok' | 'error' | 'neutral';
-/** Map a delegation status (free-form string on the wire) to a render tone. */
-declare function activityTone(status: string): ActivityTone;
-/** "$0.4000" under a cent shows 4 decimals; null when unknown/zero. */
-declare function formatActivityCost(costUsd?: number): string | null;
-/** "8s" / "2m 05s" / "1h 12m"; null when unknown. */
-declare function formatActivityDuration(durationMs?: number): string | null;
-/** A delegation record on the cross-context surface; `missionRef` links a
- *  promoted delegation back to the mission/step that spawned it. */
-interface AgentActivityRecord extends StepAgentActivity {
-    missionRef?: {
-        missionId: string;
-        stepId?: string;
-        label?: string;
-    };
-}
-interface AgentActivityPage {
-    items: AgentActivityRecord[];
-    /** Opaque continuation token; absent ⇒ no further pages. */
-    nextCursor?: string;
-}
-/**
- * Fold a fetched page into the held rows: dedupe by `taskId` with the
- * incoming row winning (a refresh re-fetches the head page, so newer
- * snapshots of in-flight runs replace stale ones), newest `startedAt` first.
- */
-declare function mergeActivityPages(existing: AgentActivityRecord[], incoming: AgentActivityRecord[]): AgentActivityRecord[];
-interface WaterfallRow {
-    name: string;
-    kind: 'pipeline' | 'model' | 'tool';
-    /** Bar geometry as percentages of the trace's total span. */
-    offsetPct: number;
-    widthPct: number;
-    durationLabel: string;
-    approx: boolean;
-    /** False only when the span's meta carries an explicit failure. */
-    ok: boolean;
-}
-/** Project a FlowTrace into proportional bar geometry for {@link FlowWaterfall}. */
-declare function waterfallLayout(trace: FlowTrace): WaterfallRow[];
-interface FlowWaterfallProps {
-    trace: FlowTrace;
-}
-/** Compact proportional waterfall over a FlowTrace — span name, bar, duration
- *  per row; total + cost in the footer. */
-declare function FlowWaterfall({ trace }: FlowWaterfallProps): react.JSX.Element | null;
-interface MissionActivityLaneProps {
-    /** The step's delegated-run snapshot (`MissionStepState.agentActivity`). */
-    activity: StepAgentActivity[];
-    /** Epoch ms origin for the expanded waterfall — usually the step start. */
-    startedAt?: number;
-    /** Wall clock for extending in-flight runs on the waterfall. */
-    nowMs?: number;
-}
-/**
- * Collapsed sub-rows under a mission step — one row per delegated run —
- * expanding to the step's waterfall. Renders nothing for an empty lane.
- *
- * A sub-row appears because a delegated run STARTED or FINISHED, which is the
- * one kind of list change worth choreographing: it arrives, and the group
- * arrives as a sequence. Keying on `taskId` is what keeps the rest still — the
- * snapshot re-renders every poll, and a row whose status merely advanced holds
- * the DOM node it already had.
- */
-declare function MissionActivityLane({ activity, startedAt, nowMs }: MissionActivityLaneProps): react.JSX.Element | null;
-interface AgentActivityPanelProps {
-    /** Data port — page through the product's delegation records. Called with
-     *  no cursor on mount/refresh, with `nextCursor` for older pages. */
-    fetchActivity: (cursor?: string) => Promise<AgentActivityPage>;
-    /** Render the mission link for a promoted delegation (chip, anchor, router
-     *  Link — the product's routing, not ours). */
-    renderMissionRef?: (ref: NonNullable<AgentActivityRecord['missionRef']>, record: AgentActivityRecord) => ReactNode;
-    title?: string;
-    emptyLabel?: string;
-}
-declare function AgentActivityPanel({ fetchActivity, renderMissionRef, title, emptyLabel }: AgentActivityPanelProps): react.JSX.Element;
-
-/** Human label for a queue state. */
-declare function reviewQueueStateLabel(state: ReviewQueueState): string;
-/** Human label for a work-product status. */
-declare function workProductStatusLabel(status: WorkProductStatus): string;
-/** Every persisted work-product anchor on one message, re-validated. */
-declare function workProductPartsFromMessageParts(parts: ReadonlyArray<Record<string, unknown>> | null | undefined): WorkProductPersistedPart[];
-/** Properties for the transcript anchor card rendered in chat */
-interface WorkProductCardProps {
-    part: WorkProductPersistedPart;
-    /** Open the work product (queue detail / pane) — the card's only action. */
-    onOpen?: (part: WorkProductPersistedPart) => void;
-    className?: string;
-}
-/** The chat transcript anchor card for one work-product version — a compact,
- *  system-authored pointer, not a parallel review surface. */
-declare function WorkProductCard({ part, onOpen, className }: WorkProductCardProps): react.JSX.Element;
-/** One fetched page of queue items with an optional continuation cursor */
-interface ReviewQueuePage {
-    items: ReviewQueueItem[];
-    /** Opaque continuation token; absent ⇒ no further pages. */
-    nextCursor?: string;
-}
-/** Properties for the review queue panel over a fetch data port */
-interface ReviewQueuePanelProps {
-    /** Data port — fetch one page of queue items (the projection's output,
-     *  re-validated here at the JSON boundary). */
-    fetchQueue: (cursor?: string) => Promise<ReviewQueuePage>;
-    /** Open one queue item (navigate to its thread / detail pane). */
-    onSelect?: (item: ReviewQueueItem) => void;
-    title?: string;
-    emptyLabel?: string;
-    className?: string;
-}
-/** Merge a fetched page into held rows: dedupe by scopeKey, incoming wins,
- *  newest updatedAt first. Exported for tests. */
-declare function mergeReviewQueuePages(existing: ReviewQueueItem[], incoming: ReviewQueueItem[]): ReviewQueueItem[];
-/** The workspace review queue — cursor-paged, refreshable, selection via
- *  callback. States, counts, and provenance render from the projection; the
- *  panel holds no domain logic. */
-declare function ReviewQueuePanel({ fetchQueue, onSelect, title, emptyLabel, className, }: ReviewQueuePanelProps): react.JSX.Element;
-/** Properties for the evidence lineage table with source click-through */
-interface EvidenceLineageTableProps {
-    evidence: readonly EvidenceEntry[];
-    /** Resolve one entry's source document to an openable URL (signed
-     *  object-store/vault download) — the `resolveFileUrl` pattern. Absent →
-     *  sources render as plain refs without links. */
-    resolveSourceUrl?: (entry: EvidenceEntry) => string;
-    className?: string;
-}
-/** Target → claim → source lineage rows: the "every material value traceable
- *  to source evidence" surface. Each row names the artifact target, the
- *  claim, and the source document location supporting it. */
-declare function EvidenceLineageTable({ evidence, resolveSourceUrl, className }: EvidenceLineageTableProps): react.JSX.Element;
-/** Properties for the severity-badged exception list */
-interface ExceptionListProps {
-    exceptions: readonly ExceptionEntry[];
-    className?: string;
-}
-/** Severity-badged exception rows with resolution state. */
-declare function ExceptionList({ exceptions, className }: ExceptionListProps): react.JSX.Element;
-/** Properties for the pass/fail quality check list */
-interface QualityCheckListProps {
-    checks: readonly QualityCheck[];
-    className?: string;
-}
-/** Pass/fail quality-check rows tagged with their source (agent self-report,
- *  platform gate, judge ensemble). */
-declare function QualityCheckList({ checks, className }: QualityCheckListProps): react.JSX.Element;
-/** Properties for the provenance stamp with the optional backtest slot */
-interface ProvenanceStampProps {
-    provenance: Pick<WorkProductProvenance, 'profileHash' | 'runId' | 'servingModels'> & Partial<Pick<WorkProductProvenance, 'costUsd' | 'producedAt'>>;
-    /** The product-resolved backtest summary for this profile hash. When its
-     *  trust gate failed, the composite renders as "quality: unverified" —
-     *  never a naked number. */
-    backtest?: ProfileBacktestSummary;
-    className?: string;
-}
-/** The audit line a reviewer approves against: which configuration produced
- *  this document, what served it, and how that configuration measured on its
- *  backtest. */
-declare function ProvenanceStamp({ provenance, backtest, className }: ProvenanceStampProps): react.JSX.Element;
-
-/**
- * The pure half of the provenance affordance: what kind of claim a value is,
- * what a reader should DO about it, and what has to be SAID when its origin
- * cannot be shown.
- *
- * Zero React, zero DOM — a loader or a worker can decide a value's standing
- * before it reaches a screen, and `./provenance`'s `ProvenanceValue` renders
- * exactly what these functions decide.
- *
- * The distinction the module exists to hold: a person typing a number, a
- * document carrying it, a formula producing it, and a model claiming it are
- * four different kinds of evidence. Rendered as one grey caption they are
- * indistinguishable, which is how an unverified model assertion reads to a
- * reviewer as a transcribed fact.
- *
- * Every domain word is a caller parameter: no field names, no document kinds,
- * and no confidence policy beyond a default the product overrides.
- */
-/**
- * How a value came to exist. Four kinds, never interchangeable:
- *
- * - `extracted` — read out of a document or message the product can open.
- * - `entered` — a person typed or confirmed it.
- * - `computed` — produced from other values, each carrying its own provenance.
- * - `asserted` — the agent stated it, with nothing outside the model behind it.
- */
-type ProvenanceBasis = 'extracted' | 'entered' | 'computed' | 'asserted';
-/** Every basis, in the order a legend should list them. */
-declare const PROVENANCE_BASES: readonly ProvenanceBasis[];
-/** The words one basis is rendered and announced with. */
-interface ProvenanceBasisMeta {
-    /** Marker text next to the value — short, and never only a colour. */
-    label: string;
-    /** One plain sentence naming what kind of claim this is. */
-    meaning: string;
-    /** What a reader can hold the value against, or `null` when nothing outside
-     *  the model can. `null` is what makes an `asserted` value uncertifiable at
-     *  any confidence. */
-    checkableAgainst: string | null;
-}
-/** Words for one basis. */
-declare function provenanceBasisMeta(basis: ProvenanceBasis): ProvenanceBasisMeta;
-/** Whether a source could be resolved. `ready` is the default for a source that
- *  says nothing. */
-type ProvenanceSourceStatus = 'ready' | 'loading' | 'unavailable';
-/** One thing a value came from. A `label` is mandatory because an unnamed
- *  source is the same as no source. */
-interface ProvenanceSource {
-    /** What the source IS, in the reader's words: "Form W-2 (Acme Corp)",
-     *  "Dana Whitfield", "Engagement letter". */
-    label: string;
-    /** The text in the source that carries the value. */
-    quote?: string;
-    /** Position inside the source — a page, a line, a span, a timestamp. The
-     *  caller's words; nothing here parses it. */
-    locator?: string;
-    /** Click-through target. Absent → the source is named but not openable. */
-    href?: string;
-    /** Defaults to `ready`. */
-    status?: ProvenanceSourceStatus;
-    /** Why an `unavailable` source cannot be opened, in one sentence. */
-    unavailableReason?: string;
-}
-/**
- * What the reader should DO about a value — the only form confidence takes on
- * screen. "89% confidence" names no next move; these three do.
- *
- * - `settled` — nothing to do.
- * - `check` — open the source and confirm before relying on it.
- * - `confirm` — a person has to confirm the value before it is used.
- */
-type ProvenanceStanding = 'settled' | 'check' | 'confirm';
-/** The words one standing is rendered and announced with. */
-interface ProvenanceStandingMeta {
-    /** Short state label. */
-    label: string;
-    /** The next move, as a sentence a person can follow. */
-    action: string;
-}
-/** Words for one standing. */
-declare function provenanceStandingMeta(standing: ProvenanceStanding): ProvenanceStandingMeta;
-/** The weaker of two standings — `confirm` beats `check` beats `settled`. */
-declare function weakerProvenanceStanding(a: ProvenanceStanding, b: ProvenanceStanding): ProvenanceStanding;
-/**
- * Where a product draws its confidence lines. These are a POLICY, not a truth:
- * a number a model reports about itself means different things per surface, so
- * the thresholds are a parameter and the number itself never reaches the screen.
- */
-interface ProvenanceConfidencePolicy {
-    /** At or above this, a value is `settled`. */
-    settledAtOrAbove: number;
-    /** At or above this (and below `settledAtOrAbove`), a value is `check`.
-     *  Below it, `confirm`. */
-    checkAtOrAbove: number;
-}
-/** The starting policy. Products with a different tolerance pass their own. */
-declare const DEFAULT_PROVENANCE_CONFIDENCE_POLICY: ProvenanceConfidencePolicy;
-/** A value, where it came from, and — when it was computed — the provenanced
- *  values it came from. The `inputs` field is what makes the shape compose:
- *  a computed value's provenance IS its inputs. */
-interface ProvenanceRecord {
-    /** The value as the reader should see it, already formatted. An empty string
-     *  is a missing value and renders as one, never as blank space. */
-    display: string;
-    /** What the value IS ("Wages", "Filing deadline"). Optional at the top level,
-     *  where the surface around it usually says; rendered for every composed
-     *  input, where nothing else names them. */
-    label?: string;
-    basis: ProvenanceBasis;
-    /** Where it came from. An `extracted` value without one is a gap, not a
-     *  detail. */
-    sources?: readonly ProvenanceSource[];
-    /** The provenanced values a `computed` value was produced from. */
-    inputs?: readonly ProvenanceRecord[];
-    /** How the inputs combine, in the caller's words ("wages + interest"). */
-    derivation?: string;
-    /** 0–1. Never rendered as a number — it selects a standing. */
-    confidence?: number;
-    /** Overrides the standing confidence and basis would produce — a reviewer
-     *  approved it, a gate failed. It can only make a value WEAKER: the
-     *  structural floors below still apply, so a product cannot mark a value
-     *  settled that has no origin on file. */
-    standing?: ProvenanceStanding;
-}
-/** The standing a bare confidence maps to under a policy. */
-declare function standingFromConfidence(confidence: number, policy?: ProvenanceConfidencePolicy): ProvenanceStanding;
-/** Something missing that the reader has to be TOLD about, because the value
- *  renders either way and a bare number reads as a fact. */
-type ProvenanceGapKind = 'no-source' | 'no-inputs' | 'unavailable-source';
-/** One stated gap. `message` is rendered verbatim. */
-interface ProvenanceGap {
-    kind: ProvenanceGapKind;
-    message: string;
-    /** The source that could not be resolved (`unavailable-source` only). */
-    source?: ProvenanceSource;
-}
-/** The sentence for a source that is not `ready`, or `null` when it is. One
- *  source of this copy, so the row and the gap list never disagree. */
-declare function describeProvenanceSourceStatus(source: ProvenanceSource): string | null;
-/**
- * What this record cannot show, at its own level. Inputs are not walked: every
- * composed input renders its own gaps next to its own value, where a reader can
- * act on them.
- */
-declare function provenanceGaps(record: ProvenanceRecord): ProvenanceGap[];
-/** The sources still resolving — rendered as their own state, never as an
- *  absence. A load in flight is not a missing source. */
-declare function loadingProvenanceSources(record: ProvenanceRecord): ProvenanceSource[];
 /**
- * This record's own standing, ignoring its inputs.
- *
- * The order is: start from the explicit standing, else from confidence, else
- * from the basis — then apply every structural floor, taking the WEAKEST. The
- * floors are what a caller cannot talk its way out of:
- *
- * - an `asserted` value never reaches `settled` (a model's own confidence
- *   cannot certify the model's claim — there is nothing to check it against),
- * - a `no-source` / `no-inputs` gap forces `confirm` (a value dressed as
- *   evidence with no evidence behind it is worse than an open guess),
- * - an unopenable source forces `check` (the value may be right; the reader
- *   just cannot confirm it).
- */
-declare function resolveProvenanceStanding(record: ProvenanceRecord, policy?: ProvenanceConfidencePolicy): ProvenanceStanding;
-/**
- * The standing a reader should see: this record's own, weakened by every value
- * it was computed from, however deep.
- *
- * A total is only as trustworthy as the weakest number in it. Rendering the
- * parent's own standing instead is how an exact sum of one document figure and
- * one model guess presents as traced.
- *
- * Cycle-safe: a record reachable from itself is counted once.
- */
-declare function rollUpProvenanceStanding(record: ProvenanceRecord, policy?: ProvenanceConfidencePolicy, seen?: Set<ProvenanceRecord>): ProvenanceStanding;
-/**
- * One plain sentence naming where the value came from — the panel's first line
- * and part of what a screen reader announces. It states the absence when there
- * is one, so no code path produces silence.
- */
-declare function describeProvenance(record: ProvenanceRecord): string;
-/**
- * The move THIS value's reader can actually make.
- *
- * `provenanceStandingMeta().action` is the generic sentence for a standing;
- * this is the one that accounts for what is on file. "Open the source and
- * confirm it" is a dead instruction on a value that has no source — an action
- * a reader cannot perform is the same defect as no action at all.
- */
-declare function provenanceNextMove(record: ProvenanceRecord, standing: ProvenanceStanding, policy?: ProvenanceConfidencePolicy): string;
-/**
- * The accessible name of the disclosure control: the value, how it came to
- * exist, and — unless there is nothing to do — the next move. This is the
- * whole affordance for someone who never sees the colour.
- */
-declare function provenanceTriggerLabel(record: ProvenanceRecord, standing: ProvenanceStanding): string;
-
-/** Properties for one provenanced value and its disclosure. */
-interface ProvenanceValueProps {
-    /** The value and where it came from. */
-    record: ProvenanceRecord;
-    /**
-     * Open one source in the product's own way (a document pane at the right
-     * page, a drawer, a route). Takes precedence over `href` when both are
-     * present, because a product that routes wants its router — a source with
-     * neither is named but not openable, which is a legitimate state and is
-     * rendered as such.
-     */
-    onOpenSource?: (source: ProvenanceSource, record: ProvenanceRecord) => void;
-    /** Retry resolving an `unavailable` source. Absent → the failure is stated
-     *  without a retry control, never swallowed. */
-    onRetrySource?: (source: ProvenanceSource, record: ProvenanceRecord) => void;
-    /** Where this product draws its confidence lines. */
-    confidencePolicy?: ProvenanceConfidencePolicy;
-    /**
-     * How many levels of composed inputs stay expandable. Past it an input still
-     * renders its value, its basis and its origin sentence — it just stops
-     * carrying its own disclosure, so a deep tree cannot run away and a record
-     * that reaches itself cannot recurse forever. Default 2.
-     */
-    maxDepth?: number;
-    /** Open the disclosure on first render — for a review surface where the
-     *  trail is the point. Several of these coexist: only a reader opening a
-     *  trail closes another one. */
-    defaultOpen?: boolean;
-    /** What an empty `display` renders as. A blank cell is the defect this
-     *  component exists to remove. */
-    missingValueLabel?: string;
-    className?: string;
-}
-/**
- * A value, its origin marker, and the disclosure that shows where it came
- * from. The marker states the basis in words and, whenever there is something
- * to do about the value, the next move — so the standing is legible at rest
- * and does not depend on anyone opening the panel.
- */
-declare function ProvenanceValue({ record, onOpenSource, onRetrySource, confidencePolicy, maxDepth, defaultOpen, missingValueLabel, className, }: ProvenanceValueProps): react.JSX.Element;
-/** Properties for the basis legend. */
-interface ProvenanceLegendProps {
-    /** Only the bases present on screen. Passing all four when only two appear
-     *  teaches distinctions the reader cannot use. */
-    bases: readonly ProvenanceBasis[];
-    className?: string;
-}
-/** The marker key for a surface that renders several bases at once — a review
- *  pane, a grid, a return. Each row is the same glyph, tone and words the
- *  markers use, plus what the basis MEANS. */
-declare function ProvenanceLegend({ bases, className }: ProvenanceLegendProps): react.JSX.Element | null;
-
-/**
- * `SeatPaywall` — the shared "unlock this product" screen every agent app
- * shows when a user has no active seat and has spent past the free tier.
- *
- * Copy contract (design §6.8): the included monthly AI usage is framed as a
- * BENEFIT the buyer receives — never the ratio, never the word "margin", never
- * "we debit 50%". Surface the allowance, hide the economics.
- *
- * Styling contract matches the rest of `web-react`: Tailwind classes over the
- * shared design tokens (`bg-card`, `border-border`, `text-muted-foreground`,
- * `bg-primary`, …); glyphs are inline SVGs; no icon or UI library.
- */
-
-interface SeatPaywallProps {
-    /** Human product name shown in the headline, e.g. "Creative". */
-    product: string;
-    /** Fired when the user clicks the unlock CTA — route them to checkout. When
-     *  it returns a promise the button shows a pending state and ignores repeat
-     *  clicks until it settles (no double-charge on a slow checkout open). */
-    onCheckout: () => void | Promise<void>;
-    /** Monthly seat price in whole dollars. Default 100. */
-    priceUsd?: number;
-    /** Included monthly AI usage in whole dollars. Default 50. */
-    includedUsageUsd?: number;
-    /** Platform catalog terms. When present, these override the legacy dollar
-     * props and show any introductory period without product-local price copy. */
-    offer?: ProductSeatOffer;
-    /** Optional one-line value prop under the headline. */
-    tagline?: string;
-    /** CTA label. Default "Continue to checkout". */
-    ctaLabel?: string;
-    /** Value-prop bullets. Default = product/usage-derived only; pass your own to
-     *  supply product-specific value props (the shell bakes no GTM copy). */
-    benefits?: ReactNode[];
-    /** Optional fine print under the CTA (e.g. "Cancel anytime."). Omitted by default. */
-    footnote?: ReactNode;
-}
-/**
- * Centered card paywall. The price line reads
- * "$100/mo · includes $50/mo of AI usage" so the included allowance anchors the
- * value without ever exposing the ratio — and says it ONCE: the default
- * benefits don't restate the usage line the subline already carries, and the
- * CTA is the next step ("Continue to checkout"), not a third repeat of the
- * eyebrow + headline's "Unlock {product}".
- */
-declare function SeatPaywall({ product, onCheckout, priceUsd, includedUsageUsd, offer, tagline, ctaLabel, benefits, footnote, }: SeatPaywallProps): ReactNode;
-
-interface UseInfiniteScrollOptions {
-    /** Only fire `onLoadMore` while true (a next page exists, none in flight). */
-    enabled: boolean;
-    /** Scroll container the sentinel lives in. Defaults to the viewport. */
-    root?: RefObject<HTMLElement | null>;
-    /** Prefetch distance before the sentinel is actually reached. */
-    rootMargin?: string;
-}
-/**
- * Fires `onLoadMore` when a sentinel element scrolls into view. Returns a ref
- * callback for that sentinel (typically the last element in a list).
- *
- * The observer is re-created whenever `enabled` flips, so a short first page
- * that leaves the sentinel on-screen keeps loading: when a load finishes and
- * `enabled` returns to true, the fresh observer re-reads the current
- * intersection state and fires again until the sentinel is pushed off-screen.
- */
-declare function useInfiniteScroll(onLoadMore: () => void, { enabled, root, rootMargin }: UseInfiniteScrollOptions): (node: HTMLElement | null) => void;
-interface SessionPageQuery {
-    /** Trimmed search term; empty string means no filter. */
-    q: string;
-    sort: SessionSort;
-    /** `null` for the first page. */
-    cursor: string | null;
-    /** Aborted when the view changes or the component unmounts. */
-    signal: AbortSignal;
-}
-/** Data port — one page of sessions for the current view. */
-type FetchSessionPage = (query: SessionPageQuery) => Promise<SessionPage>;
-interface UseSessionHistoryOptions {
-    fetchPage: FetchSessionPage;
-    /** Trimmed search term driving the fetch. */
-    q: string;
-    sort: SessionSort;
-    /** SSR page 1 of the default view, so the first paint costs no request. */
-    initialPage: SessionPage;
-    /** The sort `initialPage` was rendered for. Default `'newest'`. */
-    defaultSort?: SessionSort;
-}
-interface SessionHistoryState {
-    items: SessionSummary[];
-    hasMore: boolean;
-    isLoadingFirst: boolean;
-    isLoadingMore: boolean;
-    isError: boolean;
-    loadMore: () => void;
-    /** Re-run whichever load failed. */
-    retry: () => void;
-    /** Refetch page 1 — call after a client-side mutation (e.g. a delete). */
-    reload: () => void;
-}
-/**
- * Infinite-scroll data source for the history view. Seeds from `initialPage`
- * for the default view (no fetch) and otherwise fetches page 1 for the current
- * search/sort; `loadMore` appends the next cursor page.
- *
- * Raw promises + `AbortController` rather than a router fetcher, so a filter
- * change cancels in-flight requests, pages accumulate, and a late response from
- * a superseded view is dropped by the monotonic `seq` guard.
- */
-declare function useSessionHistory({ fetchPage, q, sort, initialPage, defaultSort, }: UseSessionHistoryOptions): SessionHistoryState;
-interface SessionActionsOptions {
-    /** Persist a new title. Reject to surface the error in the dialog. */
-    renameSession: (sessionId: string, title: string) => Promise<void>;
-    deleteSession: (sessionId: string) => Promise<void>;
-    /** Called after a successful rename/delete — revalidate the rail here. */
-    onChanged?: () => void;
-    /** Called after deleting the session the user is currently viewing, so the
-     *  product can navigate away from a route that no longer resolves. */
-    onDeletedCurrent?: () => void;
-    /** The open session, compared against the delete target. */
-    currentSessionId?: string | null;
-    /** Product toast/log seam. Errors also render inside the dialog. */
-    notify?: (level: 'success' | 'error', message: string) => void;
-    labels?: Partial<SessionActionLabels>;
-}
-interface SessionActionLabels {
-    renameTitle: string;
-    renameField: string;
-    renameSubmit: string;
-    deleteTitle: string;
-    deleteBody: (title: string) => string;
-    deleteSubmit: string;
-    cancel: string;
-    renamed: string;
-    deleted: string;
-    renameFailed: string;
-    deleteFailed: string;
-}
-interface SessionActions {
-    openRename: (session: SessionSummary) => void;
-    openDelete: (session: SessionSummary) => void;
-    /** Render once, anywhere that survives navigation (the layout). */
-    dialogs: ReactNode;
-    busy: boolean;
-}
-/**
- * Rename + delete for one session, shared by the rail kebab and the history
- * row menu so both drive the same dialogs and the same product mutations.
- *
- * Dialogs are owned here rather than returned as raw state: two surfaces
- * needing the same confirm step is exactly how a product ends up with two
- * subtly different delete confirmations.
- */
-declare function useSessionActions({ renameSession, deleteSession, onChanged, onDeletedCurrent, currentSessionId, notify, labels, }: SessionActionsOptions): SessionActions;
-interface SessionHistoryPanelProps {
-    history: SessionHistoryState;
-    /** Whether the workspace has any sessions at all — decided by the SSR page,
-     *  independent of the active search, so filtering to zero shows "no matches"
-     *  rather than the first-run empty state. */
-    hasAnySessions: boolean;
-    query: string;
-    onQueryChange: (value: string) => void;
-    sort: SessionSort;
-    onSortChange: (value: SessionSort) => void;
-    /** Product route for one session row. */
-    hrefForSession: (sessionId: string) => string;
-    /** Rendered as the row link. Defaults to an `<a>`; pass a router Link to keep
-     *  client-side navigation. */
-    linkComponent?: LinkLikeComponent;
-    /** Ids currently mid-turn — renders the responding treatment. */
-    respondingSessionIds?: ReadonlySet<string>;
-    onRename?: (session: SessionSummary) => void;
-    onDelete?: (session: SessionSummary) => void;
-    /** Product-owned mutation for selected rows or a workspace-wide age range. */
-    onBulkAction?: (action: SessionBulkAction) => Promise<void>;
-    /** Menu wording, so this surface and the rail name the same act the same way
-     *  — a product whose delete is really an archive says so in both places. */
-    renameLabel?: string;
-    deleteLabel?: string;
-    /**
-     * Row actions this shell has no opinion about — pin, categorise, share.
-     * Same seam and same ordering as the rail's `SessionRowActions.extraActions`:
-     * evaluated per session, placed between rename and delete. This menu is
-     * text-only, so `icon` is ignored here and honoured on the rail.
-     */
-    extraActions?: (session: SessionSummary) => SessionRailAction[];
-    /** New-session destination for the header action. Omitted ⇒ no button. */
-    newSessionHref?: string;
-    title?: string;
-    untitledLabel?: string;
-    emptyTitle?: string;
-    emptyDescription?: string;
-    /** Absolute → relative timestamp. Defaults to a compact built-in. */
-    formatTimestamp?: (isoDate: string | null) => string;
-    /** Max width of the reading column. `'full'` opts out for a product whose
-     *  surface really is a wide table. Default keeps title and timestamp inside
-     *  one scannable line rather than at opposite edges of a 1440px viewport. */
-    contentWidth?: 'reading' | 'full';
-    className?: string;
-}
-type SessionBulkAction = {
-    kind: 'selected';
-    ids: string[];
-} | {
-    kind: 'older-than';
-    days: number;
-} | {
-    kind: 'newer-than';
-    days: number;
-};
-interface LinkLikeProps {
-    to: string;
-    className?: string;
-    children?: ReactNode;
-}
-type LinkLikeComponent = (props: LinkLikeProps) => ReactNode;
-/** Compact relative time. Overridable — a product with its own i18n passes
- *  `formatTimestamp` rather than this being the only option. */
-declare function formatSessionTimestamp(isoDate: string | null): string;
-/**
- * The full session history: search, sort, cursor-paged rows with per-row
- * actions, and the states in between (first-run empty, loading, no matches,
- * error + retry).
- *
- * This is the surface the rail's capped list overflows into — the reason the
- * rail can stay short without hiding the user's work.
- */
-declare function SessionHistoryPanel({ history, hasAnySessions, query, onQueryChange, sort, onSortChange, hrefForSession, linkComponent: Link, respondingSessionIds, onRename, onDelete, onBulkAction, renameLabel, deleteLabel, extraActions, newSessionHref, title, untitledLabel, emptyTitle, emptyDescription, formatTimestamp, contentWidth, className, }: SessionHistoryPanelProps): react.JSX.Element;
-
-/**
- * The pure half of the editable record grid: the typed column vocabulary, the
- * per-cell parse/validate rules, display + editor formatting, and the
- * optimistic overlay a caller's rows are projected through.
- *
- * Zero React, zero DOM — a product can validate a row on a worker before it
- * ever reaches storage, and the component in `./record-grid` renders exactly
- * what these functions decide.
- *
- * Every domain word is a caller parameter: the module knows no column names,
- * no currencies, no option sets. What it owns is the mechanism four verticals
- * each re-derived — typed cells, an error a person can act on, and an
- * optimistic edit that can be taken back.
- */
-
-/** The value one cell can hold. `null` is "no value on file". */
-type RecordGridValue = string | number | boolean | null;
-/** Typed outcome for one cell. Callers MUST inspect `succeeded` before reading
- *  `value`; nothing here throws. */
-type RecordGridCellOutcome = {
-    succeeded: true;
-    value: RecordGridValue;
-} | {
-    succeeded: false;
-    error: string;
-};
-/** Typed outcome for a whole row of inputs (the add form). `cellErrors` is
- *  keyed by column id so each control can render its own message. */
-type RecordGridRowOutcome = {
-    succeeded: true;
-    value: Record<string, RecordGridValue>;
-} | {
-    succeeded: false;
-    error: string;
-    cellErrors: Readonly<Record<string, string>>;
-};
-/** Build a cell success outcome. */
-declare function recordGridOk(value: RecordGridValue): RecordGridCellOutcome;
-/** Build a cell failure outcome carrying the message shown next to the cell. */
-declare function recordGridFail(error: string): RecordGridCellOutcome;
-/**
- * How a value came to sit in a cell. Rendered as the provenance tone.
- *
- * A type alias of `./provenance-model`'s `ProvenanceBasis`, not a lookalike:
- * two vocabularies for the same concept — a grid cell's origin — shipped one
- * day apart and would have drifted the moment either one added a value. The
- * grid gains `asserted` for free (a cell an agent claimed with nothing behind
- * it), where the caller previously had no way to say that.
- */
-type RecordGridSourceBasis = ProvenanceBasis;
-/**
- * Where one cell's value came from. Optional on every row — a grid over data
- * with no lineage renders identically without it.
- */
-interface RecordGridCellSource {
-    /** The text in the source that supports this value. */
-    quote?: string;
-    /** Human name of the source document, message, or system. */
-    label?: string;
-    /** Click-through to the source. */
-    href?: string;
-    /** Position inside the source: a page, a line, a span — the caller's words. */
-    locator?: string;
-    /** How the value got here. Absent renders as `asserted` — the weakest claim
-     *  in the union — because a caller that stated no basis has established
-     *  nothing about a document, and an omission must never read as one. */
-    basis?: RecordGridSourceBasis;
-}
-/** One option of a `select` column. */
-interface RecordGridSelectOption {
-    value: string;
-    label: string;
-}
-/** A cell is only editable, rendered, and validated when the column it depends
- *  on holds `equals`. This is how a nested sub-form (a vesting schedule behind
- *  a "has vesting" toggle) stays a set of flat, individually-typed columns. */
-interface RecordGridDependency {
-    column: string;
-    equals: RecordGridValue;
-}
-/** Fields every column kind carries. */
-interface RecordGridColumnBase {
-    /** Key into a row's `values` bag. */
-    id: string;
-    /** Column heading, and the accessible name of every control in the column. */
-    header: string;
-    /** Short hint rendered under the control in the add form. */
-    hint?: string;
-    /** An empty cell is rejected. */
-    required?: boolean;
-    /** Cells are editable unless this is `false`. */
-    editable?: boolean;
-    /** Cell alignment. Numeric kinds default to `right`. */
-    align?: 'left' | 'right';
-    /** Groups this column under a labelled sub-form in the add form. */
-    group?: string;
-    /** Only applicable when another column holds a given value. */
-    dependsOn?: RecordGridDependency;
-    /** Extra rule, run after the kind's own checks pass. Return the message to
-     *  reject with, or `null` to accept. */
-    validate?: (value: RecordGridValue) => string | null;
-    /** Column summary rendered in the footer row. */
-    footerValue?: (rows: readonly RecordGridRow[]) => RecordGridValue;
-}
-/** Free text, optionally length- or pattern-constrained. */
-interface RecordGridTextColumn extends RecordGridColumnBase {
-    kind: 'text';
-    minLength?: number;
-    maxLength?: number;
-    pattern?: RegExp;
-    /** Message when `pattern` rejects. Without it the pattern source is shown. */
-    patternMessage?: string;
-    /** Render a textarea instead of a single-line input. */
-    multiline?: boolean;
-}
-/** A plain number. */
-interface RecordGridNumberColumn extends RecordGridColumnBase {
-    kind: 'number';
-    min?: number;
-    max?: number;
-    integer?: boolean;
-    /** Passed through to the editor's `step`. */
-    step?: number;
-}
-/** A money amount. The currency is a caller parameter — this module bakes no
- *  domain value, so a product with two currencies declares two columns. */
-interface RecordGridCurrencyColumn extends RecordGridColumnBase {
-    kind: 'currency';
-    /** ISO 4217 code, e.g. `USD`. */
-    currency: string;
-    min?: number;
-    max?: number;
-    /** Fraction digits for display. Defaults to the currency's own. */
-    fractionDigits?: number;
-}
-/** A calendar date held as `YYYY-MM-DD`; no time, no zone. */
-interface RecordGridDateColumn extends RecordGridColumnBase {
-    kind: 'date';
-    /** Earliest accepted date, `YYYY-MM-DD`. */
-    min?: string;
-    /** Latest accepted date, `YYYY-MM-DD`. */
-    max?: string;
-}
-/** One of a closed set of values. */
-interface RecordGridSelectColumn extends RecordGridColumnBase {
-    kind: 'select';
-    options: readonly RecordGridSelectOption[];
-}
-/** A checkbox. */
-interface RecordGridBooleanColumn extends RecordGridColumnBase {
-    kind: 'boolean';
-    /** Label for `true`. Defaults to `Yes`. */
-    trueLabel?: string;
-    /** Label for `false`. Defaults to `No`. */
-    falseLabel?: string;
-}
-/** Every column shape the grid renders. */
-type RecordGridColumn = RecordGridTextColumn | RecordGridNumberColumn | RecordGridCurrencyColumn | RecordGridDateColumn | RecordGridSelectColumn | RecordGridBooleanColumn;
-/** One row: an id, a flat value bag keyed by column id, and optional per-cell
- *  provenance. A record-backed product maps its fold output straight onto
- *  this — one entry per cell, its quote and link in `sources`. */
-interface RecordGridRow {
-    id: string;
-    values: Readonly<Record<string, RecordGridValue>>;
-    /** Per-cell provenance, keyed by column id. */
-    sources?: Readonly<Record<string, RecordGridCellSource>>;
-    /** No cell in this row may be edited or deleted. */
-    readOnly?: boolean;
-    /** Accessible name for the row's own controls. Falls back to the first text
-     *  or select column's value, then the row id. */
-    label?: string;
-}
-/** True when the column's dependency (if any) is satisfied by the row's other
- *  values. An inapplicable cell is never required, never validated, and never
- *  editable. */
-declare function isRecordGridCellApplicable(column: RecordGridColumn, values: Readonly<Record<string, RecordGridValue>>): boolean;
-/** Value equality across the grid's value union, treating `undefined` as
- *  `null` so an absent key and an explicit null never read as a change. */
-declare function sameRecordGridValue(a: RecordGridValue | undefined, b: RecordGridValue | undefined): boolean;
-/**
- * Turn what an editor control produced into a typed value. Syntax only —
- * range, length, and membership are {@link validateRecordGridCell}'s job.
- */
-declare function parseRecordGridInput(column: RecordGridColumn, raw: string): RecordGridCellOutcome;
-/**
- * Check one already-typed value against its column. Returns the value the grid
- * should store (empty text normalizes to `null`) or the message a person can
- * act on.
- */
-declare function validateRecordGridCell(column: RecordGridColumn, value: RecordGridValue): RecordGridCellOutcome;
-/** Parse editor text and validate it in one step — what a committing cell
- *  editor calls. */
-declare function readRecordGridCell(column: RecordGridColumn, raw: string): RecordGridCellOutcome;
-/**
- * Validate a whole value bag against the columns. Inapplicable cells (an
- * unsatisfied `dependsOn`) are forced to `null` rather than carried, so a
- * sub-form the user turned off cannot smuggle stale values into a write.
- */
-declare function validateRecordGridRow(columns: readonly RecordGridColumn[], values: Readonly<Record<string, RecordGridValue>>): RecordGridRowOutcome;
-/** Display text for a cell. `null` renders as the empty string; the component
- *  decides what a missing value looks like. */
-declare function formatRecordGridValue(column: RecordGridColumn, value: RecordGridValue, locale?: string): string;
-/** The text an editor control starts with — the raw value, never the formatted
- *  one, so committing an untouched cell is a no-op. */
-declare function recordGridEditorText(column: RecordGridColumn, value: RecordGridValue): string;
-/** Accessible name for a row's own controls. */
-declare function recordGridRowLabel(columns: readonly RecordGridColumn[], row: RecordGridRow): string;
-/** Sum a numeric column over the rows that hold a number. Rows with no value
- *  are absent from the sum, not zero — a total over three of five filled cells
- *  is the total of what is on file. */
-declare function sumRecordGridColumn(rows: readonly RecordGridRow[], columnId: string): number;
-/**
- * Edits the grid has applied locally but the caller's `rows` prop has not yet
- * caught up with. Every field is what rollback removes: drop the entry and the
- * caller's own data shows through again.
- */
-interface RecordGridOverlay {
-    /** rowId → columnId → optimistic value. */
-    updates: Readonly<Record<string, Readonly<Record<string, RecordGridValue>>>>;
-    /** Rows created locally, in insertion order. */
-    created: readonly RecordGridRow[];
-    /** Row ids removed locally. */
-    removed: readonly string[];
-}
-/** An overlay holding nothing. */
-declare const EMPTY_RECORD_GRID_OVERLAY: RecordGridOverlay;
-/** The rows to render: caller rows minus local deletes, with local cell edits
- *  applied, then locally-created rows. */
-declare function projectRecordGridRows(rows: readonly RecordGridRow[], overlay: RecordGridOverlay): RecordGridRow[];
-/** Record one optimistic cell edit. */
-declare function withRecordGridUpdate(overlay: RecordGridOverlay, rowId: string, columnId: string, value: RecordGridValue): RecordGridOverlay;
-/** Take back one optimistic cell edit — the rollback path. */
-declare function withoutRecordGridUpdate(overlay: RecordGridOverlay, rowId: string, columnId: string): RecordGridOverlay;
-/** Adopt a row the writer returned as canonical: for a locally-created row it
- *  replaces the draft; for an existing row it replaces the optimistic cells.
- *  Either way the draft's pending cell edits go with it — the canonical row IS
- *  the answer, and leaving an edit layered over it is how a grid keeps showing
- *  a value the server normalized away. */
-declare function withRecordGridServerRow(overlay: RecordGridOverlay, draftId: string, row: RecordGridRow): RecordGridOverlay;
-/** Record an optimistic create. */
-declare function withRecordGridCreated(overlay: RecordGridOverlay, row: RecordGridRow): RecordGridOverlay;
-/** Take back an optimistic create — the rollback path. Cell edits made against
- *  the draft go with it; the row they applied to no longer exists anywhere. */
-declare function withoutRecordGridCreated(overlay: RecordGridOverlay, rowId: string): RecordGridOverlay;
-/** Record an optimistic delete. */
-declare function withRecordGridRemoved(overlay: RecordGridOverlay, rowId: string): RecordGridOverlay;
-/** Take back an optimistic delete — the rollback path. */
-declare function withoutRecordGridRemoved(overlay: RecordGridOverlay, rowId: string): RecordGridOverlay;
-/**
- * Drop the overlay entries the caller's own rows have caught up with: a cell
- * whose value now matches, a created row now present, a removed row now gone.
- * Without this an overlay would mask every later refresh of the same cell.
- *
- * Returns the SAME overlay object when nothing settled, so a caller can prune
- * on every render without looping.
- */
-declare function pruneRecordGridOverlay(rows: readonly RecordGridRow[], overlay: RecordGridOverlay): RecordGridOverlay;
-
-/** One committed cell edit, handed to `onUpdate`. */
-interface RecordGridCellChange {
-    /** The row as it was BEFORE the edit — what rollback restores. */
-    row: RecordGridRow;
-    columnId: string;
-    value: RecordGridValue;
-    /** The full value bag after the edit: what a whole-row write would send. */
-    values: Readonly<Record<string, RecordGridValue>>;
-}
-/** Outcome of an update or a delete. `value` optionally carries the server's
- *  canonical row, which replaces the optimistic one. */
-type RecordGridWriteOutcome = {
-    succeeded: true;
-    value?: RecordGridRow;
-} | {
-    succeeded: false;
-    error: string;
-};
-/** Outcome of a create. The row is REQUIRED on success: a create that does not
- *  name the row it wrote leaves the grid unable to address it. */
-type RecordGridCreateOutcome = {
-    succeeded: true;
-    value: RecordGridRow;
-} | {
-    succeeded: false;
-    error: string;
-};
-/** Properties for the editable, provenance-aware record grid. */
-interface RecordGridProps {
-    /** Column definitions, in render order. */
-    columns: readonly RecordGridColumn[];
-    /** Fetch state over the caller's rows — `web-react/async`'s
-     *  `AsyncResourceState`, the same three-state contract every other screen
-     *  in the shell fetches through. `ready`/`empty`'s value is the base rows;
-     *  optimistic edits are layered over it and dropped as a later value
-     *  catches up. `error` always carries `retry` — there is no way to render a
-     *  failed fetch with no recovery action, by construction. */
-    state: AsyncResourceState<readonly RecordGridRow[]>;
-    /** Accessible name for the grid. Required — an unnamed grid is unusable with
-     *  a screen reader. */
-    caption: string;
-    /** What the empty state says, and what it offers next — `web-react/async`'s
-     *  `AsyncEmptySpec`, so an empty grid reads in the same words as an empty
-     *  list or panel elsewhere in the product. */
-    empty: AsyncEmptySpec;
-    /** Persist one created row. Absent → no add affordance. */
-    onCreate?: (values: Readonly<Record<string, RecordGridValue>>) => Promise<RecordGridCreateOutcome>;
-    /** Persist one cell edit. Absent → every cell renders read-only. */
-    onUpdate?: (change: RecordGridCellChange) => Promise<RecordGridWriteOutcome>;
-    /** Delete one row. Absent → no delete affordance. */
-    onDelete?: (row: RecordGridRow) => Promise<RecordGridWriteOutcome>;
-    /** Starting values for the add form. */
-    newRowDefaults?: Readonly<Record<string, RecordGridValue>>;
-    /** Label of the add control and of the add form. Defaults to `Add row`. */
-    addLabel?: string;
-    /** BCP-47 locale for number, currency, and date display. */
-    locale?: string;
-    /** Rendered above the grid — filters, counts, a product action row. */
-    toolbar?: ReactNode;
-    /** Skeleton rows in the loading state. Defaults to 3. */
-    loadingRowCount?: number;
-    className?: string;
-}
-/**
- * The shared editable record table. A row is a flat value bag keyed by column
- * id, so a record store's fold output maps straight on: one cell per entry,
- * its quote and link in `sources`.
- */
-declare function RecordGrid({ columns, caption, state, empty, onCreate, onUpdate, onDelete, newRowDefaults, addLabel, locale, toolbar, loadingRowCount, className, }: RecordGridProps): react.JSX.Element;
-
-/**
- * `Sparkline` — the series behind a number, as inline SVG.
- *
- * `/spend`, `/missions` and the eval lanes all produce a number for today, and
- * every product renders it as text. Text cannot separate "$41, up from $38"
- * from "$41, up from $4" — the same sentence, two different situations — so the
- * reader opens a second surface to find out which one they are in. The series
- * next to the number answers it in one glance.
- *
- * No chart dependency: this subpath is react + `@tangle-network/ui` only, and a
- * polyline is not worth a bundle. What a chart library would give us here is
- * axes, ticks and a tooltip, none of which belong on a 96×24 glyph.
- *
- * The three shapes a hand-rolled sparkline gets wrong, each handled here rather
- * than left to the caller:
- *
- *  - **no readings** renders an explicit empty label, never a line. A line
- *    along the baseline is a claim — "this metric sat at zero" — and a series
- *    nobody has measured yet did not sit anywhere.
- *  - **one reading** renders a point. A line needs two coordinates; drawing one
- *    from a single reading invents the segment before it.
- *  - **equal readings** render flat at MID height. The obvious normalisation
- *    divides by `max - min`, which is `0` for a perfectly stable metric, and
- *    the resulting `NaN` lands in the `points` attribute — SVG drops the whole
- *    polyline, so the metric that never moved is the one that disappears.
- *  - **a missing reading renders as a GAP, and the accessible name says so.**
- *    A `null` from a hole in a series and a `NaN` from a producer's unguarded
- *    division are not smaller series — they are readings nobody has. Deleting
- *    them closed the line straight across the hole and announced a count that
- *    was short by the number deleted: measured on `[1, NaN, 3]`, one continuous
- *    two-point line labelled "2 readings, rising from 1 to 3", with nothing
- *    anywhere saying a reading was unreadable. The card's figure slot already
- *    refuses to let a non-measurement look measured; the series one line below
- *    it holds the same rule. The x axis is the SAMPLE index, so the hole keeps
- *    its width, the line breaks at it, and the label carries "N not available".
- *
- * Accessibility: `role="img"` with an `aria-label` naming the metric, its range
- * and its direction. A sparkline with no accessible name is decoration a screen
- * reader cannot report, which would leave the shape — the entire reason the
- * component exists — visible to exactly one kind of reader.
- *
- * Deliberately not animated. `docs/product-surfaces.md` Pattern 4 lists chart
- * draw-on under what this package does not animate: the shape IS the answer,
- * and easing it in taxes every read of a surface people sit in for hours. The
- * card around it arrives (`.agent-arrive`); the line does not draw itself.
- */
-
-/** Where a series ended relative to where it started. */
-type SparklineDirection = 'rising' | 'falling' | 'flat';
-interface SparklinePoint {
-    readonly x: number;
-    readonly y: number;
-}
-interface SparklineGeometry {
-    /** The finite readings, in order — what was actually plotted. */
-    readonly readings: readonly number[];
-    /** Every plotted point, in order. Positions are on the SAMPLE axis, so a
-     *  missing reading leaves its width behind rather than closing up. */
-    readonly points: readonly SparklinePoint[];
-    /** The points split into runs of CONSECUTIVE samples. One run is one stroke:
-     *  a line drawn across a missing reading states a movement nobody measured. */
-    readonly segments: readonly (readonly SparklinePoint[])[];
-    /** Samples that carried no usable reading — a `null`, a `NaN`, an infinity.
-     *  Counted rather than discarded, because the accessible name has to state
-     *  them: a shorter series announced as a complete one is the silent loss. */
-    readonly gaps: number;
-    readonly min: number;
-    readonly max: number;
-    readonly first: number;
-    readonly last: number;
-    readonly direction: SparklineDirection;
-}
-interface SparklineGeometryOptions {
-    width?: number;
-    height?: number;
-    /** Keeps the stroke and the end dot inside the viewBox instead of clipping
-     *  them at the extremes, where the interesting readings always are. */
-    inset?: number;
-}
-declare const DEFAULT_SPARKLINE_WIDTH = 96;
-declare const DEFAULT_SPARKLINE_HEIGHT = 24;
-/** Only a name, never a metric: it exists so the accessible label is never
- *  empty. Every caller in this package passes the metric's own title. */
-declare const DEFAULT_SPARKLINE_LABEL = "Trend";
-declare const DEFAULT_SPARKLINE_EMPTY_LABEL = "No history yet";
-/** Nothing was measurable, which is not the same as nothing was measured yet —
- *  and "No history yet" over a series that arrived full of `NaN` reads as the
- *  metric being new when the producer is broken. */
-declare const DEFAULT_SPARKLINE_UNAVAILABLE_LABEL = "No readings available";
-/** The package's default number rendering, pinned to `en-US` so a card and its
- *  series read the same on every host — a series formatted by the server's
- *  locale and a value formatted by the browser's is a defect nobody sees until
- *  the decimal separators disagree. */
-declare function formatSparklineValue(value: number): string;
-/**
- * The readings that can be plotted.
- *
- * A `null` from a gap in a series, or a `NaN` from a division a producer did
- * not guard, is not plotted rather than coerced to `0`: plotting a missing
- * reading at the baseline draws a cliff that never happened.
- *
- * This returns the readings ALONE, so it cannot tell a caller how many are
- * missing. That is what {@link SparklineGeometry.gaps} is for, and what the
- * accessible name reports — dropping a sample and then announcing the shorter
- * count as the whole series is the defect, not the filter.
- */
-declare function sparklineReadings(values: readonly number[]): number[];
-/**
- * Plots the series into the viewBox.
- *
- * Pure and exported so the cases that produce a broken chart — nothing, one
- * reading, a flat series, negatives — are unit-testable without a DOM.
- */
-declare function sparklineGeometry(values: readonly number[], { width, height, inset }?: SparklineGeometryOptions): SparklineGeometry;
-/** `"2,14 48,3 94,21"` — the `points` attribute of the polyline. */
-declare function sparklinePointsAttribute(points: readonly SparklinePoint[]): string;
-interface SparklineLabelOptions {
-    label?: string;
-    format?: (value: number) => string;
-}
-/**
- * The accessible name: metric, how many readings, how many are missing, the
- * range, and the direction.
- *
- * All of it is load-bearing. The range without the direction describes a shape
- * that could have been walked in either order; the direction without the range
- * says "rising" about a metric that moved by a rounding error; and the count
- * without the gaps is the number of readings that SURVIVED announced as the
- * number that were taken — the shape a reader cannot see is exactly the one
- * this sentence exists to carry.
- */
-declare function sparklineLabel(values: readonly number[], { label, format }?: SparklineLabelOptions): string;
-interface SparklineProps {
-    values: readonly number[];
-    /** Names the metric in the accessible label. */
-    label?: string;
-    /** Renders a reading in that label; defaults to the package number format. */
-    format?: (value: number) => string;
-    width?: number;
-    height?: number;
-    /** Shown instead of a line when the metric has no history yet. */
-    emptyLabel?: string;
-    /** Shown instead of a line when every sample arrived unreadable — a different
-     *  state from "no history yet", and one the reader has to be able to tell
-     *  apart, because one is a new metric and the other is a broken producer. */
-    unavailableLabel?: string;
-    className?: string;
-}
-/** The series glyph. Strokes in `currentColor`, so tone is the caller's. */
-declare function Sparkline({ values, label, format, width, height, emptyLabel, unavailableLabel, className, }: SparklineProps): ReactElement;
-
-/**
- * `InsightCard` + `InsightDeck` — the number that moved, and the paged deck of
- * them.
- *
- * Every product on this shell computes insights already: `/spend` knows today's
- * burn against yesterday's, `/missions` knows how many runs landed, the eval
- * lanes know a pass rate per release. All of it renders as a line of text, so
- * the reader does the comparison in their head and the series behind the number
- * never reaches the screen at all.
- *
- * Two rules this surface exists to hold:
- *
- *  - **A delta needs a baseline.** `previous` absent means no delta is drawn —
- *    not a green `+0%`, which is the specific fabrication a hand-rolled card
- *    produces when it defaults its baseline to zero, and which reads as "we
- *    measured, nothing changed" when the truth is "we have nothing to compare
- *    against". {@link insightDelta} returns `null` rather than a zero.
- *  - **Direction is not sentiment.** Spend going up and missions going up are
- *    the same arrow and opposite news, so tone is a caller declaration
- *    (`polarity`), and the default is neutral. A card that paints every rise
- *    green teaches the reader to stop reading the label.
- *
- * The deck is built on `web-react/async` rather than a loading boolean, so it
- * inherits that module's invariant instead of restating it: `AsyncView` renders
- * `error` with its message and retry, and `empty` is reachable only from a load
- * that resolved — a failed fetch can never paint "No insights yet"
- * (`docs/async-state-module.md`).
- *
- * Motion: cards arrive with `.agent-arrive`, staggered by `--stagger-index`
- * from the deck, and a page TURN remounts them so the next page arrives as a
- * sequence instead of swapping text under cards that never moved. A REFRESH is
- * the opposite case and gets the opposite treatment — see the deck's own note.
- * Every piece of that is decoration, carries no `data-motion`, and collapses
- * under `prefers-reduced-motion` — the live label included.
- *
- * The live label does NOT opt out, and the reasoning is worth stating because
- * the opposite reads plausible. What tells the reader a figure is still being
- * computed is the WORD (`liveLabel`, "Updating"): it is rendered only while
- * `live`, and a settled card does not render it at all. The sweep through its
- * glyphs is emphasis on a signal that is already there, not the signal. So a
- * reader who asked for less motion still sees the word — static, in the
- * shimmer's resting gradient, still legible, and still disappearing the moment
- * the figure is final. Nothing here overrides a request the reader made.
- */
-
-type InsightDirection = 'up' | 'down' | 'flat';
-/** Which way is good news for THIS metric. `neutral` is the default because it
- *  is the only answer that is true for every metric. */
-type InsightPolarity = 'higher-is-better' | 'lower-is-better' | 'neutral';
-type InsightTone = 'positive' | 'negative' | 'neutral';
-interface InsightDelta {
-    /** The baseline the move is measured against — rendered, so the delta is
-     *  never a number floating free of what produced it. */
-    readonly previous: number;
-    readonly absolute: number;
-    /** `null` when the baseline is `0`: a share of nothing is undefined, and
-     *  "+∞%" or a silently-dropped percentage are both worse than the absolute. */
-    readonly percent: number | null;
-    readonly direction: InsightDirection;
-}
-/**
- * The move, or `null` when there is no honest one to state.
- *
- * `unknown` inputs on purpose: these arrive from a fetched payload, and the
- * cases that must not produce a delta — a missing baseline, a `null` from a
- * first-ever reading, a `NaN` from a producer's division — are exactly the ones
- * a narrower signature would let through as `0`.
- */
-declare function insightDelta(value: unknown, previous: unknown): InsightDelta | null;
-/** Maps a direction onto good/bad news, which only the caller knows. */
-declare function insightDeltaTone(direction: InsightDirection, polarity?: InsightPolarity): InsightTone;
-/**
- * The delta as words: direction, magnitude, and the baseline it is measured
- * against. Words rather than an arrow plus a bare number, because the arrow is
- * `aria-hidden` and a reader hearing "12%" learns nothing about which way.
- */
-declare function formatInsightDelta(delta: InsightDelta, format?: (value: number) => string): string;
-interface InsightAction {
-    label: string;
-    onClick: () => void;
-}
-interface InsightCardProps {
-    /** What was measured, in the reader's words ("Spend today"). */
-    title: string;
-    /** The number that moved. A `string` renders verbatim — a total the caller
-     *  already formatted with its own currency — and takes no delta, because
-     *  there is nothing to subtract. A non-finite number is not a measurement and
-     *  renders as {@link INSIGHT_UNAVAILABLE_GLYPH}, never as "NaN" or "∞". */
-    value: number | string;
-    /** "USD", "runs", "%" — the unit the number is in, beside it rather than
-     *  glued into it, so the figure stays scannable. */
-    unit?: string;
-    /** The baseline. Absent ⇒ the card renders the value and no delta. */
-    previous?: number;
-    polarity?: InsightPolarity;
-    /** One number format for the value, the delta and the series, so the three
-     *  cannot disagree about decimals on the same card. */
-    format?: (value: number) => string;
-    series?: readonly number[];
-    /** Names the series in its accessible label; defaults to the card's title. */
-    seriesLabel?: string;
-    /** One line of context under the number — what the window is, what is
-     *  excluded. Not a restatement of the title. */
-    description?: string;
-    /** The next action for this insight. An element renders as supplied (a link,
-     *  a dialog trigger); the object form renders the standard button. */
-    action?: InsightAction | ReactElement;
-    /** The number is still being computed. The label's PRESENCE is the signal, so
-     *  it reads the same with motion collapsed — see the module note. */
-    live?: boolean;
-    liveLabel?: string;
-    className?: string;
-    style?: CSSProperties;
-}
-declare function InsightCard({ title, value, unit, previous, polarity, format, series, seriesLabel, description, action, live, liveLabel, className, style, }: InsightCardProps): ReactElement;
-interface Insight extends InsightCardProps {
-    /** Stable across refreshes: it keys the card. Paired with the deck holding
-     *  the last loaded page across a reload, a stable id is what lets a settled
-     *  card keep its own DOM node — and therefore not replay its arrival — when
-     *  a poll returns the same insight. */
-    readonly id: string;
-}
-declare const DEFAULT_INSIGHT_PAGE_SIZE = 3;
-/**
- * The page size — ONE definition, read by the count and by the slice.
- *
- * Two definitions is how a deck hides an insight with no error at all: a count
- * that divides by the raw `2.5` claims two pages of a five-card deck, a slice
- * that floors it puts two cards on each, and the fifth card is on no page the
- * reader can reach. Nothing renders wrong; a card is simply gone.
- *
- * A page size is a count of cards, so a fraction, a zero and a negative are not
- * smaller decks — they are caller mistakes, and this normalises them back to the
- * default and says so once per offending value. Normalised rather than thrown
- * because the value is often computed from a measured viewport, where the first
- * paint legitimately produces a `0`: a deck that pages in threes is a far
- * smaller failure than a dashboard that throws during render.
- */
-declare function insightPageSize(pageSize?: number): number;
-/** Always at least one page, so "Page 1 of 0" cannot be rendered. */
-declare function insightPageCount(total: number, pageSize?: number): number;
-/** The items on `page`, with the page clamped into range — a deck whose list
- *  shrank under the reader shows the last page that exists, never a blank one. */
-declare function insightPageSlice<T>(items: readonly T[], page: number, pageSize?: number): readonly T[];
-interface InsightDeckProps {
-    /** The same five-state contract every other screen fetches through. */
-    state: AsyncResourceState<readonly Insight[]>;
-    /** Required by `AsyncView`: an empty deck must say what is missing and what
-     *  to do about it. */
-    empty: AsyncEmptySpec | ReactElement;
-    /** Names the region for assistive tech and titles nothing visually — the
-     *  cards carry their own headings. */
-    label?: string;
-    pageSize?: number;
-    loadingLabel?: string;
-    retryLabel?: string;
-    className?: string;
-    /**
-     * The page the reader is ON, whatever moved them there.
-     *
-     * That includes the render-time clamp: a list that shrinks under a reader
-     * standing on page 3 leaves them on the last page that exists, and a parent
-     * persisting this to a URL or to storage would otherwise keep writing a page
-     * number nothing can reach. Reported once per effective page, never twice for
-     * the same one.
-     */
-    onPageChange?: (page: number) => void;
-}
-/**
- * The paged deck.
- *
- * `AsyncView` owns the non-`ready` branches, which is what makes the invariant
- * structural here: the cards are rendered from one branch of that component,
- * and no branch of this one could paint the empty copy over a failure.
- *
- * **A REFRESH DOES NOT REPLACE WHAT IS ON SCREEN.** `useAsyncResource` re-enters
- * `loading` with no value held on every reload, and handing that straight to
- * `AsyncView` swaps the ready subtree for the busy block — which destroys the
- * DOM the reader is standing in. Measured, on a real reload: `document.
- * activeElement` fell to `document.body`, so a keyboard reader mid-page lost
- * their place on every automatic poll; and every settled card was a NEW node, so
- * `.agent-arrive` replayed across the whole visible page — the exact flash this
- * surface's motion rules exist to prevent. Holding the page NUMBER above the
- * boundary fixed the counter and none of that, because the subtree under it was
- * still being torn down.
- *
- * So the deck holds the last insights it rendered and keeps handing them to the
- * SAME `AsyncView` branch while a reload is in flight: same element, same
- * position, same keys — React reuses the nodes, focus stays where the reader put
- * it, and nothing re-animates. `aria-busy` on the region is the signal that a
- * load is in flight; a per-card one is `live` on the card.
- *
- * The bridge is only ever over a WAIT. `error` and `empty` are answers about the
- * resource, so they drop what was held and render their own branch — a failed
- * fetch still cannot paint stale numbers, and the async module's invariant is
- * untouched.
- *
- * It bridges one resource, not one component: if the SUBJECT changes (a
- * different workspace, a different window), give the deck a `key` so it remounts
- * rather than showing the previous subject's numbers while the new ones load.
- */
-declare function InsightDeck({ state, empty, label, pageSize, loadingLabel, retryLabel, className, onPageChange, }: InsightDeckProps): ReactElement;
-
+ * `@tangle-network/agent-app/web-react` — the shared chat-shell components
+ * every agent app's web UI hand-rolls: a model picker over the runtime's
+ * model catalogue, a reasoning-effort selector, and a message thread with
+ * User/Agent identity, per-message model + cost + tokens/sec metrics,
+ * canonical tool rows, and a collapsible thinking section.
+ *
+ * Works for BOTH chat shapes: router-backed copilots (LoopEvents from
+ * `runtime/openai-stream`) and sandbox-backed chats — the thread renders
+ * `ChatUiMessage`s; how they're produced is the app's business.
+ *
+ * Styling contract: Tailwind classes against the shared design tokens
+ * (`bg-card`, `border-border`, `text-muted-foreground`, `bg-primary`, …) that
+ * Tangle app shells define. No icon library of its own — the few local glyphs
+ * are inline SVGs. Markdown and provider logos are injected (`renderMarkdown`,
+ * `renderProviderBadge`).
+ *
+ * Tool rows compose the canonical run-row grammar from `@tangle-network/ui`
+ * (`InlineToolItem` over `RunRowShell`): `chatToolCallPart` adapts each
+ * `ChatToolCallInfo` to ui's `ToolPart` (the same adapter pattern ui's own
+ * `ToolCallStep` uses), so the chat surface and every other Tangle run view
+ * share one row implementation instead of drifting. That makes
+ * `@tangle-network/ui` a peer of this subpath.
+ */
+import { type ReactNode } from 'react';
+import type { ToolPart } from '@tangle-network/ui/types';
+import { type DurableChatCardsProps } from './durable-chat-cards';
+import { type ChatAttachmentPart } from './chat-attachments';
+import type { WorkProductPersistedPart } from '../work-product/types';
+export * from './chat-stream';
+export * from './chat-interactions';
+export * from './chat-composer';
+export * from './interaction-card-support';
+export * from './interaction-question-card';
+export * from './interaction-plan-card';
+export * from './durable-plan-flow';
+export * from './durable-plan-card';
+export * from './durable-chat-cards';
+export * from './durable-interaction-submit';
+export * from './use-chat-interactions';
+export * from './use-file-mentions';
+export * from './chat-mentions';
+export * from './chat-attachments';
+export * from './message-attachments';
+export * from './use-composer-attachments';
+export * from './provider-logo';
+export * from './harness-glyphs';
+export * from './smooth-text';
+export * from './mission-activity';
+export * from './work-product';
+export * from './provenance';
+export * from './sandbox-terminal';
+export * from './seat-paywall';
+export * from './session-history';
+export * from './record-grid';
+export * from './sparkline';
+export * from './insight-card';
+export { usePopover, usePending, PopoverSurface, POPOVER_SURFACE_ATTR, ModelPicker, EffortPicker, EffortMeter, effortMeterFill, effortLevelLabel, effortLevelsFromIds, reconcileEffortLevels, DEFAULT_EFFORT_LEVELS, EFFORT_METER_SEGMENTS, OVERLAY_SHADOW, type ModelPickerProps, type EffortPickerProps, type EffortLevel, type PopoverSurfaceProps, } from './controls';
+export { AgentSessionControls, type AgentSessionControlsProps, } from './agent-session-controls';
+import type { CatalogModel } from '../runtime/model-catalog';
+export type { CatalogModel } from '../runtime/model-catalog';
 /** Describe metrics related to a chat message including model, token counts, and duration */
-interface ChatMessageMetrics {
+export interface ChatMessageMetrics {
     modelUsed?: string;
     promptTokens?: number;
     completionTokens?: number;
     durationMs?: number;
 }
 /** "$0.0042" from token counts × catalogue per-token pricing; null when unknown. */
-declare function formatModelCost(msg: ChatMessageMetrics, models: CatalogModel[]): string | null;
+export declare function formatModelCost(msg: ChatMessageMetrics, models: CatalogModel[]): string | null;
 /** "38 tok/s" from completion tokens over first-token→end duration; null when unknown. */
-declare function formatTokensPerSecond(msg: ChatMessageMetrics): string | null;
+export declare function formatTokensPerSecond(msg: ChatMessageMetrics): string | null;
 /** One step of a retained tool run (e.g. a sandbox command + its output). */
-interface ToolRunStep {
+export interface ToolRunStep {
     at: string;
     label: string;
     detail?: string;
@@ -2345,7 +80,7 @@ interface ToolRunStep {
 /** A retained tool run keyed by the parent message's toolCallId. The product
  *  persists these server-side (fail-closed: only ids its own loop created)
  *  and serves them to the drill-in panel. */
-interface ToolRunRecord {
+export interface ToolRunRecord {
     toolCallId: string;
     toolName: string;
     title: string;
@@ -2353,7 +88,7 @@ interface ToolRunRecord {
     steps: ToolRunStep[];
 }
 /** Define properties required to run a drill and handle its closure event */
-interface RunDrillInProps {
+export interface RunDrillInProps {
     run: ToolRunRecord;
     onClose: () => void;
 }
@@ -2362,9 +97,9 @@ interface RunDrillInProps {
  * "drill into what the sandbox actually did" view. Follow-ups happen in the
  * main chat, never here.
  */
-declare function RunDrillIn({ run, onClose }: RunDrillInProps): react.JSX.Element;
+export declare function RunDrillIn({ run, onClose }: RunDrillInProps): import("react").JSX.Element;
 /** Describe the structure and state of a tool call within a chat interaction */
-interface ChatToolCallInfo {
+export interface ChatToolCallInfo {
     id: string;
     name: string;
     status: 'running' | 'done' | 'error';
@@ -2377,7 +112,7 @@ interface ChatToolCallInfo {
 }
 /** Extract `{proposalId, status}` from a tool outcome when it is a proposal
  *  awaiting human approval; null otherwise. */
-declare function pendingApprovalOf(call: ChatToolCallInfo): {
+export declare function pendingApprovalOf(call: ChatToolCallInfo): {
     proposalId: string;
 } | null;
 /** One ordered piece of an assistant turn: a run of answer text, or a tool
@@ -2385,7 +120,7 @@ declare function pendingApprovalOf(call: ChatToolCallInfo): {
  *  is rendered in order — interleaving text and tool rows — so the agent's
  *  pre- and post-tool reasoning reads chronologically instead of as one text
  *  blob with the tool rows collected after it. */
-type ChatMessageSegment = {
+export type ChatMessageSegment = {
     kind: 'text';
     content: string;
 } | {
@@ -2393,7 +128,7 @@ type ChatMessageSegment = {
     call: ChatToolCallInfo;
 };
 /** Describe the structure and properties of a chat message with roles, content, and optional metadata */
-interface ChatUiMessage extends ChatMessageMetrics {
+export interface ChatUiMessage extends ChatMessageMetrics {
     id: string;
     role: 'user' | 'assistant' | 'system';
     content: string;
@@ -2408,7 +143,7 @@ interface ChatUiMessage extends ChatMessageMetrics {
     parts?: Array<Record<string, unknown>>;
 }
 /** Define properties for rendering chat messages with optional models, markdown, extras, and durable cards */
-interface ChatMessagesProps {
+export interface ChatMessagesProps {
     messages: ChatUiMessage[];
     /** Shared reading scale for both user and assistant prose. Defaults to 16px
      *  at a 1.6 line height; `large` uses 17px at the same leading without
@@ -2477,7 +212,7 @@ interface ChatMessagesProps {
 }
 /** One starting "door" in the chat first-run state — a concrete, labeled action
  *  (start from a template, do it by hand, ask the agent), not a placeholder. */
-interface ChatEmptyDoor {
+export interface ChatEmptyDoor {
     label: string;
     description?: string;
     onSelect: () => void;
@@ -2485,7 +220,7 @@ interface ChatEmptyDoor {
     icon?: ReactNode;
 }
 /** Define properties for rendering the chat empty state with customizable text and starting doors */
-interface ChatEmptyStateProps {
+export interface ChatEmptyStateProps {
     /** Product name shown next to the Tangle mark. Default "Agent". */
     productName?: string;
     /** Headline. Default frames delegation, not messaging. */
@@ -2500,15 +235,15 @@ interface ChatEmptyStateProps {
  * up to three concrete doors. Replaces the blank thread that read as "empty or
  * broken". Concrete + actionable — never a "coming soon" placeholder.
  */
-declare function ChatEmptyState({ productName, headline, subline, doors, }: ChatEmptyStateProps): react.JSX.Element;
+export declare function ChatEmptyState({ productName, headline, subline, doors, }: ChatEmptyStateProps): import("react").JSX.Element;
 /** Handle approval and rejection actions for proposals with asynchronous support */
-interface ProposalApprovalHandlers {
+export interface ProposalApprovalHandlers {
     onApprove: (proposalId: string, toolCallId: string) => void | Promise<void>;
     onReject: (proposalId: string, toolCallId: string) => void | Promise<void>;
 }
 /** Per-tool custom detail renderers for the expanded card body — keyed by
  *  tool name. Return null to fall back to the generic detail view. */
-type ToolDetailRenderers = Record<string, (call: ChatToolCallInfo, message: ChatUiMessage) => ReactNode>;
+export type ToolDetailRenderers = Record<string, (call: ChatToolCallInfo, message: ChatUiMessage) => ReactNode>;
 /**
  * Adapt a chat tool call to the canonical `@tangle-network/ui` `ToolPart`, so
  * the row renders through ui's `InlineToolItem` — one run-row grammar shared
@@ -2518,12 +253,12 @@ type ToolDetailRenderers = Record<string, (call: ChatToolCallInfo, message: Chat
  * every other tool keeps its real name. agent-app carries no per-call timings,
  * so `state.time` stays unset and the row shows no duration.
  */
-declare function chatToolCallPart(call: ChatToolCallInfo): ToolPart;
+export declare function chatToolCallPart(call: ChatToolCallInfo): ToolPart;
 /** Whole seconds elapsed while `active`, ticking once a second. Powers the live
  *  "thinking" timers (the pre-first-token row and the reasoning box) so a long
  *  thinking gap shows progress instead of a frozen label. Counts from when
  *  `active` first turns true; freezes when it clears. */
-declare function useThinkingSeconds(active: boolean): number;
+export declare function useThinkingSeconds(active: boolean): number;
 /**
  * The message thread: one centered column; user messages are right-aligned
  * bubbles with a User label; agent messages carry an Agent meta line with
@@ -2531,6 +266,4 @@ declare function useThinkingSeconds(active: boolean): number;
  * tool rows. `chrome="quiet"` opts into the label-free variant: the
  * label/meta row becomes a hover-revealed meta lane under each row.
  */
-declare function ChatMessages({ messages, messageSize, chrome, models, renderMarkdown, renderExtras, durableCards, userLabel, agentLabel, loading, approval, onToolCallClick, toolRenderers, error, onRetry, renderEmpty, emptyState, header, resolveAttachmentUrl, workProductCards, }: ChatMessagesProps): react.JSX.Element;
-
-export { type ActivityTone, type AgentActivityPage, AgentActivityPanel, type AgentActivityPanelProps, type AgentActivityRecord, type AttachmentFileResult, CatalogModel, ChatAttachmentInput, ChatAttachmentKind, ChatAttachmentPart, ChatComposer, type ChatComposerProps, type ChatEmptyDoor, ChatEmptyState, type ChatEmptyStateProps, ChatInteraction, ChatInteractionField, type ChatInteractionRestoreMode, ChatInteractionStatus, ChatMentionPart, type ChatMessageMetrics, type ChatMessageSegment, ChatMessages, type ChatMessagesProps, ChatSelectField, type ChatStreamCallbacks, type ChatStreamToolCall, type ChatStreamToolResult, type ChatToolCallInfo, type ChatUiMessage, type ComposerFile, type ComposerFilePart, type ComposerSendFailure, type ComposerSendHandler, type ComposerSendOutcome, type ComposerSendPartsHandler, type ComposerSendRejected, type ComposerSendResult, type ConsumeChatStreamResult, DEFAULT_INSIGHT_PAGE_SIZE, DEFAULT_PROVENANCE_CONFIDENCE_POLICY, DEFAULT_SPARKLINE_EMPTY_LABEL, DEFAULT_SPARKLINE_HEIGHT, DEFAULT_SPARKLINE_LABEL, DEFAULT_SPARKLINE_UNAVAILABLE_LABEL, DEFAULT_SPARKLINE_WIDTH, type DurableChatCard, DurableChatCards, type DurableChatCardsProps, type DurableInteractionAnswerSubmitterOptions, DurablePlanCard, type DurablePlanCardProps, DurablePlanClientError, type DurablePlanCurrentInput, type DurablePlanDecision, type DurablePlanDecisionClient, type DurablePlanDecisionClientOptions, type DurablePlanDecisionInput, type DurablePlanDecisionResult, type DurablePlanFollowUpReceipt, EMPTY_RECORD_GRID_OVERLAY, EvidenceLineageTable, type EvidenceLineageTableProps, ExceptionList, type ExceptionListProps, type FetchSessionPage, type FieldValues, FlowWaterfall, type FlowWaterfallProps, HarnessGlyph, type HarnessGlyphProps, INTERACTION_SUBMIT_TIMEOUT_MESSAGE, INTERACTION_SUBMIT_TIMEOUT_MS, type Insight, type InsightAction, InsightCard, type InsightCardProps, InsightDeck, type InsightDeckProps, type InsightDelta, type InsightDirection, type InsightPolarity, type InsightTone, InteractionActionButton, type InteractionAnswerSubmission, type InteractionAnswerSubmitterOptions, InteractionAnswers, type InteractionAttemptStore, InteractionBadge, type InteractionBadgeVariant, InteractionCancelData, InteractionPlanCard, type InteractionPlanCardProps, InteractionQuestionCard, type InteractionQuestionCardProps, InteractionRequestWire, type InteractionSubmitResult, type LinkLikeComponent, type LinkLikeProps, type MentionTextSegment, MessageAttachments, type MessageAttachmentsProps, MissionActivityLane, type MissionActivityLaneProps, PROVENANCE_BASES, type ProposalApprovalHandlers, type ProvenanceBasis, type ProvenanceBasisMeta, type ProvenanceConfidencePolicy, type ProvenanceGap, type ProvenanceGapKind, ProvenanceLegend, type ProvenanceLegendProps, type ProvenanceRecord, type ProvenanceSource, type ProvenanceSourceStatus, ProvenanceStamp, type ProvenanceStampProps, type ProvenanceStanding, type ProvenanceStandingMeta, ProvenanceValue, type ProvenanceValueProps, ProviderLogo, type ProviderLogoProps, QualityCheckList, type QualityCheckListProps, QuestionOptionList, type QuestionOptionListProps, RecordGrid, type RecordGridBooleanColumn, type RecordGridCellChange, type RecordGridCellOutcome, type RecordGridCellSource, type RecordGridColumn, type RecordGridColumnBase, type RecordGridCreateOutcome, type RecordGridCurrencyColumn, type RecordGridDateColumn, type RecordGridDependency, type RecordGridNumberColumn, type RecordGridOverlay, type RecordGridProps, type RecordGridRow, type RecordGridRowOutcome, type RecordGridSelectColumn, type RecordGridSelectOption, type RecordGridSourceBasis, type RecordGridTextColumn, type RecordGridValue, type RecordGridWriteOutcome, type RestoreChatInteractionsOptions, ReviewQueueItem, type ReviewQueuePage, ReviewQueuePanel, type ReviewQueuePanelProps, ReviewQueueState, RunDrillIn, type RunDrillInProps, SeatPaywall, type SeatPaywallProps, type SessionActionLabels, type SessionActions, type SessionActionsOptions, type SessionBulkAction, SessionHistoryPanel, type SessionHistoryPanelProps, type SessionHistoryState, type SessionPageQuery, type SmoothRevealOptions, Sparkline, type SparklineDirection, type SparklineGeometry, type SparklineGeometryOptions, type SparklineLabelOptions, type SparklinePoint, type SparklineProps, type StreamChatOptions, type SubmitInteractionAnswer, type ToolDetailRenderers, type ToolRunRecord, type ToolRunStep, type UseChatInteractionsOptions, type UseChatInteractionsResult, type UseComposerAttachmentsOptions, type UseComposerAttachmentsResult, type UseDurablePlanFlowOptions, type UseDurablePlanFlowResult, type UseInfiniteScrollOptions, type UseSessionHistoryOptions, type WaterfallRow, WorkProductCard, type WorkProductCardProps, __resetAttachmentFileCacheForTests, activityTone, buildAnswerData, cancelChatInteraction, chatToolCallPart, consumeChatStream, createDurableInteractionAnswerSubmitter, createDurablePlanDecisionClient, createInteractionAnswerSubmitter, createMemoryInteractionAttemptStore, createSessionInteractionAttemptStore, describeProvenance, describeProvenanceSourceStatus, dispatchChatStreamLine, durableChatCardsFromParts, fieldAnswer, fieldValuesFromAnswers, formatActivityCost, formatActivityDuration, formatInsightDelta, formatModelCost, formatRecordGridValue, formatSessionTimestamp, formatSparklineValue, formatTokensPerSecond, hasSecretField, hydrateChatInteractions, insightDelta, insightDeltaTone, insightPageCount, insightPageSize, insightPageSlice, interactionStatusLabels, interactionSubmissionSignature, interactionTerminalNotes, isLateAnswerableStatus, isRecordGridCellApplicable, lateAnswerMessage, loadAttachmentFile, loadingProvenanceSources, mergeActivityPages, mergeReviewQueuePages, nextRevealCount, parseRecordGridInput, pendingApprovalOf, projectRecordGridRows, provenanceBasisMeta, provenanceGaps, provenanceNextMove, provenanceStandingMeta, provenanceTriggerLabel, pruneRecordGridOverlay, readRecordGridCell, recordGridEditorText, recordGridFail, recordGridOk, recordGridRowLabel, resolveChatInteraction, resolveProvenanceStanding, responseErrorMessage, restoreChatInteractions, reviewQueueStateLabel, rollUpProvenanceStanding, sameRecordGridValue, segmentMentionContent, settleInteractionSubmit, sparklineGeometry, sparklineLabel, sparklinePointsAttribute, sparklineReadings, standingFromConfidence, streamChatTurn, sumRecordGridColumn, terminalizePendingChatInteractions, triggerAttachmentDownload, upsertChatInteraction, useChatInteractions, useComposerAttachments, useDurablePlanFlow, useInfiniteScroll, useSessionActions, useSessionHistory, useSmoothText, useThinkingSeconds, validateRecordGridCell, validateRecordGridRow, waterfallLayout, weakerProvenanceStanding, withRecordGridCreated, withRecordGridRemoved, withRecordGridServerRow, withRecordGridUpdate, withoutRecordGridCreated, withoutRecordGridRemoved, withoutRecordGridUpdate, workProductPartsFromMessageParts, workProductStatusLabel };
+export declare function ChatMessages({ messages, messageSize, chrome, models, renderMarkdown, renderExtras, durableCards, userLabel, agentLabel, loading, approval, onToolCallClick, toolRenderers, error, onRetry, renderEmpty, emptyState, header, resolveAttachmentUrl, workProductCards, }: ChatMessagesProps): import("react").JSX.Element;