@yadsh/dsh-qa-surface 0.3.0 → 0.5.0

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

@@ -0,0 +1,54 @@
+/**
+ * Composer-side attachment intake: which files are accepted, how a pasted
+ * blob turns into an attachment, and the browser-side ceilings. The Host
+ * remains authoritative — these checks exist so a refusal happens before a
+ * round trip, not to replace the Host's own admission.
+ */
+import type { QaAttachmentDraft, QaFileDraft, QaImageMediaType, ResolvedQaSurfaceConfig } from "../types.js";
+/** Raster formats the host attachment path accepts. */
+export declare const QA_IMAGE_MEDIA_TYPES: readonly QaImageMediaType[];
+/** Soft image ceiling; the Host stays authoritative at admission. */
+export declare const QA_MAX_IMAGE_BYTES: number;
+/** The attachment policy as the composer reads it. */
+export interface QaAttachmentLimits {
+    readonly textFiles: boolean;
+    readonly pastedTextLines: number;
+    readonly maxFileBytes: number;
+    readonly maxPending: number;
+    readonly extensions: readonly string[];
+}
+/**
+ * Project the deployment's resolved configuration into the composer's policy.
+ * @param config - effective QA configuration.
+ * @returns the attachment ceilings the composer enforces.
+ */
+export declare function attachmentLimits(config: ResolvedQaSurfaceConfig): QaAttachmentLimits;
+/**
+ * The file picker's `accept` value: the raster formats plus either the
+ * configured text extensions or the browser's whole `text/*` family.
+ * @param limits - attachment policy in effect.
+ * @returns the accept attribute value.
+ */
+export declare function attachmentAccept(limits: QaAttachmentLimits): string;
+/** Whether a dropped payload may be attached as a text file at all. */
+export declare function acceptsTextFile(name: string, mediaType: string, limits: QaAttachmentLimits): boolean;
+/**
+ * Turn one dropped or picked file into a composer draft, or into the message
+ * the visitor sees when the file is not accepted.
+ * @param file - browser file from a picker, drop or paste.
+ * @param limits - attachment policy in effect.
+ * @returns the draft, or a refusal message.
+ */
+export declare function draftFromFile(file: File, limits: QaAttachmentLimits): Promise<QaAttachmentDraft | string>;
+/**
+ * Convert a large pasted blob into an attached file. Pasted text has no file
+ * name of its own, so the name states what it is; the model resolves it from
+ * the durable store like any other attachment.
+ * @param text - pasted plain text.
+ * @param limits - attachment policy in effect.
+ * @returns the draft, or null when the paste stays in the input field.
+ */
+export declare function draftFromPaste(text: string, limits: QaAttachmentLimits): QaFileDraft | null;
+/** Format one attachment size for a card, a chip or a refusal message. */
+export declare function formatFileSize(bytes: number): string;
+//# sourceMappingURL=attachments.d.ts.map

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

@@ -0,0 +1,10 @@
+/**
+ * Browser-side binary-to-base64. Chunked so `String.fromCharCode` never
+ * crosses the engine's argument limit on large attachments.
+ */
+/**
+ * @param bytes - raw bytes to encode.
+ * @returns the canonical base64 text (no `data:` prefix, no padding tricks).
+ */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+//# sourceMappingURL=base64.d.ts.map

package/lib/types/client/chat-files.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Attachment roster of one chat, projected for the rail's files tab: a pure
+ * scan of the durable transcript, newest message first. The browser never
+ * re-reads file bytes (the attachment route serves images), so a row keeps
+ * the same handle the transcript shows.
+ */
+import type { QaImageView, QaMessage, QaFileView } from "../types.js";
+/** Everything one user message carried, in prompt order. */
+export interface QaChatFileGroup {
+    /** The user message id; doubles as the transcript turn anchor. */
+    readonly messageId: string;
+    /** Wall-clock send time, when the transcript recorded one. */
+    readonly timestamp?: number;
+    readonly files: readonly QaFileView[];
+    readonly images: readonly QaImageView[];
+}
+/** Whether the group carries at least one attachment of either kind. */
+export declare function groupHasAttachments(group: QaChatFileGroup): boolean;
+/** Total attachment count across groups; the header badge's value. */
+export declare function countChatAttachments(groups: readonly QaChatFileGroup[]): number;
+/**
+ * Group the attachments of a chat by their sending message. Only user
+ * messages can carry attachments; messages without any are dropped. The
+ * groups come out newest message first, matching a roster that grows at the
+ * bottom of the transcript.
+ * @param messages - the chat's projected transcript.
+ * @returns attachment groups, newest message first.
+ */
+export declare function collectChatFiles(messages: readonly QaMessage[]): readonly QaChatFileGroup[];
+//# sourceMappingURL=chat-files.d.ts.map

package/lib/types/client/components/QaApproval.d.ts

@@ -0,0 +1,13 @@
+import type { QaApprovalDecision, QaPendingApproval } from "../../types.js";
+export interface QaApprovalProps {
+    readonly approvals: readonly QaPendingApproval[];
+    readonly onAnswer: (requestId: string, decision: QaApprovalDecision) => Promise<void>;
+}
+/**
+ * The tool calls a composed gate parked for a person. One row per request, the
+ * gate's own reason on top, and the two answers stock DSH offers: refuse, or
+ * let this one call through. Nothing here decides on its own — an unanswered
+ * request simply keeps the turn waiting.
+ */
+export declare const QaApproval: import("react").MemoExoticComponent<(props: QaApprovalProps) => import("react/jsx-runtime").JSX.Element | null>;
+//# sourceMappingURL=QaApproval.d.ts.map

package/lib/types/client/components/QaChangelog.d.ts

@@ -17,5 +17,5 @@ export interface QaChangelogModalProps {
  * The version/changelog dialog opened from the sidebar footer. Rendering is
  * a no-op while closed; Escape and a backdrop click close it.
  */
-export declare function QaChangelogModal(props: QaChangelogModalProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function QaChangelogModal(props: QaChangelogModalProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=QaChangelog.d.ts.map

package/lib/types/client/components/QaComposer.d.ts

@@ -1,4 +1,5 @@
-import type { QaImageDraft } from "../../types.js";
+import type { QaAttachmentDraft } from "../../types.js";
+import { type QaAttachmentLimits } from "../attachments.js";
 export interface QaComposerProps {
     readonly placeholder: string;
     readonly quickQuestions?: readonly string[];
@@ -7,15 +8,18 @@ export interface QaComposerProps {
     readonly running: boolean;
     readonly showStop: boolean;
     readonly status: string | null;
-    readonly images: readonly QaImageDraft[];
-    readonly onImagesChange: (images: readonly QaImageDraft[]) => void;
-    readonly onSend: (text: string, images: readonly QaImageDraft[]) => Promise<boolean>;
+    readonly attachments: readonly QaAttachmentDraft[];
+    /** Deployment policy: accepted kinds, ceilings and the paste threshold. */
+    readonly limits: QaAttachmentLimits;
+    readonly onAttachmentsChange: (attachments: readonly QaAttachmentDraft[]) => void;
+    readonly onSend: (text: string, attachments: readonly QaAttachmentDraft[]) => Promise<boolean>;
     readonly onStop: () => Promise<void>;
 }
 /**
  * Memoized with the default shallow compare: every prop is a scalar, a
  * stable array or a stable callback, so a stream of transcript frames never
  * re-renders the composer and typing stays responsive while an answer runs.
+ * The caller owns the draft array identity: `limits` must be stable too.
  */
 export declare const QaComposer: import("react").MemoExoticComponent<(props: QaComposerProps) => import("react/jsx-runtime").JSX.Element>;
 //# sourceMappingURL=QaComposer.d.ts.map

package/lib/types/client/components/QaFileAttachment.d.ts

@@ -0,0 +1,14 @@
+export interface QaFileAttachmentProps {
+    readonly name: string;
+    readonly bytes: number;
+    /** Pending draft vs already-sent attachment: pending offers removal. */
+    readonly tone: "draft" | "sent";
+    readonly onRemove?: () => void;
+}
+/**
+ * One attached file: the extension badge, the name and the size. The browser
+ * never re-reads these bytes (the Host attachment route serves images), so
+ * both the composer card and the sent row show the same handle.
+ */
+export declare function QaFileAttachment({ name, bytes, tone, onRemove, }: QaFileAttachmentProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=QaFileAttachment.d.ts.map

package/lib/types/client/components/QaFilesPanel.d.ts

@@ -0,0 +1,15 @@
+import type { QaChatFileGroup } from "../chat-files.js";
+export interface QaFilesPanelProps {
+    readonly groups: readonly QaChatFileGroup[];
+    /** Resolve an image attachment to an object URL; images render inert without it. */
+    readonly resolveImage?: (attachmentId: string) => Promise<string>;
+    /** Scroll the transcript to the group's user message. */
+    readonly onJumpToMessage: (messageId: string) => void;
+}
+/**
+ * The chat's attachment roster: one section per sending message, newest
+ * first. Rows mirror the transcript's handles — the browser never reads a
+ * file back, and the images are the same object URLs the message showed.
+ */
+export declare function QaFilesPanel({ groups, resolveImage, onJumpToMessage, }: QaFilesPanelProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=QaFilesPanel.d.ts.map

package/lib/types/client/components/QaHeader.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The surface's header chrome: brand row, the derived conversation title, the
+ * agents/sources/files controls and the reset action. Plain (non-memoized)
+ * rendering — the badge counts move with the session state anyway, so
+ * reference guards would never pay off here.
+ */
+/**
+ * The subagent indication for headerless deployments: a slim status line
+ * above the transcript with the way back to the parent chat. With a header,
+ * the same indication lives in the title row instead.
+ */
+export declare function QaSubagentBanner({ onClose, }: {
+    readonly onClose: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+export interface QaHeaderProps {
+    readonly logoUrl: string | null;
+    /** The derived conversation title; null hides the heading. */
+    readonly title: string | null;
+    /** A subagent view replaces the mode caption with its return control. */
+    readonly viewingSubagent: boolean;
+    readonly onCloseSubagent: () => void;
+    readonly agentPreset: string | null;
+    readonly agentCount: number;
+    readonly agentsOpen: boolean;
+    /** Toggles the agents drawer; also closes the right rail. */
+    readonly onToggleAgents: () => void;
+    /** Whether the deployment shows the sources control in the header at all. */
+    readonly sourcesVisible: boolean;
+    readonly sourcesCount: number;
+    readonly sourcesComplete: boolean;
+    readonly sourcesOpen: boolean;
+    readonly onOpenSources: () => void;
+    readonly fileCount: number;
+    readonly filesOpen: boolean;
+    readonly onOpenFiles: () => void;
+    readonly showReset: boolean;
+    readonly resetDisabled: boolean;
+    readonly onReset: () => void;
+}
+export declare function QaHeader({ logoUrl, title, viewingSubagent, onCloseSubagent, agentPreset, agentCount, agentsOpen, onToggleAgents, sourcesVisible, sourcesCount, sourcesComplete, sourcesOpen, onOpenSources, fileCount, filesOpen, onOpenFiles, showReset, resetDisabled, onReset, }: QaHeaderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=QaHeader.d.ts.map

package/lib/types/client/components/QaMessage.d.ts

@@ -16,6 +16,8 @@ export interface QaMessageProps {
     readonly onOpenSources?: (sources: readonly QaSource[], complete: boolean, incompleteOrigins: QaTurnSources["incompleteOrigins"]) => void;
     /** Open one path-backed source's detail (an inline footnote click). */
     readonly onSourceDetail?: (source: QaSource) => void;
+    /** Operator-configured running phrases; omitted reads the built-in list. */
+    readonly thinkingPhrases?: readonly string[];
 }
 /**
  * Whether two transcript messages render identically. The transcript
@@ -24,5 +26,5 @@ export interface QaMessageProps {
  * comparison is by value, which keeps fresh copies cheap to recognize.
  */
 export declare function sameMessage(a: QaMessageModel, b: QaMessageModel): boolean;
-export declare const QaMessage: import("react").MemoExoticComponent<({ message, renderMarkdown, showTimestamp, stateKey, onRegenerate, resolveImage, onOpenSources, onSourceDetail, }: QaMessageProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const QaMessage: import("react").MemoExoticComponent<({ message, renderMarkdown, showTimestamp, stateKey, onRegenerate, resolveImage, onOpenSources, onSourceDetail, thinkingPhrases, }: QaMessageProps) => import("react/jsx-runtime").JSX.Element>;
 //# sourceMappingURL=QaMessage.d.ts.map

package/lib/types/client/components/QaModal.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from "react";
+export interface QaModalProps {
+    readonly open: boolean;
+    /** Dialog title; also the dialog's accessible name. */
+    readonly title: string;
+    /** Accessible label of the close control, e.g. "Закрыть профиль". */
+    readonly closeLabel: string;
+    readonly onClose: () => void;
+    readonly children: ReactNode;
+    /** Actions pinned under the body; omit for a body-only dialog. */
+    readonly footer?: ReactNode;
+    /**
+     * Wider panel, for a dialog whose prose must not wrap mid-sentence: the
+     * profile form and the changelog both take it. The default width stays with
+     * the text-list dialogs it was sized for.
+     */
+    readonly wide?: boolean;
+}
+/**
+ * The shared QA dialog shell: backdrop, panel, head with the close control,
+ * a scrolling body, and an optional footer. Escape and a backdrop click close
+ * it, and the close control takes focus on open. Rendering is a no-op while
+ * closed, so a closed dialog costs nothing.
+ */
+export declare function QaModal(props: QaModalProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=QaModal.d.ts.map

package/lib/types/client/components/QaProfile.d.ts

@@ -0,0 +1,25 @@
+import type { QaAccountIdentityField, QaAccountProfile, QaAccountProfileInput } from "../../types.js";
+export interface QaProfileModalProps {
+    readonly open: boolean;
+    readonly email: string;
+    readonly profile: QaAccountProfile;
+    /** Handle fields the deployment declares, in its configured order. */
+    readonly identities: readonly QaAccountIdentityField[];
+    readonly instructionsMaxLength: number;
+    readonly onClose: () => void;
+    /**
+     * Persist the edited profile. Resolves to audience-safe refusal copy, or
+     * null once the Host stored it.
+     */
+    readonly onSave: (input: QaAccountProfileInput) => Promise<string | null>;
+}
+/**
+ * The signed-in user's own profile: the full name, one field per declared
+ * external system, and the free-form instructions the assistant receives.
+ *
+ * The form is seeded from the stored profile each time it opens, so a closed
+ * dialog never keeps stale edits; limits mirror the Host's, which stays the
+ * authority — the browser only avoids a round trip for the obvious refusals.
+ */
+export declare function QaProfileModal(props: QaProfileModalProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=QaProfile.d.ts.map

package/lib/types/client/components/QaQuestions.d.ts

@@ -0,0 +1,13 @@
+import type { QaPendingQuestion, QaQuestionAnswerItem } from "../../types.js";
+export interface QaQuestionsProps {
+    readonly questions: readonly QaPendingQuestion[];
+    readonly onAnswer: (requestId: string, answers: readonly QaQuestionAnswerItem[]) => Promise<void>;
+    readonly onCancel: (requestId: string) => Promise<void>;
+}
+/**
+ * The questions a running turn waits on. Answers are the operator's own: the
+ * form refuses to submit a question left blank, and a question explicitly
+ * skipped is reported as skipped rather than answered by guesswork.
+ */
+export declare const QaQuestions: import("react").MemoExoticComponent<(props: QaQuestionsProps) => import("react/jsx-runtime").JSX.Element | null>;
+//# sourceMappingURL=QaQuestions.d.ts.map

package/lib/types/client/components/QaRightRail.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from "react";
+import type { QaRailTab } from "../use-session-ui-state.js";
+/** One rail tab's strip chip: label, live count, and its body is the panel. */
+export interface QaRailTabModel {
+    readonly id: QaRailTab;
+    readonly title: string;
+    /** Items the tab will show; 0 hides the badge. */
+    readonly count: number;
+    readonly body: ReactNode;
+}
+export interface QaRightRailProps {
+    readonly tabs: readonly QaRailTabModel[];
+    readonly activeTab: QaRailTab;
+    readonly onTabSelect: (tab: QaRailTab) => void;
+    readonly onClose: () => void;
+}
+/**
+ * The chat's right rail: a fixed column whose top edge is the tab strip,
+ * mirroring the Harness right Sidebar's chrome. Tabs are plain chips with
+ * counts; the strip's last control collapses the whole column.
+ */
+export declare function QaRightRail({ tabs, activeTab, onTabSelect, onClose, }: QaRightRailProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=QaRightRail.d.ts.map

package/lib/types/client/components/QaSidebar.d.ts

@@ -1,4 +1,5 @@
 import type { SessionSummary } from "@deepseek-ai/dsh-api-session-controller/client";
+import type { QaAccountIdentityField, QaAccountProfile, QaAccountProfileInput } from "../../types.js";
 /** One renderable row of the chat-history sidebar. */
 export interface QaChatRow {
     readonly id: string;
@@ -56,6 +57,19 @@ export interface QaSidebarProps {
         readonly email: string;
         readonly role: string;
         readonly onLogout: () => void;
+        /**
+         * Self-service profile editing. Omitted when the deployment turns the
+         * feature off, which also leaves the footer name as plain text. Memoized
+         * by the caller: this object is compared by reference.
+         */
+        readonly profileDialog?: {
+            readonly profile: QaAccountProfile;
+            /** Handle fields the dialog renders, in the deployment's order. */
+            readonly fields: readonly QaAccountIdentityField[];
+            readonly instructionsMaxLength: number;
+            /** Persist edited fields; resolves to refusal copy, or null. */
+            readonly onSave: (input: QaAccountProfileInput) => Promise<string | null>;
+        };
     };
 }
 /**

package/lib/types/client/components/{QaSourcesDrawer.d.ts → QaSourcesPanel.d.ts}

@@ -3,7 +3,7 @@ import type { QaBoundSourceApi } from "../types.js";
 export declare function SourceIcon({ kind }: {
     readonly kind: QaSource["kind"];
 }): import("react/jsx-runtime").JSX.Element;
-export interface QaSourcesDrawerProps {
+export interface QaSourcesPanelProps {
     readonly sources: readonly QaSource[];
     readonly complete: boolean;
     readonly incompleteOrigins?: QaTurnSources["incompleteOrigins"];
@@ -13,8 +13,11 @@ export interface QaSourcesDrawerProps {
     readonly filePreview: ResolvedQaSurfaceConfig["sources"]["filePreview"];
     /** Open straight onto this source's detail (an inline footnote click). */
     readonly initialDetail?: QaSource | null;
-    readonly onClose: () => void;
+    /** The list is a message-scoped subset rather than the whole chat. */
+    readonly pinned?: boolean;
+    /** Dismiss the pinned subset and show the whole chat's sources. */
+    readonly onShowAll?: () => void;
 }
 /** Canonical grouped source panel and safe local-file preview. */
-export declare function QaSourcesDrawer({ sources, complete, incompleteOrigins, sessionId, sourceApi, display, filePreview, initialDetail, onClose, }: QaSourcesDrawerProps): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=QaSourcesDrawer.d.ts.map
+export declare function QaSourcesPanel({ sources, complete, incompleteOrigins, sessionId, sourceApi, display, filePreview, initialDetail, pinned, onShowAll, }: QaSourcesPanelProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=QaSourcesPanel.d.ts.map

package/lib/types/client/components/QaTurnRail.d.ts

@@ -55,5 +55,11 @@ declare function QaTurnRailView({ items, activeTurn, busyTurn, scrollerRef, onNa
 export declare const QaTurnRail: import("react").MemoExoticComponent<typeof QaTurnRailView>;
 /** Land the transcript on a turn's prompt row, harness-style. */
 export declare function turnScrollTarget(scroller: HTMLElement, row: HTMLElement): number;
+/**
+ * Find the message slot carrying `anchorId` and land the transcript on it,
+ * harness-style. Returns whether the anchor row exists; callers tie their
+ * near-bottom bookkeeping and rail-mark updates to that outcome.
+ */
+export declare function scrollToTranscriptAnchor(scroller: HTMLElement, anchorId: string): boolean;
 export {};
 //# sourceMappingURL=QaTurnRail.d.ts.map

package/lib/types/client/components/QaWidthHandle.d.ts

@@ -1,15 +1,21 @@
 import { type RefObject } from "react";
-/** DSH's dragged content-width floor; a lower operator cap still wins. */
-export declare const QA_CONTENT_MIN_WIDTH = 640;
 /**
  * Space kept outside the content: 88px per side leaves room for the handle,
- * its inset, and a safe zone that remains draggable in both directions.
+ * its inset, and a safe zone that remains draggable in both directions. It is
+ * the whole ceiling too: like DSH, the page bounds the width, so a wide column
+ * lets the transcript fill it.
  */
 export declare const QA_CONTENT_EDGE_BUDGET = 176;
 export declare function readQaContentWidth(storage: Pick<Storage, "getItem">, key: string): number | null;
 export declare function writeQaContentWidth(storage: Pick<Storage, "setItem">, key: string, width: number): void;
-/** Resolve the centered content width for the currently available column. */
-export declare function resolveQaContentWidth(columnWidth: number, preference: number | null, maxContentWidth: number): number;
+/**
+ * Resolve the centered content width for the currently available column. The
+ * operator sets only the floor; the column is the ceiling, so the content may
+ * grow until its handles reach the edge budget and a wider window keeps
+ * widening it. A column too narrow even for the floor wins over the floor —
+ * there is nothing else to give up.
+ */
+export declare function resolveQaContentWidth(columnWidth: number, preference: number | null, minContentWidth: number): number;
 interface QaWidthHandleProps {
     readonly side: "left" | "right";
     readonly onStart: () => number;
@@ -24,13 +30,14 @@ interface UseQaContentWidthOptions {
     readonly root: RefObject<HTMLDivElement | null>;
     readonly storage: Pick<Storage, "getItem" | "setItem">;
     readonly storageKey: string;
-    readonly maxContentWidth: number;
+    readonly minContentWidth: number;
 }
-export declare function useQaContentWidth({ active, root, storage, storageKey, maxContentWidth, }: UseQaContentWidthOptions): {
+export declare function useQaContentWidth({ active, root, storage, storageKey, minContentWidth, }: UseQaContentWidthOptions): {
     readonly onStart: () => number;
     readonly onDrag: (requestedWidth: number) => void;
     readonly onCommit: (requestedWidth: number) => void;
     readonly onEnd: () => void;
 };
+export type UseQaContentWidthResult = ReturnType<typeof useQaContentWidth>;
 export {};
 //# sourceMappingURL=QaWidthHandle.d.ts.map

package/lib/types/client/components/QaWorkGroup.d.ts

@@ -1,12 +1,14 @@
 import type { QaWorkItem } from "../../types.js";
 export interface QaWorkGroupProps {
-    readonly status: "running" | "complete";
+    /** "error" marks a turn the host ended with a provider failure. */
+    readonly status: "running" | "complete" | "error";
     readonly startedAt?: number;
     readonly endedAt?: number;
     readonly items: readonly QaWorkItem[];
     readonly renderMarkdown: boolean;
+    /** Operator-configured running phrases; omitted reads the built-in list. */
+    readonly thinkingPhrases?: readonly string[];
 }
-export declare const THINKING_PHRASES: readonly string[];
 /**
  * Whether two work items render identically. The transcript projection
  * rebuilds every item object on each published frame, so memoized work rows
@@ -15,5 +17,5 @@ export declare const THINKING_PHRASES: readonly string[];
 export declare function sameWorkItem(a: QaWorkItem, b: QaWorkItem): boolean;
 /** Whether two work item lists render identically, item for item. */
 export declare function sameWorkItems(a: readonly QaWorkItem[], b: readonly QaWorkItem[]): boolean;
-export declare const QaWorkGroup: import("react").MemoExoticComponent<({ status, startedAt, endedAt, items, renderMarkdown, }: QaWorkGroupProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const QaWorkGroup: import("react").MemoExoticComponent<({ status, startedAt, endedAt, items, renderMarkdown, thinkingPhrases, }: QaWorkGroupProps) => import("react/jsx-runtime").JSX.Element>;
 //# sourceMappingURL=QaWorkGroup.d.ts.map

package/lib/types/client/components/surface-utils.d.ts

@@ -0,0 +1,11 @@
+import type { QaSessionState } from "../../types.js";
+/**
+ * Small pure projections of the session state shared by surface regions: the
+ * composer's status line and the conversation title. Keeping them out of
+ * QaSurface leaves that file pure composition.
+ */
+/** The composer's status line, or null when nothing is due. */
+export declare function statusText(state: QaSessionState, runningPhrase: string | null): string | null;
+/** The conversation title derived from the first user prompt, clipped. */
+export declare function titleFromMessages(state: QaSessionState): string | null;
+//# sourceMappingURL=surface-utils.d.ts.map

package/lib/types/client/components/thinking-phrases.d.ts

@@ -0,0 +1,9 @@
+import { DEFAULT_THINKING_PHRASES, thinkingPhrase } from "../../thinking-phrases.js";
+export { DEFAULT_THINKING_PHRASES, thinkingPhrase };
+/**
+ * Phrase for a turn that started at `startedAt`. Every reader that passes the
+ * same start time and phrase list lands on the same phrase, so the composer
+ * hint and the work list never disagree.
+ */
+export declare function useThinkingPhrase(running: boolean, startedAt: number | undefined, phrases?: readonly string[]): string | null;
+//# sourceMappingURL=thinking-phrases.d.ts.map

package/lib/types/client/create-session.d.ts

@@ -1,16 +1,13 @@
-import type { ResolvedQaSurfaceConfig } from "../types.js";
-import type { QaSessions, QaSessionsApi } from "./types.js";
+import type { QaCreateSession } from "./types.js";
 /**
- * Create one Host session and pin the configured preset and model onto the
- * still-blank session. The creation wire takes no preset, so
- * agentPresets/select recomposes the agent and durably logs
- * `agent-preset/selected`, which the client projection replays. The session
+ * Ask the QA Host boundary to create a fully composed session. The browser
+ * supplies only its account token and cannot select cwd, workspace, owner,
+ * preset, model, or permission policy. The resulting session
  * is addressed only here — no prompt can run before the caller attests the
  * composed preset.
  */
 export declare function createQaSession(args: {
-    readonly sessions: QaSessions;
-    readonly api: QaSessionsApi;
-    readonly config: ResolvedQaSurfaceConfig;
+    readonly createSession: QaCreateSession;
+    readonly token: string;
 }): Promise<string>;
 //# sourceMappingURL=create-session.d.ts.map

package/lib/types/client/failure-copy.d.ts

@@ -0,0 +1,19 @@
+/**
+ * QA-facing copy for provider failures, keyed by the stable failure code the
+ * host records on retry and turn-end events. Raw provider messages never
+ * reach these rows — they can carry stack traces and local paths — so every
+ * text here derives from the code alone.
+ */
+/** Terminal turn-failure row shown after the work group. */
+export declare function turnErrorCopy(code: string | undefined): string;
+export interface RetryCopySource {
+    readonly mode: "normal" | "always";
+    readonly retry: number;
+    readonly maxRetries?: number;
+    readonly delayMs: number;
+    readonly retryState: "scheduled" | "started" | "cancelled";
+    readonly failureCode?: string;
+}
+/** Work-group row for one host-scheduled model-request retry. */
+export declare function retryWorkCopy(node: RetryCopySource): string;
+//# sourceMappingURL=failure-copy.d.ts.map

package/lib/types/client/project-session-state.d.ts

@@ -1,6 +1,6 @@
 import type { SessionFace } from "@deepseek-ai/dsh-api-session-controller/client";
 import type { ConversationSnapshot } from "@deepseek-ai/dsh-client-ui-conversation/client";
-import type { QaSessionState, QaSubagentView, QaTurnSources, ResolvedQaSurfaceConfig } from "../types.js";
+import type { QaPendingApproval, QaPendingQuestion, QaSessionState, QaSubagentView, QaTurnSources, ResolvedQaSurfaceConfig } from "../types.js";
 /** Everything the bound-chat projection reads; the computation is pure. */
 export interface QaBoundProjectionInput {
     readonly connected: boolean;
@@ -9,6 +9,13 @@ export interface QaBoundProjectionInput {
     readonly conversationSnapshot: ConversationSnapshot | undefined;
     /** Turn bundles with the Host provenance already merged in (Host wins). */
     readonly sourceBundles: readonly QaTurnSources[];
+    /**
+     * Tool calls and questions the Host parked for the operator. They are
+     * host-side state, not part of the session snapshot, so the controller polls
+     * them separately.
+     */
+    readonly approvals: readonly QaPendingApproval[];
+    readonly questions: readonly QaPendingQuestion[];
     readonly operationError: string | null;
     readonly policyReady: boolean;
     readonly admissionPending: boolean;

package/lib/types/client/prompt-content.d.ts

@@ -0,0 +1,30 @@
+import type { SessionFace } from "@deepseek-ai/dsh-api-session-controller/client";
+import type { QaAttachmentDraft, QaFileDraft } from "../types.js";
+import type { QaFileUpload, QaPromptContent } from "./types.js";
+/**
+ * Stage every pending file on the Host and collect the receipts the prompt
+ * cites. Sequential on purpose: a partial batch must be attributable to the
+ * exact file that failed, and the visitor's file counts are small.
+ * `service` is undefined on a page the deployment serves without the upload
+ * plugin, which leaves attachments unavailable rather than broken. The
+ * receipt is opaque and host-minted — the upload service answers with a
+ * plain string, and only the session wire brand knows it as an id.
+ */
+export declare function stageQaFiles(service: QaFileUpload | undefined, session: SessionFace, files: readonly QaFileDraft[]): Promise<{
+    readonly kind: "ok";
+    readonly receipts: Map<string, string>;
+} | {
+    readonly kind: "unavailable";
+} | {
+    readonly kind: "failed";
+}>;
+/**
+ * Assemble the wire content of one prompt: the text part, images riding the
+ * prompt inline, and files cited by their staged receipts. The visitor's own
+ * order decides the prompt order, so images and files are assembled from one
+ * walk over the drafts; an unpaired file receipt (a draft kept while its
+ * staging failed elsewhere) degrades to an empty receipt rather than
+ * dropping the attachment.
+ */
+export declare function buildQaPromptContent(prompt: string, attachments: readonly QaAttachmentDraft[], receipts: ReadonlyMap<string, string>): QaPromptContent;
+//# sourceMappingURL=prompt-content.d.ts.map

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

@@ -0,0 +1,45 @@
+import type { QaPendingQuestion, QaQuestionAnswerItem } from "../types.js";
+import type { QaQuestionApi } from "./types.js";
+/**
+ * The operator's side of a parked `ask_user_question` call.
+ *
+ * Like a parked approval, the request lives on the Host: it survives a reload,
+ * and the surface learns about it by asking while a turn runs. Unlike an
+ * approval, an answer is a whole form — every question of the request, with the
+ * operator's selections and free text — so the bridge forwards the form and
+ * re-reads the list afterwards.
+ */
+export declare class QaHostQuestionBridge {
+    private readonly questionApi;
+    private questions;
+    private signature;
+    private refreshing;
+    private answering;
+    /** Bumped on reset so a stale in-flight response never lands. */
+    private generation;
+    constructor(questionApi: QaQuestionApi | undefined);
+    /** Leave the chat: a chat switch drops the previous chat's requests. */
+    reset(): void;
+    /** The last list this bridge saw; empty when the deployment refuses them. */
+    list(): readonly QaPendingQuestion[];
+    /** Whether this page can ask the Host about questions at all. */
+    get available(): boolean;
+    /**
+     * Re-read the chat's pending questions; a changed list republishes through
+     * the callback. Overlapping calls coalesce, and a response that outlives its
+     * chat is dropped.
+     */
+    refresh(sessionId: string, token: string, onChanged: () => void): Promise<void>;
+    /** Send the operator's answers to one request and re-read the list. */
+    answer(sessionId: string, token: string, requestId: string, answers: readonly QaQuestionAnswerItem[]): Promise<void>;
+    /** Close one request without answering it. */
+    cancel(sessionId: string, token: string, requestId: string): Promise<void>;
+    /**
+     * Run one write against a request, then re-read the list it belonged to. A
+     * refusal is not an error: the request was already settled (the turn was
+     * stopped, the call went away), so the refresh — not the write — is what the
+     * surface shows.
+     */
+    private settle;
+}
+//# sourceMappingURL=questions.d.ts.map