@tangle-network/agent-app 0.45.53 → 0.45.55

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

@@ -1,92 +1 @@
-/** Define the connection details and status for a sandbox terminal session */
-interface SandboxTerminalConnection {
-    runtimeUrl: string | null;
-    sidecarUrl: string | null;
-    token: string | null;
-    expiresAt: string | null;
-    status: string;
-    error: string | null;
-    loading: boolean;
-    sandboxId?: string;
-    connectionId?: string;
-}
-/**
- * Define the response structure for a sandbox terminal connection including URLs, token, status, and errors
- *
- * The browser-direct scoped-token route (`createSandboxTerminalConnectionRoute`,
- * `src/sandbox/terminal-connection.ts`) returns `sidecarUrl`. The hook also
- * exposes that URL through the historical `runtimeUrl` state field so existing
- * terminal panels do not need transport-specific branching.
- *
- * `connectionId` is the id the route's minted token's `sid` is bound to
- * (echoed back from the `connectionId` the hook sent) — pass it straight
- * through as `TerminalView`'s `connectionId` prop, since any other value
- * fails the WS upgrade on the current platform.
- */
-interface SandboxTerminalConnectionResponse {
-    runtimeUrl?: string;
-    sidecarUrl?: string;
-    token?: string;
-    expiresAt?: string;
-    status?: string;
-    error?: string;
-    sandboxId?: string;
-    connectionId?: string;
-}
-/**
- * Define options for configuring a sandbox terminal connection including workspace ID and connection parameters
- *
- * `connectionId`, when set, is passed to
- * `createSandboxTerminalConnectionRoute` as the `connectionId` query
- * parameter — pass `tabTerminalConnectionId()` here so the route mints a
- * token whose `sid` is bound to the same id `TerminalView` will dial. Give
- * `TerminalView` the response's echoed `connectionId` (not this input
- * value) alongside `sidecarUrl` as `apiUrl` and `token`, since a product's
- * `resolveConnectionId` seam may rewrite it server-side.
- */
-interface UseSandboxTerminalConnectionOptions {
-    workspaceId: string;
-    connectionUrl?: string | ((workspaceId: string) => string);
-    connectionId?: string;
-    fetcher?: typeof fetch;
-    provisionPollIntervalMs?: number;
-    provisionPollTimeoutMs?: number;
-    tokenRefreshSkewMs?: number;
-}
-/** Resolve sandbox terminal connection status and provide a method to initiate the connection */
-interface UseSandboxTerminalConnectionResult extends SandboxTerminalConnection {
-    connect: () => Promise<void>;
-}
-/**
- * Manage and maintain a sandbox terminal connection with automatic polling and token refresh handling
- *
- * `connectionUrl` is backed by the browser-direct scoped-token route
- * (`createSandboxTerminalConnectionRoute`,
- * `src/sandbox/terminal-connection.ts`). The route returns `sidecarUrl`; the
- * hook normalizes it into both URL fields for compatibility with existing
- * terminal panels.
- *
- * Pass `tabTerminalConnectionId()` as `opts.connectionId` — the hook forwards
- * it as the `connectionId` query parameter the browser-direct route requires
- * to mint a token whose `sid` is bound to that exact id (the orchestrator's
- * terminal WS gate fails closed on any other value). Give `TerminalView` the
- * RESULT's echoed `connectionId` (not the input value — a product's
- * `resolveConnectionId` seam may rewrite it), the resolved `sidecarUrl`/
- * `runtimeUrl` as `apiUrl`, and `token` as its token prop.
- */
-declare function useSandboxTerminalConnection(opts: UseSandboxTerminalConnectionOptions): UseSandboxTerminalConnectionResult;
-/**
- * Stable-per-tab, unique-per-client terminal connection id.
- *
- * Persists in `sessionStorage` so a reload in the same tab reuses the id (the
- * sidecar restores the same PTY session via `TerminalView.connectionId`), while
- * separate tabs/windows each get a distinct id. Pass the result as
- * `TerminalView`'s `connectionId`. Without it (e.g. gtm-agent today) every tab
- * shares one connection id and their reconnects evict each other.
- *
- * Falls back to an ephemeral id when `sessionStorage` is unavailable (SSR,
- * privacy mode) — still unique per call, just not reload-stable.
- */
-declare function tabTerminalConnectionId(storageKey?: string): string;
-
-export { type SandboxTerminalConnection, type SandboxTerminalConnectionResponse, type UseSandboxTerminalConnectionOptions, type UseSandboxTerminalConnectionResult, tabTerminalConnectionId, useSandboxTerminalConnection };
+export * from './sandbox-terminal';

package/dist/web-react/use-chat-interactions.d.ts

@@ -0,0 +1,78 @@
+/**
+ * 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.
+ */
+import { type ChatInteraction, type ChatInteractionStatus, type InteractionAnswers, type InteractionCancelData, type InteractionRequestWire } from './chat-interactions';
+/** 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. */
+export declare function upsertChatInteraction(list: ChatInteraction[], interaction: ChatInteraction): ChatInteraction[];
+/** Applies an `interaction.cancel` event: only a pending ask moves, to
+ *  `expired` (reason:"timeout") or `cancelled`. */
+export declare function cancelChatInteraction(list: ChatInteraction[], cancel: InteractionCancelData): ChatInteraction[];
+/** Marks one ask resolved locally (the card's `onResolved`). Forward-only. */
+export 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. */
+export declare function terminalizePendingChatInteractions(list: ChatInteraction[], status: Extract<ChatInteractionStatus, 'answered' | 'expired'>): ChatInteraction[];
+/** Define modes for restoring chat interactions with legacy or durable strategies */
+export type ChatInteractionRestoreMode = 'legacy' | 'durable';
+/** Define options to control how chat interactions are restored during the restore process */
+export 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`. */
+export 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. */
+export declare function hydrateChatInteractions(list: ChatInteraction[], persisted: ChatInteraction[]): ChatInteraction[];
+/** Resolve and manage chat interactions with methods to update, cancel, mark resolved, and restore state */
+export 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 */
+export type UseChatInteractionsOptions = RestoreChatInteractionsOptions;
+/** Manage chat interactions state with upsert, cancel, resolve, and restore capabilities */
+export declare function useChatInteractions(options?: UseChatInteractionsOptions): UseChatInteractionsResult;

package/dist/web-react/use-composer-attachments.d.ts

@@ -0,0 +1,111 @@
+/**
+ * `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.
+ */
+import type { ChatAttachmentInput, ChatAttachmentKind } from './chat-stream';
+import type { ComposerFile } from './chat-composer';
+export { ATTACHMENT_ACCEPT } from '../chat-routes/attachment-validation';
+/** Define options for configuring file upload behavior and handling in a composer component */
+export 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 */
+export 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.
+ */
+export declare function useComposerAttachments(options: UseComposerAttachmentsOptions): UseComposerAttachmentsResult;

package/dist/web-react/use-file-mentions.d.ts

@@ -0,0 +1,94 @@
+/**
+ * `useFileMentions` — the glue a host passes straight into `AgentComposer`'s
+ * `mention` prop (`@tangle-network/sandbox-ui#184`) to wire up `@`-file
+ * mentions against `createSandboxFileIndexRoute` (`/chat-routes`).
+ *
+ * Fetches the index once per session from `indexUrl`, refreshes it in the
+ * background whenever the popover opens (a `fetchItems` call) if the cached
+ * copy has aged past `refreshAfterMs`, and answers every keystroke from an
+ * in-memory fuzzy filter — no per-keystroke network round trip. The returned
+ * `refresh()` lets a caller force a re-fetch immediately instead of waiting
+ * on `refreshAfterMs` — e.g. right after the agent creates a file mid-session.
+ *
+ * `MentionItem`/the `mention` prop shape mirror the FROZEN contract from
+ * sandbox-ui#184 structurally (no import: `/web-react` stays dependency-free
+ * beyond React, and `@tangle-network/sandbox-ui` is an optional peer).
+ */
+import type { ReactNode } from 'react';
+import type { FileMention } from '../chat-routes/wire';
+/** Mirrors sandbox-ui#184's `MentionItem` — the atomic pill's payload. For a
+ *  file mention, `id` is the workspace-relative path (the pill's stable
+ *  identity and the `@<id>` serialization sandbox-ui uses to round-trip
+ *  `value`), `label` is the display name, and `detail` carries the full path
+ *  for the popover row's secondary line. */
+export interface MentionItem {
+    id: string;
+    label: string;
+    detail?: string;
+    kind?: string;
+}
+/** Mirrors sandbox-ui#184's `AgentComposerProps['mention']` shape — plug the
+ *  hook's `mention` return value straight into that prop. */
+export interface ComposerMentionProp {
+    trigger?: string;
+    fetchItems(query: string): Promise<MentionItem[]>;
+    onMentionsChange?(mentions: MentionItem[]): void;
+    renderItem?(item: MentionItem): ReactNode;
+    emptyText?: string;
+}
+/**
+ * Ranks `files` against `query` (case-insensitive), capped to `limit`:
+ * name-prefix matches first, then name-substring, then path-substring.
+ * Within a tier, shorter names sort first (the more specific match), then
+ * alphabetically by path for a stable order. An empty query returns the
+ * first `limit` entries unranked — the popover's default list before typing.
+ * Pure and dependency-free (no fuzzy-match library) so it's cheap enough to
+ * re-run on every keystroke against a 10k-entry index.
+ */
+export declare function rankFileMentions(files: readonly FileMention[], query: string, limit: number): FileMention[];
+/** Max popover results per query — enough to show a useful spread of matches
+ *  without pushing the fuzzy-filtered list past what a popover can usefully
+ *  render in one screen. */
+export declare const DEFAULT_MENTION_LIMIT = 20;
+/** How long a `ready` index is served before a background refetch — long
+ *  enough that a full session's worth of popover opens don't repeatedly hit
+ *  the index endpoint, short enough that a stale listing doesn't linger too
+ *  far past workspace file changes. Callers who need the index current right
+ *  now (e.g. just after the agent creates a file) call `refresh()` instead of
+ *  waiting on this window. */
+export declare const INDEX_REFRESH_AFTER_MS: number;
+/** Popover empty-state copy for a `ready` index whose query matched nothing.
+ *  Loading/warming/error states have their own copy — see `emptyTextFor`. */
+export declare const DEFAULT_MENTION_EMPTY_TEXT = "No matching files";
+/** Define options for configuring file mention fetching, caching, and display behavior */
+export interface UseFileMentionsOptions {
+    /** GET endpoint returning `FileIndexResponse` (a `createSandboxFileIndexRoute`). */
+    indexUrl: string;
+    /** Max popover results per query. Default {@link DEFAULT_MENTION_LIMIT}. */
+    limit?: number;
+    /** How long a `ready` index is served without a background refetch.
+     *  Default {@link INDEX_REFRESH_AFTER_MS}. */
+    refreshAfterMs?: number;
+    /** `fetch` override for tests / non-global-fetch hosts. Default `fetch`. */
+    fetchImpl?: typeof fetch;
+    /** Text shown in the popover's empty state once the index is loaded and
+     *  the query matched nothing. Default {@link DEFAULT_MENTION_EMPTY_TEXT}. */
+    emptyText?: string;
+}
+/** Provide properties and methods to manage and refresh file mentions in a composer interface */
+export interface UseFileMentionsResult {
+    /** Spread straight into `AgentComposer`'s `mention` prop. */
+    mention: ComposerMentionProp;
+    /** The files currently referenced by mentions in the composer's value —
+     *  the send-body list (map through `fileMentionsToParts`). */
+    mentions: FileMention[];
+    /** Drop all currently-referenced mentions (e.g. after a successful send). */
+    clearMentions: () => void;
+    /** Force a re-fetch of the index right now, ignoring `refreshAfterMs` — for
+     *  example right after the agent creates a file mid-session, so the next
+     *  popover open sees it. Dedupes against an already-in-flight load rather
+     *  than firing a second request. */
+    refresh: () => Promise<void>;
+}
+/** Resolve and manage file mention data with configurable fetching and state handling */
+export declare function useFileMentions(options: UseFileMentionsOptions): UseFileMentionsResult;

package/dist/web-react/work-product.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Work-product review surfaces — the sandbox-ui-FREE half of the vertical:
+ *
+ *  - {@link ReviewQueuePanel}: the practice/matters/campaign review queue over
+ *    a `fetchQueue(cursor)` data port (the `AgentActivityPanel` shape).
+ *  - {@link WorkProductCard}: the persisted `type:'work_product'` transcript
+ *    anchor rendered inside `ChatMessages` — chat stays the driver surface.
+ *  - {@link EvidenceLineageTable}: target → claim → source rows with
+ *    click-through via an injected `resolveSourceUrl` (the
+ *    `MessageAttachments.resolveFileUrl` pattern).
+ *  - {@link ExceptionList} / {@link QualityCheckList}: severity-badged
+ *    exception rows and pass/fail check rows.
+ *  - {@link ProvenanceStamp}: profileHash prefix + runId + serving-model
+ *    chips + the optional backtest slot ("182 cases · composite 0.81 ·
+ *    trust PASS" — or "quality: unverified" when the trust gate failed).
+ *
+ * Anything hosting sandbox-ui (DiffView, CodeView, PillTabs) lives in
+ * `./work-product-react` instead — this module must stay importable without
+ * the optional sandbox-ui peer.
+ */
+import { parseReviewQueueItem, type ReviewQueueItem, type ReviewQueueState } from '../work-product/queue';
+import type { EvidenceEntry, ExceptionEntry, ProfileBacktestSummary, QualityCheck, WorkProductPersistedPart, WorkProductProvenance, WorkProductStatus } from '../work-product/types';
+export { parseReviewQueueItem };
+export type { ReviewQueueItem, ReviewQueueState };
+/** Human label for a queue state. */
+export declare function reviewQueueStateLabel(state: ReviewQueueState): string;
+/** Human label for a work-product status. */
+export declare function workProductStatusLabel(status: WorkProductStatus): string;
+/** Every persisted work-product anchor on one message, re-validated. */
+export declare function workProductPartsFromMessageParts(parts: ReadonlyArray<Record<string, unknown>> | null | undefined): WorkProductPersistedPart[];
+/** Properties for the transcript anchor card rendered in chat */
+export 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. */
+export declare function WorkProductCard({ part, onOpen, className }: WorkProductCardProps): import("react").JSX.Element;
+/** One fetched page of queue items with an optional continuation cursor */
+export interface ReviewQueuePage {
+    items: ReviewQueueItem[];
+    /** Opaque continuation token; absent ⇒ no further pages. */
+    nextCursor?: string;
+}
+/** Properties for the review queue panel over a fetch data port */
+export 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. */
+export 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. */
+export declare function ReviewQueuePanel({ fetchQueue, onSelect, title, emptyLabel, className, }: ReviewQueuePanelProps): import("react").JSX.Element;
+/** Properties for the evidence lineage table with source click-through */
+export 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. */
+export declare function EvidenceLineageTable({ evidence, resolveSourceUrl, className }: EvidenceLineageTableProps): import("react").JSX.Element;
+/** Properties for the severity-badged exception list */
+export interface ExceptionListProps {
+    exceptions: readonly ExceptionEntry[];
+    className?: string;
+}
+/** Severity-badged exception rows with resolution state. */
+export declare function ExceptionList({ exceptions, className }: ExceptionListProps): import("react").JSX.Element;
+/** Properties for the pass/fail quality check list */
+export interface QualityCheckListProps {
+    checks: readonly QualityCheck[];
+    className?: string;
+}
+/** Pass/fail quality-check rows tagged with their source (agent self-report,
+ *  platform gate, judge ensemble). */
+export declare function QualityCheckList({ checks, className }: QualityCheckListProps): import("react").JSX.Element;
+/** Properties for the provenance stamp with the optional backtest slot */
+export 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. */
+export declare function ProvenanceStamp({ provenance, backtest, className }: ProvenanceStampProps): import("react").JSX.Element;