@yadsh/dsh-qa-surface 0.13.0 → 0.15.0

package/lib/types/client/focus-ring.d.ts

@@ -0,0 +1,65 @@
+import type { KeyboardEvent } from "react";
+/**
+ * Whether a modal gate has taken this element away from the keyboard: the
+ * element itself or an ancestor of it is marked inert.
+ *
+ * `inert` is read as a property, not looked up as an attribute. The gate marks
+ * the page inert from script (`QaWelcomeNotice`), a browser reflects that into
+ * the attribute, and jsdom stores nothing but the property on the element it
+ * was given — so the property is the one thing the two agree on, and the walk
+ * up the parent chain is what stands in for the browser's own inheritance.
+ * That a browser additionally refuses focus to everything found here is the
+ * browser's doing: what a live stand has to settle is that the ring's edge and
+ * the gate's own trap hold the keyboard between them without help from this
+ * file.
+ */
+export declare function isInert(element: HTMLElement): boolean;
+/**
+ * Every control of `root` the keyboard can still reach, in DOM order: what the
+ * page has not hidden, in its markup or in its layout, what still carries a
+ * place in the tab order, what no `inert` ancestor has handed to a dialog, and
+ * what no closed fold keeps out of sight.
+ */
+export declare function focusable(root: HTMLElement): HTMLElement[];
+/**
+ * Hand the keyboard to the first candidate that takes it.
+ *
+ * `focusable` reads the layout as well as the markup, so the candidates are
+ * already the controls the width leaves in the path. This is the post-condition
+ * for a refusal that no read predicts: a page can keep a control from taking
+ * focus in ways its own styles do not say, and a test environment applies no CSS
+ * at all, so each candidate is checked at the moment it is asked — a control that
+ * leaves `document.activeElement` where it was is passed over, instead of leaving
+ * the reader on the same control they pressed Tab from.
+ */
+export declare function focusFirst(candidates: readonly (HTMLElement | null | undefined)[]): void;
+/**
+ * The Tab ring over the roots a surface owns, in the order it walks them.
+ *
+ * A root under a modal gate contributes nothing: none of its controls can take
+ * focus, so an edge of the ring that pointed into one would be a key the page
+ * had already swallowed with nowhere to go — a Tab that sticks.
+ */
+export declare function focusRing(roots: readonly (HTMLElement | null)[]): HTMLElement[];
+/**
+ * Keep Tab inside the ring the surface painted, and let the reader out at
+ * neither edge.
+ *
+ * The ring is wider than `<main>`: a notice stack the surface paints in
+ * `document.body` sits after it in the page, so a Tab leaving the composer
+ * walks into the stack, and the edge where the key is caught and turned back is
+ * the stack's last button — not the last control inside `<main>`, which is where
+ * the ring used to stop the reader short of the notice. A key typed inside such
+ * a portal is trapped by the handler mounted on the portal: the `<main>` above
+ * it is not its ancestor and never hears the key.
+ *
+ * A ring with no controls in it answers nothing: there is nothing here to keep
+ * the reader inside, and a key prevented with nowhere to hand the focus is a key
+ * that sticks.
+ *
+ * The two ends the key is caught at are ends of the *walked* path, so a control
+ * the current width has switched off is neither of them: it holds no focus for
+ * the reader to stand on, and an edge drawn at it is an edge no Tab arrives at.
+ */
+export declare function trapKeys(event: KeyboardEvent<HTMLElement>, roots: readonly (HTMLElement | null)[]): void;
+//# sourceMappingURL=focus-ring.d.ts.map

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

@@ -31,19 +31,9 @@ export interface SubagentNameCandidate {
     /** The Host's own wording for the delegation; empty when it listed none. */
     readonly label: string;
 }
-/** One durable delegation catalog entry, as the Host lists it. */
-export interface SubagentCatalogEntry {
-    readonly kind?: string;
-    readonly id?: string;
-    readonly label?: string;
-}
-/** Direct delegation catalogs keyed by their parent chat. */
-export type SubagentCatalogs = Readonly<Record<string, {
-    readonly entries?: readonly SubagentCatalogEntry[];
-} | undefined>>;
 /**
- * Delegated sessions whose names a page may sign its notices with: the
- * children of the chats it lists, catalog labels first and list titles after.
+ * Delegated sessions whose names a page may sign its notices with: the children
+ * of the chats it lists, named by the row title the Host's session list carries.
  *
  * `chats` is the visible chat set — the account's own chats while accounts are
  * on, and `undefined` for a deployment without accounts, where every chat on
@@ -53,5 +43,5 @@ export type SubagentCatalogs = Readonly<Record<string, {
  * therefore contributes no id and no label — a foreign chat can neither sign
  * a notice nor be named by one.
  */
-export declare function visibleSubagentCandidates(byId: Readonly<Record<string, SessionSummary>>, catalogs: SubagentCatalogs, chats: ReadonlySet<string> | undefined): readonly SubagentNameCandidate[];
+export declare function visibleSubagentCandidates(byId: Readonly<Record<string, SessionSummary>>, chats: ReadonlySet<string> | undefined): readonly SubagentNameCandidate[];
 //# sourceMappingURL=lineage.d.ts.map

package/lib/types/client/markdown/blocks.d.ts

@@ -16,6 +16,15 @@
  * delimiters stay literal text, exactly as the Host renders them. Footnote
  * definitions (`[^id]: …`) are collected the way GitHub's dialect does, with
  * lazy and indented continuation lines.
+ *
+ * A frame of a live stream is parsed with `streaming: true`, which says one
+ * thing only: the text may still grow. Block boundaries stay the business of
+ * this module — a caller that knows the answer is being written passes the
+ * flag, and nothing here is re-detected elsewhere. Two readings change with
+ * it: a block whose region runs to the end of the text has not met its
+ * terminator, so a fence or a `$$` block reports `pending`, and a table treats
+ * its live last line as still written (a delimiter row being typed opens the
+ * header, a row being typed stays out of the cells).
  */
 /** `#`-through-`######` heading levels. */
 export type HeadingDepth = 1 | 2 | 3 | 4 | 5 | 6;
@@ -39,6 +48,8 @@ export type MarkdownBlock = {
     readonly kind: "code";
     readonly text: string;
     readonly lang?: string;
+    /** The fence has not met its closing marker: the stream is inside it. */
+    readonly pending?: true;
 } | {
     readonly kind: "quote";
     readonly blocks: readonly MarkdownBlock[];
@@ -56,6 +67,8 @@ export type MarkdownBlock = {
 } | {
     readonly kind: "math";
     readonly text: string;
+    /** The `$$` fence has not closed: the stream is still typing the TeX. */
+    readonly pending?: true;
 } | {
     readonly kind: "rule";
 };
@@ -67,21 +80,36 @@ export interface ParsedMarkdown {
     /** Footnote bodies by upper-cased identifier; first definition wins. */
     readonly footnotes: ReadonlyMap<string, readonly MarkdownBlock[]>;
 }
+/** How to read the end of the text being parsed. */
+export interface MarkdownParseOptions {
+    /**
+     * The text is a frame of a live stream, so its last content line may be
+     * half-typed: a block that reaches the end of the text is reported as
+     * `pending` instead of being treated as settled, and a table leaves an
+     * unfinished last row out of its cells. Omitted for a settled answer, which
+     * is where the two readings must not drift apart.
+     */
+    readonly streaming?: boolean;
+}
 /** Split one table row into trimmed cells, honoring escaped pipes. */
 export declare function splitTableRow(line: string): string[];
 /**
  * Parse a whole document.
  * @param text - Markdown source with any line endings.
+ * @param options - How to read the end of the text; a live stream frame marks
+ * the block it stopped inside as pending.
  * @returns Blocks plus the definitions the inline pass resolves against.
  */
-export declare function parseMarkdown(text: string): ParsedMarkdown;
+export declare function parseMarkdown(text: string, options?: MarkdownParseOptions): ParsedMarkdown;
 /**
  * Parse the blocks of one container (document, quote, or list item).
  * @param lines - Container lines, already de-indented by the caller.
  * @param definitions - Document-wide definition accumulator.
  * @param footnotes - Document-wide footnote accumulator.
  * @param depth - Container nesting depth.
+ * @param streaming - Whether the text is a live frame, so the container's last
+ * line may still be typed.
  * @returns The container's blocks.
  */
-export declare function parseBlocks(lines: readonly string[], definitions: Map<string, string>, footnotes: Map<string, readonly MarkdownBlock[]>, depth: number): MarkdownBlock[];
+export declare function parseBlocks(lines: readonly string[], definitions: Map<string, string>, footnotes: Map<string, readonly MarkdownBlock[]>, depth: number, streaming?: boolean): MarkdownBlock[];
 //# sourceMappingURL=blocks.d.ts.map

package/lib/types/client/markdown/render.d.ts

@@ -1,4 +1,5 @@
 import type { ReactNode } from "react";
+import type { MarkdownParseOptions } from "./blocks.js";
 import { type MarkdownSourceContext } from "./source-chip.js";
 /**
  * Render markdown source as semantic React elements. Raw HTML never enters the
@@ -7,8 +8,10 @@ import { type MarkdownSourceContext } from "./source-chip.js";
  * instead of a plain link or code token.
  * @param text - Assistant-authored markdown.
  * @param context - Source resolution handed down by the owning message.
+ * @param options - How to read the end of the text; a live stream frame holds
+ * the block it stopped inside instead of rendering it as settled.
  * @returns The document's blocks, plus the footnote section when the document
  * references a defined footnote.
  */
-export declare function renderMarkdown(text: string, context: MarkdownSourceContext): ReactNode[];
+export declare function renderMarkdown(text: string, context: MarkdownSourceContext, options?: MarkdownParseOptions): ReactNode[];
 //# sourceMappingURL=render.d.ts.map

package/lib/types/client/notifications/notification-dispatcher.d.ts

@@ -0,0 +1,68 @@
+import type { QaTurnCompletion } from "./turn-completion-source.js";
+import type { QaNoticeChannels } from "./preferences.js";
+/** What the browser exposes of the desktop notification API. */
+export type QaNotificationPermission = NotificationPermission | "unsupported";
+/** One entry of the in-app stack. */
+export interface QaTurnNoticeItem {
+    readonly key: string;
+    readonly sessionId: string;
+    readonly title: string;
+}
+/** A finished turn and the channels it takes. */
+export interface PlannedTurnNotice {
+    readonly item: QaTurnNoticeItem;
+    /** Keep the line in this page, or send the fact to the desktop alone. */
+    readonly inApp: boolean;
+    /** Raise the desktop notice as well, or keep this one inside the page. */
+    readonly desktop: boolean;
+}
+export interface QaNoticeContext {
+    /** `config.notifications`: the deployment's switches over both channels. */
+    readonly switches: {
+        readonly enabled: boolean;
+        readonly allowOs: boolean;
+    };
+    /** The reader's own choice, from their account or from this browser. */
+    readonly channels: QaNoticeChannels;
+    readonly permission: QaNotificationPermission;
+    /** Whether this page is the one the person is looking at right now. */
+    readonly focused: boolean;
+    /** The chat the composer is showing. */
+    readonly activeSessionId: string | null;
+}
+/** Body text of every desktop notice: the fact, never the content. */
+export declare const QA_TURN_NOTICE_BODY = "\u0425\u043E\u0434 \u0437\u0430\u0432\u0435\u0440\u0448\u0451\u043D";
+/**
+ * Decide what one finished turn is worth, if anything.
+ *
+ * A notice exists to say "this happened where you were not looking". The chat
+ * on screen answers itself — the reply arrives in front of the reader — so it
+ * gets nothing, while a background chat that settles under their eyes still
+ * gets the in-app line. Each channel then needs its own two answers: the
+ * deployment's and the reader's. The desktop additionally needs the browser's
+ * permission, which neither of those can grant on its behalf.
+ */
+export declare function planTurnNotice(completion: QaTurnCompletion, context: QaNoticeContext): PlannedTurnNotice | null;
+/**
+ * Whether the person is looking at this page. A hidden tab and a visible tab
+ * behind another window both count as away: the notice is for the difference
+ * between "watching" and "not watching", not for the tab's own state.
+ */
+export declare function isPageFocused(documentState?: {
+    visibilityState: DocumentVisibilityState;
+}, hasFocus?: () => boolean): boolean;
+/** The desktop channel's current answer, or `unsupported` off a secure context. */
+export declare function readNotificationPermission(): QaNotificationPermission;
+/**
+ * Ask the browser for the desktop channel. Only ever called from a click: the
+ * permission prompt is the user's decision about this origin, and a page that
+ * asks on load — or once per finished turn — spends it on the wrong moment.
+ */
+export declare function requestNotificationPermission(): Promise<QaNotificationPermission>;
+/**
+ * Hand one finished turn to the desktop. Returns false when the platform
+ * refuses: a notification that cannot be raised costs the reader nothing, and
+ * the in-app line is already on its way.
+ */
+export declare function raiseDesktopNotice(completion: QaTurnCompletion): boolean;
+//# sourceMappingURL=notification-dispatcher.d.ts.map

package/lib/types/client/notifications/preferences.d.ts

@@ -0,0 +1,44 @@
+import type { QaAccountNotifications } from "../../types.js";
+import type { StorageLike } from "../types.js";
+/** One reader's choice about the desktop channel. */
+export interface QaNotificationPrefs {
+    /** Raise a desktop notice for a finished turn while this page is in the background. */
+    readonly osEnabled: boolean;
+    /** The offer was answered or waved off: a notice never asks a second time. */
+    readonly osOffered: boolean;
+}
+/** The channels one finished turn may use, whoever decided them. */
+export interface QaNoticeChannels {
+    readonly inApp: boolean;
+    readonly desktop: boolean;
+}
+export declare const QA_NOTIFICATION_DEFAULT_PREFS: QaNotificationPrefs;
+/**
+ * Read the stored choice; a denied, full or foreign-shaped store falls back to
+ * the silent default rather than raising notices nobody asked for.
+ *
+ * What is left in this browser is what belongs to a browser: the answer to the
+ * desktop offer, and the desktop choice itself for as long as there is no
+ * account to hold it. Signed in, the account's {@link QaAccountNotifications}
+ * wins — see {@link resolveNoticeChannels} — because a preference that follows
+ * the person is the point of storing it on the account at all.
+ */
+export declare function readNotificationPrefs(storage: StorageLike | undefined, key: string): QaNotificationPrefs;
+/** Persist the choice. A store that refuses only costs it across reloads. */
+export declare function writeNotificationPrefs(storage: StorageLike | undefined, key: string, prefs: QaNotificationPrefs): void;
+/**
+ * Which channels this reader may use for a finished turn.
+ *
+ * The account's answer wins once it exists, so the choice follows the person to
+ * another browser or another laptop. Without an account the browser's own
+ * answer stands: an anonymous stand is the common shape of a QA deployment, and
+ * a mute switch that only appeared once signed in would leave it with no switch
+ * at all. The in-page line has no browser-level switch of its own — a stand that
+ * wants it gone has `notifications.enabled`, and the offer this page makes is
+ * only ever about the desktop channel.
+ */
+export declare function resolveNoticeChannels(input: {
+    readonly account: QaAccountNotifications | undefined;
+    readonly prefs: QaNotificationPrefs;
+}): QaNoticeChannels;
+//# sourceMappingURL=preferences.d.ts.map

package/lib/types/client/notifications/turn-completion-source.d.ts

@@ -0,0 +1,114 @@
+/** One chat of this browser's own list, as the page currently sees it. */
+export interface QaChatActivity {
+    readonly id: string;
+    readonly title: string;
+    readonly running: boolean;
+}
+/** One turn that ended between two observations of the chat list. */
+export interface QaTurnCompletion {
+    readonly sessionId: string;
+    /** The chat's own display title: the only text a notice may carry. */
+    readonly title: string;
+    readonly at: number;
+}
+/**
+ * What this page last read about one chat's turn. Four readings, because two
+ * facts decide whether the end of a run is this reader's news: whether the chat
+ * was running, and whether the frame that said so was one the browser could
+ * vouch for. A frame read while the link was down settles neither fact, but the
+ * way `running` pointed in it still decides what this page is short of: the
+ * start of a run it cannot account for, or an idle reading it cannot yet trust.
+ */
+export type QaTurnSighting = 
+/**
+ * Not running, read while the link held — so a run seen next is one this
+ * page watches begin.
+ */
+"idle"
+/**
+ * Running, and this page saw this very run begin: it held `idle` in the first
+ * frame that found the chat running. The frames after that keep the reading —
+ * the evidence is the witnessed start, so a run does not lose it by lasting
+ * longer than one frame.
+ */
+ | "watched"
+/**
+ * Running, with no evidence of where the run began: the page found the chat
+ * running without seeing it start — which is how the page opens, and how a run
+ * that outlived the link looks once the link is back. A run ending here is not
+ * this reader's news.
+ */
+ | "unwatched"
+/**
+ * Not running, but read only in frames the browser cannot vouch for: the link
+ * was down when this was read, or it has returned and the chat's row has not
+ * moved since. A row that has not moved is no news about now — it may well be
+ * the reading the gap left behind, and this page cannot tell the two apart —
+ * so it arms nothing, because a run that began inside the gap would leave it
+ * exactly as it is. Only the row moving ends it.
+ */
+ | "stale";
+export interface QaTurnCompletionOptions {
+    /**
+     * Re-project the baseline and report nothing. While the browser is
+     * reconnecting the list it holds is stale, and the first frame after the
+     * link returns would otherwise read as a batch of finished turns. This flag
+     * goes back off with the link, which is sooner than the host list is read
+     * again: the re-pull belongs to the host store and is not awaited, so a live
+     * frame can carry the rows the drop left. What a pause costs this page is
+     * therefore carried by the readings rather than by the flag — see `stale`. A
+     * gap that left no frame with this flag set is named as a rule of
+     * `docs/specs/owner-scoped-notifications.md` §12, not as a detail of this
+     * file.
+     */
+    readonly paused?: boolean;
+    readonly now?: number;
+}
+/**
+ * Report the turns that ended since the previous observation of `chats`.
+ *
+ * The input is this reader's own rows — see {@link scopeNoticesToOwnChats},
+ * which is what keeps an admin's shared history out of them — because a notice
+ * is an outward report about the chat it names. The host list is the whole
+ * deployment's, so anything wider than these rows would tell one user that
+ * another user's turn had stopped.
+ *
+ * `seen` is the caller's per-page map of the last reading, and a chat is
+ * reported only when a `watched` run is seen ending in a frame the browser
+ * could vouch for. So the notice always tells the reader about a turn they were
+ * waiting for, and never about one that was already under way when they could
+ * not see it: a chat found running on the page's first frame, or in the frames
+ * around a reconnect, is `unwatched`, and its end passes in silence. Nor does a
+ * gap the page was shown spare a run it lands inside: the paused frame takes
+ * back the evidence that this page watched that run begin, because while the
+ * link was down the chat may have run another turn and the rows that come back
+ * name neither. The first run to end after a gap passes in silence too, in a
+ * chat whose row never moved across it — the only idle this page holds for that
+ * chat was read through the gap, and a run that began inside the gap would look
+ * exactly like it. That reading arms nothing until the chat's own row moves, and
+ * the move that arms it is a run ending: the very one this page then keeps
+ * silent about. So a turn is reported only when no gap falls between the idle
+ * reading that armed this page and the frame that sees the run end, which is why
+ * a run begun and finished on the recovered link can still pass unreported, and
+ * why a gap the page was shown costs a chat one turn — or two, where a turn
+ * ended inside the gap. A gap that reached no committed frame hands this function
+ * nothing to go silent about, and §12 of
+ * `docs/specs/owner-scoped-notifications.md` owns that case. The turn that a link
+ * which held carries from an armed idle to its end is the page's own, so a page
+ * that stays open notifies again once the turn paying for the gap has ended —
+ * once per turn from there.
+ */
+export declare function settleTurnCompletions(seen: Map<string, QaTurnSighting>, chats: readonly QaChatActivity[], options?: QaTurnCompletionOptions): QaTurnCompletion[];
+/**
+ * Keep the rows a notice may be raised for: the sidebar's rows down to the
+ * chats this account owns outright.
+ *
+ * The sidebar is a *read* surface, and an admin's shared view is deliberately
+ * wider than ownership — the same opt-in that shows another account's chat
+ * must not decide whose activity this browser reports outward. A notice is
+ * that outward report, and it names a chat by title, so it takes the narrow
+ * list. `undefined` is the deployment with no accounts, where the browser's own
+ * index already is the owned set and there is nothing narrower to ask for.
+ */
+export declare function scopeNoticesToOwnChats(chats: readonly QaChatActivity[], ownIds: readonly string[] | undefined): readonly QaChatActivity[];
+//# sourceMappingURL=turn-completion-source.d.ts.map

package/lib/types/client/notifications/use-turn-notifications.d.ts

@@ -0,0 +1,51 @@
+import type { QaAccountNotifications, QaAccountNotificationsInput, ResolvedQaSurfaceConfig } from "../../types.js";
+import type { StorageLike } from "../types.js";
+import { type QaTurnNoticeItem } from "./notification-dispatcher.js";
+import { type QaChatActivity } from "./turn-completion-source.js";
+export interface QaTurnNotificationsInput {
+    /** The sidebar's rows: this browser's chats with their running state. */
+    readonly chats: readonly QaChatActivity[];
+    /**
+     * The chats this account owns outright, which is narrower than the rows: an
+     * admin's shared history lists chats it only reads, and the turn of such a
+     * chat is that other account's business. Absent where there is no account to
+     * be narrower than — a stand without accounts, whose rows are the browser's
+     * own index.
+     */
+    readonly ownChatIds?: readonly string[];
+    readonly notifications: ResolvedQaSurfaceConfig["notifications"];
+    readonly storage: StorageLike | undefined;
+    readonly storageKey: string;
+    /**
+     * The signed-in reader's own channels and the write that changes them.
+     * Absent on a stand without accounts, where the browser's own answer is the
+     * only one there is to ask.
+     */
+    readonly account?: {
+        readonly notifications: QaAccountNotifications;
+        readonly onSave: (input: QaAccountNotificationsInput) => Promise<string | null>;
+    };
+    /**
+     * The link is down, so no run read among these rows is this reader's news. The
+     * flag says nothing about the rows: it goes back off with the link, while the
+     * host list is re-read after it and unawaited, so the reading named `stale` is
+     * what carries the gap over a live frame whose row has not moved since.
+     */
+    readonly paused: boolean;
+    readonly activeSessionId: string | null;
+    readonly onSwitch: (sessionId: string) => void;
+}
+export interface QaTurnNotifications {
+    readonly items: readonly QaTurnNoticeItem[];
+    readonly onOpen: (sessionId: string) => void;
+    readonly onDismiss: (key: string) => void;
+    readonly onEnableDesktop?: () => void;
+}
+/**
+ * Turn-completion notices for the chats this reader owns. Of the rows the
+ * sidebar shows, only the ones this account owns outright are watched, and when
+ * one of them stops running after this page watched that run begin, the reader
+ * is told in the channels they and the deployment allow.
+ */
+export declare function useQaTurnNotifications(input: QaTurnNotificationsInput): QaTurnNotifications;
+//# sourceMappingURL=use-turn-notifications.d.ts.map

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

@@ -1,11 +1,27 @@
 import type { SessionFace } from "@deepseek-ai/dsh-api-session-controller/client";
+import type { UserMessage } from "@deepseek-ai/dsh-llm";
 import type { ConversationSnapshot } from "@deepseek-ai/dsh-client-ui-conversation/client";
-import type { QaPendingApproval, QaPendingQuestion, QaSessionState, QaSlashView, QaSubagentView, QaTurnSources, ResolvedQaSurfaceConfig } from "../types.js";
+import type { QaPendingApproval, QaPendingQuestion, QaQueueStatus, QaSessionState, QaSlashView, QaSubagentView, QaTurnSources, ResolvedQaSurfaceConfig } from "../types.js";
 /** Everything the bound-chat projection reads; the computation is pure. */
 export interface QaBoundProjectionInput {
     readonly connected: boolean;
     readonly sessionId: string;
+    /** Chat identity from the controller; see `QaSessionState.chatKey`. */
+    readonly chatKey: number;
     readonly sessionSnapshot: ReturnType<SessionFace["getSnapshot"]>;
+    /**
+     * The Host's Inbox projection for this session: the messages waiting for the
+     * agent's next turn. A projection key the Host has not published reads as an
+     * empty list, which is what a session with no queued work shows anyway.
+     */
+    readonly queuedMessages: readonly UserMessage[];
+    /**
+     * Request ids this binding has already seen the Host name, out of
+     * {@link queuedMessages} and the transcript. The mask {@link projectQueue}
+     * draws with while the session library's echo retirement waits on a frame the
+     * surface may never get.
+     */
+    readonly admittedSubmissions: ReadonlySet<string>;
     readonly conversationSnapshot: ConversationSnapshot | undefined;
     /** Turn bundles with the Host provenance already merged in (Host wins). */
     readonly sourceBundles: readonly QaTurnSources[];
@@ -17,6 +33,13 @@ export interface QaBoundProjectionInput {
     readonly approvals: readonly QaPendingApproval[];
     readonly questions: readonly QaPendingQuestion[];
     readonly operationError: string | null;
+    /**
+     * A send the stand had no room for. The dialog is the whole of what the
+     * visitor learns: the question never reached the Host, so the transcript has
+     * no row to carry the refusal on. Distinct from `queue`, the waiting rows of
+     * this chat.
+     */
+    readonly requestQueue: QaQueueStatus | null;
     readonly policyReady: boolean;
     /** Historical binding retained for transcript access after policy drift. */
     readonly compatibilityReadOnly?: boolean;
@@ -37,6 +60,17 @@ export interface QaBoundProjectionInput {
      */
     readonly author?: string;
 }
+/**
+ * The request ids the Host has itself named for a send, out of the two lists it
+ * publishes: the messages waiting in its Inbox and the durable input rows of its
+ * transcript (`user` opens the turn that took the message, `steering` is one
+ * injected into the turn already running). Either is the server's own receipt
+ * that the message crossed, and reading both is what makes the receipt
+ * independent of which frame carried the news: a message the turn has claimed is
+ * gone from the Inbox yet stays in the transcript, so a send admitted and claimed
+ * between two notifications is still named by the next transcript frame.
+ */
+export declare function hostNamedSubmissionIds(queued: readonly UserMessage[], conversationSnapshot: ConversationSnapshot | undefined): Set<string>;
 /**
  * Project one bound chat into the observable surface state: phase, transcript
  * with per-turn sources, footer sources, and the composer's capabilities.

package/lib/types/client/role/RoleSelector.d.ts

@@ -15,10 +15,16 @@ export declare function QaRoleSelector(props: QaRoleSelectorProps): import("reac
  * is hidden — the previewed profile need not be one the account holds — so
  * without a control here the only exit was the browser's Back button, and a new
  * chat meanwhile ran as the previewed profile instead of the account's default.
- * @param props - the previewed role's name, and how to leave the preview.
+ *
+ * Leaving is a new chat, so the way out waits for the same moments the header's
+ * "Новый чат" and the role selector wait for: while a chat is still being
+ * created, this click would take the screen from the question on its way in.
+ * @param props - the previewed role's name, how to leave the preview, and whether
+ * that way is currently blocked by a chat being created.
  */
 export declare function QaAdminPreviewBanner(props: {
     readonly role: string;
     readonly onExit?: () => void;
+    readonly disabled?: boolean;
 }): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=RoleSelector.d.ts.map

package/lib/types/client/settings/card.d.ts

@@ -8,16 +8,47 @@
  * mutation; the status view re-reads the Remote while the card is visible, so
  * a saved change is confirmed against the Host rather than against the form.
  */
-import type { SettingsScope } from "@deepseek-ai/dsh-client-ui-settings/client";
+import type { ConfigForm } from "@deepseek-ai/dsh-client-ui-settings/client";
 import type { InjectFace, PropsRuntime } from "@deepseek-ai/dsh-client-ui-slots";
 import type { RemoteResult } from "@deepseek-ai/dsh-typert-protocol";
 import type { QaSurfaceConfig, ResolvedQaSurfaceConfig } from "../../types.js";
-/** The face the slot entry injects into this card. */
+/**
+ * The face the row seat injects into this card.
+ *
+ * The live form is named `settingsForm`, not `form`: the seat hands its
+ * registrant a `form` of its own — the page's `ConfigPageForm`, which is only
+ * `{ state, mutate }` (`formFor` in
+ * `@deepseek-ai/dsh-client-ui-plugin-manager/lib/client.js` snapshots the same
+ * namespace's form and forwards `mutate` and nothing else), so it can neither be
+ * subscribed to nor written field by field, and which the page leaves
+ * `undefined` for a Config declaring no volatile field — and the renderer
+ * spreads that owner prop after this face. The card therefore keeps resolving
+ * the full `ConfigForm` of its own namespace through `ctx.configForms` and takes
+ * no copy of the page's view.
+ */
 export interface QaSettingsCardFace {
-    readonly scope: SettingsScope<QaSurfaceConfig>;
+    readonly settingsForm: ConfigForm<QaSurfaceConfig>;
     describe(): Promise<RemoteResult<ResolvedQaSurfaceConfig>>;
 }
-type CardProps = PropsRuntime<"settings.plugin.item"> & InjectFace<QaSettingsCardFace>;
-export declare function QaSettingsCard({ scope, describe }: CardProps): import("react/jsx-runtime").JSX.Element | null;
+type CardProps = PropsRuntime<"plugins.row.config"> & InjectFace<QaSettingsCardFace>;
+export declare function QaSettingsCard({ settingsForm, describe }: CardProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * The entry this plugin registers in the row's configuration seat.
+ *
+ * `RowDetail` in `@deepseek-ai/dsh-client-ui-plugin-manager/lib/client.js` can
+ * ask this seat for two shapes of the same entry: `view: 'summary'` as the row's
+ * one-liner and `view: 'page'` in the configuration column under the row's
+ * heading. Which of the two it asks for is the page's decision and §4.2 of
+ * `docs/DSH-0.1.7-MIGRATION.md` is where that is measured and stated — the row's
+ * description comes from the installed manifest, and the summary seat is the
+ * fallback for a row that declares none — so this bundle answers both without
+ * claiming either call is its own. The summary lands inside a line of the page's
+ * text, so it stays a sentence: a card seated there would draw a page within a
+ * line and start a second poll of the `qaSurface/describe` Remote. The page view
+ * is the body alone — the row's page already draws the card surface, the heading
+ * and the expand control, so a shell of ours would be a second frame inside the
+ * first (AGENTS.md, card-shell contract).
+ */
+export declare function QaSettingsCardEntry(props: CardProps): "A focused end-user QA surface backed by native DeepSeek Harness sessions" | import("react/jsx-runtime").JSX.Element;
 export {};
 //# sourceMappingURL=card.d.ts.map