@deepseek-ai/dsh-client-ui-chat 0.1.6-alpha.2 → 0.1.7-alpha.1

package/lib/types/client/chat/use-chat-reading.d.ts

@@ -0,0 +1,95 @@
+import type { ChatScrollPosition, ChatViewSlotProps } from '../contract/slots.ts';
+import type { ChatViewport, ViewportLanding, ViewportScroll } from './use-chat-viewport.ts';
+/** Reading facts that affect Chat chrome and initial rail placement. */
+export interface ChatReadingState {
+    readonly initialized: boolean;
+    readonly followingTail: boolean;
+    readonly activeTurn: number | null;
+}
+/** Settled reader position delivered to history-navigation policy. */
+export interface ReadingSample {
+    readonly position: ChatScrollPosition | null;
+    readonly movedByReader: boolean;
+    readonly followingTail: boolean;
+}
+type PositionStore = ChatViewSlotProps['chatScroll'];
+/** Owns reading policy and its cancellable sampling work, without DOM access. */
+export declare class ChatReading {
+    private readonly viewport;
+    private store;
+    private state;
+    private readonly onChange;
+    private sampleTimer;
+    private probeFrame;
+    private sampled;
+    constructor(viewport: ChatViewport, store: PositionStore, state: ChatReadingState, onChange: (state: ChatReadingState) => void);
+    /**
+     * Expose pending reader ownership to navigation and resize handlers.
+     * @returns whether reader input still awaits interval or scrollend sampling.
+     */
+    get pending(): boolean;
+    /**
+     * Expose the active follow policy.
+     * @returns whether content growth retains bottom-follow ownership.
+     */
+    get followingTail(): boolean;
+    /**
+     * Adopt the committed Session's scroll memory.
+     * @param store - scroll memory for the current Session.
+     */
+    setStore(store: PositionStore): void;
+    /**
+     * Connect history policy to settled reading observations.
+     * @param sampled - receives settled reader positions.
+     * @returns a disposer that disconnects only this listener.
+     */
+    connect(sampled: (sample: ReadingSample) => void): () => void;
+    /** Cancel timers and animation frames and detach the sample listener. */
+    dispose(): void;
+    /** Release bottom follow and pending sampling for an explicit navigation. */
+    pauseFollowing(): void;
+    /** Land at the current floor and clear saved reader position. */
+    followTail(): void;
+    /** Restore the Session's semantic position, or follow the tail when none is saved. */
+    restore(): void;
+    /**
+     * Adopt a known landing without rediscovering its anchor.
+     * @param landing - measured navigation result that replaces pending reader input.
+     */
+    acceptNavigation(landing: ViewportLanding): void;
+    /**
+     * Retain reading policy while history changes the anchor's geometry.
+     * @param landing - compensated position that retains the current reading policy.
+     */
+    preservePosition(landing: ViewportLanding): void;
+    /**
+     * Handle pinned layout movement and reader arrivals at the floor immediately.
+     * @param scroll - attributed scroll delivery; other reader movement remains pending until sampled.
+     */
+    readonly onScroll: (scroll: ViewportScroll) => void;
+    /** Settle pending reader movement at the browser's scrollend. */
+    readonly onScrollEnd: () => void;
+    /** Reconcile a layout change without overriding unsampled reader input. */
+    onResize(): void;
+    /** Resolve the active turn from tail ownership or a coalesced reading-line probe. */
+    refreshActiveTurn(): void;
+    private nearBottom;
+    private commit;
+    private publish;
+    private cancelPending;
+    private readonly probe;
+    private readonly flushSample;
+}
+/**
+ * Retain reading policy and expose only changes in visible reading state.
+ * @param viewport - turn-aware DOM operations.
+ * @param store - Session-owned semantic scroll memory.
+ * @param initialTurn - latest loaded turn before the first landing.
+ * @returns the reading owner and its React-visible state.
+ */
+export declare function useChatReading(viewport: ChatViewport, store: PositionStore, initialTurn: number | null): {
+    reading: ChatReading;
+    state: ChatReadingState;
+};
+export {};
+//# sourceMappingURL=use-chat-reading.d.ts.map

package/lib/types/client/chat/use-chat-scroll.d.ts

@@ -0,0 +1,35 @@
+/** Composes viewport operations, reading policy, and history navigation for Chat. */
+import { type RefObject } from 'react';
+import type { ChatSnapshot } from '../contract/snapshot.ts';
+import type { ChatViewSlotProps } from '../contract/slots.ts';
+import { type ChatNavigation, type ChatNavigationInput } from './use-chat-navigation.ts';
+import { type ChatReadingState } from './use-chat-reading.ts';
+/** Committed content and Session operations used to reconcile scroll ownership. */
+export interface ChatScrollInput extends ChatNavigationInput {
+    readonly chatScroll: ChatViewSlotProps['chatScroll'];
+    readonly ready: boolean;
+    readonly order: readonly string[];
+    readonly lastKey: string | null;
+    readonly lastIsUser: boolean;
+    readonly steeringId: string | null;
+    readonly submissionId: string | null;
+    readonly running: boolean;
+    readonly loadedTurns: ReturnType<ChatSnapshot['navigation']['items']>;
+}
+interface ChatScrollState extends ChatReadingState {
+    readonly listRef: RefObject<HTMLDivElement>;
+    readonly columnRef: RefObject<HTMLDivElement>;
+    readonly busyTurn: number | null;
+    readonly navigateToTurn: ChatNavigation['navigateToTurn'];
+    readonly loadEarlier: ChatNavigation['loadEarlier'];
+    readonly returnToBottom: () => void;
+}
+/**
+ * Coordinate scroll policy after Chat content commits.
+ * New submitted input supersedes pending reader sampling.
+ * @param input - current Chat content, scroll memory, and history operations.
+ * @returns element refs, visible reading state, and navigation callbacks.
+ */
+export declare function useChatScroll(input: ChatScrollInput): ChatScrollState;
+export {};
+//# sourceMappingURL=use-chat-scroll.d.ts.map

package/lib/types/client/chat/use-chat-viewport.d.ts

@@ -0,0 +1,147 @@
+/** Turn-aware DOM scrolling and geometry, without history-loading or follow policy. */
+import { type RefObject } from 'react';
+import type { ChatScrollPosition } from '../contract/slots.ts';
+import type { ChatSnapshot } from '../contract/snapshot.ts';
+/** Scroll position, maximum top, and viewport height from one geometry read. */
+export interface ViewportMetrics {
+    readonly top: number;
+    readonly floor: number;
+    readonly height: number;
+}
+/** Scroll geometry attributed against the last acknowledged position. */
+export interface ViewportScroll {
+    readonly metrics: ViewportMetrics;
+    readonly movedByReader: boolean;
+}
+/** Actual clamped scroll result, including any known semantic anchor and turn. */
+export interface ViewportLanding {
+    readonly metrics: ViewportMetrics;
+    readonly position: ChatScrollPosition | null;
+    readonly turn: number | null;
+}
+interface ViewportEvents {
+    scroll: (event: ViewportScroll) => void;
+    scrollEnd: () => void;
+    resize: () => void;
+    interact: () => void;
+}
+/** Owns one Chat scrollport's DOM operations, event listeners, and size observer. */
+export declare class ChatViewport {
+    private elements;
+    private observer;
+    private events;
+    private turns;
+    private observation;
+    private paging;
+    /**
+     * Bind to the containing scrollport and observe content and viewport sizes.
+     * @param list - Chat root inside an optional shared conversation scrollport.
+     * @param column - ordered outer Node/Group boxes; its size changes invalidate cached landings.
+     */
+    attach(list: HTMLElement, column: HTMLElement): void;
+    /** Disconnect DOM resources and clear observations for the detached view. */
+    detach(): void;
+    /**
+     * Connect business policy without changing DOM listener ownership.
+     * @param events - business handlers for scroll and layout changes.
+     * @returns a disposer that disconnects only these handlers.
+     */
+    connect(events: ViewportEvents): () => void;
+    /**
+     * Adopt the loaded turn anchors without querying the DOM.
+     * @param turns - ordered loaded turns from the committed Chat snapshot.
+     */
+    updateTurns(turns: ReturnType<ChatSnapshot['navigation']['items']>): void;
+    /**
+     * Resolve the tail from the committed turn index.
+     * @returns the latest loaded turn, or null for an empty window.
+     */
+    get latestTurn(): number | null;
+    /** Discard geometry-dependent landing knowledge while retaining scroll attribution. */
+    invalidate(): void;
+    /**
+     * Accept a sampled reader position without retaining a known landing.
+     * @param metrics - settled reader position used as the next attribution baseline.
+     */
+    acknowledge(metrics: ViewportMetrics): void;
+    /**
+     * Compare the current scroll geometry with the last acknowledged position.
+     * @returns current metrics and movement attribution, or null while detached.
+     */
+    readScroll(): ViewportScroll | null;
+    private metrics;
+    private anchor;
+    /**
+     * Capture visible transcript content, excluding Turn controls that relocate when history expands.
+     * @returns a visible semantic anchor, or null when no anchor can be resolved.
+     */
+    capturePosition(): ChatScrollPosition | null;
+    /**
+     * Approximate the active Turn by binary-searching outer Node/Group boxes.
+     * Gaps retain the last visited Turn candidate, not necessarily the immediate predecessor.
+     * A known landing bypasses measurement while its position is unchanged.
+     * @param metrics - reusable scroll metrics; omitted callers request a fresh read.
+     * @returns the Turn near the reading line, or null while detached or empty.
+     */
+    readVisibleTurn(metrics?: ViewportMetrics | null): number | null;
+    /**
+     * Align a known loaded turn and return its actual clamped position.
+     * A split Node anchor selects its first visible part.
+     * @param turn - loaded turn to align below the scrollport's top edge.
+     * @returns the actual landing, or null when its anchor is unavailable.
+     */
+    scrollToTurn(turn: number): ViewportLanding | null;
+    /**
+     * Align the nearest available fallback for an unavailable turn anchor.
+     * @param turn - minimum turn number for a mounted fallback row.
+     * @returns the fallback landing, or null when no eligible row exists.
+     */
+    scrollToTurnAtOrAfter(turn: number): ViewportLanding | null;
+    /**
+     * Restore a semantic anchor with a raw-position fallback.
+     * @param position - semantic scroll memory; raw top is used only if its row is absent.
+     * @returns the actual landing, or null while detached.
+     */
+    restore(position: ChatScrollPosition): ViewportLanding | null;
+    /** Retain the first eligible transcript seat in DOM order; selection reads no geometry. */
+    beginPaging(): void;
+    /**
+     * Retain one old row and its inner/outer offsets for paging and later content growth.
+     * @param position - an explicit landing to retain; omitted callers capture the current reading position.
+     */
+    beginPreserving(position?: ChatScrollPosition | null): void;
+    private retain;
+    /** Release paging ownership and its content-size observation. */
+    stopPreserving(): void;
+    /**
+     * Expose retained paging ownership to navigation and resize policy.
+     * @returns whether a paging row is retained for subsequent layout changes.
+     */
+    get preserving(): boolean;
+    /**
+     * Compensate inner scrolling first, then the outer scrollport, within their actual scroll ranges.
+     * @returns the actual landing, or null when no visible retained row remains.
+     */
+    preserve(): ViewportLanding | null;
+    /**
+     * Align the scrollport with its current floor.
+     * @returns the actual floor landing, or null while detached.
+     */
+    scrollToBottom(): ViewportLanding | null;
+    private align;
+    private write;
+    private readonly onScroll;
+    private readonly onScrollEnd;
+    private readonly onIntent;
+}
+/**
+ * Bind viewport resource ownership to the component's layout lifetime.
+ * @returns one viewport owner and the element refs attached for this mount.
+ */
+export declare function useChatViewport(): {
+    viewport: ChatViewport;
+    listRef: RefObject<HTMLDivElement>;
+    columnRef: RefObject<HTMLDivElement>;
+};
+export {};
+//# sourceMappingURL=use-chat-viewport.d.ts.map

package/lib/types/client/chat/use-disclosure.d.ts

@@ -0,0 +1,15 @@
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+import type { UseDisclosure } from '../contract/slots.ts';
+/**
+ * Own one initially collapsed disclosure without an external subscription.
+ * @param version - reset generation; unchanged generations retain local open state.
+ * @returns the open state, an explicit setter, and a toggle action.
+ */
+export declare function useDisclosure(version?: number): ReturnType<UseDisclosure>;
+/**
+ * Bind a Hook without subscribing until a component calls it.
+ * @param reset - stable source whose version advances when the seat is hidden by its Turn.
+ * @returns a Hook with independent open state for each invocation.
+ */
+export declare function bindDisclosure(reset: ObservableSnapshot<number>): UseDisclosure;
+//# sourceMappingURL=use-disclosure.d.ts.map

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

@@ -76,8 +76,6 @@ export interface TurnTailChatData {
     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;
 }

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

@@ -0,0 +1,9 @@
+/** Chat-only row visibility; durable events and trajectory inspection remain intact. */
+import type { ChatNode } from './chat-nodes.ts';
+/**
+ * Exclude system prompts, ordinary Context, and permission commands from visible Chat rows.
+ * @param node - projected Chat node.
+ * @returns whether the node contributes a visible Chat row.
+ */
+export declare function isVisibleChatNode(node: ChatNode): boolean;
+//# sourceMappingURL=chat-visibility.d.ts.map

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

@@ -0,0 +1,23 @@
+/** Business data for Chat process groups; source Nodes remain in the Chat store. */
+export type ProcessActivity = 'read' | 'search' | 'edit' | 'commands' | 'code' | 'webSearch' | 'webFetch' | 'subagents' | 'plan' | 'questions' | 'tools';
+/** Distinct-call category ranking and the current live task detail. */
+export interface ProcessActivitySummary {
+    readonly counts: readonly {
+        readonly kind: ProcessActivity;
+        readonly count: number;
+    }[];
+    readonly running: ProcessActivity | undefined;
+    readonly runningDetail: string;
+}
+/** Presentation facts for one group between independent replies or input. */
+export interface ProcessGroupData {
+    readonly turn: number;
+    readonly closed: boolean;
+    readonly summary: ProcessActivitySummary;
+}
+declare module '@deepseek-ai/dsh-client-ui-conversation/client' {
+    interface ConversationGroupDataMap {
+        chat: ProcessGroupData;
+    }
+}
+//# sourceMappingURL=process-groups.d.ts.map

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

@@ -1,22 +1,29 @@
 /** Chat-owned Slot declarations and composed component props. */
 import type { MessageId } from '@deepseek-ai/dsh-llm/brand';
 import type { SessionId, SessionSeq } from '@deepseek-ai/dsh-session/types';
-import type { CommandNode, CompactionSummaryNode, ConversationLocationDataStore, ConversationTurnDataMap, MessageImageLoader, MessageImagesOwnerProps, RenderMessageImages, TurnLocation } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import type { CommandNode, CompactionSummaryNode, ConversationLocationDataStore, ConversationTurnDataMap, ConversationGroupData, GroupSnapshot, MessageImageLoader, MessageImagesOwnerProps, RenderMessageImages, TurnLocation } from '@deepseek-ai/dsh-client-ui-conversation/client';
 import type { InjectFace, KeyedSnapshotSelectorHook, PropsLocale, PropsRenderSlots, PropsRuntime, PropsStore, SlotHookFactory, SnapshotSelectorHook } from '@deepseek-ai/dsh-client-ui-slots';
-import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
 import type { MarkdownFileMentions } from '@deepseek-ai/dsh-client-ui-primitives';
 import type { createChatStore } from '../stores.ts';
+import type { ChatPresentationPolicy } from '../presentation-policy.ts';
 import type { ToolCallId } from './store.ts';
 import type { ChatConversationViewNode, ChatNode, ChatNodeKind } from './chat-nodes.ts';
 import type { ChatNodeProcessSource, ChatNodeSource, ChatSnapshot, ChatTurnProcessPresentation } from './snapshot.ts';
 import type { TurnProcessSpec } from './turn-process.ts';
-import type { TranscriptViewMode } from '../../chat-settings.ts';
+import type { PerformanceUsageMode } from '../../chat-settings.ts';
 /** Selector hook over the current Conversation binding's Chat target. */
 export type UseChat = SnapshotSelectorHook<ChatSnapshot>;
 /** Per-key selector hook over one Chat Node. */
 export type UseChatNode = KeyedSnapshotSelectorHook<ChatConversationViewNode | undefined>;
 /** Per-key selector hook over one Chat Node's Turn-process presentation. */
 export type UseChatNodeProcess = KeyedSnapshotSelectorHook<ChatTurnProcessPresentation | undefined>;
+/**
+ * Selector hook over the live presentation policy. Callers select one field or
+ * a derived conclusion, never the whole policy, so a mode change re-renders
+ * only components whose selected value changed.
+ */
+export type UsePresentation = SnapshotSelectorHook<ChatPresentationPolicy>;
 /** Where in a file an open should land. */
 export interface OpenFileOptions {
     /** 1-based line to reveal; absent = the file's beginning. */
@@ -50,19 +57,38 @@ declare module '@deepseek-ai/cordis' {
 }
 /** 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 {
+/**
+ * Subscribe to enclosing-Turn resets and own one initially collapsed disclosure.
+ * Each invocation has independent open state; display-mode changes do not reset it.
+ * @returns the current open state, explicit setter, and toggle action.
+ */
+export type UseDisclosure = () => {
+    readonly expanded: boolean;
+    /** @param open - whether this disclosure is expanded. */
+    readonly setExpanded: (open: boolean) => void;
+    readonly toggle: () => void;
+};
+/** Stable sources bound to one rendered Chat Node. */
+export interface ChatNodeHookContext {
+    readonly turnData: ConversationLocationDataStore<ConversationTurnDataMap> | undefined;
+    readonly disclosureReset: ObservableSnapshot<number>;
+}
+/** Slot-level Hook factories for keyed Chat renderers. */
+export interface ChatNodeInjected {
     hooks: {
         turnData: SlotHookFactory<'conversation.chat.node', UseChatNodeTurnData>;
+        disclosure: SlotHookFactory<'conversation.chat.node', UseDisclosure>;
     };
 }
 /** Stable owner currency delivered to a keyed Chat renderer. */
 export interface ChatNodeOwnerProps {
+    /** Renderer-owned Node portion selected by the grouping Definition. */
+    groupPart?: string;
     cwd?: string | undefined;
     /** Open the current source file of a skill referenced by a sent message. */
     openSkill: (name: string) => void;
     openFile: (path: string, options?: OpenFileOptions) => void;
-    inspectCall: (callId: ToolCallId) => void;
+    inspectCall: ((callId: ToolCallId) => void) | undefined;
     forkAt: (seq: number) => void;
     /**
      * Session-authorized image loader, down-threaded from the Chat view so a
@@ -78,11 +104,20 @@ export interface ChatNodeOwnerProps {
 }
 /** Shared presentation state for one Turn-process answer generation. */
 export interface TurnProcessOwnerProps {
+    /** Process content eligible to share one Turn-level disclosure. */
+    readonly hasContent: boolean;
     readonly spec: TurnProcessSpec;
     readonly foldable: boolean;
     readonly open: boolean;
     setOpen(open: boolean): void;
 }
+/** Shared presentation policy source for renderers that depend on the work-details mode. */
+export interface PresentationInjected {
+    hooks: {
+        /** Live presentation policy derived from the accepted work-details mode. */
+        presentation: ObservableSnapshot<ChatPresentationPolicy>;
+    };
+}
 /** Full props of one keyed Chat renderer. */
 export type ChatNodeViewProps<Kind extends ChatNodeKind = ChatNodeKind> = PropsRuntime<'conversation.chat.node', Kind> & PropsLocale<'chat'>;
 /** Command-row owner share. */
@@ -100,21 +135,30 @@ export interface ChatScrollPosition {
     readonly anchorTop: number;
     readonly scrollTop: number;
 }
+/** Shared settings source for the performance row, composer, and turn tail. */
+export interface PerformanceUsageInjected {
+    hooks: {
+        /** Accepted performance and usage detail preference. */
+        performanceUsage: ObservableSnapshot<PerformanceUsageMode>;
+    };
+}
 /** Business callbacks injected into the Chat view. */
 export interface ChatViewInjected {
     hooks: {
-        /** Persisted completed-Turn transcript presentation. */
-        transcriptView: SnapshotStore<TranscriptViewMode>;
+        /** Live presentation policy derived from the accepted work-details mode. */
+        presentation: ObservableSnapshot<ChatPresentationPolicy>;
     };
     keyedHooks: {
         /** Resolve the stable source for one Chat Node key. */
         chatNode: (key: string) => ChatNodeSource;
         /** Resolve the stable Turn-process source for one Chat Node key. */
         chatNodeProcess: (key: string) => ChatNodeProcessSource;
+        /** Resolve one optional group without subscribing the root View to its data. */
+        chatGroup: (key: string) => ObservableSnapshot<GroupSnapshot<ConversationGroupData<'chat'>> | undefined> | undefined;
     };
     /** Open the current source file of a skill referenced by a sent message. */
     openSkill: (name: string) => void;
-    /** Open one HTTP(S) message link in a Sidebar Browser tab. */
+    /** Open one HTTP(S) message link at the selected destination, using an external tab if Sidebar Browser is unavailable. */
     openExternalLink: (url: string) => void;
     openFile: (path: string, options?: OpenFileOptions) => Promise<void>;
     loadOlder: () => void;
@@ -156,8 +200,8 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
                     node: ChatNode<Kind>;
                 };
             };
-            hookContext: ConversationLocationDataStore<ConversationTurnDataMap> | undefined;
-            inject: ChatNodeTurnDataInjected;
+            hookContext: ChatNodeHookContext;
+            inject: ChatNodeInjected;
         };
         /**
          * Renderer for one consecutive group of durable message images. The owner

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

@@ -1,5 +1,6 @@
 import type { ConversationNode, ConversationTimelineSnapshot, PartialAssistant, RunningToolCall } from '@deepseek-ai/dsh-client-ui-conversation/client';
-import type { ChatConversationViewNode } from './chat-nodes.ts';
+import type { ChatConversationViewNode, ChatNodeDataMap, ChatNodeKind } from './chat-nodes.ts';
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
 import type { TurnProcessSpec } from './turn-process.ts';
 export type { AssistantBlock, AssistantMessageNode, AssistantProviderMetadataView, AssistantRequestConfig, AssistantTiming, CommandNode, CompactionSummaryNode, ContextMessageNode, ConversationNode, ModelRetryNode, PartialAssistant, RunningToolCall, SteeringMessageNode, TodoItem, ToolCallBlock, ToolResultNode, TurnErrorNode, TurnMaxTokensNode, UnknownSurfaceNode, UserMessageNode, } from '@deepseek-ai/dsh-client-ui-conversation/client';
 /** Per-key observable used by one mounted Chat Node Seat. */
@@ -22,6 +23,14 @@ export interface ChatNodeStore {
     get(key: string): ChatConversationViewNode | undefined;
     /** @param key - stable Conversation Context key. @returns its identity-stable observable source. */
     source(key: string): ChatNodeSource;
+    /**
+     * Observe one Turn's data for a single Node kind, including hidden Nodes, in anchor order.
+     * Other Turns and kinds do not notify this source.
+     * @param turn - resolved owning Turn.
+     * @param kind - business Node kind.
+     * @returns an identity-stable source whose array changes only with its members.
+     */
+    turnDataSource<Kind extends ChatNodeKind>(turn: number, kind: Kind): ObservableSnapshot<readonly ChatNodeDataMap[Kind][]>;
     /** @param key - stable Conversation Context key. @returns its Turn-process presentation source. */
     processSource(key: string): ChatNodeProcessSource;
     /** @returns all currently materialized Nodes without imposing render order. */
@@ -58,8 +67,12 @@ export interface ChatLocationNodeIndex {
 export interface ChatTurnProcessPresentation {
     readonly turn: number;
     readonly spec: TurnProcessSpec;
+    /** Whether the loaded window contains this Turn's `turn/start`; folding is decided per Turn on this fact. */
+    readonly turnStarted: boolean;
     readonly turnClosed: boolean;
     readonly hasExternalProcess: boolean;
+    /** A visible input after process output prevents one disclosure from hiding its surrounding groups. */
+    readonly hasInterleavedInput: boolean;
     readonly compactAnswer: boolean;
 }
 /** Compatibility projection backing StatsPills and the legacy top-level snapshot fields. */

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

@@ -1,11 +1,4 @@
-import type { AssistantMessageNode, ConversationNode } from '@deepseek-ai/dsh-client-ui-conversation/client';
-/** 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;
-}
+import type { AssistantMessageNode } from '@deepseek-ai/dsh-client-ui-conversation/client';
 /** One assistant step's derivable latency facts; null marks an unrecorded part. */
 export interface StepReading {
     /** step/start → first token delta, in ms. */
@@ -22,17 +15,5 @@ type AssistantNode = AssistantMessageNode;
  * @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

@@ -1,3 +1,4 @@
+import type { ChatNode } from './chat-nodes.ts';
 /** Current process range and finalized answer boundary derived from one Turn. */
 export interface TurnProcessSpec {
     readonly turn: number;
@@ -30,4 +31,10 @@ export declare function sameTurnProcessSpec(left: TurnProcessSpec, right: TurnPr
  * @returns whether the call creates or forks a subagent.
  */
 export declare function isSubagentDelegationTool(name: string): boolean;
+/**
+ * Keep live, stopped, and failed Turns open.
+ * @param node - Node carrying the owning Turn.
+ * @returns whether whole-Turn collapse is unavailable.
+ */
+export declare function turnProcessAlwaysOpen(node: ChatNode | undefined): boolean;
 //# sourceMappingURL=turn-process.d.ts.map

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

@@ -21,11 +21,10 @@ interface AssistantState {
     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. */
+/** Per-step Assistant lifecycle; materialized keys survive cleared stream content as hidden Nodes. */
 export declare const assistantDefinition: ConversationNodeDefinition<AssistantState>;
 /**
  * Register the Assistant lifecycle business contribution.

package/lib/types/client/conversation-nodes/chat-snapshot-builder.d.ts

@@ -1,10 +1,10 @@
 import type { Context } from '@deepseek-ai/cordis';
-import type { ConversationTimelineSnapshot, ConversationViewBuilder, ConversationViewDefinition } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import type { ConversationTimelineSnapshot, ConversationViewBuilder, ConversationViewDefinition, ConversationGroupInput } from '@deepseek-ai/dsh-client-ui-conversation/client';
 import type { ChatConversationViewNode } from '../contract/chat-nodes.ts';
 import type { ChatNodeStore, ChatSnapshot } from '../contract/snapshot.ts';
 /**
  * Order visible Chat Nodes without changing existing relative order as process
- * eligibility changes. Opening human input precedes process candidates, while
+ * eligibility changes. Opening input precedes process candidates, while
  * each synthetic process control sits between them.
  * @param nodes - currently materialized Chat Nodes.
  * @returns visible Nodes in presentation order.
@@ -72,6 +72,10 @@ export declare class ChatSnapshotBuilder implements ConversationViewBuilder<Chat
     private readonly referenceLabels;
     private readonly skillNames;
     private order;
+    private latestGroupInput;
+    private readonly readGroupNode;
+    private readonly readGroupTurn;
+    private readonly readGroupPosition;
     /** Last published timeline: a Turn boundary can land without a new node. */
     private timeline;
     readonly empty: ChatSnapshot;
@@ -83,7 +87,10 @@ export declare class ChatSnapshotBuilder implements ConversationViewBuilder<Chat
     apply(input: {
         readonly upserts: readonly ChatConversationViewNode[];
         readonly timeline: ConversationTimelineSnapshot;
+        readonly changedTurns?: readonly number[];
     }): ChatSnapshot;
+    groupInput(): ConversationGroupInput<ChatConversationViewNode>;
+    publish(): void;
     private snapshot;
 }
 /** Chat target factory contributed to the Conversation view registry. */

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

@@ -1,28 +1,38 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { ConversationNodeDefinition } from '@deepseek-ai/dsh-client-ui-conversation/client';
+interface InboxIdentity {
+    readonly id: string;
+    readonly source: {
+        readonly kind: string;
+    };
+}
 interface PendingSnapshot {
     readonly kind: 'snapshot';
-    readonly ids: readonly string[];
+    readonly ids: readonly InboxIdentity[];
 }
 interface PendingSplice {
     readonly kind: 'splice';
     readonly previous: PendingState;
     readonly start: number;
     readonly removedCount: number;
-    readonly inserted: readonly string[];
+    readonly inserted: readonly InboxIdentity[];
 }
 type PendingState = PendingSnapshot | PendingSplice;
-/** Persistent next-step state after one durable Inbox splice. */
+/** Persistent Inbox state after one durable Inbox splice. */
 export interface InboxState {
-    /** Persistent splice chain materialized only when a next-step batch is claimed. */
+    /** Persistent splice chain materialized only when a batch is claimed. */
     readonly pending: PendingState;
     /** Message ids in the current claim, shared until the next claim. */
     readonly currentClaimed: ReadonlySet<string>;
+    readonly claimSeq: number;
+    readonly claimedHuman: boolean;
 }
-/** Persistent next-step Inbox state used to classify the current claimed batch as steering. */
+/** Persistent next-step claims identify messages admitted into a running Turn. */
 export declare const nextStepInboxDefinition: ConversationNodeDefinition<InboxState>;
+/** Persistent next-turn claims identify messages that wake a new Turn. */
+export declare const nextTurnInboxDefinition: ConversationNodeDefinition<InboxState>;
 /**
- * Register the next-step Inbox state used by Chat message classification.
+ * Register the Inbox state used by Chat message classification.
  * @param ctx - owning UI Conversation context.
  */
 export declare function registerInboxConversationNodes(ctx: Context): void;