@yadsh/dsh-qa-surface 0.13.0 → 0.15.0

package/lib/types/integration/answer.d.ts

@@ -20,6 +20,15 @@ export interface QaTurnAnswer {
     /** Durable seq of the message the answer came from, when there was one. */
     readonly seq: number | null;
 }
+/** One request's answer, additionally attributed to the turn it came from. */
+export interface QaRequestAnswer extends QaTurnAnswer {
+    /**
+     * The harness turn number the answer was read out of, or null when the log
+     * named no turn for the request's own row. The provenance bundle of a turn is
+     * the evidence of its answer, so the caller cites the same number.
+     */
+    readonly turn: number | null;
+}
 /** The empty answer: what a turn that committed nothing readable looks like. */
 export declare const QA_EMPTY_ANSWER: QaTurnAnswer;
 /**
@@ -35,6 +44,24 @@ export declare const QA_EMPTY_ANSWER: QaTurnAnswer;
  * @returns the publishable answer and whether the turn was interrupted.
  */
 export declare function answerAfter(events: readonly StoredSessionEvent[], afterSeq: number): QaTurnAnswer;
+/**
+ * Project the answer of the turn one request's own prompt opened.
+ *
+ * The harness stamps the prompt's rpc id onto the durable user row it claims,
+ * so the row is found by id rather than guessed from the newest human message:
+ * two questions in flight on one chat open two turns, and a selection by
+ * "latest" answers each caller with the other's turn. The turn that answers a
+ * request is the one its row was claimed into — `turn/start` opens a turn and
+ * the claimed rows follow it — so the answer is read out of that turn's
+ * assistant messages only, and its number travels with it for the citation.
+ *
+ * @param events - durable events, in any order.
+ * @param requestId - the rpc id the prompt was submitted with.
+ * @returns the answer of this request's turn, or `undefined` when the log
+ * holds no row for the request (an unflushed prompt, or a harness that does not
+ * echo the id), which leaves the choice of cursor to the caller.
+ */
+export declare function answerForRequest(events: readonly StoredSessionEvent[], requestId: string): QaRequestAnswer | undefined;
 /**
  * Cut an answer down to the size the caller publishes.
  *

package/lib/types/integration/expert-memory.d.ts

@@ -0,0 +1,49 @@
+import type { QaExpertMemoryRecord, QaExpertMemoryScope } from "../types.js";
+/**
+ * The slice of `@yadsh/dsh-domain-experts` the QA console uses.
+ *
+ * Declared structurally instead of imported, for the same reason the audit
+ * remote is: the QA surface has to load on a stand where the experts plugin is
+ * not composed at all, and a package dependency would turn "not installed" into
+ * "does not boot".
+ *
+ * What is reached is the plugin's `memoryAdmin` seam — not its `@Remote`
+ * methods. A domain-experts remote takes no token and checks no permission,
+ * because inside the Harness its caller is already a trusted component; the QA
+ * console answers a browser on a LAN port, so it carries the identity itself
+ * and goes through the host-plane seam instead.
+ */
+export interface QaExpertMemoryAdmin {
+    scopes(): Promise<readonly QaExpertMemoryScope[]>;
+    search(namespace: string, query: string, limit: number, offset: number): Promise<{
+        readonly records: readonly QaExpertMemoryRecord[];
+        readonly total: number;
+    }>;
+    correct(input: QaExpertMemoryRecordInput): Promise<QaExpertMemoryRecord>;
+    remove(namespace: string, key: string): Promise<boolean>;
+    removeMany(namespace: string, keys: readonly string[]): Promise<number>;
+    wipe(namespace: string): Promise<number>;
+}
+/** What a correction says one record should hold. The key is the address. */
+export interface QaExpertMemoryRecordInput {
+    readonly namespace: string;
+    readonly key: string;
+    readonly text: string;
+    readonly tags?: readonly string[];
+}
+/** The part of the domain-experts service the console addresses. */
+export interface QaDomainExpertsFace {
+    readonly memoryAdmin: QaExpertMemoryAdmin;
+}
+/**
+ * Why a memory call failed, in the coarse vocabulary the console's copy table
+ * speaks.
+ *
+ * The refusal is read off the plugin's stable `code` field rather than its
+ * message: a message is written for a log and gets reworded, and matching one
+ * here would mean a rename in another package silently turns a refusal into an
+ * unhandled fault. `cause` is checked too, because the storage seam wraps what
+ * the backend threw.
+ */
+export declare function expertMemoryReasonOf(error: unknown): "forbidden" | "memory-record-unknown" | "memory-unavailable" | "invalid-memory" | undefined;
+//# sourceMappingURL=expert-memory.d.ts.map

package/lib/types/notifications.d.ts

@@ -0,0 +1,32 @@
+import type { QaAccountNotifications, QaAccountNotificationsInput } from "./types.js";
+/**
+ * What an account that never opened the notifications form gets.
+ *
+ * The in-page line is the shipped default of the feature itself, so an
+ * untouched account keeps behaving as it did before the form existed. The
+ * desktop channel stays off until asked for: raising an operating-system notice
+ * is the one choice that leaves the page, and a stand where the browser was
+ * never asked must not make it on the account's behalf.
+ */
+export declare function emptyNotifications(): QaAccountNotifications;
+/**
+ * Read one stored (or wire-delivered) notifications record into its public
+ * shape. Unknown or hand-edited input degrades to the readable subset rather
+ * than throwing, mirroring the starters read path: a malformed record must
+ * never cost the account its session.
+ */
+export declare function normalizeNotifications(value: unknown): QaAccountNotifications;
+export type QaNotificationsWriteResult = {
+    readonly ok: true;
+    readonly value: QaAccountNotificationsInput;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+/**
+ * Validate one full-replace notifications write. Both channels are required: a
+ * payload that names only one would silently reset the other, and the form
+ * always sends the pair it was rendered with.
+ */
+export declare function validateNotificationsWrite(input: unknown): QaNotificationsWriteResult;
+//# sourceMappingURL=notifications.d.ts.map

package/lib/types/personal-skills/errors.d.ts

@@ -3,7 +3,7 @@
  * `(reason: <code>)` marker the account remotes established: the browser maps
  * them to audience-safe copy, while the precise cause stays in the Host log.
  */
-export type QaPersonalSkillErrorReason = "skills-disabled" | "workspace-unavailable" | "skill-not-found" | "skill-exists" | "skill-conflict" | "skill-name-invalid" | "skill-invalid" | "storage-unavailable";
+export type QaPersonalSkillErrorReason = "skills-disabled" | "workspace-unavailable" | "skill-not-found" | "skill-exists" | "skill-conflict" | "skill-truncated" | "skill-name-invalid" | "skill-invalid" | "storage-unavailable";
 export declare class QaPersonalSkillError extends Error {
     readonly reason: QaPersonalSkillErrorReason;
     constructor(reason: QaPersonalSkillErrorReason, message: string);

package/lib/types/personal-skills/service.d.ts

@@ -55,6 +55,12 @@ export interface QaStoredSkill {
     readonly contents: QaSkillFileContents | undefined;
     readonly diagnostics: readonly QaSkillDiagnostic[];
     readonly resourceCount: number;
+    /**
+     * True when `raw` is only the head of the file: an oversized `SKILL.md` is
+     * read up to the ceiling, and what follows it was never loaded. A write must
+     * not overwrite such a document without saying so out loud.
+     */
+    readonly truncated: boolean;
 }
 export interface QaPersonalSkillsOptions {
     readonly getConfig: () => ResolvedQaSurfaceConfig;

package/lib/types/prompt-notes.d.ts

@@ -1,13 +1,26 @@
 import type { Context } from "@deepseek-ai/cordis";
+import type { ContextSnapshotSection } from "@deepseek-ai/dsh-llm";
 import type { PluginLogger } from "@yadsh/dsh-plugin-log";
 import type { QaAccounts } from "./accounts/store.js";
 import type { QaAccountIdentityField, QaAccountProfile, ResolvedQaSurfaceConfig } from "./types.js";
 /**
- * Plugin marker on every injected message. The chat projection turns a
- * plugin-sourced user message into injected context rather than a chat
- * bubble, and the QA transcript keeps exactly those hidden.
+ * This plugin's own producer source kind. The `@deepseek-ai/dsh-llm` source map
+ * is merge-extensible and ships no catch-all `plugin` kind, so a producer names
+ * itself here. The chat projection turns a `qa-notes`-sourced user message into
+ * injected context rather than a chat bubble, and the QA transcript keeps
+ * exactly those hidden.
  */
-export declare const QA_NOTES_PLUGIN = "qa-surface";
+export interface QaNotesMessageSource {
+    readonly kind: "qa-notes";
+    /** Every note is superseded by the next one this plugin injects. */
+    readonly form: "snapshot";
+    readonly sections: readonly ContextSnapshotSection[];
+}
+declare module "@deepseek-ai/dsh-llm" {
+    interface MessageSourceMap {
+        "qa-notes": QaNotesMessageSource;
+    }
+}
 /** Note name carrying who the assistant is talking to. */
 export declare const QA_IDENTITY_NOTE = "dsh-qa-surface:user-identity";
 /** Note name carrying the deployment's rule about source provenance. */

package/lib/types/request-queue.d.ts

@@ -0,0 +1,32 @@
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import type { QaQueueStatus } from "./types.js";
+/**
+ * Chat turns the stand is answering right now.
+ *
+ * `running` is the harness's own definition of an active request: an agent
+ * enters it when waking input starts the driver and leaves it when the driver
+ * retires, which is what `agent/status` reports. Reading the live agents rather
+ * than counting the plugin's own sends is what keeps the places honest — a
+ * browser that closes mid-answer, an answer started through the HTTP API and a
+ * turn resumed by another surface all occupy a place, and none of them has to
+ * report it here. Only top-level agents count: a delegated expert's requests
+ * belong to the chat turn that delegated them, so charging both would bill one
+ * conversation twice.
+ *
+ * The count is of the model's load, not of this plugin's traffic: a turn the
+ * native assistant runs occupies a place exactly like a QA question does,
+ * because the ceiling exists for the card that is busy either way.
+ */
+export declare function qaActiveRequests(agents: readonly {
+    readonly status: Agent["status"];
+}[]): number;
+/**
+ * Judge the live count against the deployment's ceiling. A ceiling of 0 sets no
+ * limit, so the stand is never full and nobody waits.
+ *
+ * There is deliberately no "ahead of you" number: `active` includes this
+ * visitor's own turns, and a stand that cannot say which place belongs to whom
+ * should not pretend to know who is waiting behind whom.
+ */
+export declare function qaQueueStatus(limit: number, active: number): QaQueueStatus;
+//# sourceMappingURL=request-queue.d.ts.map

package/lib/types/shared/settings.d.ts

@@ -5,6 +5,23 @@
  * browser build must not pull the Host config surface (schemastery) into the
  * page just to learn the namespace name.
  */
-/** Settings namespace the QA surface owns and its card binds to. */
-export declare const QA_SURFACE_SETTINGS_NAMESPACE = "qa-surface";
+/**
+ * Settings namespace the QA surface owns and its card binds to.
+ *
+ * The namespace is the profile entry id the bundle declares in
+ * `cordis.patch.yml`, not a name this plugin picks: the Host derives the
+ * configuration form of every entry from its volatile `Config` fields and serves
+ * it under that id.
+ */
+export declare const QA_SURFACE_SETTINGS_NAMESPACE = "dsh-qa-surface";
+/**
+ * The key of the seat this card takes on the Host's Plugins page.
+ *
+ * `plugins.row.config` is keyed `<package name>#<row id>`, so the two names the
+ * page joins are this bundle's `package.json.name` and the profile entry id
+ * above. Neither is a name this plugin picks: a key that drifts from that pair
+ * leaves the row without its configure control and the card off the page, with
+ * nothing said about it.
+ */
+export declare const QA_SURFACE_ROW_CONFIG_KEY = "@yadsh/dsh-qa-surface#dsh-qa-surface";
 //# sourceMappingURL=settings.d.ts.map

package/lib/types/turn-failure-log.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { PluginLogger } from "@yadsh/dsh-plugin-log";
+/**
+ * Write a failed turn where the operator of the stand reads it.
+ *
+ * The chat row of a failed turn carries the failure code and nothing else: the
+ * provider's own message is deliberately kept out of the browser, and the
+ * session journal that holds it is a zstd archive nobody reads over an
+ * operator's shoulder. So a stand whose provider adapters never registered —
+ * every turn ending `NO_ADAPTER` — shows its tester «Помощнику не удалось
+ * завершить ответ.» and stays undiagnosable until someone decodes frames by
+ * hand. This listener puts the facts an operator needs — the chat, the session
+ * that died inside it, the turn, the code, and the provider the Host was asked
+ * to route to — into the plugin's own daily log, which is mirrored to the
+ * container's stdout from `warn` up.
+ */
+export declare function registerTurnFailureLog(ctx: Context, logger: PluginLogger, resolveChat: (sessionId: string) => string | undefined): () => void;
+//# sourceMappingURL=turn-failure-log.d.ts.map

package/lib/types/types.d.ts

@@ -44,7 +44,14 @@ export type QaAccountRole = "user" | "reviewer" | "admin";
 /** Administrative permissions a role grants; see `admin/permissions.ts`. */
 export type QaPermission = "users.read" | "users.manage" | "roles.read" | "roles.manage" | "conversations.read.all" | "conversations.read.own" | "conversations.delete" | "reviews.read" | "reviews.write" | "analytics.read" | "audit.read" | "settings.manage"
 /** Write access to skill files, personal and deployment-wide. */
- | "skills.manage";
+ | "skills.manage"
+/**
+ * What the domain experts wrote into their durable memory. Reading is split
+ * from correcting because a reviewer is the one who notices a remembered
+ * inaccuracy in an answer, and an answer the expert keeps getting wrong is
+ * the reviewer's business even though the fix is not.
+ */
+ | "memory.read" | "memory.manage";
 /**
  * Tools split by how they become available. `always` is visible from the first
  * model step; `skillGrantable` is a ceiling — the tool only appears once an
@@ -217,7 +224,9 @@ export interface QaEffectiveCapabilityPolicy {
     readonly skills: readonly string[];
     /**
      * Visible skills a person may invoke with `/name`, including skills that
-     * opted out of model invocation and therefore stay out of the catalog.
+     * opted out of model invocation and therefore stay out of the catalog. The
+     * skills this account owns are here for it without a role grant, unless an
+     * administrator has withdrawn the name outright.
      */
     readonly userSkills: readonly string[];
     readonly sources: {
@@ -290,6 +299,8 @@ export interface QaAccountUserPublic {
     readonly profile: QaAccountProfile;
     /** The account's own starter buttons; empty until customized. */
     readonly starters: QaAccountStarters;
+    /** Which channels a finished turn may use for this reader. */
+    readonly notifications: QaAccountNotifications;
 }
 /** One external system the deployment collects a handle for. */
 export interface QaAccountIdentityField {
@@ -339,6 +350,31 @@ export interface QaAccountStartersInput {
     readonly items: readonly QaAccountStarter[];
     readonly hideDefaults: boolean;
 }
+/**
+ * What one account allows a finished turn to do to it. Pure UI preferences:
+ * unlike the profile, none of this reaches the agent prompt, and unlike the
+ * starter buttons, none of it is content — it is two switches over the
+ * channels the plugin already knows how to raise.
+ *
+ * The deployment's `config.notifications` sits above these: a channel the stand
+ * closed stays closed whatever an account asks for, which is the operator's
+ * answer to a laptop more than one person signs in on.
+ */
+export interface QaAccountNotifications {
+    /** Show the in-page line naming the chat whose turn ended. */
+    readonly inApp: boolean;
+    /**
+     * Hand the same fact to the operating system while this page is hidden or
+     * behind another window. Needs the browser's permission as well: without it
+     * the line stays inside the page and nothing asks a second time.
+     */
+    readonly desktop: boolean;
+}
+/** Full-replace notifications write: both channels are always sent. */
+export interface QaAccountNotificationsInput {
+    readonly inApp: boolean;
+    readonly desktop: boolean;
+}
 /** One successful login/registration: the bearer token plus the user. */
 export interface QaAccountSession {
     readonly token: string;
@@ -425,7 +461,7 @@ export interface QaOwnershipEntry {
  * Why one skill draft cannot be saved, or why it saves with a caveat. Codes
  * stay stable on the wire; the browser owns the Russian copy.
  */
-export type QaSkillDiagnosticCode = "name-required" | "name-invalid" | "name-mismatch" | "description-required" | "description-too-long" | "when-to-use-too-long" | "field-type-invalid" | "invocation-never" | "invocation-invalid" | "invocation-legacy-key" | "allowed-tools-invalid" | "tool-name-invalid" | "tool-unavailable" | "tools-too-many" | "file-too-large" | "frontmatter-missing" | "skill-file-missing" | "frontmatter-invalid" | "unknown-field" | "resource-unsupported";
+export type QaSkillDiagnosticCode = "name-required" | "name-invalid" | "name-mismatch" | "description-required" | "description-too-long" | "when-to-use-too-long" | "field-type-invalid" | "invocation-never" | "invocation-invalid" | "invocation-legacy-key" | "allowed-tools-invalid" | "tool-name-invalid" | "tool-unavailable" | "tools-too-many" | "file-too-large" | "frontmatter-missing" | "skill-file-missing" | "skill-file-truncated" | "frontmatter-invalid" | "unknown-field" | "resource-unsupported";
 /** One finding about a skill file or an editor draft. */
 export interface QaSkillDiagnostic {
     readonly code: QaSkillDiagnosticCode;
@@ -482,6 +518,40 @@ export interface QaAdminSkillsView {
     /** Absolute directory this scope reads and writes, rendered read-only. */
     readonly rootPath: string;
 }
+/**
+ * One memory namespace as the console lists it: which expert it belongs to and
+ * whether it takes writes. `access` comes from the expert's own definition, so
+ * a shared carrier shows up as what its owner declared rather than as whatever
+ * the browser guessed.
+ */
+export interface QaExpertMemoryScope {
+    readonly domainId: string;
+    readonly domainName: string;
+    readonly namespace: string;
+    readonly access: "read-write" | "read-only";
+    readonly records: number;
+}
+/** One line an expert recorded. */
+export interface QaExpertMemoryRecord {
+    readonly namespace: string;
+    readonly key: string;
+    readonly text: string;
+    readonly tags: readonly string[];
+    readonly createdAt: number;
+    readonly updatedAt: number;
+}
+/** One page of a namespace, with the count the filter matched. */
+export interface QaExpertMemoryPage {
+    readonly records: readonly QaExpertMemoryRecord[];
+    readonly total: number;
+    readonly offset: number;
+    readonly limit: number;
+}
+/** What an operator says a record should hold. The key never moves. */
+export interface QaExpertMemoryDraft {
+    readonly text: string;
+    readonly tags: readonly string[];
+}
 export interface QaSkillSummary {
     readonly name: string;
     readonly description: string;
@@ -516,6 +586,12 @@ export interface QaSkillDocument extends QaSkillSummary {
     readonly sourcePath: string;
     /** The canonical file the serializer writes, built from the parsed content. */
     readonly preview: string;
+    /**
+     * True when the stored file is larger than the Host's read ceiling, so `body`
+     * and `preview` describe its head only. A save over such a document erases
+     * the unread tail, and the Host refuses it until the client confirms.
+     */
+    readonly truncated: boolean;
 }
 /** One tool the picker can offer, with this deployment's availability. */
 export interface QaSkillToolDescriptor {
@@ -535,6 +611,13 @@ export interface QaSkillDraftInput {
     readonly body: string;
     /** Echo of the revision the editor read; a stale one is refused. */
     readonly expectedRevision: string | null;
+    /**
+     * The client's acknowledgement that it is saving from an incomplete copy: the
+     * stored `SKILL.md` is over the read ceiling, so the draft carries the head
+     * of the file and a save would drop everything the read never loaded. A write
+     * without it is refused.
+     */
+    readonly confirmPartialOverwrite?: boolean;
 }
 /**
  * The Host's answer about one unsaved draft: the file a save would write and
@@ -666,6 +749,14 @@ export interface QaSurfaceConfig {
         readonly provider?: string | null;
         readonly model?: string | null;
         readonly reasoningEffort?: string | null;
+        /**
+         * How many chat turns the deployment answers at once. A ceiling is what a
+         * locally hosted model needs: the card runs out long before the queue does,
+         * and a third request makes every answer on the stand slower instead of
+         * adding capacity. 0 leaves the count unbounded, which is the default
+         * because a hosted model has no such ceiling.
+         */
+        readonly maxActiveRequests?: number;
     };
     readonly ui?: {
         readonly showHeader?: boolean;
@@ -840,6 +931,17 @@ export interface QaSurfaceConfig {
         /** Cookie-less /qa navigations go through the one-time ?token= exchange. */
         readonly cookieBootstrap?: boolean;
     };
+    /** Notices for a turn that ended in one of this browser's own chats. */
+    readonly notifications?: {
+        /** Master switch: with it off no channel raises anything. */
+        readonly enabled?: boolean;
+        /**
+         * Allow the desktop (operating-system) channel on this stand at all.
+         * A reader's own choice only applies while this is on: it is the answer
+         * for a shared laptop, where a personal notice is everybody's notice.
+         */
+        readonly allowOs?: boolean;
+    };
     readonly sources?: QaSourcesConfig;
     readonly attachments?: QaAttachmentsConfig;
     readonly notes?: QaNotesConfig;
@@ -923,6 +1025,7 @@ export interface ResolvedQaSurfaceConfig {
         readonly provider: string | null;
         readonly model: string | null;
         readonly reasoningEffort: string | null;
+        readonly maxActiveRequests: number;
     };
     readonly ui: {
         readonly showHeader: boolean;
@@ -1007,6 +1110,11 @@ export interface ResolvedQaSurfaceConfig {
         readonly redirectNonLoopback: boolean;
         readonly cookieBootstrap: boolean;
     };
+    /** Channels a finished turn of this browser's own chats may use. */
+    readonly notifications: {
+        readonly enabled: boolean;
+        readonly allowOs: boolean;
+    };
     readonly tools: {
         readonly dynamicActivation: boolean;
         readonly activationSkill: string;
@@ -1530,9 +1638,55 @@ export interface QaPendingQuestion {
     readonly questions: readonly QaPendingQuestionItem[];
     readonly createdAt: number;
 }
+/**
+ * One message that waits for the agent's next turn. Rows the Host already
+ * admitted carry their durable occurrence id, which is what a queue operation
+ * addresses; a row still in flight carries a browser id and edits nothing.
+ */
+export interface QaQueueRow {
+    readonly id: string;
+    /** Short single-line text for the strip; newlines are folded away. */
+    readonly preview: string;
+    /** Full text to edit, or null when the row is not plain text. */
+    readonly text: string | null;
+    /** Attachments the row carries besides its text. */
+    readonly attachments: number;
+    /** Set for a local row the Host queue has not echoed back yet. */
+    readonly sending: boolean;
+}
+/** What the queue strip may ask the Host to do with one waiting message. */
+export type QaQueueOperation = "edit" | "remove" | "steer";
+/**
+ * What `qaSurface/queueStatus` answers: how much of the deployment's request
+ * ceiling is in use right now. The Host counts the chats whose agent is running
+ * a turn, so the load is read where the whole of it is visible rather than
+ * guessed from one browser's view of the stand.
+ */
+export interface QaQueueStatus {
+    /** The configured ceiling; 0 means the deployment sets none. */
+    readonly limit: number;
+    /**
+     * Turns answering at the moment of the read, this visitor's own included —
+     * the stand cannot tell a place it owes someone from one it owes you.
+     */
+    readonly active: number;
+    /** Whether one more turn fits; false while no ceiling is set. */
+    readonly full: boolean;
+}
 export interface QaSessionState {
     readonly phase: QaSessionPhase;
     readonly sessionId: string | null;
+    /**
+     * Identity of the chat the surface is showing. Unique across every chat the
+     * page has opened — a controller that is re-created for a new chat is handed
+     * a new identity, so a component keyed by it cannot carry one chat's composer
+     * text into another. It is taken only when the chat changes: a draft that
+     * creates its session on the first prompt keeps its key, because the composer
+     * holds an unsent question in component state, and remounting it on the new
+     * session id would throw that text away before the Host has accepted
+     * anything. `0` means no chat — see `QA_SESSION_IDLE_STATE`.
+     */
+    readonly chatKey: number;
     readonly messages: readonly QaMessage[];
     /** Immediate send feedback, kept outside the durable transcript. */
     readonly pendingMessage: QaPendingUserMessage | null;
@@ -1545,6 +1699,14 @@ export interface QaSessionState {
     readonly compatibilityReadOnly?: boolean;
     readonly canSend: boolean;
     readonly canStop: boolean;
+    /**
+     * Messages waiting for the next turn, oldest first. Sending while the agent
+     * runs lands here instead of in the transcript, so the strip beside the
+     * composer is the only place the user can still see them.
+     */
+    readonly queue: readonly QaQueueRow[];
+    /** Whether a queue operation may be issued on this binding right now. */
+    readonly canEditQueue: boolean;
     /** Bumped whenever this browser's chat index changes (add/forget). */
     readonly chatsRevision: number;
     /** Tool-derived sources of the current chat (web targets and files read). */
@@ -1557,6 +1719,14 @@ export interface QaSessionState {
     readonly approvals: readonly QaPendingApproval[];
     /** Question requests parked for the operator's answer, oldest first. */
     readonly questions: readonly QaPendingQuestion[];
+    /**
+     * Set when a send was held back because the stand is already answering as
+     * many questions as it allows. The question never left the browser, so this
+     * is the whole of what the visitor is told about it; the surface answers with
+     * the request-ceiling dialog and the composer keeps the draft. Named apart
+     * from `queue`, which is the same chat's list of waiting messages.
+     */
+    readonly requestQueue: QaQueueStatus | null;
     /** Slash palette state, keyed to the chat this snapshot describes. */
     readonly slash: QaSlashView;
 }
@@ -1666,7 +1836,13 @@ export interface QaReviewQueueItem {
 /** Administrative actions recorded in the audit trail. */
 export type QaAdminAuditAction = "user.created" | "user.updated" | "user.enabled" | "user.disabled"
 /** An operator set a new password for an account that had requested one. */
- | "user.password-reset" | "authorization.changed" | "subrole.assignment.changed" | "subrole.created" | "subrole.updated" | "subrole.deleted" | "common_capabilities.updated" | "conversation.reviewed" | "conversation.deleted" | "review.updated" | "review.queued" | "admin.settings.updated" | "skill.created" | "skill.updated" | "skill.deleted";
+ | "user.password-reset" | "authorization.changed" | "subrole.assignment.changed" | "subrole.created" | "subrole.updated" | "subrole.deleted" | "common_capabilities.updated" | "conversation.reviewed" | "conversation.deleted" | "review.updated" | "review.queued" | "admin.settings.updated" | "skill.created" | "skill.updated" | "skill.deleted"
+/** An operator rewrote a line an expert had remembered. */
+ | "memory.corrected"
+/** One or several remembered lines were deleted; the count is in the target. */
+ | "memory.deleted"
+/** A whole namespace was emptied. */
+ | "memory.wiped";
 export interface QaAdminAuditEvent {
     readonly id: string;
     readonly timestamp: string;