@yadsh/dsh-qa-surface 0.4.0 → 0.6.0

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

@@ -0,0 +1,83 @@
+export declare const QA_SURFACE_PANEL_SLOT: "qa.surface.panel";
+export type QaSurfacePanelOpenReason = "user" | "extension" | "activity";
+export type QaSurfacePanelCloseReason = "user" | "extension";
+export type QaSurfacePanelPresentation = "side" | "fullscreen";
+export interface QaSurfacePanelDefinition {
+    /** Globally unique implementation identity. Package names are preferred. */
+    readonly id: string;
+    /** Stable logical identity used by navigation. */
+    readonly kind: string;
+    /** User-facing, lazily localized title. */
+    readonly title: () => string;
+    readonly description?: () => string;
+    /** Presentation token interpreted by QA Surface, never a React value. */
+    readonly icon?: string;
+    readonly order?: number;
+    /** Defaults to true. Programmatic navigation remains available when false. */
+    readonly userVisible?: boolean;
+    /** Defaults to false. Hidden retained bodies stay mounted but inert. */
+    readonly keepMounted?: boolean;
+}
+export interface QaSurfacePanelOpenOptions {
+    readonly focus?: boolean;
+    readonly params?: unknown;
+    readonly reason?: QaSurfacePanelOpenReason;
+}
+export interface QaSurfacePanelOwnerProps {
+    readonly panelId: string;
+    readonly panelKind: string;
+    readonly sessionId: string | null;
+    /**
+     * Current QA bearer credential for Host remotes that authorize access to
+     * `sessionId`. Panel plugins must not persist, log, or place it in URLs.
+     * Empty when QA accounts are disabled.
+     */
+    readonly qaToken: string;
+    readonly visible: boolean;
+    readonly presentation: QaSurfacePanelPresentation;
+    readonly params: unknown;
+    readonly actions: {
+        close(): void;
+        reveal(options?: {
+            readonly focus?: boolean;
+        }): void;
+    };
+    /** Aborts with registration/body lifetime, never merely because it is hidden. */
+    readonly signal: AbortSignal;
+}
+export interface QaSurfacePanelContext {
+    readonly sessionId: string | null;
+    readonly qaToken: string;
+}
+export interface QaSurfacePanels {
+    register(definition: QaSurfacePanelDefinition): () => void;
+    open(kind: string, options?: QaSurfacePanelOpenOptions): boolean;
+    close(options?: {
+        readonly reason?: QaSurfacePanelCloseReason;
+    }): void;
+    toggle(kind: string): boolean;
+    isRegistered(kind: string): boolean;
+    getActiveKind(): string | null;
+    /** Current QA session/credential pair for activity-driven extensions. */
+    getContext(): QaSurfacePanelContext;
+    list(): readonly QaSurfacePanelDefinition[];
+}
+declare module "@deepseek-ai/cordis" {
+    interface Context {
+        qaSurfacePanels: QaSurfacePanels;
+    }
+}
+declare module "@deepseek-ai/dsh-client-ui-slots" {
+    interface SlotMap {
+        /**
+         * QA Surface owns this keyed seat. Panel plugins register their body under
+         * the exact `QaSurfacePanelDefinition.id` used by the metadata service.
+         */
+        "qa.surface.panel": {
+            kind: "keyed";
+            scope: "root";
+            owner: QaSurfacePanelOwnerProps;
+        };
+    }
+}
+//# sourceMappingURL=contract.d.ts.map

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

@@ -0,0 +1,3 @@
+export { QA_SURFACE_PANEL_SLOT } from "./contract.js";
+export type { QaSurfacePanelContext, QaSurfacePanelCloseReason, QaSurfacePanelDefinition, QaSurfacePanelOpenOptions, QaSurfacePanelOpenReason, QaSurfacePanelOwnerProps, QaSurfacePanelPresentation, QaSurfacePanels, } from "./contract.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/panels/registry.d.ts

@@ -0,0 +1,40 @@
+import type { QaSurfacePanelDefinition, QaSurfacePanelContext, QaSurfacePanelOpenOptions, QaSurfacePanels } from "./contract.js";
+export interface QaSurfacePanelsSnapshot {
+    readonly definitions: readonly QaSurfacePanelDefinition[];
+    readonly activeKind: string | null;
+    readonly params: unknown;
+    readonly focusRequest: number;
+    readonly focus: boolean;
+}
+/** Client-only metadata/navigation registry. It never stores React components. */
+export declare class QaSurfacePanelRegistry implements QaSurfacePanels {
+    private readonly byId;
+    private readonly byKind;
+    private readonly listeners;
+    private readonly paramsByKind;
+    private activeKind;
+    private focusRequest;
+    private focus;
+    private snapshot;
+    private context;
+    private disposed;
+    readonly subscribe: (listener: () => void) => (() => void);
+    readonly getSnapshot: () => QaSurfacePanelsSnapshot;
+    register(definition: QaSurfacePanelDefinition): () => void;
+    open(kind: string, options?: QaSurfacePanelOpenOptions): boolean;
+    close(_options?: {
+        readonly reason?: "user" | "extension";
+    }): void;
+    toggle(kind: string): boolean;
+    isRegistered(kind: string): boolean;
+    getActiveKind(): string | null;
+    getContext(): QaSurfacePanelContext;
+    /** QA Surface-owned lifecycle update; extensions consume it read-only. */
+    setContext(context: QaSurfacePanelContext): void;
+    list(): readonly QaSurfacePanelDefinition[];
+    signal(kind: string): AbortSignal | undefined;
+    params(kind: string): unknown;
+    dispose(): void;
+    private publish;
+}
+//# sourceMappingURL=registry.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,12 +9,24 @@ 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;
     readonly chatsRevision: number;
     readonly viewingSubagent: QaSubagentView | null;
     readonly config: ResolvedQaSurfaceConfig;
+    /**
+     * The chat's subagent display names keyed by session id, read from the
+     * host list snapshot; settlement notices prefer them over the raw ids.
+     */
+    readonly subagentNames?: Readonly<Record<string, string>>;
     /**
      * The chat owner's display name for author labels; present only when an
      * admin reads a foreign chat (chat-level, not per-message).

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

package/lib/types/client/settings/sections/documents.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Documents: the document pipeline's deployment knobs.
+ *
+ * Everything here is optional — the defaults are usable as they are — but two
+ * of them decide whether the four document tools work at all in a given
+ * deployment: the Docling endpoint and the executables the renderer needs.
+ * The section therefore shows the effective values the Host resolved, not only
+ * what this browser has written.
+ */
+import { type ConfigProps } from "./common.js";
+/** Document creation, conversion and extraction. */
+export declare function DocumentsSection(props: ConfigProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=documents.d.ts.map

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

@@ -15,6 +15,7 @@ export { AccessSection } from "./sections/access.js";
 export { AccountsSection } from "./sections/accounts.js";
 export { AttachmentsSection } from "./sections/attachments.js";
 export { BrandingSection } from "./sections/branding.js";
+export { DocumentsSection } from "./sections/documents.js";
 export { EmbeddingSection } from "./sections/embedding.js";
 export { InterfaceSection } from "./sections/interface.js";
 export { LockdownSection } from "./sections/lockdown.js";

package/lib/types/client/settings-extensions/contract.d.ts

@@ -0,0 +1,32 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { ComponentType } from "react";
+/** Trusted browser identity supplied by QA Surface to a settings extension. */
+export interface QaUserSettingsSectionProps {
+    /** Current QA account token. It is used only as transport authentication. */
+    readonly token: string;
+}
+/** One first-class page in the signed-in user's QA settings dialog. */
+export interface QaUserSettingsSectionRegistration {
+    readonly id: string;
+    readonly title: string;
+    readonly order?: number;
+    readonly component: ComponentType<QaUserSettingsSectionProps>;
+}
+export interface QaUserSettingsSectionsSnapshot {
+    readonly sections: readonly QaUserSettingsSectionRegistration[];
+    readonly revision: number;
+}
+/** Client-side registry exposed by QA Surface to additive plugins. */
+export interface QaUserSettingsSections {
+    readonly subscribe: (listener: () => void) => () => void;
+    readonly getSnapshot: () => QaUserSettingsSectionsSnapshot;
+    register(section: QaUserSettingsSectionRegistration): () => void;
+}
+declare module "@deepseek-ai/cordis" {
+    interface Context {
+        qaUserSettingsSections: QaUserSettingsSections;
+    }
+}
+/** Structural face used by consumers that do not otherwise depend on Cordis. */
+export type QaUserSettingsSectionsContext = Pick<Context, "qaUserSettingsSections">;
+//# sourceMappingURL=contract.d.ts.map

package/lib/types/client/settings-extensions/index.d.ts

@@ -0,0 +1,3 @@
+export type { QaUserSettingsSectionProps, QaUserSettingsSectionRegistration, QaUserSettingsSections, QaUserSettingsSectionsContext, QaUserSettingsSectionsSnapshot, } from "./contract.js";
+export { QaUserSettingsSectionRegistry } from "./registry.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/settings-extensions/registry.d.ts

@@ -0,0 +1,15 @@
+import type { QaUserSettingsSectionRegistration, QaUserSettingsSections, QaUserSettingsSectionsSnapshot } from "./contract.js";
+/** Deterministic, observable registry backing the settings extension service. */
+export declare class QaUserSettingsSectionRegistry implements QaUserSettingsSections {
+    private readonly entries;
+    private readonly listeners;
+    private revision;
+    private disposed;
+    private snapshot;
+    readonly subscribe: (listener: () => void) => (() => void);
+    readonly getSnapshot: () => QaUserSettingsSectionsSnapshot;
+    register(section: QaUserSettingsSectionRegistration): () => void;
+    dispose(): void;
+    private publish;
+}
+//# sourceMappingURL=registry.d.ts.map

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

@@ -1,6 +1,42 @@
-/** Fold the host settlement wording into a title plus the closing message. */
-export declare function parseSettlement(text: string): {
-    title: string;
-    body: string;
-} | undefined;
+/** Raw pieces of one settlement notice, before display naming. */
+export interface SettledSubagent {
+    /** Full child session id the host named in the notice. */
+    readonly id: string;
+    /** Russian completion verb phrase ("завершён", "остановлен", …). */
+    readonly ending: string;
+    /** The child's closing message, trimmed and capped. */
+    readonly body: string;
+}
+/** Fold the host settlement wording into its raw pieces. */
+export declare function parseSettlement(text: string): SettledSubagent | undefined;
+/** Operator-facing view of one settled subagent. */
+export interface SettlementView {
+    readonly title: string;
+    readonly body: string;
+    /** Muted correlation line above the body; absent when the title says it all. */
+    readonly meta?: string;
+}
+/**
+ * A list title the operator can read: whitespace-collapsed, and not the
+ * session id itself — the host falls back to the raw id where a child has no
+ * title of its own, and a hash is exactly what this module exists to hide.
+ */
+export declare function readableSubagentName(title: string | undefined, id: string): string | undefined;
+export interface SettlementViewOptions {
+    /**
+     * The chat's subagent display names keyed by session id (the delegation
+     * description the host keeps, or the session's own title).
+     */
+    readonly nameOf?: (id: string) => string | undefined;
+    /** Sign titles with deterministic codenames instead of the raw name or id. */
+    readonly codenames?: boolean;
+}
+/**
+ * Build the operator-facing title for one settled subagent. A codename wins
+ * when enabled, then the child's readable name, and the short id stands in
+ * when neither exists. The folded-out facts move into the meta line: the
+ * real task name under a codename, and the id wherever the title does not
+ * already carry it, so a notice stays matchable against the session logs.
+ */
+export declare function settlementView(settled: SettledSubagent, options?: SettlementViewOptions): SettlementView;
 //# sourceMappingURL=settlement.d.ts.map

package/lib/types/client/source-preview.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Panel copy for a refused source preview. The Host answers with the shared
+ * `(reason: <code>)` marker, so the panel can say what actually happened
+ * instead of telling every audience that a file which is present moved away.
+ */
+/** The sentence behind one failed preview request, keyed by the Host reason. */
+export declare function sourcePreviewFailureCopy(failure: unknown): string;
+//# sourceMappingURL=source-preview.d.ts.map

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

@@ -1,2 +1,4 @@
+/** Every `--dsh-qa-*` custom property the root rule declares. */
+export declare const QA_BRAND_TOKEN_NAMES: readonly string[];
 export declare const QA_SURFACE_STYLES: string;
 //# sourceMappingURL=styles.d.ts.map

package/lib/types/client/subagent-codenames.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Deterministic display codenames for subagent sessions.
+ *
+ * The host addresses a background child by its session UUID — opaque noise in
+ * an operator-facing notice. A pure string hash folds the full UUID into a
+ * stable adjective-plus-noun codename ("Дотошный Барсук"): the same child
+ * keeps its codename across reloads and reconnects, nothing is stored, and
+ * within one chat's handful of subagents collisions are rare. A codename is
+ * decoration only — the short session id stays in the notice body for log
+ * correlation.
+ */
+/**
+ * The codename one subagent session displays: two FNV-1a passes with
+ * different seeds pick the adjective and the noun independently, so the
+ * pairs spread across the whole vocabulary instead of walking it in lockstep.
+ */
+export declare function codenameFor(id: string): string;
+//# sourceMappingURL=subagent-codenames.d.ts.map

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

@@ -1,7 +1,7 @@
 import type { ClientRemote } from "@deepseek-ai/dsh-api-gateway/client";
 import type { ISessions, SessionFace } from "@deepseek-ai/dsh-api-session-controller/client";
 import type { UiConversation } from "@deepseek-ai/dsh-client-ui-conversation/client";
-import type { QaAccountProfileInput, QaAccountSession, QaAccountUserPublic, QaClaimResult, QaLockdownProof, QaOwnershipEntry, QaSessionState, QaSourceFilePreview, QaTurnSources, QaWhoamiResult } from "../types.js";
+import type { QaAccountProfileInput, QaAccountSession, QaAccountStartersInput, QaAccountStarter, QaAccountUserPublic, QaApprovalDecision, QaClaimResult, QaLockdownProof, QaOwnershipEntry, QaPendingApproval, QaPendingQuestion, QaQuestionAnswerItem, QaSessionState, QaSkillDocument, QaSkillDraftInput, QaSkillRemoval, QaSkillSummary, QaSkillToolDescriptor, QaSkillValidation, QaSourceFilePreview, QaTurnSources, QaWhoamiResult } from "../types.js";
 /** Wire content one prompt carries: text plus base64 image uploads. */
 export type QaPromptContent = Parameters<SessionFace["prompt"]>[0];
 /** DSH session runtime surface the QA controller is allowed to touch. */
@@ -87,6 +87,81 @@ export type QaBoundSourceApi = {
         readonly error: unknown;
     }>;
 };
+/**
+ * Approval remotes of this plugin's namespace. Read-only listing plus the one
+ * write: the operator's answer to a parked tool call.
+ */
+export interface QaApprovalApi {
+    pendingApprovals(token: string, sessionId: string): Promise<{
+        readonly ok: true;
+        readonly value: readonly QaPendingApproval[];
+    } | {
+        readonly ok: false;
+        readonly error: unknown;
+    }>;
+    answerApproval(token: string, sessionId: string, requestId: string, decision: QaApprovalDecision): Promise<{
+        readonly ok: true;
+        readonly value: boolean;
+    } | {
+        readonly ok: false;
+        readonly error: unknown;
+    }>;
+}
+/**
+ * Question remotes of this plugin's namespace: the parked `ask_user_question`
+ * requests of one chat, the operator's answers, and closing one unanswered.
+ */
+export interface QaQuestionApi {
+    pendingQuestions(token: string, sessionId: string): Promise<{
+        readonly ok: true;
+        readonly value: readonly QaPendingQuestion[];
+    } | {
+        readonly ok: false;
+        readonly error: unknown;
+    }>;
+    answerQuestion(token: string, sessionId: string, requestId: string, answers: readonly QaQuestionAnswerItem[]): Promise<{
+        readonly ok: true;
+        readonly value: boolean;
+    } | {
+        readonly ok: false;
+        readonly error: unknown;
+    }>;
+    cancelQuestion(token: string, sessionId: string, requestId: string): Promise<{
+        readonly ok: true;
+        readonly value: boolean;
+    } | {
+        readonly ok: false;
+        readonly error: unknown;
+    }>;
+}
+/**
+ * Personal-skill remotes of this plugin's namespace. The browser names a
+ * skill, never a directory: the account token behind the call decides where
+ * that name resolves.
+ */
+export interface QaSkillApi {
+    skillsList(token: string): Promise<RemoteResult<{
+        readonly skills: readonly QaSkillSummary[];
+    }>>;
+    skillsGet(token: string, name: string): Promise<RemoteResult<QaSkillDocument>>;
+    skillsCreate(token: string, input: QaSkillDraftInput): Promise<RemoteResult<QaSkillDocument>>;
+    skillsUpdate(token: string, name: string, input: QaSkillDraftInput): Promise<RemoteResult<QaSkillDocument>>;
+    skillsRemove(token: string, name: string, expectedRevision: string | null): Promise<RemoteResult<QaSkillRemoval>>;
+    skillsTools(token: string): Promise<RemoteResult<{
+        readonly tools: readonly QaSkillToolDescriptor[];
+    }>>;
+    skillsValidate(token: string, name: string | null, input: QaSkillDraftInput): Promise<RemoteResult<QaSkillValidation>>;
+}
+/** The skill API with the account token already bound at the call site. */
+export interface QaBoundSkillApi {
+    list(): Promise<RemoteResult<readonly QaSkillSummary[]>>;
+    get(name: string): Promise<RemoteResult<QaSkillDocument>>;
+    create(input: QaSkillDraftInput): Promise<RemoteResult<QaSkillDocument>>;
+    update(name: string, input: QaSkillDraftInput): Promise<RemoteResult<QaSkillDocument>>;
+    remove(name: string, expectedRevision: string | null): Promise<RemoteResult<QaSkillRemoval>>;
+    tools(): Promise<RemoteResult<readonly QaSkillToolDescriptor[]>>;
+    validate(name: string | null, input: QaSkillDraftInput): Promise<RemoteResult<QaSkillValidation>>;
+}
 /** Account remotes exposed by the plugin's own typert namespace. */
 export interface QaAccountsApi {
     accountsWhoami(token: string): Promise<RemoteResult<QaWhoamiResult>>;
@@ -101,8 +176,13 @@ export interface QaAccountsApi {
     }>>;
     /** Replace the caller's own self-declared profile; the token is the identity. */
     accountsUpdateProfile(token: string, input: QaAccountProfileInput): Promise<RemoteResult<QaAccountUserPublic>>;
+    /** Replace the caller's own starter buttons; the token is the identity. */
+    accountsUpdateStarters(token: string, input: QaAccountStartersInput): Promise<RemoteResult<QaAccountUserPublic>>;
 }
-type RemoteResult<Value> = {
+/** One button above an empty composer: what it reads and what it sends. */
+export type QaQuickQuestion = QaAccountStarter;
+/** Result shape every generated remote call resolves to. */
+export type RemoteResult<Value> = {
     readonly ok: true;
     readonly value: Value;
 } | {
@@ -117,5 +197,4 @@ export interface StorageLike {
 }
 /** The state projected while no QA chat is bound (route inactive or booting). */
 export declare const QA_SESSION_IDLE_STATE: QaSessionState;
-export {};
 //# sourceMappingURL=types.d.ts.map

package/lib/types/client/user-settings/GeneralSettingsPage.d.ts

@@ -0,0 +1,14 @@
+export interface QaGeneralSettingsPageProps {
+    readonly email: string;
+    readonly role: string;
+    readonly chatCount: number;
+}
+/**
+ * Placeholder with a purpose: the section exists so the dialog has a home for
+ * the user-scoped preferences that follow (notifications, integrations,
+ * privacy), and so the thing it must not become is written down — deployment
+ * and chat policy live in the Host settings, not here. It shows the account
+ * facts a user can act on today and nothing invented.
+ */
+export declare function QaGeneralSettingsPage(props: QaGeneralSettingsPageProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=GeneralSettingsPage.d.ts.map

package/lib/types/client/user-settings/ProfileSettingsPage.d.ts

@@ -0,0 +1,18 @@
+import type { QaAccountIdentityField, QaAccountProfile, QaAccountProfileInput } from "../../types.js";
+export interface QaProfileSettingsPageProps {
+    readonly email: string;
+    readonly profile: QaAccountProfile;
+    /** Handle fields the deployment declares, in its configured order. */
+    readonly identities: readonly QaAccountIdentityField[];
+    readonly instructionsMaxLength: number;
+    /** Persist the edited profile; resolves to refusal copy, or null. */
+    readonly onSave: (input: QaAccountProfileInput) => Promise<string | null>;
+}
+/**
+ * The signed-in user's profile, moved into the settings dialog unchanged: the
+ * same fields, the same storage and the same limits as the modal it replaces.
+ * The form is seeded from the stored profile whenever that profile changes, so
+ * a reload or a write from another tab never leaves stale edits on screen.
+ */
+export declare function QaProfileSettingsPage(props: QaProfileSettingsPageProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ProfileSettingsPage.d.ts.map

package/lib/types/client/user-settings/SkillCatalog.d.ts

@@ -0,0 +1,16 @@
+import type { QaSkillSummary } from "../../types.js";
+export interface QaSkillCatalogProps {
+    readonly skills: readonly QaSkillSummary[];
+    readonly loading: boolean;
+    readonly error: string | null;
+    readonly onOpen: (name: string) => void;
+    readonly onCreate: () => void;
+    readonly onReload: () => void;
+}
+/**
+ * The skills list: what exists, how it is invoked, and what needs attention.
+ * Search is client-side over the fields the spec names (name, description,
+ * whenToUse) — the catalog of one account is small by construction.
+ */
+export declare function QaSkillCatalog(props: QaSkillCatalogProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SkillCatalog.d.ts.map

package/lib/types/client/user-settings/SkillEditor.d.ts

@@ -0,0 +1,42 @@
+import type { QaSkillDiagnostic, QaSkillDocument, QaSkillDraftInput, QaSkillToolDescriptor } from "../../types.js";
+/** What the Host last answered about the draft being edited. */
+export interface QaSkillValidationState {
+    /** The file a save would write, as the Host's serializer renders it. */
+    readonly preview: string;
+    readonly diagnostics: readonly QaSkillDiagnostic[];
+    /** True while a newer draft is on its way to the Host. */
+    readonly pending: boolean;
+}
+export interface QaSkillEditorProps {
+    /** `create` starts from an empty draft; `edit` from the loaded document. */
+    readonly mode: "create" | "edit";
+    /** Absent while a fresh skill is being created. */
+    readonly document: QaSkillDocument | null;
+    /** The Host's answer for the current draft. */
+    readonly validation: QaSkillValidationState;
+    /** Report the draft so the page can ask the Host about it. */
+    readonly onDraftChange: (input: QaSkillDraftInput) => void;
+    readonly tools: readonly QaSkillToolDescriptor[];
+    readonly toolsError: string | null;
+    readonly saving: boolean;
+    readonly error: string | null;
+    /** True once a save was refused because the file changed elsewhere. */
+    readonly conflict: boolean;
+    readonly onBack: () => void;
+    readonly onSave: (input: QaSkillDraftInput) => void;
+    readonly onDelete: () => void;
+    /** Re-read the stored skill after a conflict; absent on create. */
+    readonly onReload: () => void;
+}
+/**
+ * One skill's editor. It never wraps itself in a nested modal — the settings
+ * dialog's own content area is the page.
+ *
+ * Two validators run: this component checks the rules it can check instantly,
+ * and the Host answers with the authoritative set plus the exact file a save
+ * would write. Both are shown, and a save is only offered when neither has an
+ * error — the Host still refuses on write, because a stale answer is always
+ * possible between a keystroke and a round trip.
+ */
+export declare function QaSkillEditor(props: QaSkillEditorProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SkillEditor.d.ts.map

package/lib/types/client/user-settings/SkillToolPicker.d.ts

@@ -0,0 +1,17 @@
+import type { QaSkillToolDescriptor } from "../../types.js";
+export interface QaSkillToolPickerProps {
+    readonly open: boolean;
+    readonly tools: readonly QaSkillToolDescriptor[];
+    readonly toolsError: string | null;
+    readonly selected: readonly string[];
+    readonly onApply: (tools: readonly string[]) => void;
+    readonly onClose: () => void;
+}
+/**
+ * Multi-select over the deployment's tool catalog. Availability is the QA
+ * session's own scope, and the picker says so: a tool the session cannot reach
+ * is still offered — an imported skill has to stay repairable — but it is
+ * grouped and labelled as unavailable, and choosing it grants nothing.
+ */
+export declare function QaSkillToolPicker(props: QaSkillToolPickerProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SkillToolPicker.d.ts.map

package/lib/types/client/user-settings/SkillsSettingsPage.d.ts

@@ -0,0 +1,15 @@
+import type { QaBoundSkillApi } from "../types.js";
+export interface QaSkillsSettingsPageProps {
+    /** The token-bound skill API the surface hands to this page. */
+    readonly api: QaBoundSkillApi;
+}
+/**
+ * Personal skills: the catalog, and the editor for one skill or a new one.
+ *
+ * The page owns the server state (list, tools, loaded document, in-flight
+ * failures) and hands the editor a draft only once a document has loaded, so
+ * a save always carries the revision it read. Creating and editing share one
+ * route: the difference is whether a loaded document exists to compare with.
+ */
+export declare function QaSkillsSettingsPage(props: QaSkillsSettingsPageProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SkillsSettingsPage.d.ts.map

package/lib/types/client/user-settings/StartersSettingsPage.d.ts

@@ -0,0 +1,14 @@
+import type { QaAccountStarters, QaAccountStartersInput } from "../../types.js";
+export interface QaStartersSettingsPageProps {
+    readonly starters: QaAccountStarters;
+    /** Persist the edited list; resolves to refusal copy, or null. */
+    readonly onSave: (input: QaAccountStartersInput) => Promise<string | null>;
+}
+/**
+ * The signed-in user's own starter buttons: what each button reads, what
+ * pressing it sends, and whether the deployment's standard suggestions stay
+ * visible next to them. Same full-replace contract as the profile form — the
+ * list is seeded from the stored record whenever that record changes.
+ */
+export declare function QaStartersSettingsPage(props: QaStartersSettingsPageProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=StartersSettingsPage.d.ts.map