@opengeni/react 0.28.2 → 0.32.1

package/dist/timeline/fold-memory.d.ts

@@ -0,0 +1,15 @@
+export type FoldRestingState = "open" | "closed";
+/** Provide a per-timeline resting-state map (MessageTimeline owns one). */
+export declare const FoldMemoryProvider: import("react").Provider<Map<string, FoldRestingState> | null>;
+/** The ancestor fold-memory map, or null when none is mounted (inert). */
+export declare function useFoldMemory(): Map<string, FoldRestingState> | null;
+/**
+ * Single-cluster activity→turn wrap: copy the activity resting state onto the
+ * new turn-* key. Those ids differ across the wrap; without this the turn
+ * remounts settleFold and re-opens a chip the reader already watched collapse.
+ *
+ * Multi-cluster wraps deliberately do NOT inherit — the outer turn chip is new
+ * and still takes one settle beat; nested clusters keep their own activity-*
+ * memory so they stay closed under that beat.
+ */
+export declare function inheritFoldRestingState(memory: Map<string, FoldRestingState>, targetKey: string, sourceKeys: readonly string[]): void;

package/dist/timeline/index.d.ts

@@ -0,0 +1,18 @@
+export { buildTimeline, creditExhaustedFromEvents, extractSessionRef, groupTimeline, sessionStatusFromEvents, toolDisplayName, } from "./projection";
+export type { ActivityItem, AgentMessageItem, AuthNeededItem, ContextCompactionItem, FleetDecisionItem, FleetDecisionScoreItem, GoalItem, MachineInputBatchItem, MachineInputMember, MemoryItem, NoticeItem, ReasoningItem, SandboxItem, SessionStatusItem, TimelineGroup, TimelineItem, TurnEndItem, ToolCallItem, UserMessageItem, WorkerCompletionItem, WorkerItem, } from "./types";
+export { createToolRegistry, rawTypeOf } from "./registry";
+export type { CreateToolRegistryOptions, ToolRegistry, ToolRegistryEntry, ToolRenderer, ToolRendererProps, } from "./registry";
+export { createDefaultToolRegistry, defaultToolRegistry } from "./tool-renderers";
+export { ActivityRail } from "./activity-rail";
+export type { ActivityRailProps } from "./activity-rail";
+export { ActivityDisclosure, BodyNote, MediaEmpty, MediaSkeleton, PayloadBlock, ScreenshotFigure, TermBlock, Thumbnail, } from "./shared";
+export type { ActivityDisclosureProps, DisclosureChip } from "./shared";
+export { LightboxProvider, useLightbox, useLightboxOptional } from "./screenshot-lightbox";
+export { DisclosureDefaultsProvider, useForcedDefaultOpen } from "./disclosure-context";
+export { FoldMemoryProvider, inheritFoldRestingState, useFoldMemory } from "./fold-memory";
+export type { FoldRestingState } from "./fold-memory";
+export { SeenActivityIdsProvider, useSeenActivityIds } from "./seen-activity-ids";
+export { BUILT_IN_TURN_SUMMARY_FACET_IDS, TurnSummary, useTurnSettleOpen } from "./turn-summary";
+export type { BuiltInTurnSummaryFacetId, TurnOutcome, TurnSummaryContext, TurnSummaryFacet, TurnSummaryFacetConfiguration, TurnSummaryFacetResult, TurnSummaryOptions, TurnSummaryProps, } from "./turn-summary";
+export { applyPatchOps, controlCaret, execTruncated, isApplyPatch, isExecSessionLostBanner, looksBinary, parseExecBannerSessionId, parseToolArgs, redactSecrets, sandboxCommandExitCode, stripExecBanner, tailPeek, unwrapMcpOutput, v4aToGitFileDiff, } from "./parsers";
+export type { ApplyPatchOperation } from "./parsers";

package/dist/timeline/parsers.d.ts

@@ -0,0 +1,96 @@
+import { type GitFileDiff } from "@opengeni/sdk";
+/** Recover the exit code from a sandbox exec banner (`Process exited with code N`). */
+export declare function sandboxCommandExitCode(out: unknown): number | null;
+/**
+ * Recover the numeric exec-session id the sandbox embeds for a STILL-RUNNING
+ * (backgrounded) process (`Process running with session ID N`). A finished
+ * command emits `Process exited with code N` instead, which yields `null`.
+ */
+export declare function parseExecBannerSessionId(out: unknown): number | null;
+/** Strip the exec banner (`Chunk ID ...\n...\nOutput:\n`) down to the command's stdout. */
+export declare function stripExecBanner(out: unknown): string;
+/** The sandbox clamped the output (token/line truncation markers in the banner). */
+export declare function execTruncated(out: unknown): boolean;
+/** A `write_stdin` whose target PTY vanished (`write_stdin failed: session not found: N`). */
+export declare function isExecSessionLostBanner(out: unknown): boolean;
+/** True when the exec stdout looks binary/garbled (a NUL byte or ELF magic). */
+export declare function looksBinary(text: string): boolean;
+/**
+ * Render unprintable control characters as caret notation (0x03 -> `^C`) so a
+ * `write_stdin` keystroke payload reads cleanly in the row title.
+ */
+export declare function controlCaret(printable: string): string;
+/** One operation inside an `apply_patch_call` (a V4A file edit). */
+export type ApplyPatchOperation = {
+    /**
+     * The V4A op kind. The three canonical values are `create_file`,
+     * `update_file`, and `delete_file`; the open `string` tail tolerates a
+     * forward-compatible/unknown op kind from the provider without a type error
+     * (it falls through to the "Edited" treatment).
+     */
+    type: "create_file" | "update_file" | "delete_file" | (string & {});
+    path: string;
+    /** Rename target -- when present the op is a move/rename. */
+    moveTo?: string | null | undefined;
+    /** The V4A hunk string (`@@ ...` lines with `+`/`-`/context prefixes). */
+    diff?: string | undefined;
+};
+/**
+ * Parse a single V4A `apply_patch` operation into the SDK's `GitFileDiff` shape
+ * so it can flow into the SAME `DiffView` / `PierreDiff` the Files tab uses.
+ * Throws on a hunk string it cannot structure (no `@@` anchor on an update); the
+ * renderer catches and falls back to a raw-patch view.
+ */
+export declare function v4aToGitFileDiff(op: ApplyPatchOperation): GitFileDiff;
+/**
+ * Extract the `apply_patch` operations from a provider-native tool item's `raw`
+ * payload, normalizing the two wire shapes (`raw.operations[]` for a multi-file
+ * patch, `raw.operation` for a single op). The single owner of this shape so the
+ * renderer and the turn-summary facet counter never drift.
+ */
+export declare function applyPatchOps(raw: unknown): ApplyPatchOperation[];
+/**
+ * True when a tool item is an `apply_patch_call` — by its provider-native
+ * `raw.type` (the live-wire source of truth) or by tool `name` (first-party
+ * replays that omit `raw`). Centralizes the rawType-or-name check.
+ */
+export declare function isApplyPatch(item: {
+    name: string;
+    raw: unknown;
+}): boolean;
+/** Deep-redact secret-looking values so arguments never leak a key into the UI. */
+export declare function redactSecrets(value: unknown): unknown;
+/** Parse tool arguments that may arrive as a JSON string or an object. */
+export declare function parseToolArgs(args: unknown): Record<string, unknown>;
+/** The last non-empty line of a string -- the compact "what happened" peek. */
+export declare function tailPeek(text: string): string;
+/**
+ * Unwrap an MCP tool result (`{ content: [{ type: "text", text }], isError? }`)
+ * into a flat `{ text, isError }`. Non-MCP outputs pass through as their string
+ * form.
+ */
+export declare function unwrapMcpOutput(output: unknown): {
+    text: string;
+    isError: boolean;
+};
+/**
+ * Extract a renderable `data:` URL from a computer-use screenshot output,
+ * whatever transport produced it. The hosted `computer_call` and the
+ * function-text mode persist a plain `data:image/...` string; the
+ * function-image mode (codex-backed sessions) persists the STRUCTURED image
+ * output — `{type:"image", image:{data, mediaType}}` with `data` arriving as a
+ * number array / index map / Buffer-JSON / base64 string after event
+ * serialization — or the agents-core normalized `input_image` content item.
+ * Returns null when the output carries no image (so callers fall back to their
+ * text/empty presentation).
+ */
+export declare function screenshotDataUrl(out: unknown): string | null;
+export type TimelineMediaPreview = {
+    type: "media_preview";
+    mediaType: string;
+    inlineBytes: number | null;
+    fullOutputAvailable: false;
+    preview: string;
+};
+/** Find the explicit non-retained inline-media fact in a tool output. */
+export declare function mediaPreviewFact(out: unknown): TimelineMediaPreview | null;

package/dist/timeline/projection.d.ts

@@ -0,0 +1,38 @@
+import type { SessionEvent, SessionStatus } from "@opengeni/sdk";
+import type { TimelineGroup, TimelineItem } from "./types";
+/** Readable label for a tool call, without leaking an MCP server prefix. */
+export declare function toolDisplayName(name: string): string;
+export declare function buildTimeline(events: SessionEvent[]): TimelineItem[];
+/**
+ * Codex subscription web search can return private citation handles without
+ * the URL annotation table that would make them resolvable. Keep the canonical
+ * model-history item untouched, but never expose those unusable handles in the
+ * human timeline. Ordinary markdown links and structured URL citations remain.
+ */
+export declare function stripOpaqueCitationTokens(text: string): string;
+/**
+ * Whether the session's most recent turn ended in credit exhaustion — the
+ * terminal credit state apps key their "add credits" affordances on. Derived
+ * from the LAST turn-end event (completed/failed/cancelled): a later turn that
+ * settles any other way (someone topped up and kept working) clears it.
+ */
+export declare function creditExhaustedFromEvents(events: SessionEvent[]): boolean;
+/** The latest session status carried in the event log, if any. */
+export declare function sessionStatusFromEvents(events: SessionEvent[]): SessionStatus | null;
+export declare function groupTimeline(items: TimelineItem[]): TimelineGroup[];
+/**
+ * Find a session id in orchestration tool arguments or output. Handles raw
+ * objects, JSON strings, and MCP tool results (`{ content: [{ type: "text",
+ * text: "{...}" }], structuredContent? }`).
+ */
+export declare function extractSessionRef(value: unknown, depth?: number): string | null;
+/**
+ * Readable label for a tool call ("session_create" -> "session create").
+ *
+ * MCP tools are namespaced `<serverId>__<toolName>` (see prefixedMcpToolName),
+ * and for catalog-imported servers that serverId is an opaque slug+hash
+ * ("mcp-integrations-sh-supabase-com-34ed9dcf1390-0i6tcf8"). De-slugging the
+ * whole thing leaked that id into the timeline; strip the server prefix and show
+ * just the tool ("list organizations"). Names without the `__` boundary (plain
+ * built-ins like "session_create") are unaffected.
+ */

package/dist/timeline/registry.d.ts

@@ -0,0 +1,40 @@
+import type { ComponentType } from "react";
+import type { ToolCallItem } from "./types";
+export type ToolRendererProps = {
+    item: ToolCallItem;
+};
+export type ToolRenderer = ComponentType<ToolRendererProps>;
+/** A registry entry: which key it matches and the component that renders it. */
+export type ToolRegistryEntry = {
+    match: "rawType";
+    type: string;
+    render: ToolRenderer;
+} | {
+    match: "name";
+    name: string;
+    render: ToolRenderer;
+};
+export type ToolRegistry = {
+    /** Resolve the renderer for a call (never null — falls back to generic). */
+    resolve: (item: ToolCallItem) => ToolRenderer;
+    /** The generic fallback renderer. */
+    fallback: ToolRenderer;
+};
+export type CreateToolRegistryOptions = {
+    /**
+     * Entries that take precedence over the built-ins. Earlier entries win, so a
+     * consumer can shadow a default renderer for the same key.
+     */
+    entries?: ToolRegistryEntry[] | undefined;
+    /** Replace the generic fallback used for unmatched tools. */
+    fallback?: ToolRenderer | undefined;
+};
+/** The `raw.type` of a projected tool call, when the provider item carries one. */
+export declare function rawTypeOf(item: ToolCallItem): string | null;
+/**
+ * Build a tool registry from a set of entries and a fallback. The returned
+ * registry resolves in priority order: `raw.type` entries first, then `name`
+ * entries, then the fallback. Consumer `entries` are consulted before the
+ * built-in `baseEntries`, so they shadow defaults cleanly.
+ */
+export declare function createToolRegistry(baseEntries: ToolRegistryEntry[], baseFallback: ToolRenderer, options?: CreateToolRegistryOptions): ToolRegistry;

package/dist/timeline/screenshot-lightbox.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from "react";
+type LightboxController = {
+    open: (src: string, caption?: string) => void;
+};
+/** Open the app-level screenshot lightbox. No-op outside a `LightboxProvider`. */
+export declare function useLightbox(): LightboxController;
+/**
+ * The lightbox controller when one is mounted, or `null` outside a
+ * `LightboxProvider`. Lets a media primitive degrade to a non-interactive image
+ * (rather than a dead "Expand" button that announces an action it cannot do).
+ */
+export declare function useLightboxOptional(): LightboxController | null;
+/**
+ * The app-level screenshot lightbox. Render once near the timeline; renderers
+ * call `useLightbox().open(src)`.
+ *
+ * Idempotent by design: when an ancestor `LightboxProvider` already exists (e.g.
+ * a `MessageTimeline` mounted inside an app that already wraps its shell), this
+ * one becomes a pass-through and does NOT mount a second focus-trapping Dialog.
+ * That keeps `MessageTimeline` self-sufficient (it owns its own provider) while
+ * composing cleanly when nested.
+ */
+export declare function LightboxProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/timeline/seen-activity-ids.d.ts

@@ -0,0 +1,2 @@
+export declare const SeenActivityIdsProvider: import("react").Provider<Set<string> | null>;
+export declare function useSeenActivityIds(): Set<string> | null;

package/dist/timeline/shared.d.ts

@@ -0,0 +1,125 @@
+import { type ReactNode } from "react";
+/**
+ * A subtle settle signal — see the CHIP DOCTRINE above. The closed tone set.
+ * `"interrupted"` is a calm neutral tone for cancelled items — no dot, same
+ * quiet weight as `"muted"`, but semantically distinct from metadata.
+ */
+export type DisclosureChip = {
+    tone: "ok" | "bad" | "muted" | "interrupted";
+    text: string;
+};
+export type ActivityDisclosureProps = {
+    icon: ReactNode;
+    /** Icon tint. Defaults to the muted foreground; renderers pass accent/failed. */
+    iconTone?: "accent" | "failed" | "running" | "muted" | undefined;
+    title: ReactNode;
+    /** Render the title in the mono face (commands, paths). */
+    titleMono?: boolean | undefined;
+    /** Shimmer the title while the tool is in-flight. */
+    running?: boolean | undefined;
+    /**
+     * Quiet single-line secondary text (truncated). It is detail-on-demand: hidden
+     * when a media preview is set, AND hidden once the row is expanded (the body
+     * then owns the detail), so a stat/path never appears twice at once.
+     */
+    preview?: ReactNode | undefined;
+    /** A small inline media preview (a screenshot thumbnail) shown in place of `preview`. */
+    media?: ReactNode | undefined;
+    /** At most one quiet settle chip, right-aligned to the gutter. */
+    chip?: DisclosureChip | undefined;
+    /**
+     * When true the row carries the standard failure affordance: the icon is tinted
+     * red and a "failed" bad-chip appears in the right gutter (unless an explicit
+     * `chip` is already supplied — the caller's chip wins). Output is still visible
+     * on expand; this is a quiet status signal, not a blocking banner.
+     *
+     * Renderers should pass `failed={item.status === "failed"}` on their settled
+     * (non-running) paths so any tool with a failed status shows a consistent
+     * affordance without each renderer having to duplicate the logic.
+     */
+    failed?: boolean | undefined;
+    /**
+     * When true the row carries a calm "interrupted" affordance: the icon stays
+     * muted (no red) and a quiet "interrupted" chip appears in the right gutter
+     * (unless an explicit `chip` is already supplied — the caller's chip wins).
+     * This is the cancelled-status analogue of `failed`, but deliberately calm
+     * and neutral — it is NOT an error; the user chose to stop.
+     *
+     * Renderers should pass `cancelled={item.status === "cancelled"}` so any
+     * in-flight item that was interrupted on turn.cancelled reads consistently.
+     * `cancelled` is ignored when `failed` is also true (failure takes precedence).
+     */
+    cancelled?: boolean | undefined;
+    /** When false the row is a static line (no expand affordance). */
+    expandable?: boolean | undefined;
+    children?: ReactNode | undefined;
+};
+/**
+ * The one disclosure row shape every activity row reuses (tool calls, reasoning,
+ * sandbox ops): a chevron, a tinted icon, a title, an optional muted preview or
+ * inline media, and at most one right-gutter settle chip. Compact by default;
+ * the body mounts only when expanded.
+ */
+export declare function ActivityDisclosure({ icon, iconTone: iconToneProp, title, titleMono, running, preview, media, chip: chipProp, failed, cancelled, expandable, children, }: ActivityDisclosureProps): import("react/jsx-runtime").JSX.Element;
+export declare function TermBlock({ command, workdir, output, live, tailLines, failed, }: {
+    /**
+     * The command shown in the prompt header. Pass `null` when the row title
+     * already carries it (e.g. an exec row titled `$ cmd`): the header then drops
+     * the command — and the whole prompt line if there is no workdir either — so
+     * the command never reads twice, stacked, above the output.
+     */
+    command: string | null;
+    workdir?: string | null | undefined;
+    /** The FULL output. TermBlock owns the tail/full slicing internally. */
+    output: string;
+    live?: boolean | undefined;
+    /** A non-zero exit / failed call — tints the left accent red (the one hue). */
+    failed?: boolean | undefined;
+    /**
+     * When the output exceeds the tail window, only the last `tailLines` are shown
+     * with a "show full output" toggle. The component holds the full text, so the
+     * toggle reveals the rest (never a dead affordance). Defaults to 12.
+     */
+    tailLines?: number | undefined;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function PayloadBlock({ label, value, failed, }: {
+    label: string;
+    value: unknown;
+    failed?: boolean | undefined;
+}): import("react/jsx-runtime").JSX.Element | null;
+/** A quiet inline note inside an expanded body (lost output, empty frame, …). */
+export declare function BodyNote({ children, tone, }: {
+    children: ReactNode;
+    tone?: "error" | "muted" | undefined;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * A loading screenshot placeholder. A faint camera glyph over a shimmering box,
+ * so a still frame of the running state reads unambiguously as "capturing" — not
+ * a broken thumbnail.
+ */
+export declare function MediaSkeleton(): import("react/jsx-runtime").JSX.Element;
+/** A standardized "tool ran, produced no image" placeholder in the media slot. */
+export declare function MediaEmpty(): import("react/jsx-runtime").JSX.Element;
+/**
+ * A small inline screenshot thumbnail that opens the app lightbox on click.
+ *
+ * Requires a `LightboxProvider` ancestor for the click-to-expand affordance.
+ * Outside one it degrades to a plain, non-interactive image — never a dead
+ * "Expand" button that announces an action it cannot perform.
+ */
+export declare function Thumbnail({ src, caption, alt, }: {
+    src: string;
+    caption?: string | undefined;
+    alt?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * The expanded screenshot inside a tool body: a contained, clickable preview
+ * (opens the lightbox) with a quiet caption. Constrained height + object-contain
+ * so it never breaks the row layout. Like {@link Thumbnail}, it degrades to a
+ * plain image outside a `LightboxProvider`.
+ */
+export declare function ScreenshotFigure({ src, caption, alt, }: {
+    src: string;
+    caption?: string | undefined;
+    alt?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/timeline/tool-diff.d.ts

@@ -0,0 +1,8 @@
+import type { GitFileDiff } from "@opengeni/sdk";
+export declare function ToolDiff({ files }: {
+    files: GitFileDiff[];
+}): import("react/jsx-runtime").JSX.Element;
+/** Raw-patch fallback for a V4A hunk string the parser could not structure. */
+export declare function RawPatch({ diff }: {
+    diff: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/timeline/tool-display-name.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Readable label for a tool call ("session_create" -> "session create").
+ *
+ * MCP tools are namespaced `<serverId>__<toolName>` (see prefixedMcpToolName),
+ * and for catalog-imported servers that serverId is an opaque slug+hash.
+ * De-slugging the whole thing leaked that id into the timeline; strip the
+ * server prefix and show just the tool. Names without the `__` boundary (plain
+ * built-ins like "session_create") are unaffected.
+ */
+export declare function toolDisplayName(name: string): string;

package/dist/timeline/tool-renderers.d.ts

@@ -0,0 +1,5 @@
+import { createToolRegistry, type ToolRegistry } from "./registry";
+/** The built-in tool renderer registry: every first-party tool plus a fallback. */
+export declare const defaultToolRegistry: ToolRegistry;
+/** Build a registry that extends the built-ins with consumer entries/fallback. */
+export declare function createDefaultToolRegistry(options?: Parameters<typeof createToolRegistry>[2]): ToolRegistry;

package/dist/timeline/turn-summary.d.ts

@@ -0,0 +1,116 @@
+import { type ReactNode } from "react";
+import type { ActivityItem, ToolCallItem, TurnOutcome } from "./types";
+export type { TurnOutcome } from "./types";
+/**
+ * True while settle chrome is active (open beat, slow collapse, or the short
+ * cancel-close latch). Nested cluster chips stay mounted and forced OPEN for
+ * this window so the body keeps a stable height — never flat-map to bare
+ * rails, and never remount closed nested chips mid-collapse (that yanked).
+ */
+export declare function useTurnSettleOpen(): boolean;
+export declare const BUILT_IN_TURN_SUMMARY_FACET_IDS: readonly ["steps", "files", "commands", "screenshots", "memories", "compacted", "duration"];
+export type BuiltInTurnSummaryFacetId = (typeof BUILT_IN_TURN_SUMMARY_FACET_IDS)[number];
+export type TurnSummaryContext = Readonly<{
+    /** Every normalized activity item folded into this summary. */
+    items: readonly ActivityItem[];
+    /** Tool calls from `items`, retained in timeline order for convenient aggregation. */
+    toolCalls: readonly ToolCallItem[];
+    /** The settled turn verdict, or absent for a neutral/incomplete cluster. */
+    outcome: TurnOutcome | undefined;
+    /** The bounded failure reason rendered by the enclosing summary, when present. */
+    failureText: string | undefined;
+    /** Total turn duration when the enclosing group has both valid timestamps. */
+    durationMs: number | undefined;
+    /** False when any projected activity is still running or streaming. */
+    settled: boolean;
+    /**
+     * Adjacent compaction landmarks next to this fold. Landmark remains the
+     * primary UI; this is a secondary chip signal only.
+     */
+    contextCompactionCount: number;
+}>;
+export type TurnSummaryFacetResult = Readonly<{
+    icon?: ReactNode;
+    content: ReactNode;
+    ariaLabel?: string;
+    title?: string;
+}>;
+export type TurnSummaryFacet = Readonly<{
+    /** Stable identity used for removal and deterministic de-duplication. */
+    id: string;
+    /** Return null when this facet has nothing useful to show. */
+    summarize(context: TurnSummaryContext): TurnSummaryFacetResult | null;
+}>;
+type ModifyTurnSummaryFacets = Readonly<{
+    /** Appended after the remaining built-ins, in supplied order. */
+    add?: readonly TurnSummaryFacet[];
+    /** Built-ins to omit before custom facets are appended. */
+    remove?: readonly BuiltInTurnSummaryFacetId[];
+    replace?: never;
+}>;
+type ReplaceTurnSummaryFacets = Readonly<{
+    /** The complete ordered facet list. Mutually exclusive with add/remove. */
+    replace: readonly TurnSummaryFacet[];
+    add?: never;
+    remove?: never;
+}>;
+export type TurnSummaryFacetConfiguration = ModifyTurnSummaryFacets | ReplaceTurnSummaryFacets;
+export type TurnSummaryOptions = Readonly<{
+    facets?: TurnSummaryFacetConfiguration;
+}>;
+export type TurnSummaryProps = {
+    /** The activity items in the turn (used only to compute the facet counts). */
+    items: ActivityItem[];
+    /**
+     * The settled verdict — or absent for a completed CLUSTER of a still-running
+     * turn, which folds neutrally: no verdict glyph (the turn has none yet), a
+     * quiet pulse dot in its place so alignment and the running feel both hold.
+     */
+    outcome?: TurnOutcome | undefined;
+    /** A short failure reason shown inline on a failed chip (never hidden). */
+    failureText?: string | undefined;
+    /** Elapsed turn duration; shown as a trailing facet when at least 1s. */
+    durationMs?: number | undefined;
+    /** Start expanded. */
+    defaultOpen?: boolean | undefined;
+    /**
+     * A nested fold — a cluster or sub-turn INSIDE an already-expanded turn. It
+     * drops the bordered/filled chip and renders as a plain disclosure node on the
+     * parent's rail (chevron + glyph + facets), so expanding a turn reveals a thread
+     * of nodes, never a stack of boxes-in-boxes. The top-level fold stays a chip.
+     */
+    bare?: boolean | undefined;
+    /** Per-instance facet customization. Omit to preserve the built-in summary exactly. */
+    facets?: TurnSummaryFacetConfiguration | undefined;
+    /**
+     * Settle choreography: this fold replaced rows the reader was just watching
+     * live. Instead of yanking them behind a chip in one frame, the fold mounts
+     * OPEN with the summary chip easing in above the still-visible rows, holds a
+     * short beat so the reader registers the settle, then glides closed. Any
+     * user interaction during the beat cancels the auto-collapse. Captured at
+     * mount; ignored when the fold starts expanded (e.g. a failed turn).
+     */
+    settleFold?: boolean | undefined;
+    /**
+     * Durable identity (timeline group id) for cross-remount fold memory. When
+     * an ancestor provides a {@link FoldMemoryProvider} map, reaching a resting
+     * state is recorded under this key: "closed" when the settle choreography
+     * completes its collapse or the reader closes the chip, "open" when the
+     * reader expands it. A later remount under the same key restores that
+     * resting state and never replays the open settle beat — the activity→turn
+     * wrap and the nested force-open during settle chrome must not re-expand a
+     * fold that already settled closed.
+     */
+    foldKey?: string | undefined;
+    /**
+     * When set, a hover/focus copy control sits on the chip row (outside the
+     * disclosure trigger) so the reader can copy the turn's assistant prose
+     * without toggling the fold.
+     */
+    copyText?: string | undefined;
+    /** Adjacent compaction landmark count for the secondary chip facet. */
+    contextCompactionCount?: number | undefined;
+    /** The rendered activity rail revealed on expand. */
+    children: ReactNode;
+};
+export declare function TurnSummary({ items, outcome, failureText, durationMs, defaultOpen, bare, facets: facetConfiguration, settleFold, foldKey, copyText, contextCompactionCount, children, }: TurnSummaryProps): import("react/jsx-runtime").JSX.Element;