@prettier-ai/dsh-client-ui-chat 0.1.2-alpha.1

package/lib/types/client/chat/message-chrome.d.ts

@@ -0,0 +1,49 @@
+import type { Translate } from '@prettier-ai/dsh-client-ui-slots';
+/** The date-template share of the conversation dictionary the clock consumes. */
+export type ClockTranslate = Translate<'clock.md' | 'clock.ymd'>;
+/** The elapsed-duration share of the conversation dictionary. */
+export type RunDurationTranslate = Translate<'duration.seconds' | 'duration.minutes'>;
+/**
+ * Local calendar-day epoch (ms at local midnight) for an instant.
+ * @param ms - Unix epoch ms.
+ * @returns Midnight of that local calendar day.
+ */
+export declare function startOfLocalDay(ms: number): number;
+/**
+ * Delay until the next local midnight after `ms` (at least 1ms).
+ * @param ms - Unix epoch ms.
+ * @returns Milliseconds until the following local midnight.
+ */
+export declare function msUntilNextLocalMidnight(ms: number): number;
+/**
+ * Localized elapsed-time label shared by running and settled turn chrome.
+ * @param ms - Elapsed duration in milliseconds (negatives clamp to zero).
+ * @param t - Translate seat supplying the duration templates.
+ * @returns Display string in whole seconds.
+ */
+export declare function formatRunDuration(ms: number, t: RunDurationTranslate): string;
+/**
+ * Sub-turn latency figure: one decimal under ten seconds, whole seconds
+ * beyond. Unit-less so the locale template owns the second suffix.
+ * @param ms - Latency in milliseconds (negatives clamp to zero).
+ * @returns Display number in seconds without unit.
+ */
+export declare function formatLatencySeconds(ms: number): string;
+/**
+ * Decode-throughput figure: whole tokens from ten up, one decimal below.
+ * @param tps - Tokens per second.
+ * @returns Display number without unit.
+ */
+export declare function formatTokensPerSecond(tps: number): string;
+/**
+ * Compact local timestamp for message IconActions. Same calendar day →
+ * `HH:mm`; earlier this year → the `clock.md` date template + clock; other
+ * years → the `clock.ymd` template + clock. Pure: the date templates arrive
+ * through the caller's locale seat.
+ * @param time - Unix epoch ms from the source session event.
+ * @param t - translate seat supplying the `clock.md` / `clock.ymd` templates.
+ * @param now - Reference instant for the day/year cut (defaults to wall clock).
+ * @returns Date-aware clock string (24-hour, zero-padded time).
+ */
+export declare function formatMessageClock(time: number, t: ClockTranslate, now?: number): string;
+//# sourceMappingURL=message-chrome.d.ts.map

package/lib/types/client/chat/register-node-renderers.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '@prettier-ai/cordis';
+/**
+ * Register this package's business renderers behind the keyed Chat Node seat.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerChatNodeRenderers(ctx: Context): void;
+//# sourceMappingURL=register-node-renderers.d.ts.map

package/lib/types/client/chat/searchable-hidden.d.ts

@@ -0,0 +1,9 @@
+import { type RefObject } from 'react';
+/**
+ * Apply searchable hidden state without unmounting a stable subtree.
+ * @param hidden - whether the subtree is currently hidden.
+ * @param reveal - callback for browser find's `beforematch` reveal.
+ * @returns ref for the stable subtree root.
+ */
+export declare function useSearchableHidden(hidden: boolean, reveal: () => void): RefObject<HTMLDivElement>;
+//# sourceMappingURL=searchable-hidden.d.ts.map

package/lib/types/client/chat/token-format.d.ts

@@ -0,0 +1,25 @@
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+/**
+ * Compact token count: 517 / 12.2K / 517K / 1.2M.
+ * @param value - non-negative token count.
+ * @param t - Chat locale seat.
+ * @returns locale-owned compact display string.
+ */
+export declare function formatTokens(value: number, t: ChatViewSlotProps['t']): string;
+/**
+ * Exact integer token count with locale-owned digit grouping.
+ * @param value - non-negative safe integer token count.
+ * @param t - Chat locale seat.
+ * @returns an unrounded display string.
+ */
+export declare function formatExactTokens(value: number, t: ChatViewSlotProps['t']): string;
+/**
+ * Display-ready cache-hit share without rounding a partial hit to 100%.
+ * @param cacheReadTokens - exact prompt tokens served from cache.
+ * @param promptTokens - exact aggregate prompt tokens.
+ * @param decimalPlaces - ordinary-ratio precision; partial hits that would
+ * round to 100 automatically use enough additional precision to stay honest.
+ * @returns percentage text, or null when there was no prompt input.
+ */
+export declare function formatCacheHitPercent(cacheReadTokens: number, promptTokens: number, decimalPlaces?: 0 | 1): string | null;
+//# sourceMappingURL=token-format.d.ts.map

package/lib/types/client/chat/turn-assistant.d.ts

@@ -0,0 +1,8 @@
+import type { AssistantBlock } from '../contract/snapshot.ts';
+/**
+ * Collect visible prose from one Assistant lifecycle.
+ * @param blocks - Assistant content blocks.
+ * @returns concatenated text blocks.
+ */
+export declare function assistantText(blocks: readonly AssistantBlock[]): string;
+//# sourceMappingURL=turn-assistant.d.ts.map

package/lib/types/client/chat/use-calendar-day.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Local calendar-day epoch that advances at each local midnight.
+ * @returns Midnight ms for the current local day; updates after the boundary.
+ */
+export declare function useCalendarDay(): number;
+//# sourceMappingURL=use-calendar-day.d.ts.map

package/lib/types/client/chat/use-throttled-visual-update.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Return a stable scheduler that coalesces visual updates over a frame interval.
+ * @param update - DOM alignment to run after the throttle interval.
+ * @param intervalFrames - frames to wait before applying the latest alignment.
+ * @returns a stable function that schedules the latest update.
+ */
+export declare function useThrottledVisualUpdate(update: () => void, intervalFrames?: number): () => void;
+//# sourceMappingURL=use-throttled-visual-update.d.ts.map

package/lib/types/client/contract/assistant-content.d.ts

@@ -0,0 +1,9 @@
+import type { AssistantBlock } from './snapshot.ts';
+/**
+ * Test whether Assistant blocks contain a user-facing reply rather than only
+ * reasoning or Tool-call protocol material.
+ * @param blocks - Assistant content blocks.
+ * @returns whether the blocks contain visible reply content.
+ */
+export declare function hasAssistantReplyContent(blocks: readonly AssistantBlock[]): boolean;
+//# sourceMappingURL=assistant-content.d.ts.map

package/lib/types/client/contract/chat-nodes.d.ts

@@ -0,0 +1,110 @@
+import type { AssistantBlock, AssistantMessageNode, CommandNode, CompactionSummaryNode, ConversationLocation, ConversationViewNode, ModelRetryNode, RunningToolCall, ToolCallBlock } from '@prettier-ai/dsh-client-ui-conversation/client';
+/** Final Chat render unit produced by a Chat business Definition. */
+export interface ChatConversationViewNode extends ConversationViewNode {
+    readonly target: 'chat';
+    readonly anchorSeq: number;
+    readonly location: ConversationLocation;
+    readonly visibility: 'visible' | 'hidden';
+}
+/** Merge-extensible payload registry keyed by final Chat renderer kind. */
+export interface ChatNodeDataMap {
+}
+/** Renderer kinds contributed by the currently installed Chat business modules. */
+export type ChatNodeKind = Extract<keyof ChatNodeDataMap, string>;
+/** Final Chat Node narrowed to one registered renderer kind and payload. */
+export type ChatNode<Kind extends ChatNodeKind = ChatNodeKind> = {
+    [RegisteredKind in Kind]: ChatConversationViewNode & {
+        readonly kind: RegisteredKind;
+        readonly data: ChatNodeDataMap[RegisteredKind];
+    };
+}[Kind];
+/** Final Assistant row payload shared by streaming and settled states. */
+export interface AssistantChatData {
+    readonly status: 'running' | 'settled' | 'interrupted';
+    readonly turn: number;
+    readonly step: number;
+    readonly blocks: readonly AssistantBlock[];
+    readonly time: number;
+    readonly usage?: unknown;
+    readonly finalNode?: AssistantMessageNode;
+}
+/** Settled or interrupted Assistant payload with its durable presentation node. */
+export type FinalAssistantChatData = AssistantChatData & {
+    readonly finalNode: AssistantMessageNode;
+};
+/** Root Tool row payload; the root lifecycle owns all recursive subcalls. */
+export interface ToolChatData {
+    readonly root: ToolCallBlock;
+}
+/** One manual command and its correlated compaction transaction. */
+export interface ManualCompactionChatData {
+    readonly command: CommandNode;
+    readonly compaction: CompactionSummaryNode | null;
+}
+/** One durable retry chain rendered as a single row. */
+export interface RetryChatData {
+    readonly attempts: readonly ModelRetryNode[];
+    readonly current: ModelRetryNode;
+}
+/** One provider/model route that contributed a billed request attempt. */
+export interface TurnTokenUsageRoute {
+    readonly provider: string;
+    readonly model: string;
+}
+/** Exact provider-reported token accounting for every attempt in one completed Turn. */
+export interface TurnTokenUsage {
+    /** Sum of uncached prompt input across all attempts. */
+    readonly uncachedInputTokens: number;
+    readonly outputTokens: number;
+    /** Exact aggregate prompt plus output total across all attempts. */
+    readonly totalTokens: number;
+    /** Present only when every attempt reported the bucket. */
+    readonly cacheReadTokens?: number;
+    /** Present only when every attempt reported the bucket. */
+    readonly cacheWriteTokens?: number;
+    /** Output subset, present only when every attempt reported it. */
+    readonly reasoningTokens?: number;
+    /** Present only when every billed attempt has provider/model attribution. */
+    readonly routes?: readonly TurnTokenUsageRoute[];
+}
+/** Turn-local footer row that owns actions and optional feature contributions. */
+export interface TurnTailChatData {
+    readonly turn: number;
+    readonly seq: number;
+    readonly time: number;
+    /** Last finalized content-bearing Assistant in this Turn. */
+    readonly closing: FinalAssistantChatData | null;
+    /** Whether non-rendered later evidence makes the closing seq non-tail. */
+    readonly branchUnavailable: boolean;
+    readonly ttftMs?: number;
+    readonly tokensPerSecond?: number;
+    /** Exact per-Turn accounting; absent when the loaded evidence is incomplete. */
+    readonly tokenUsage?: TurnTokenUsage;
+}
+/** Turn-level process disclosure projected before the finalized answer. */
+export interface TurnProcessChatData {
+    readonly turn: number;
+    readonly controlAnchorSeq: number;
+    readonly processStartSeq: number;
+    readonly answerAnchorSeq: number | null;
+    readonly answerStep: number | null;
+    readonly inlineReasoning: boolean;
+    readonly messageCount: number;
+    readonly toolCallCount: number;
+    readonly subagentCount: number;
+}
+/**
+ * Test whether a Tool root has settled.
+ * @param block - Tool root lifecycle value.
+ * @returns whether the root carries its final result.
+ */
+export declare function isSettledTool(block: ToolCallBlock): block is Extract<ToolCallBlock, {
+    kind: 'tool-result';
+}>;
+/**
+ * Test whether a Tool root is still running.
+ * @param block - Tool root lifecycle value.
+ * @returns whether the root lacks a final result.
+ */
+export declare function isRunningTool(block: ToolCallBlock): block is RunningToolCall;
+//# sourceMappingURL=chat-nodes.d.ts.map

package/lib/types/client/contract/slots.d.ts

@@ -0,0 +1,195 @@
+/** Chat-owned Slot declarations and composed component props. */
+import type { MessageId } from '@prettier-ai/dsh-llm/brand';
+import type { ConversationTurnDataMap, MessageImageLoader, MessageImagesOwnerProps, RenderMessageImages, TurnLocation } from '@prettier-ai/dsh-client-ui-conversation/client';
+import type { InjectFace, PropsLocale, PropsRenderSlots, PropsRuntime, PropsStore, SlotHookFactory, SnapshotSelectorHook } from '@prettier-ai/dsh-client-ui-slots';
+import type { SnapshotStore } from '@prettier-ai/dsh-client-store';
+import type { MarkdownFileMentions } from '@prettier-ai/dsh-client-ui-primitives';
+import type { createChatStore } from '../stores.ts';
+import type { ToolCallId, SelectionTarget } from './store.ts';
+import type { ChatNode, ChatNodeKind } from './chat-nodes.ts';
+import type { ChatSnapshot, CommandNode, CompactionSummaryNode, ToolCallBlock } from './snapshot.ts';
+import type { TurnProcessSpec } from './turn-process.ts';
+import type { TranscriptViewMode } from '../../chat-settings.ts';
+/** Selector hook over the current Conversation binding's Chat target. */
+export type UseChat = SnapshotSelectorHook<ChatSnapshot>;
+/** Owner currency of the completed-Turn extension chain. */
+export interface TurnTailOwnerProps {
+    turn: TurnLocation;
+    seq: number;
+    openFile: (path: string) => void;
+}
+/** Owner currency of finalized-assistant actions. */
+export interface AssistantActionOwnerProps {
+    messageId: MessageId;
+}
+/** Optional prose file-mention provider consumed by Chat. */
+export interface ChatFileMentions {
+    /**
+     * Resolve prose links for one closing Turn.
+     * @param owner - closing-Turn identity and file opener.
+     * @returns link resolver when available.
+     */
+    forClosing(owner: TurnTailOwnerProps): MarkdownFileMentions | undefined;
+}
+declare module '@prettier-ai/cordis' {
+    interface Context {
+        /** Optional prose file-mention provider. */
+        chatFileMentions: ChatFileMentions;
+    }
+}
+/** Hook constrained to business data published on the current Chat Node's Turn. */
+export type UseChatNodeTurnData = <Key extends Extract<keyof ConversationTurnDataMap, string>>(key: Key) => Readonly<ConversationTurnDataMap[Key]> | undefined;
+/** Slot-level Hook factory for keyed Chat renderers. */
+export interface ChatNodeTurnDataInjected {
+    hooks: {
+        turnData: SlotHookFactory<'conversation.chat.node', UseChatNodeTurnData>;
+    };
+}
+/** Stable owner currency delivered to a keyed Chat renderer. */
+export interface ChatNodeOwnerProps {
+    selectedCallId?: ToolCallId | undefined;
+    cwd?: string | undefined;
+    openFile: (path: string) => void;
+    inspectCall: (callId: ToolCallId) => void;
+    forkAt: (seq: number) => void;
+    renderMessageImages: RenderMessageImages;
+    fileMentions: (owner: TurnTailOwnerProps) => MarkdownFileMentions | undefined;
+    /** Turn-process state when this Node belongs to a projected Turn. */
+    turnProcess?: TurnProcessOwnerProps | undefined;
+}
+/** Shared presentation state for one Turn-process answer generation. */
+export interface TurnProcessOwnerProps {
+    readonly spec: TurnProcessSpec;
+    readonly foldable: boolean;
+    readonly open: boolean;
+    setOpen(open: boolean): void;
+}
+/** Full props of one keyed Chat renderer. */
+export type ChatNodeViewProps<Kind extends ChatNodeKind = ChatNodeKind> = PropsRuntime<'conversation.chat.node', Kind> & PropsLocale<'chat'>;
+/** Tool block rendered in the details panel. */
+export interface DetailsToolOwnerProps {
+    block: ToolCallBlock;
+    cwd?: string | undefined;
+}
+/** Command-row owner share. */
+export interface CommandRowOwnerProps {
+    node: CommandNode;
+    compaction?: CompactionSummaryNode;
+}
+/** Full props of a registered command row. */
+export type CommandRowProps = PropsRuntime<'conversation.chat.commandview'>;
+/** Shared Chat store handle. */
+export type ChatStore = ReturnType<typeof createChatStore>;
+/** In-memory reader position resilient to transcript reflow. */
+export interface ChatScrollPosition {
+    readonly anchorKey: string;
+    readonly anchorTop: number;
+    readonly scrollTop: number;
+}
+/** Business callbacks injected into the Chat view. */
+export interface ChatViewInjected {
+    hooks: {
+        /** Persisted completed-Turn transcript presentation. */
+        transcriptView: SnapshotStore<TranscriptViewMode>;
+    };
+    openDetails: (target: SelectionTarget) => void;
+    openFile: (path: string) => Promise<void>;
+    loadOlder: () => void;
+    loadImage: MessageImageLoader;
+    chatScroll: {
+        save: (position: ChatScrollPosition | null) => void;
+        read: () => ChatScrollPosition | null;
+    };
+    forkAt: (seq: number) => void;
+    fileMentions: (owner: TurnTailOwnerProps) => MarkdownFileMentions | undefined;
+}
+/** Full Chat view props. */
+export type ChatViewSlotProps = PropsRuntime<'conversation.view'> & PropsRenderSlots<'conversation.chat.node' | 'conversation.message.images'> & PropsStore<ChatStore> & InjectFace<ChatViewInjected> & PropsLocale<'chat'>;
+/** Full props of the durable-message image renderer. */
+export type MessageImagesProps = PropsRuntime<'conversation.message.images'> & PropsLocale<'conversation'>;
+/** Details-panel callbacks. */
+export interface DetailsInjected {
+    closeDetails: () => void;
+}
+/** Full details-panel props. */
+export type DetailsSlotProps = PropsRuntime<'details'> & PropsRenderSlots<'conversation.details.tool'> & PropsStore<ChatStore> & InjectFace<DetailsInjected> & PropsLocale<'chat'>;
+declare module '@prettier-ai/dsh-client-ui-slots' {
+    interface SessionStandardProps {
+        /** Selector hook over the current Conversation binding's Chat target. */
+        useChat: UseChat;
+    }
+    interface LocaleNamespaceMap {
+        /** Chat target, transcript node, statistics, and details copy. */
+        chat: import('../locale.ts').ChatKey;
+    }
+    interface SlotMap {
+        /**
+         * Final Chat node renderer, keyed by `ChatNodeKind`. The component receives
+         * the typed node, shared Chat actions, and Turn-data hook. Reusing a key
+         * replaces that node renderer; a kind with no occupant renders no row.
+         */
+        'conversation.chat.node': {
+            kind: 'keyed';
+            scope: 'session';
+            owner: ChatNodeOwnerProps;
+            keyProps: {
+                [Kind in ChatNodeKind]: {
+                    node: ChatNode<Kind>;
+                };
+            };
+            hookContext: string;
+            inject: ChatNodeTurnDataInjected;
+        };
+        /**
+         * Renderer for one consecutive group of durable message images. The owner
+         * supplies image references, an authorized loader, and alignment. A
+         * registration replaces the shipped gallery; without one, images are omitted.
+         */
+        'conversation.message.images': {
+            kind: 'single';
+            scope: 'session';
+            owner: MessageImagesOwnerProps;
+        };
+        /**
+         * Command row keyed by the command name. The component receives the folded
+         * command lifecycle and linked compaction when present. Reusing a key
+         * replaces that command renderer; an unoccupied key uses the generic card.
+         */
+        'conversation.chat.commandview': {
+            kind: 'keyed';
+            scope: 'session';
+            owner: CommandRowOwnerProps;
+        };
+        /**
+         * Selector-routed extension before a completed Turn's action row. The
+         * component receives the Turn, closing sequence, and file opener. The first
+         * selector that accepts the owner renders; an all-declined chain is empty.
+         */
+        'conversation.chat.turnTail': {
+            kind: 'chain';
+            scope: 'session';
+            owner: TurnTailOwnerProps;
+        };
+        /**
+         * Ordered actions for one finalized assistant message. Each entry receives
+         * the durable message id; a fresh `id` adds an action and reusing one replaces
+         * that entry. With no entries, the standard action row remains unchanged.
+         */
+        'conversation.chat.assistant-actions': {
+            kind: 'list';
+            scope: 'session';
+            owner: AssistantActionOwnerProps;
+        };
+        /**
+         * Whole details-panel body for the selected Tool call. The component receives
+         * the running or settled block and optional workspace root. A registration
+         * replaces the shipped Tool details renderer; absence uses the raw fallback.
+         */
+        'conversation.details.tool': {
+            kind: 'single';
+            scope: 'session';
+            owner: DetailsToolOwnerProps;
+        };
+    }
+}
+//# sourceMappingURL=slots.d.ts.map

package/lib/types/client/contract/snapshot.d.ts

@@ -0,0 +1,65 @@
+import type { ConversationNode, ConversationTimelineSnapshot, PartialAssistant, RunningToolCall } from '@prettier-ai/dsh-client-ui-conversation/client';
+import type { ChatConversationViewNode } from './chat-nodes.ts';
+export type { AssistantBlock, AssistantMessageNode, AssistantProvenanceView, AssistantRequestConfig, AssistantTiming, CommandNode, CompactionSummaryNode, ContextMessageNode, ConversationNode, ModelRetryNode, PartialAssistant, RunningToolCall, SteeringMessageNode, TodoItem, ToolCallBlock, ToolResultNode, TurnErrorNode, TurnMaxTokensNode, UnknownSurfaceNode, UserMessageNode, } from '@prettier-ai/dsh-client-ui-conversation/client';
+/** Stable live per-key reader for Chat nodes. */
+export interface ChatNodeStore {
+    /** @param key - stable Conversation Context key. @returns current Node, when visible or hidden. */
+    get(key: string): ChatConversationViewNode | undefined;
+    /** @returns all currently materialized Nodes without imposing render order. */
+    values(): readonly ChatConversationViewNode[];
+}
+/** One loaded Turn projected into the compact Chat navigation rail. */
+export interface TurnNavigationItem {
+    readonly turn: number;
+    /** Stable Conversation Context key the rail scrolls to. */
+    readonly anchorKey: string;
+    /** Bounded prompt preview; empty when the loaded window starts mid-Turn. */
+    readonly prompt: string;
+    /** Bounded assistant-response preview; empty until the Turn answers. */
+    readonly response: string;
+}
+/** Stable live navigation projection of the loaded Turns. */
+export interface ChatTurnNavigationIndex {
+    /**
+     * Loaded Turns that have a visible anchor, in timeline order. The array
+     * identity changes exactly when a Turn enters, leaves, or changes preview,
+     * so a renderer can select it directly as its change signal.
+     * @returns current navigation items.
+     */
+    items(): readonly TurnNavigationItem[];
+}
+/** Stable live Location index for Chat nodes. */
+export interface ChatLocationNodeIndex {
+    /** @param turn - owning turn. @returns ordered Chat Node keys in the turn. */
+    getTurn(turn: number): readonly string[];
+    /** @param turn - owning turn. @param step - owning step. @returns ordered Chat Node keys in the step. */
+    getStep(turn: number, step: number): readonly string[];
+}
+/** Compatibility projection backing StatsLine and the legacy top-level snapshot fields. */
+export interface LegacyConversationSlice {
+    readonly nodes: readonly ConversationNode[];
+    readonly turnTimings: ReadonlyMap<number, {
+        readonly startTime: number;
+        readonly endTime?: number;
+    }>;
+    readonly turnEnds: ReadonlyMap<number, number>;
+    readonly partial: PartialAssistant | null;
+    readonly runningCalls: readonly RunningToolCall[];
+}
+/** Incremental Chat publication with immutable order and stable live keyed readers. */
+export interface ChatSnapshot {
+    readonly order: readonly string[];
+    readonly nodes: ChatNodeStore;
+    readonly locations: ChatLocationNodeIndex;
+    readonly navigation: ChatTurnNavigationIndex;
+    readonly timeline: ConversationTimelineSnapshot;
+    readonly legacy: LegacyConversationSlice;
+}
+declare module '@prettier-ai/dsh-client-ui-conversation/client' {
+    interface ConversationViewSnapshotMap {
+        chat: ChatSnapshot;
+    }
+}
+/** Empty Chat target used before a view builder is registered. */
+export declare const EMPTY_CHAT_SNAPSHOT: ChatSnapshot;
+//# sourceMappingURL=snapshot.d.ts.map

package/lib/types/client/contract/store.d.ts

@@ -0,0 +1,22 @@
+/** Chat-owned selection state shared by the transcript and details panel. */
+import type { TurnProcessGeneration } from './turn-process.ts';
+/** Tool call identity as carried by Chat nodes. */
+export type ToolCallId = string;
+/** Selection target for the Chat details linkage channel. */
+export interface SelectionTarget {
+    turnSeq: number;
+    stepSeq?: number;
+    callId?: ToolCallId;
+    toolName?: string;
+}
+/** One manually expanded Turn answer generation. */
+export interface TurnProcessViewEntry {
+    readonly turn: number;
+    readonly generation: TurnProcessGeneration;
+}
+/** Per-Session state shared only by the Chat view and details surface. */
+export interface ChatStoreState {
+    selection: SelectionTarget | null;
+    turnProcesses: TurnProcessViewEntry[];
+}
+//# sourceMappingURL=store.d.ts.map

package/lib/types/client/contract/turn-metrics.d.ts

@@ -0,0 +1,38 @@
+import type { AssistantMessageNode, ConversationNode } from './snapshot.ts';
+/** Latency and decode-throughput readings for one turn's footer. */
+export interface TurnMetrics {
+    /** First-step TTFT in ms; absent when that step carries no recorded timing. */
+    ttftMs?: number;
+    /** Decode throughput over steps carrying both timing and provider usage. */
+    tokensPerSecond?: number;
+}
+/** One assistant step's derivable latency facts; null marks an unrecorded part. */
+export interface StepReading {
+    /** step/start → first token delta, in ms. */
+    ttftMs: number | null;
+    /** First token delta → final message, in ms. */
+    decodeMs: number | null;
+    /** Provider-reported completion tokens. */
+    outputTokens: number | null;
+}
+type AssistantNode = AssistantMessageNode;
+/**
+ * Read one assistant node's TTFT, decode wall time, and output tokens.
+ * @param node - A settled assistant node.
+ * @returns Per-part readings with `null` for unrecorded values.
+ */
+export declare function assistantStepReading(node: AssistantNode): StepReading;
+/**
+ * Fold assistant nodes into per-turn footer metrics.
+ *
+ * TTFT is the turn's lowest-step request-dispatch-to-first-token reading, so
+ * it is only meaningful when the turn's start is inside
+ * the loaded window (the caller gates on `turnTimings`, which shares that
+ * window). Throughput divides summed output tokens by summed decode wall time,
+ * counting only steps that carry both.
+ * @param nodes - Snapshot nodes of the loaded window.
+ * @returns Turn number → available metrics; turns with none are absent.
+ */
+export declare function deriveTurnMetrics(nodes: readonly ConversationNode[]): Map<number, TurnMetrics>;
+export {};
+//# sourceMappingURL=turn-metrics.d.ts.map

package/lib/types/client/contract/turn-process.d.ts

@@ -0,0 +1,48 @@
+/** Turn-local process window encoded as a reference-stable Location-data scalar. */
+export type TurnProcessSignature = string;
+/** Stable identity of one finalized answer generation, independent of its exact ordering anchor. */
+export type TurnProcessGeneration = string;
+/** Current process range and finalized answer boundary derived from one Turn. */
+export interface TurnProcessSpec {
+    readonly turn: number;
+    /** Stable control-node anchor source, including currently ineligible evidence. */
+    readonly controlAnchorSeq: number;
+    readonly processStartSeq: number;
+    readonly answerAnchorSeq: number | null;
+    readonly answerStep: number | null;
+    readonly inlineReasoning: boolean;
+    /** Reply-bearing durable Assistant messages before the final answer. */
+    readonly messageCount: number;
+    /** Durable non-subagent Tool calls recorded by this Turn. */
+    readonly toolCallCount: number;
+    /** Tool calls whose configured name identifies a subagent delegation. */
+    readonly subagentCount: number;
+}
+/** Chat Node kinds that remain independent of a Turn's process disclosure. */
+export declare const TURN_PROCESS_INDEPENDENT_KINDS: ReadonlySet<string>;
+/**
+ * Identify one finalized answer generation without using its ordering anchor.
+ * @param spec - current Turn process specification.
+ * @returns stable identity until the finalized answer Step is withdrawn or replaced.
+ */
+export declare function turnProcessGeneration(spec: TurnProcessSpec): TurnProcessGeneration;
+/**
+ * Encode one process specification as a primitive Location-data value.
+ * @param spec - current Turn process specification.
+ * @returns reference-stable scalar for equal specifications.
+ */
+export declare function encodeTurnProcess(spec: TurnProcessSpec): TurnProcessSignature;
+/**
+ * Decode a same-process signature produced by {@link encodeTurnProcess}.
+ * @param signature - encoded Turn process value.
+ * @returns decoded process specification.
+ */
+export declare function decodeTurnProcess(signature: TurnProcessSignature): TurnProcessSpec;
+/**
+ * Recognize the shipped subagent delegation name and its configured variants.
+ * Control tools use distinct names such as `send_message` and `list_agents`.
+ * @param name - durable Tool-call name.
+ * @returns whether the call creates or forks a subagent.
+ */
+export declare function isSubagentDelegationTool(name: string): boolean;
+//# sourceMappingURL=turn-process.d.ts.map

package/lib/types/client/conversation-nodes/assistant.d.ts

@@ -0,0 +1,37 @@
+import type { Context } from '@prettier-ai/cordis';
+import type { ConversationMatch, ConversationNodeDefinition } from '@prettier-ai/dsh-client-ui-conversation/client';
+import type { AssistantChatData } from '../contract/chat-nodes.ts';
+import type { AssistantBlock } from '../contract/snapshot.ts';
+declare module '../contract/chat-nodes.ts' {
+    interface ChatNodeDataMap {
+        /** Streaming, settled, or interrupted Assistant step. */
+        'assistant-step': AssistantChatData;
+    }
+}
+declare module '@prettier-ai/dsh-client-ui-conversation/client' {
+    interface ConversationStepDataMap {
+        /** Streaming, settled, or interrupted Assistant material for this Step. */
+        'assistant-step': AssistantChatData;
+    }
+}
+interface AssistantState {
+    readonly turn: number;
+    readonly step: number;
+    readonly blocks: readonly (AssistantBlock | undefined)[];
+    readonly visibleBlocks: number;
+    readonly firstVisibleSeq: number | undefined;
+    readonly firstVisibleTime: number | undefined;
+    readonly firstTokenTime: number | undefined;
+    readonly hidden: boolean;
+    readonly final: ConversationMatch | undefined;
+    readonly usage: unknown;
+}
+/** Per-step Assistant streaming/final/interruption Definition. */
+export declare const assistantDefinition: ConversationNodeDefinition<AssistantState>;
+/**
+ * Register the Assistant lifecycle business contribution.
+ * @param ctx - owning UI Conversation context.
+ */
+export declare function registerAssistantConversationNode(ctx: Context): void;
+export {};
+//# sourceMappingURL=assistant.d.ts.map