@qilin-agent/client-ui-chat 3.1.3 → 3.1.4

package/lib/types/client/apply.d.ts

@@ -1,5 +1,10 @@
 /** Register the Chat Conversation target, renderers, stats, and details surface. */
 import type { Context } from '@qilin-agent/kylin';
+import type { ChatFlowInjected, ChatNodeInjected } from './contract/slots.ts';
+/** Bind group and header visibility to the viewport of one flow render. */
+export declare const CHAT_FLOW_INJECT: ChatFlowInjected;
+/** Bind node-local sources and forward the flow's existing visibility hook. */
+export declare const CHAT_NODE_INJECT: ChatNodeInjected;
 /** Services required by the Chat target and its presentation registrations. */
 export declare const inject: string[];
 /**

package/lib/types/client/chat/AssistantMarkdown.d.ts

@@ -1,5 +1,6 @@
 import type { MarkdownFileMentions } from '@qilin-agent/client-ui-primitives';
-import type { ChatNodeOwnerProps, ChatViewSlotProps, UsePresentation } from '../contract/slots.ts';
+import type { PropsRenderSlots } from '@qilin-agent/client-ui-slots';
+import type { ChatNodeOwnerProps, ChatViewSlotProps, UseGroupAction, UsePresentation } from '../contract/slots.ts';
 import type { AssistantBlock } from '../contract/snapshot.ts';
 /**
  * Standalone fallback for image destinations (query/fragment suffixes are ignored).
@@ -30,6 +31,8 @@ export interface AssistantMarkdownProps {
     renderMessageImages: ChatNodeOwnerProps['renderMessageImages'];
     /** Hide reasoning that belongs to the Turn-level process disclosure. */
     reasoningHidden?: boolean | undefined;
+    /** Process hiding bound by the node slot to its current viewport. */
+    useGroupAction: UseGroupAction;
     /** Reveal the owning Turn-level process disclosure. */
     revealProcess?: (() => void) | undefined;
     /** Resolved prose file mentions for this Assistant's closing turn. */
@@ -39,9 +42,11 @@ export interface AssistantMarkdownProps {
      * compositions previews every settled reasoning summary (the Standard mode).
      */
     usePresentation?: UsePresentation | undefined;
+    /** Expanded-reasoning Body Slot renderer declared by this node's owner. */
+    renderSlot: PropsRenderSlots<'conversation.chat.reasoning.body'>['renderSlot'];
     /** The owning view's locale seat, passed down as a plain prop. */
     t: ChatViewSlotProps['t'];
 }
 /** Reasoning block as the Think variant summary row (figma 39:28304). */
-export declare const AssistantMarkdown: import("react").MemoExoticComponent<({ groupPart, blocks, streaming, interrupted, renderMessageImages, reasoningHidden, revealProcess, mentions, usePresentation, t, }: AssistantMarkdownProps) => import("react").JSX.Element | null>;
+export declare const AssistantMarkdown: import("react").MemoExoticComponent<({ groupPart, blocks, streaming, interrupted, renderMessageImages, reasoningHidden, revealProcess, mentions, usePresentation, useGroupAction, renderSlot, t, }: AssistantMarkdownProps) => import("react").JSX.Element | null>;
 //# sourceMappingURL=AssistantMarkdown.d.ts.map

package/lib/types/client/chat/AssistantNodeView.d.ts

@@ -1,7 +1,7 @@
-import type { InjectFace } from '@qilin-agent/client-ui-slots';
+import type { InjectFace, PropsRenderSlots } from '@qilin-agent/client-ui-slots';
 import type { ChatNodeViewProps, PresentationInjected } from '../contract/slots.ts';
-type AssistantNodeViewProps = ChatNodeViewProps<'assistant-step'> & InjectFace<PresentationInjected>;
+type AssistantNodeViewProps = ChatNodeViewProps<'assistant-step'> & InjectFace<PresentationInjected> & PropsRenderSlots<'conversation.chat.reasoning.body'>;
 /** Streaming, settled, and interrupted Assistant states share one keyed renderer instance. */
-export declare const AssistantNodeView: import("react").MemoExoticComponent<({ node, groupPart, useTurnData, turnProcess, openFile, renderMessageImages, fileMentions, usePresentation, t, }: AssistantNodeViewProps) => import("react").JSX.Element>;
+export declare const AssistantNodeView: import("react").MemoExoticComponent<({ node, groupPart, useGroupAction, useTurnData, turnProcess, openFile, renderMessageImages, fileMentions, usePresentation, renderSlot, t, }: AssistantNodeViewProps) => import("react").JSX.Element>;
 export {};
 //# sourceMappingURL=AssistantNodeView.d.ts.map

package/lib/types/client/chat/ChatFlow.d.ts

@@ -0,0 +1,4 @@
+import type { ChatFlowSlotProps } from '../contract/slots.ts';
+/** Render the flow without adding a DOM parent or changing keyed row positions. */
+export declare const ChatFlow: import("react").MemoExoticComponent<({ entries, pendingInputs, lastInputTurn, deferCollapse, useSession, useChat, useChatNode, useChatNodeBottom, useChatNodeProcess, useChatGroup, usePresentation, useStore, actions, renderSlot, t, useGroupAction, useGroupHeaderAction, cwd, openFile, openSkill, inspectCall, forkAt, editUserMessage, loadImage, fileMentions, }: ChatFlowSlotProps) => import("react").JSX.Element[]>;
+//# sourceMappingURL=ChatFlow.d.ts.map

package/lib/types/client/chat/ChatGroupSeat.d.ts

@@ -1,14 +1,15 @@
 /** Stable process container; display policy changes visibility, never member parents. */
 import { type ComponentProps } from 'react';
 import type { GroupKey } from '@qilin-agent/client-ui-conversation/client';
-import type { ChatViewSlotProps } from '../contract/slots.ts';
+import type { ChatFlowSlotProps } from '../contract/slots.ts';
 import { ChatNodeSeat } from './ChatNodeSeat.tsx';
 type SeatProps = Omit<ComponentProps<typeof ChatNodeSeat>, 'nodeKey' | 'groupPart'>;
 type ChatGroupSeatProps = SeatProps & {
     readonly groupKey: GroupKey;
-    readonly useChatGroup: ChatViewSlotProps['useChatGroup'];
+    readonly useChatGroup: ChatFlowSlotProps['useChatGroup'];
+    readonly useGroupHeaderAction: ChatFlowSlotProps['useGroupHeaderAction'];
 };
 /** Render a process group with local disclosure and the existing outer-Turn visibility. */
-export declare const ChatGroupSeat: import("react").MemoExoticComponent<({ groupKey, useChatGroup, ...props }: ChatGroupSeatProps) => import("react").JSX.Element | null>;
+export declare const ChatGroupSeat: import("react").MemoExoticComponent<({ groupKey, useChatGroup, useGroupHeaderAction, ...props }: ChatGroupSeatProps) => import("react").JSX.Element | null>;
 export {};
 //# sourceMappingURL=ChatGroupSeat.d.ts.map

package/lib/types/client/chat/ChatNodeSeat.d.ts

@@ -1,22 +1,25 @@
-import type { ChatNodeOwnerProps, ChatViewSlotProps, UsePresentation } from '../contract/slots.ts';
+import type { ChatNodeOwnerProps, ChatFlowSlotProps, UsePresentation } from '../contract/slots.ts';
 import type { ChatNodeStore } from '../contract/snapshot.ts';
 interface ChatNodeSeatProps extends ChatNodeOwnerProps {
     readonly nodeKey: string;
     /** A replaced Builder must rebind keyed hooks even when references and keys survive. */
     readonly nodeStore: ChatNodeStore;
-    readonly useChatNode: ChatViewSlotProps['useChatNode'];
-    readonly useChatNodeProcess: ChatViewSlotProps['useChatNodeProcess'];
+    readonly useChatNode: ChatFlowSlotProps['useChatNode'];
+    readonly useChatNodeProcess: ChatFlowSlotProps['useChatNodeProcess'];
     readonly usePresentation: UsePresentation;
-    readonly useStore: ChatViewSlotProps['useStore'];
-    readonly actions: ChatViewSlotProps['actions'];
-    readonly renderSlot: ChatViewSlotProps['renderSlot'];
-    readonly t: ChatViewSlotProps['t'];
+    readonly useStore: ChatFlowSlotProps['useStore'];
+    readonly actions: ChatFlowSlotProps['actions'];
+    readonly renderSlot: ChatFlowSlotProps['renderSlot'];
+    readonly t: ChatFlowSlotProps['t'];
+    readonly useChatNodeBottom: ChatFlowSlotProps['useChatNodeBottom'];
+    readonly deferCollapse: boolean;
+    readonly useGroupAction: ChatFlowSlotProps['useGroupAction'];
 }
 /**
  * Subscribe, apply Turn-process visibility, and dispatch one stable Context key.
  * Policy reads select this seat's own conclusion, so a mode change re-renders
  * only seats whose visibility actually changes.
  */
-export declare const ChatNodeSeat: import("react").MemoExoticComponent<({ nodeKey, groupPart, useChatNode, useChatNodeProcess, usePresentation, cwd, openFile, openSkill, inspectCall, forkAt, editUserMessage, loadImage, renderMessageImages, fileMentions, useStore, actions, renderSlot, t, }: ChatNodeSeatProps) => import("react").JSX.Element | null>;
+export declare const ChatNodeSeat: import("react").MemoExoticComponent<({ nodeKey, groupPart, useChatNode, useChatNodeProcess, usePresentation, cwd, openFile, openSkill, inspectCall, forkAt, editUserMessage, loadImage, renderMessageImages, fileMentions, useStore, actions, renderSlot, t, useChatNodeBottom, deferCollapse, useGroupAction, }: ChatNodeSeatProps) => import("react").JSX.Element | null>;
 export {};
 //# sourceMappingURL=ChatNodeSeat.d.ts.map

package/lib/types/client/chat/ChatView.d.ts

@@ -3,5 +3,5 @@ import type { ChatViewSlotProps } from '../contract/slots.ts';
  * The chat view slot entry: pure component over the composed props; each
  * ordered business Node crosses the keyed renderer seat.
  */
-export declare function ChatView({ useSession, useChat, useChatNode, useChatNodeProcess, useChatGroup, useConversation, useSessions, useStore, actions, renderSlot, sessionId, openFile, openSkill, openExternalLink, loadOlder, loadThrough, loadImage, openTrajectory, chatScroll, forkAt, editUserMessage, fileMentions, usePresentation, useProjection, t, }: ChatViewSlotProps): import("react").JSX.Element;
+export declare function ChatView({ useSession, useChat, useConversation, useSessions, renderSlot, sessionId, openFile, openSkill, openExternalLink, loadOlder, loadThrough, loadImage, openTrajectory, chatScroll, forkAt, fileMentions, editUserMessage, usePresentation, useProjection, t, }: ChatViewSlotProps): import("react").JSX.Element;
 //# sourceMappingURL=ChatView.d.ts.map

package/lib/types/client/chat/ReasoningContent.d.ts

@@ -0,0 +1,16 @@
+import type { FactoryComponentPropsOf, PropsRenderFactories, PropsRuntime } from '@qilin-agent/client-ui-slots';
+type ReasoningBodyProps = PropsRuntime<'conversation.chat.reasoning.body'> & PropsRenderFactories;
+/**
+ * Render compact reasoning with caller-supplied labels or Chat's defaults.
+ * @param props - display text, streaming state, optional localized labels, and the Factory's locale seat; no Session is required.
+ * @returns the standard reasoning content; supplied labels are used without merging defaults.
+ */
+export declare const ReasoningContent: import("react").MemoExoticComponent<({ text, running, labels, t }: FactoryComponentPropsOf<"conversation.chat.reasoning.content">) => import("react").JSX.Element>;
+/**
+ * Render the default Body through the same Factory available to third-party wrappers.
+ * @param props - original reasoning and the framework's Factory renderer.
+ * @returns an occurrence of the official reasoning Content Factory.
+ */
+export declare function DefaultReasoningBody({ text, running, renderFactorySlot }: ReasoningBodyProps): import("react").ReactNode;
+export {};
+//# sourceMappingURL=ReasoningContent.d.ts.map

package/lib/types/client/chat/ReasoningRow.d.ts

@@ -1,3 +1,4 @@
+import type { PropsRenderSlots } from '@qilin-agent/client-ui-slots';
 import type { ChatViewSlotProps, UsePresentation } from '../contract/slots.ts';
 /**
  * Render one assistant reasoning block collapsed until the reader opens it. The
@@ -8,13 +9,15 @@ import type { ChatViewSlotProps, UsePresentation } from '../contract/slots.ts';
  * @param props.text - complete or streaming reasoning text.
  * @param props.running - whether this block is the streaming tail.
  * @param props.usePresentation - live display-policy selector for this reasoning row.
- * @param props.t - conversation locale seat for status and Markdown actions.
+ * @param props.renderSlot - the declared expanded-body slot every reasoning body renders through.
+ * @param props.t - conversation locale seat for status and row copy.
  * @returns the reasoning disclosure.
  */
-export declare function ReasoningRow({ text, running, usePresentation, t }: {
+export declare function ReasoningRow({ text, running, usePresentation, renderSlot, t }: {
     text: string;
     running: boolean;
     usePresentation?: UsePresentation | undefined;
+    renderSlot: PropsRenderSlots<'conversation.chat.reasoning.body'>['renderSlot'];
     t: ChatViewSlotProps['t'];
 }): import("react").JSX.Element;
 //# sourceMappingURL=ReasoningRow.d.ts.map

package/lib/types/client/chat/flow-motion.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Fade-then-close transitions owned by one Chat viewport. Rows fade before their boxes close;
+ * the owner reserves removed height and holds scrolling until that viewport's folds finish.
+ * Motion is opt-in under `[data-chat-motion]`, respects reduced motion, and clears temporary styles.
+ */
+import { type RefObject } from 'react';
+/** Row-local operations supplied by the containing viewport. */
+export interface FlowMotionRows {
+    /** @param element - visible row. @param done - commits hidden state before idle callbacks run. */
+    collapse(element: HTMLElement, done: () => void): void;
+    /** @param element - newly visible row to grow to its natural size. */
+    reveal(element: HTMLElement): void;
+    /** @param element - row whose active transition should be cancelled without hiding it. */
+    cancelMotion(element: HTMLElement): void;
+}
+/** Animation lifetime and fold coordination for one viewport. */
+export interface FlowMotion extends FlowMotionRows {
+    /** @returns whether a row owned by this viewport is closing. */
+    foldActive(): boolean;
+    /** @param listener - callback after the last fold. @returns cancellation for a pending callback. */
+    onFoldIdle(listener: () => void): () => void;
+    /** Cancel owned animations and pending work when the viewport detaches. */
+    clear(): void;
+}
+/**
+ * Decide whether a row may animate: inside a live scope and not under reduced motion.
+ * @param element - row about to be hidden.
+ * @returns whether the fade-then-close transition applies.
+ */
+export declare function motionEnabled(element: HTMLElement): boolean;
+/**
+ * Whether a row is already hidden or on its way there.
+ * @param element - row under Turn-level visibility control.
+ * @returns hidden attribute present or a collapse transition outstanding.
+ */
+export declare function hiddenOrCollapsing(element: HTMLElement): boolean;
+/**
+ * Create animation coordination without cross-viewport broadcasts.
+ * @param reserve - reserve the deduplicated removed height in this viewport.
+ * @param foldingChanged - disable or restore this viewport's native scroll anchoring.
+ * @returns stable callbacks and cleanup for this viewport's animations.
+ */
+export declare function createFlowMotion(reserve: (px: number) => void, foldingChanged: (active: boolean) => void): FlowMotion;
+/**
+ * Apply searchable hiding with the containing Chat viewport's optional fold animation.
+ * @param hidden - desired visibility.
+ * @param reveal - browser-find and focus-protection callback.
+ * @param motion - owning viewport's row callbacks; absent in standalone rendering.
+ * @returns the stable subtree ref.
+ */
+export declare function useFlowHidden(hidden: boolean, reveal: () => void, motion: FlowMotionRows | undefined): RefObject<HTMLDivElement>;
+/**
+ * Toggle a plain hidden attribute on the fold clock, growing newly revealed headers.
+ * @param ref - element whose visibility follows hidden.
+ * @param hidden - desired hidden state.
+ * @param motion - containing viewport's row callbacks.
+ */
+export declare function useMotionHidden(ref: RefObject<HTMLElement | null>, hidden: boolean, motion: FlowMotionRows): void;
+//# sourceMappingURL=flow-motion.d.ts.map

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

@@ -1,9 +1,17 @@
 import { type RefObject } from 'react';
+/**
+ * Optional visibility operation; its caller owns cancellation and eventually commits the attribute.
+ * @param element - stable subtree root.
+ * @param hidden - desired hidden state.
+ * @param commit - apply the final visibility before reporting the operation complete.
+ */
+export type HiddenTransition = (element: HTMLElement, hidden: boolean, commit: () => void) => void;
 /**
  * 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.
+ * @param reveal - callback for browser find's beforematch reveal.
+ * @param transition - optional caller-owned visibility operation; otherwise apply synchronously.
  * @returns ref for the stable subtree root.
  */
-export declare function useSearchableHidden(hidden: boolean, reveal: () => void): RefObject<HTMLDivElement>;
+export declare function useSearchableHidden(hidden: boolean, reveal: () => void, transition?: HiddenTransition): RefObject<HTMLDivElement>;
 //# sourceMappingURL=searchable-hidden.d.ts.map

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

@@ -52,8 +52,13 @@ export declare class ChatReading {
     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;
+    /**
+     * Land at the current floor and clear saved reader position.
+     * @param behavior - immediate positioning, or one native animation when the reader's own input moved the tail.
+     */
+    followTail(behavior?: 'instant' | 'smooth'): void;
+    /** Stop a native follow animation where it is; the next sampled position decides follow intent. */
+    interruptFollow(): void;
     /** Restore the Session's semantic position, or follow the tail when none is saved. */
     restore(): void;
     /**
@@ -71,8 +76,11 @@ export declare class ChatReading {
      * @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;
+    /**
+     * Settle pending reader movement; only the outer scroller can finish its native follow animation.
+     * @param outer - whether the event belongs to the outer scroller rather than a process body.
+     */
+    readonly onScrollEnd: (outer?: boolean) => void;
     /**
      * Reconcile a layout change without overriding unsampled reader input.
      * A resize the reader did not cause moves their row; put it back on its

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

@@ -1,9 +1,11 @@
 /** Composes viewport operations, reading policy, and history navigation for Chat. */
 import { type RefObject } from 'react';
+import type { TranscriptViewMode } from '../../chat-settings.ts';
 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';
+import type { FlowMotionRows } from './flow-motion.ts';
 /** Committed content and Session operations used to reconcile scroll ownership. */
 export interface ChatScrollInput extends ChatNavigationInput {
     readonly chatScroll: ChatViewSlotProps['chatScroll'];
@@ -14,6 +16,10 @@ export interface ChatScrollInput extends ChatNavigationInput {
     readonly steeringId: string | null;
     readonly submissionId: string | null;
     readonly running: boolean;
+    /** Enable the browser-local delayed-fold experiment and its input reveal animation. */
+    readonly deferCompletedTurns: boolean;
+    /** A changed work-details preference resets fold reservations after the layout settles. */
+    readonly transcriptView: TranscriptViewMode;
     readonly loadedTurns: ReturnType<ChatSnapshot['navigation']['items']>;
 }
 interface ChatScrollState extends ChatReadingState {
@@ -23,9 +29,11 @@ interface ChatScrollState extends ChatReadingState {
     readonly navigateToTurn: ChatNavigation['navigateToTurn'];
     readonly loadEarlier: ChatNavigation['loadEarlier'];
     readonly returnToBottom: () => void;
+    readonly motion: FlowMotionRows;
 }
 /**
- * Coordinate scroll policy after Chat content commits.
+ * Coordinate scroll policy after Chat content commits. Initial history must be ready
+ * before automatic scroll or resize handling can initialize reading state and fold motion.
  * 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.

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

@@ -17,9 +17,12 @@ export interface ViewportLanding {
 }
 interface ViewportEvents {
     scroll: (event: ViewportScroll) => void;
-    scrollEnd: () => void;
+    /** Settled scroll; `outer` distinguishes the transcript scroller from a process body. */
+    scrollEnd: (outer: boolean) => void;
     resize: () => void;
     interact: () => void;
+    /** Any reading gesture, before paging ownership is consulted. */
+    intent?: () => void;
 }
 /** Owns one Chat scrollport's DOM operations, event listeners, and size observer. */
 export declare class ChatViewport {
@@ -31,6 +34,8 @@ export declare class ChatViewport {
     private resized;
     private readerIntent;
     private paging;
+    /** Transition state and row callbacks owned by this viewport's attachment. */
+    readonly motion: import("./flow-motion.ts").FlowMotion;
     /**
      * Bind to the containing scrollport and observe content and viewport sizes.
      * @param list - Chat root inside an optional shared conversation scrollport.
@@ -57,6 +62,27 @@ export declare class ChatViewport {
     get latestTurn(): number | null;
     /** Discard geometry-dependent landing knowledge while retaining scroll attribution. */
     invalidate(): void;
+    private spacerHeight;
+    private setSpacer;
+    /**
+     * Add room below the flow before rows above the reader close, so the scrollport never clamps:
+     * the closing gap pulls the content below it upward while everything above stays put.
+     * @param px - height about to leave the flow.
+     */
+    reserveBelow(px: number): void;
+    /** Clear fold reservations after a display-mode change, allowing the scroll range to shrink. */
+    resetBelow(): void;
+    /**
+     * Give reserved room back only as content grows into it, never by scrolling back down: growth fills
+     * the blank before it moves the floor. Holds still while rows are closing, because trimming mid-close
+     * would let the next frame clamp.
+     */
+    reclaimBelow(): void;
+    /**
+     * Stop an outstanding native follow animation at its current position before a reading gesture.
+     * @param follow - follow controller bound to this scrollport.
+     */
+    interruptFollow(follow: ScrollFollow): void;
     /**
      * Accept a sampled reader position without retaining a known landing.
      * @param metrics - settled reader position used as the next attribution baseline.
@@ -148,9 +174,11 @@ export declare class ChatViewport {
     /**
      * Align the scrollport with its current floor.
      * @param follow - independent follow intent and scrolling controller.
-     * @returns the actual floor landing, or null while detached.
+     * @param behavior - immediate positioning, or one native animation for a reader-caused tail change.
+     * @returns the actual floor landing, or null while detached. A smooth landing reports the starting
+     * position; native scroll delivery moves it.
      */
-    scrollToBottom(follow: ScrollFollow): ViewportLanding | null;
+    scrollToBottom(follow: ScrollFollow, behavior?: 'instant' | 'smooth'): ViewportLanding | null;
     private align;
     private write;
     private readonly onScroll;

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

@@ -1,4 +1,4 @@
-/** Scroll position, maximum top, and viewport height from one geometry read. */
+/** Scroll position, caller-supplied floor, and viewport height; raw measurements use the physical floor. */
 export interface ViewportMetrics {
     readonly top: number;
     readonly floor: number;
@@ -80,11 +80,12 @@ export declare class ScrollFollow {
     jump(element: HTMLElement, metrics: ViewportMetrics, top: number): ViewportMetrics;
     /**
      * Follow the measured floor, respecting reduced motion for smooth requests.
-     * An outstanding smooth target finishes before another is issued.
+     * Smooth requests preserve an outstanding target; immediate follow updates
+     * retarget active motion when content changes the floor.
      * Within-tolerance positioning is immediate while no animation is outstanding.
      * @param element - scrolling element.
      * @param metrics - current geometry.
-     * @param behavior - native animation for growth, or immediate positioning.
+     * @param behavior - native animation for growth, or immediate positioning unless motion is already active.
      * @returns current geometry; smooth requests retain their starting position until native scroll delivery.
      */
     toBottom(element: HTMLElement, metrics: ViewportMetrics, behavior: 'instant' | 'smooth'): ViewportMetrics;

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

@@ -1,16 +1,20 @@
 /** Chat-owned Slot declarations and composed component props. */
+import type { RefObject } from 'react';
 import type { MessageId } from '@qilin-agent/llm/brand';
 import type { SessionId, SessionSeq } from '@qilin-agent/session/types';
-import type { CommandNode, CompactionSummaryNode, ConversationGroupData, ConversationLocationDataStore, ConversationTurnDataMap, GroupSnapshot, MessageImageLoader, MessageImagesOwnerProps, RenderMessageImages, TurnLocation } from '@qilin-agent/client-ui-conversation/client';
+import type { PendingSubmission } from '@qilin-agent/api-session-controller/client';
+import type { InboxState } from '@qilin-agent/agent/types';
+import type { CommandNode, CompactionSummaryNode, ConversationGroupData, ConversationLocationDataStore, ConversationTurnDataMap, GroupSnapshot, MessageImageLoader, MessageImagesOwnerProps, RenderEntry, RenderMessageImages, TurnLocation } from '@qilin-agent/client-ui-conversation/client';
 import type { InjectFace, KeyedSnapshotSelectorHook, PropsLocale, PropsRenderSlots, PropsRuntime, PropsStore, SlotHookFactory, SnapshotSelectorHook } from '@qilin-agent/client-ui-slots';
-import type { MarkdownFileMentions } from '@qilin-agent/client-ui-primitives';
+import type { ObservableSnapshot } from '@qilin-agent/client-store';
+import type { MarkdownFileMentions, MarkdownLabels } from '@qilin-agent/client-ui-primitives';
 import type { createChatStore } from '../stores.ts';
+import type { ChatPresentationPolicy } from '../presentation-policy.ts';
+import type { FlowMotionRows } from '../chat/flow-motion.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 { ObservableSnapshot } from '@qilin-agent/client-store';
-import type { ChatPresentationPolicy } from '../presentation-policy.ts';
 import type { PerformanceUsageMode } from '../../chat-settings.ts';
 /** Selector hook over the current Conversation binding's Chat target. */
 export type UseChat = SnapshotSelectorHook<ChatSnapshot>;
@@ -68,16 +72,43 @@ export type UseDisclosure = () => {
     readonly setExpanded: (open: boolean) => void;
     readonly toggle: () => void;
 };
-/** Stable sources bound to one rendered Chat Node. */
+/**
+ * Searchable process hiding bound to the current node render's viewport.
+ * @param hidden - desired hidden state.
+ * @param reveal - browser-find and focus-protection callback.
+ * @returns the stable process-container ref.
+ */
+export type UseGroupAction = (hidden: boolean, reveal: () => void) => RefObject<HTMLDivElement>;
+/**
+ * Plain header visibility bound to the flow's viewport, including growth on reveal.
+ * @param ref - stable header element.
+ * @param hidden - desired hidden state.
+ */
+export type UseGroupHeaderAction = (ref: RefObject<HTMLElement | null>, hidden: boolean) => void;
+/** Viewport capability supplied once for each rendered Chat flow. */
+export interface ChatFlowHookContext {
+    readonly motion: FlowMotionRows;
+}
+/** Flow-wide behavior hooks bound to one viewport, independently of Session identity. */
+export interface ChatFlowInjected {
+    hooks: {
+        groupAction: SlotHookFactory<'conversation.chat.flow', UseGroupAction>;
+        groupHeaderAction: SlotHookFactory<'conversation.chat.flow', UseGroupHeaderAction>;
+    };
+}
+/** Stable sources and capabilities bound to one rendered Chat Node. */
 export interface ChatNodeHookContext {
     readonly turnData: ConversationLocationDataStore<ConversationTurnDataMap> | undefined;
     readonly disclosureReset: ObservableSnapshot<number>;
+    /** Absent for standalone rendering without a Chat flow. */
+    readonly useGroupAction?: UseGroupAction | undefined;
 }
 /** Slot-level Hook factories for keyed Chat renderers. */
 export interface ChatNodeInjected {
     hooks: {
         turnData: SlotHookFactory<'conversation.chat.node', UseChatNodeTurnData>;
         disclosure: SlotHookFactory<'conversation.chat.node', UseDisclosure>;
+        groupAction: SlotHookFactory<'conversation.chat.node', UseGroupAction>;
     };
 }
 /** Stable owner currency delivered to a keyed Chat renderer. */
@@ -129,6 +160,18 @@ export interface PerformanceUsageInjected {
 }
 /** Full props of one keyed Chat renderer. */
 export type ChatNodeViewProps<Kind extends ChatNodeKind = ChatNodeKind> = PropsRuntime<'conversation.chat.node', Kind> & PropsLocale<'chat'>;
+/** Original model-provided reasoning offered to the expanded Body Slot. */
+export interface ReasoningBodyOwnerProps {
+    /** Complete or streaming reasoning text. */
+    readonly text: string;
+    /** Whether the reasoning tail is still streaming. */
+    readonly running: boolean;
+}
+/** Session-independent original or derived display input to the Content Factory. */
+export interface ReasoningContentInput extends ReasoningBodyOwnerProps {
+    /** Localized Markdown controls, used unchanged when supplied; omission uses Chat's defaults. */
+    readonly labels?: MarkdownLabels;
+}
 /** Command-row owner share. */
 export interface CommandRowOwnerProps {
     node: CommandNode;
@@ -153,6 +196,8 @@ export interface ChatViewInjected {
     keyedHooks: {
         /** Resolve the stable source for one Chat Node key. */
         chatNode: (key: string) => ChatNodeSource;
+        /** Observe assembler-owned bottom membership for one Node. */
+        chatNodeBottom: (key: string) => ObservableSnapshot<boolean>;
         /** 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. */
@@ -182,8 +227,19 @@ export interface ChatViewInjected {
     editUserMessage?: ((text: string) => void) | undefined;
     fileMentions: (owner: TurnTailOwnerProps) => MarkdownFileMentions | undefined;
 }
+/** Existing Session-owned node sources shared by the view and its flow renderer. */
+export type ChatFlowDataInjected = Pick<ChatViewInjected, 'hooks' | 'keyedHooks'>;
+/** Ordered rows and reconciled local echoes rendered inside one Chat viewport. */
+export interface ChatFlowOwnerProps extends Pick<ChatNodeOwnerProps, 'cwd' | 'openSkill' | 'openFile' | 'inspectCall' | 'forkAt' | 'editUserMessage' | 'loadImage' | 'fileMentions'> {
+    readonly entries: readonly RenderEntry[];
+    readonly pendingInputs: readonly (PendingSubmission | InboxState['next-step'][number])[];
+    readonly lastInputTurn: number | undefined;
+    readonly deferCollapse: boolean;
+}
+/** Full props of the Chat-owned flow renderer. */
+export type ChatFlowSlotProps = PropsRuntime<'conversation.chat.flow'> & PropsRenderSlots<'conversation.chat.node' | 'conversation.message.images'> & PropsStore<ChatStore> & InjectFace<ChatFlowDataInjected> & PropsLocale<'chat'>;
 /** Full Chat view props. */
-export type ChatViewSlotProps = PropsRuntime<'conversation.view'> & PropsRenderSlots<'conversation.chat.node' | 'conversation.message.images'> & PropsStore<ChatStore> & InjectFace<ChatViewInjected> & PropsLocale<'chat'>;
+export type ChatViewSlotProps = PropsRuntime<'conversation.view'> & PropsRenderSlots<'conversation.chat.flow'> & PropsStore<ChatStore> & InjectFace<ChatViewInjected> & PropsLocale<'chat'>;
 /** Full props of the durable-message image renderer. */
 export type MessageImagesProps = PropsRuntime<'conversation.message.images'> & PropsLocale<'conversation'>;
 declare module '@qilin-agent/client-ui-slots' {
@@ -195,7 +251,23 @@ declare module '@qilin-agent/client-ui-slots' {
         /** Chat target, transcript node, statistics, and details copy. */
         chat: import('../locale.ts').ChatKey;
     }
+    interface SlotFactoryMap {
+        /** Session-independent reasoning Markdown with Chat labels and compact typography. */
+        'conversation.chat.reasoning.content': {
+            scope: 'root';
+            props: ReasoningContentInput;
+            locale: 'chat';
+        };
+    }
     interface SlotMap {
+        /** Ordered Chat rows and local echoes with viewport-bound visibility hooks. */
+        'conversation.chat.flow': {
+            kind: 'single';
+            scope: 'session';
+            owner: ChatFlowOwnerProps;
+            hookContext: ChatFlowHookContext;
+            inject: ChatFlowInjected;
+        };
         /**
          * Final Chat node renderer, keyed by `ChatNodeKind`. The component receives
          * the typed node, shared Chat actions, and Turn-data hook. Reusing a key
@@ -223,6 +295,16 @@ declare module '@qilin-agent/client-ui-slots' {
             scope: 'session';
             owner: MessageImagesOwnerProps;
         };
+        /**
+         * Expanded reasoning body with the unchanged model text. The official entry
+         * has priority 100 and calls the reasoning Content Factory; smaller priority
+         * values replace it. Contributions must preserve access to the original text.
+         */
+        'conversation.chat.reasoning.body': {
+            kind: 'single';
+            scope: 'session';
+            owner: ReasoningBodyOwnerProps;
+        };
         /**
          * Command row keyed by the command name. The component receives the folded
          * command lifecycle and linked compaction when present. Reusing a key

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

@@ -23,6 +23,8 @@ export interface ChatNodeStore {
     get(key: string): ChatConversationViewNode | undefined;
     /** @param key - stable Conversation Context key. @returns its identity-stable observable source. */
     source(key: string): ChatNodeSource;
+    /** @param key - Chat Node identity. @returns whether the visible Node belongs to the last Turn in the loaded timeline. */
+    bottomSource(key: string): ObservableSnapshot<boolean>;
     /**
      * 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.

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

@@ -1,10 +1,12 @@
 /** Chat-owned per-Session view state. */
 /** Tool call identity as carried by Chat nodes. */
 export type ToolCallId = string;
-/** One manually expanded Turn answer generation. */
+/** One manual whole-Turn disclosure choice for a Turn answer generation. */
 export interface TurnProcessViewEntry {
     readonly turn: number;
     readonly answerStep: number;
+    /** Explicitly collapsed; absent means explicitly opened. */
+    readonly collapsed?: true;
 }
 /** Per-Session state shared only by the Chat view and details surface. */
 export interface ChatStoreState {

package/lib/types/client/index.d.ts

@@ -18,7 +18,7 @@ export type { ChatStoreState, ToolCallId, TurnProcessViewEntry } from './contrac
 export type { TranscriptViewRowInjected, TranscriptViewRowProps } from './settings/TranscriptViewRow.tsx';
 export type { TranscriptViewMode } from '../chat-settings.ts';
 export type { ChatPresentationPolicy } from './presentation-policy.ts';
-export type { AssistantActionOwnerProps, ChatFileMentions, ChatNodeHookContext, ChatNodeInjected, ChatNodeOwnerProps, ChatNodeViewProps, ChatScrollPosition, ChatStore, ChatViewInjected, ChatViewSlotProps, CommandRowOwnerProps, CommandRowProps, MessageImagesProps, OpenFileOptions, PerformanceUsageInjected, PresentationInjected, TurnProcessOwnerProps, TurnTailOwnerProps, UseChat, UseChatNodeTurnData, UseDisclosure, UsePresentation, } from './contract/slots.ts';
+export type { AssistantActionOwnerProps, ChatFileMentions, ChatNodeHookContext, ChatNodeInjected, ChatNodeOwnerProps, ChatNodeViewProps, ChatScrollPosition, ChatStore, ChatViewInjected, ChatViewSlotProps, ChatFlowDataInjected, ChatFlowHookContext, ChatFlowInjected, ChatFlowOwnerProps, ChatFlowSlotProps, UseGroupHeaderAction, ReasoningBodyOwnerProps, ReasoningContentInput, CommandRowOwnerProps, CommandRowProps, MessageImagesProps, OpenFileOptions, PerformanceUsageInjected, PresentationInjected, TurnProcessOwnerProps, TurnTailOwnerProps, UseChat, UseChatNodeTurnData, UseDisclosure, UsePresentation, UseGroupAction, } from './contract/slots.ts';
 export type { ProcessActivity, ProcessActivitySummary, ProcessGroupData, } from './contract/process-groups.ts';
 export type { TurnProcessSpec, } from './contract/turn-process.ts';
 export type { ChatKey } from './locale.ts';

package/lib/types/client/locale.d.ts

@@ -45,6 +45,10 @@ export declare const zh: {
     'settings.links.description': string;
     'settings.links.sidebar': string;
     'settings.links.newTab': string;
+    'settings.collapse.title': string;
+    'settings.collapse.description': string;
+    'settings.collapse.completion': string;
+    'settings.collapse.nextInput': string;
     'fileOpen.title': string;
     'fileOpen.unknown': string;
     'message.extraBlock': string;
@@ -233,6 +237,10 @@ export declare const en: {
     'settings.links.description': string;
     'settings.links.sidebar': string;
     'settings.links.newTab': string;
+    'settings.collapse.title': string;
+    'settings.collapse.description': string;
+    'settings.collapse.completion': string;
+    'settings.collapse.nextInput': string;
     'fileOpen.title': string;
     'fileOpen.unknown': string;
     'message.extraBlock': string;