@tangle-network/agent-app 0.45.53 → 0.45.55

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

@@ -0,0 +1,39 @@
+/**
+ * `inert`, across the React versions this package's peer range admits.
+ *
+ * MEASURED, not reasoned. `react` + `react-dom` 18.3.1 and 19.2.8, each
+ * rendering `<div inert={…}>x</div>` through `renderToStaticMarkup`, and the
+ * same four cases re-read as `outerHTML` after `createRoot().render` — server
+ * and client agreed on every row:
+ *
+ * | prop            | React 18.3.1                    | React 19.2.8                    |
+ * | --------------- | ------------------------------- | ------------------------------- |
+ * | `inert={false}` | `<div>x</div>` — NO attribute   | `<div>x</div>` — NO attribute   |
+ * | `inert={''}`    | `<div inert="">x</div>` — inert | `<div>x</div>` — NO attribute   |
+ * | `inert={true}`  | `<div>x</div>` — NO attribute   | `<div inert="">x</div>` — inert |
+ * | `inert={'1'}`   | `<div inert="1">x</div>` — inert | `<div inert="">x</div>` — inert |
+ *
+ * React 18 warns on the two it drops (`Received \`false\`/\`true\` for a
+ * non-boolean attribute \`inert\`.`); React 19 warns on the one it drops
+ * (`Received an empty string for a boolean attribute \`inert\`.`).
+ *
+ * So the FALSE case needs no help: both majors already emit nothing, and a
+ * plain `inert={!open}` binding never made an open panel inert on either. The
+ * TRUE case is the defect — `true` is dropped by 18 and `''` is dropped by 19,
+ * so a plain boolean binding leaves a COLLAPSED panel focusable and
+ * screen-reader readable on React 18, which `peerDependencies` (`react >=18`)
+ * admits.
+ *
+ * The last row is the answer, and it is why this file no longer detects
+ * anything. `inert` is an HTML boolean attribute: its PRESENCE is what makes an
+ * element inert, whatever the value reads. A non-empty string is emitted by
+ * both majors, warned about by neither, and inert on both — so there is one
+ * spelling and no branch.
+ */
+/**
+ * Props that make an element inert when `inert` is true, and nothing at all
+ * when it is false.
+ */
+export declare function inertProps(inert: boolean): {
+    inert?: boolean;
+};

package/dist/web-react/insight-card.d.ts

@@ -0,0 +1,203 @@
+/**
+ * `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.
+ */
+import { type CSSProperties, type ReactElement } from 'react';
+import { type AsyncEmptySpec, type AsyncResourceState } from './async';
+export 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. */
+export type InsightPolarity = 'higher-is-better' | 'lower-is-better' | 'neutral';
+export type InsightTone = 'positive' | 'negative' | 'neutral';
+export 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`.
+ */
+export declare function insightDelta(value: unknown, previous: unknown): InsightDelta | null;
+/** Maps a direction onto good/bad news, which only the caller knows. */
+export 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.
+ */
+export declare function formatInsightDelta(delta: InsightDelta, format?: (value: number) => string): string;
+export interface InsightAction {
+    label: string;
+    onClick: () => void;
+}
+export 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;
+}
+export declare function InsightCard({ title, value, unit, previous, polarity, format, series, seriesLabel, description, action, live, liveLabel, className, style, }: InsightCardProps): ReactElement;
+export 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;
+}
+export 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.
+ */
+export declare function insightPageSize(pageSize?: number): number;
+/** Always at least one page, so "Page 1 of 0" cannot be rendered. */
+export 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. */
+export declare function insightPageSlice<T>(items: readonly T[], page: number, pageSize?: number): readonly T[];
+export 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.
+ */
+export declare function InsightDeck({ state, empty, label, pageSize, loadingLabel, retryLabel, className, onPageChange, }: InsightDeckProps): ReactElement;

package/dist/web-react/interaction-card-support.d.ts

@@ -0,0 +1,115 @@
+/**
+ * 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…".
+ */
+import type { ChatInteraction, ChatInteractionField, ChatInteractionStatus, InteractionAnswers, InteractionData } from './chat-interactions';
+/** 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). */
+export 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. */
+export 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 */
+export 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. */
+export 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. */
+export 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. */
+export declare function buildAnswerData(fields: ChatInteractionField[], values: FieldValues): InteractionAnswers | null;
+/** Determine if a status is late answerable by checking if it is expired or cancelled */
+export 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. */
+export 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). */
+export declare function lateAnswerMessage(interaction: ChatInteraction, data: InteractionData): string;
+/** Define the timeout duration in milliseconds for submitting an interaction */
+export declare const INTERACTION_SUBMIT_TIMEOUT_MS = 30000;
+/** Provide the timeout message displayed when the agent cannot be reached during interaction submission */
+export declare const INTERACTION_SUBMIT_TIMEOUT_MESSAGE = "Could not reach the agent. Try again.";
+/** One card submission: which ask, resolved how, with what answers. */
+export interface InteractionAnswerSubmission {
+    id: string;
+    outcome: 'accepted' | 'declined';
+    data?: InteractionData;
+}
+/** Resolve the result of an interaction submission indicating success or failure with details */
+export 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. */
+export type SubmitInteractionAnswer = (submission: InteractionAnswerSubmission) => Promise<InteractionSubmitResult>;
+/** Extracts the most specific error message a route returned. */
+export declare function responseErrorMessage(res: Response): Promise<{
+    code?: string;
+    message: string;
+}>;
+/** Define options for submitting interaction answers including URL, body, timeout, and fetch implementation */
+export 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.
+ */
+export 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.
+ */
+export declare function createInteractionAnswerSubmitter(options: InteractionAnswerSubmitterOptions): SubmitInteractionAnswer;

package/dist/web-react/interaction-plan-card.d.ts

@@ -0,0 +1,39 @@
+/**
+ * InteractionPlanCard — the plan-approval round-trip card (kind:"plan",
+ * claude-code plan mode). The plan itself arrives as markdown in
+ * `interaction.body`; the answerSpec is producer-defined, so fields render
+ * generically — a free-text field doubles as the rejection-feedback input.
+ * Approve POSTs outcome:"accepted", Request changes POSTs outcome:"declined"
+ * with any typed feedback.
+ *
+ * Markdown is injected (`renderMarkdown`, matching the rest of `web-react`);
+ * without it the plan body falls back to pre-wrapped plain text. Pure data +
+ * callbacks: no fetch inside the component.
+ */
+import { type ReactNode } from 'react';
+import type { ChatInteraction, ChatInteractionStatus } from './chat-interactions';
+import { type SubmitInteractionAnswer } from './interaction-card-support';
+export 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;
+}
+export declare function InteractionPlanCard({ interaction, canWrite, submitAnswer, onResolved, onReRequest, reRequestLabel, renderMarkdown, className, }: InteractionPlanCardProps): import("react").JSX.Element;

package/dist/web-react/interaction-question-card.d.ts

@@ -0,0 +1,100 @@
+/**
+ * InteractionQuestionCard — the agent-ask card every sandbox-backed chat UI
+ * forked (~1,000 lines each in gtm/legal/tax). Renders the answerSpec
+ * verbatim: selects (radio/checkbox by `multi`, write-in row only when the
+ * sidecar granted `allowCustom`), free text, and minimal number/boolean/secret
+ * inputs for open kinds.
+ *
+ * Behavior lifted from the gtm-agent fork (the most fix-absorbed):
+ *   - a terminal stream status always wins over local optimistic state,
+ *   - a 410 from the answer route flips the card to the same dead state a
+ *     cancel event produces (never a raw error),
+ *   - expired/withdrawn asks stay answerable: the answer is delivered as a NEW
+ *     chat turn via `onLateAnswer` (secret-bearing asks are blocked from that
+ *     path),
+ *   - one submit in flight at a time; a failed/timed-out submit stays
+ *     retryable.
+ *
+ * Pure data + callbacks: no fetch inside the component. Products bind the wire
+ * via `createInteractionAnswerSubmitter` (or any `SubmitInteractionAnswer`).
+ */
+import { type ReactNode } from 'react';
+import type { ChatInteraction, ChatInteractionStatus, ChatSelectField } from './chat-interactions';
+import { type SubmitInteractionAnswer } from './interaction-card-support';
+export type InteractionBadgeVariant = 'outline' | 'default' | 'destructive';
+export declare function InteractionBadge({ variant, children }: {
+    variant: InteractionBadgeVariant;
+    children: string;
+}): import("react").JSX.Element;
+export declare function InteractionActionButton({ variant, onClick, disabled, children, }: {
+    variant?: 'primary' | 'outline';
+    onClick: () => void;
+    disabled?: boolean;
+    children: string;
+}): import("react").JSX.Element;
+export 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. */
+export declare function QuestionOptionList({ groupName, idPrefix, options, multi, selectedValues, disabled, onToggle, answered, }: QuestionOptionListProps): import("react").JSX.Element;
+export 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;
+}
+export declare function InteractionQuestionCard({ interaction, canWrite, submitAnswer, onResolved, onLateAnswer, kindLabel, timeoutNote, renderMarkdown, className, }: InteractionQuestionCardProps): import("react").JSX.Element;

package/dist/web-react/message-attachments.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 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.
+ */
+import { type ReactNode } from 'react';
+import type { ChatAttachmentPart } from './chat-attachments';
+/** 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. */
+export type AttachmentFileResult = {
+    ok: true;
+    blob: Blob;
+} | {
+    ok: false;
+    message: string;
+};
+export 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. */
+export 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. */
+export declare function triggerAttachmentDownload(name: string, blob: Blob): {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};
+export 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. */
+export declare function MessageAttachments({ parts, resolveFileUrl, justify, fetchFile }: MessageAttachmentsProps): ReactNode;

package/dist/web-react/mission-activity.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Mission + delegation observability surfaces — different nouns, one trace
+ * tree:
+ *
+ *  - {@link MissionActivityLane}: the collapsed sub-rows under a mission step
+ *    (what the step's agent is actually doing), expanding to a compact web
+ *    waterfall rendered from the `/trace` converters.
+ *  - {@link AgentActivityPanel}: the standalone cross-context surface — every
+ *    delegation a workspace ran, regardless of which mission (if any) spawned
+ *    it — behind a `fetchActivity` data port with cursor + refresh.
+ *  - {@link FlowWaterfall}: the web counterpart of `/trace`'s ASCII
+ *    `renderWaterfall` (which stays CLI) — proportional bars over a FlowTrace.
+ *
+ * Same styling contract as the rest of `/web-react`: Tailwind classes against
+ * the shared design tokens, inline SVG glyphs, no icon library. The pure
+ * layout/merge/format helpers are exported for tests and reuse.
+ */
+import { type ReactNode } from 'react';
+import type { StepAgentActivity } from '../missions/agent-activity';
+import type { FlowTrace } from '../trace/index';
+export type ActivityTone = 'live' | 'ok' | 'error' | 'neutral';
+/** Map a delegation status (free-form string on the wire) to a render tone. */
+export declare function activityTone(status: string): ActivityTone;
+/** "$0.4000" under a cent shows 4 decimals; null when unknown/zero. */
+export declare function formatActivityCost(costUsd?: number): string | null;
+/** "8s" / "2m 05s" / "1h 12m"; null when unknown. */
+export 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. */
+export interface AgentActivityRecord extends StepAgentActivity {
+    missionRef?: {
+        missionId: string;
+        stepId?: string;
+        label?: string;
+    };
+}
+export 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.
+ */
+export declare function mergeActivityPages(existing: AgentActivityRecord[], incoming: AgentActivityRecord[]): AgentActivityRecord[];
+export 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}. */
+export declare function waterfallLayout(trace: FlowTrace): WaterfallRow[];
+export interface FlowWaterfallProps {
+    trace: FlowTrace;
+}
+/** Compact proportional waterfall over a FlowTrace — span name, bar, duration
+ *  per row; total + cost in the footer. */
+export declare function FlowWaterfall({ trace }: FlowWaterfallProps): import("react").JSX.Element | null;
+export 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.
+ */
+export declare function MissionActivityLane({ activity, startedAt, nowMs }: MissionActivityLaneProps): import("react").JSX.Element | null;
+export 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;
+}
+export declare function AgentActivityPanel({ fetchActivity, renderMissionRef, title, emptyLabel }: AgentActivityPanelProps): import("react").JSX.Element;