@yadsh/dsh-qa-surface 0.5.0 → 0.6.0

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, QaApprovalDecision, QaClaimResult, QaLockdownProof, QaOwnershipEntry, QaPendingApproval, QaPendingQuestion, QaQuestionAnswerItem, 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. */
@@ -134,6 +134,34 @@ export interface QaQuestionApi {
         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>>;
@@ -148,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;
 } | {
@@ -164,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

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

@@ -0,0 +1,43 @@
+import type { QaAccountIdentityField, QaAccountProfile, QaAccountProfileInput, QaAccountStarters, QaAccountStartersInput } from "../../types.js";
+import type { QaBoundSkillApi } from "../types.js";
+import type { QaUserSettingsSections } from "../settings-extensions/index.js";
+/** Sections of the user-facing settings dialog. */
+export type QaSettingsSectionId = "profile" | "starters" | "general" | "skills" | (string & {});
+export interface QaUserSettingsDialogProps {
+    readonly open: boolean;
+    /** Section to show when the dialog opens. */
+    readonly initialSection: QaSettingsSectionId;
+    readonly onClose: () => void;
+    readonly email: string;
+    readonly role: string;
+    readonly chatCount: number;
+    /** Self-service profile editing; absent when the deployment turns it off. */
+    readonly profile?: {
+        readonly profile: QaAccountProfile;
+        readonly fields: readonly QaAccountIdentityField[];
+        readonly instructionsMaxLength: number;
+        readonly onSave: (input: QaAccountProfileInput) => Promise<string | null>;
+    };
+    /** Self-service starter buttons; absent when the deployment turns them off. */
+    readonly starters?: {
+        readonly starters: QaAccountStarters;
+        readonly onSave: (input: QaAccountStartersInput) => Promise<string | null>;
+    };
+    /** Personal skills; absent when the deployment cannot host them. */
+    readonly skills?: QaBoundSkillApi;
+    /** Additive pages contributed by separately shipped QA plugins. */
+    readonly extensions?: QaUserSettingsSections;
+    /** Current account token, passed only to the selected extension page. */
+    readonly token?: string;
+}
+/**
+ * One settings dialog for everything the signed-in user owns: the profile, a
+ * place for personal preferences, and their skills.
+ *
+ * It replaces the separate profile modal rather than sitting beside it — the
+ * section list is the single entry point — and it is deliberately a plain
+ * tablist inside the shared dialog shell: on a narrow screen the same element
+ * becomes a horizontal strip instead of a second navigation screen.
+ */
+export declare function QaUserSettingsDialog(props: QaUserSettingsDialogProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=UserSettingsDialog.d.ts.map

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

@@ -0,0 +1,25 @@
+import type { QaSkillDiagnostic } from "../../types.js";
+/**
+ * Audience-facing copy for the settings dialog. The Host sends stable codes
+ * and never Russian prose, so every message a user reads is written here.
+ */
+/** One message per diagnostic code; `detail` carries the offending value. */
+export declare function diagnosticMessage(diagnostic: QaSkillDiagnostic): string;
+/**
+ * Turn one remote refusal into copy. The Host folds domain failures into a
+ * `(reason: <code>)` marker on the wire message; anything else — a transport
+ * fault, an unknown code — reads as the generic failure.
+ */
+export declare function skillFailureCopy(error: unknown): string;
+/** Whether a failure is the optimistic-concurrency refusal. */
+export declare function isSkillConflict(error: unknown): boolean;
+export declare const SKILLS_EMPTY_COPY: {
+    readonly title: "У вас пока нет навыков.";
+    readonly body: "Навык — это набор инструкций, который помогает ассистенту стабильно выполнять повторяющиеся задачи.";
+    readonly action: "Создать первый навык";
+};
+export declare const SKILLS_TOOLS_HINT = "\u0418\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B, \u043A\u043E\u0442\u043E\u0440\u044B\u0435 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0435\u0442 \u044D\u0442\u043E\u0442 \u043D\u0430\u0432\u044B\u043A. \u041E\u043D\u0438 \u043D\u0435 \u043F\u0440\u0435\u0434\u043E\u0441\u0442\u0430\u0432\u043B\u044F\u044E\u0442 \u0434\u043E\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C\u043D\u044B\u0445 \u0440\u0430\u0437\u0440\u0435\u0448\u0435\u043D\u0438\u0439.";
+export declare const SKILLS_DESCRIPTION_HINT = "\u041A\u0440\u0430\u0442\u043A\u043E \u043E\u043F\u0438\u0448\u0438\u0442\u0435, \u0447\u0442\u043E \u0434\u0435\u043B\u0430\u0435\u0442 \u043D\u0430\u0432\u044B\u043A \u0438 \u0432 \u043A\u0430\u043A\u0438\u0445 \u0441\u0438\u0442\u0443\u0430\u0446\u0438\u044F\u0445 \u0435\u0433\u043E \u0441\u0442\u043E\u0438\u0442 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C.";
+export declare const SKILLS_NAME_HINT = "\u0421\u0442\u0440\u043E\u0447\u043D\u044B\u0435 \u043B\u0430\u0442\u0438\u043D\u0441\u043A\u0438\u0435 \u0431\u0443\u043A\u0432\u044B, \u0446\u0438\u0444\u0440\u044B \u0438 \u0434\u0435\u0444\u0438\u0441\u044B. \u041D\u0430\u043F\u0440\u0438\u043C\u0435\u0440: jira-investigation.";
+export declare const SKILLS_BEHAVIOUR_HINT = "\u00AB\u0410\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438\u00BB \u0437\u043D\u0430\u0447\u0438\u0442, \u0447\u0442\u043E \u0430\u0441\u0441\u0438\u0441\u0442\u0435\u043D\u0442 \u043C\u043E\u0436\u0435\u0442 \u043F\u0440\u0438\u043C\u0435\u043D\u0438\u0442\u044C \u043D\u0430\u0432\u044B\u043A \u0441\u0430\u043C, \u043A\u043E\u0433\u0434\u0430 \u0437\u0430\u0434\u0430\u0447\u0430 \u0441\u043E\u0432\u043F\u0430\u0434\u0451\u0442 \u0441 \u043E\u043F\u0438\u0441\u0430\u043D\u0438\u0435\u043C. \u0421\u043E\u0434\u0435\u0440\u0436\u0438\u043C\u043E\u0435 \u043D\u0430\u0432\u044B\u043A\u0430 \u043D\u0435 \u0445\u0440\u0430\u043D\u0438\u0442\u0441\u044F \u0432 \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u0435 \u043F\u043E\u0441\u0442\u043E\u044F\u043D\u043D\u043E.";
+//# sourceMappingURL=copy.d.ts.map

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

@@ -0,0 +1,51 @@
+import type { QaSkillDiagnostic, QaSkillDocument, QaSkillDraftInput, QaSkillSummary } from "../../types.js";
+/**
+ * The editor's draft: a plain, mutable-shaped snapshot of one skill, plus the
+ * pure helpers the pages share.
+ *
+ * This module holds no serializer on purpose. The Host owns the file format;
+ * the editor checks the subset of rules it can check by itself — the name
+ * grammar, the required fields, the declared tools — and asks the Host for the
+ * rest: the exact file, the operator's size limit, the preserved frontmatter.
+ * A YAML library's Node build carries `require` calls the browser module
+ * loader cannot answer, so the format's YAML half stays on the Host.
+ */
+export interface QaSkillDraft {
+    readonly name: string;
+    readonly description: string;
+    readonly whenToUse: string;
+    readonly modelInvocable: boolean;
+    readonly userInvocable: boolean;
+    readonly allowedTools: readonly string[];
+    readonly body: string;
+}
+export declare function emptyDraft(): QaSkillDraft;
+export declare function draftFromDocument(document: QaSkillDocument): QaSkillDraft;
+/** Whether a fresh draft carries anything worth warning about on exit. */
+export declare function draftHasContent(draft: QaSkillDraft): boolean;
+/** Collapse diagnostics that describe the same thing for the same field. */
+export declare function mergeDiagnostics(...groups: readonly (readonly QaSkillDiagnostic[])[]): readonly QaSkillDiagnostic[];
+export declare function draftIsDirty(draft: QaSkillDraft, document: QaSkillDocument): boolean;
+export interface QaSkillDraftDiagnostics {
+    readonly availableTools: readonly string[];
+}
+/**
+ * The rules the editor checks by itself, so typing is answered immediately.
+ * The size limit, the preserved frontmatter and the serialized file are the
+ * Host's business and arrive from it; the Host also re-checks all of this on
+ * every write, so nothing here is the authority.
+ */
+export declare function draftDiagnostics(draft: QaSkillDraft, options: QaSkillDraftDiagnostics): readonly QaSkillDiagnostic[];
+/** Whether the draft is complete enough to send. */
+export declare function draftIsSavable(draft: QaSkillDraft): boolean;
+export declare function draftInput(draft: QaSkillDraft, revision: string | null): QaSkillDraftInput;
+/** The terse line under a catalog row: invocation, command, tool count. */
+export declare function skillMetaLine(skill: QaSkillSummary): string;
+/** Tools the catalog cannot use right now, as the row's warning text. */
+export declare function skillToolWarning(skill: QaSkillSummary): string | null;
+/** Case-insensitive search over the fields the catalog offers. */
+export declare function skillMatchesQuery(skill: QaSkillSummary, query: string): boolean;
+/** Editing one tool name out of a draft, wherever the picker put it. */
+export declare function withToolRemoved(tools: readonly string[], name: string): readonly string[];
+export declare function withToolAdded(tools: readonly string[], name: string): readonly string[];
+//# sourceMappingURL=draft.d.ts.map

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

@@ -0,0 +1,43 @@
+import type { ReactNode } from "react";
+/**
+ * Field primitives for the settings dialog. The plugin's host-facing settings
+ * card owns `qa-card-*`, whose stylesheet is injected only where that card is
+ * mounted; the QA page carries its own `dsh-qa-settings-*` rules instead, so
+ * the dialog looks the same whether or not a loopback operator ever opened
+ * the deployment settings.
+ */
+export interface QaSettingsFieldProps {
+    readonly label: string;
+    /** Secondary line under the control; not part of the field's name. */
+    readonly hint?: string;
+    readonly children: ReactNode;
+}
+export declare function QaSettingsField(props: QaSettingsFieldProps): import("react/jsx-runtime").JSX.Element;
+export declare function QaSettingsSection(props: {
+    readonly title: string;
+    readonly aside?: ReactNode;
+    readonly children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function QaSettingsToggle(props: {
+    readonly label: string;
+    readonly checked: boolean;
+    readonly disabled?: boolean;
+    readonly hint?: string;
+    readonly onChange: (checked: boolean) => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function QaSettingsNotice(props: {
+    readonly tone: "info" | "warn" | "error";
+    readonly children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function QaSettingsActions(props: {
+    readonly children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function QaSettingsButton(props: {
+    readonly label: string;
+    readonly tone?: "primary" | "plain" | "danger";
+    readonly type?: "button" | "submit";
+    readonly disabled?: boolean;
+    readonly title?: string;
+    readonly onClick?: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=fields.d.ts.map

package/lib/types/config-resolvers/tools.d.ts

@@ -0,0 +1,6 @@
+import type { QaSurfaceConfig, ResolvedQaSurfaceConfig } from "../types.js";
+type ToolsSlice = ResolvedQaSurfaceConfig["tools"];
+/** Resolve the QA tool delivery domain: activation trigger, policy, and scope. */
+export declare function resolveTools(input: QaSurfaceConfig): ToolsSlice;
+export {};
+//# sourceMappingURL=tools.d.ts.map

package/lib/types/documents/artifacts/ids.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ULID generation for artifact ids (§18).
+ *
+ * `doc_<ULID>` — 48 bits of time followed by 80 bits of randomness, encoded in
+ * Crockford base32. The time prefix keeps a directory listing chronological,
+ * and the randomness keeps ids unguessable without a UUID dependency.
+ */
+/** A fresh ULID for the current millisecond. */
+export declare function createUlid(now?: number): string;
+/** A fresh artifact id: `doc_<ULID>`. */
+export declare function createArtifactId(now?: number): string;
+/** Whether a string is an artifact id this pipeline could have issued. */
+export declare function isArtifactId(value: string): boolean;
+//# sourceMappingURL=ids.d.ts.map

package/lib/types/documents/artifacts/manifest.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Manifest construction and persistence (§19).
+ *
+ * The manifest is the source of truth about an artifact: which operation,
+ * which backends and versions, which template (and its hash), which files came
+ * out, which warnings were raised, and which session/workspace the bundle
+ * belongs to. Logical reproducibility rests on it, because byte-level
+ * reproducibility of DOCX/PDF cannot be promised (§31).
+ */
+import type { BackendInfo, DocumentFileResult, DocumentFormat, DocumentManifest, DocumentWarning } from "../types.js";
+import type { ArtifactStore } from "./store.js";
+export declare const MANIFEST_FILE = "manifest.json";
+export declare const MANIFEST_SCHEMA_VERSION: 1;
+export interface BuildManifestInput {
+    readonly artifactId: string;
+    readonly operation: DocumentManifest["operation"];
+    readonly createdAt: string;
+    readonly input: DocumentManifest["input"];
+    readonly outputs: DocumentManifest["outputs"];
+    readonly template?: string;
+    readonly templateSha256?: string;
+    readonly backends: Readonly<Record<string, BackendInfo>>;
+    readonly warnings: readonly DocumentWarning[];
+    readonly scope: DocumentManifest["scope"];
+}
+export declare function buildManifest(input: BuildManifestInput): DocumentManifest;
+export declare function writeManifest(store: ArtifactStore, artifactId: string, manifest: DocumentManifest): Promise<string>;
+export declare function readManifest(store: ArtifactStore, artifactId: string): Promise<DocumentManifest>;
+/** Project a tool-level file result onto the manifest's output record. */
+export declare function outputRecord(file: DocumentFileResult): DocumentManifest["outputs"][number];
+export declare function formatOfOperation(operation: DocumentManifest["operation"]): DocumentFormat | "unknown";
+//# sourceMappingURL=manifest.d.ts.map

package/lib/types/documents/artifacts/store.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Artifact bundle storage (§18, §47).
+ *
+ * One directory per operation:
+ *
+ * ```text
+ * <root>/<artifact-id>/
+ *   manifest.json
+ *   source.md
+ *   input/original.pdf
+ *   assets/
+ *   output.docx
+ *   extracted.md
+ * ```
+ *
+ * Everything the store writes goes through a root-relative path that is
+ * validated first, and every file lands atomically (temp file + rename) so a
+ * crashed host never leaves a half-written artifact that a later read would
+ * trust. Job temp directories live under `<root>/.tmp` and are removed on both
+ * success and failure (§47).
+ */
+export interface FileFingerprint {
+    readonly path: string;
+    readonly size: number;
+    readonly sha256: string;
+}
+export declare function sha256Hex(data: string | Buffer): string;
+export declare function sha256OfFile(filePath: string): Promise<string>;
+export interface ArtifactStoreOptions {
+    /** Directory the bundles live in; created on demand. */
+    readonly root: string;
+}
+export declare class ArtifactStore {
+    readonly root: string;
+    constructor(options: ArtifactStoreOptions);
+    /** Absolute path of a root-relative artifact member, containment checked. */
+    path(relativePath: string): string;
+    artifactDir(artifactId: string): string;
+    /** Prepare a fresh bundle directory and return its id. */
+    create(now?: number): Promise<{
+        artifactId: string;
+        dir: string;
+    }>;
+    ensureDir(relativePath: string): Promise<string>;
+    /** Atomically write a root-relative member. */
+    write(relativePath: string, data: string | Buffer): Promise<FileFingerprint>;
+    read(relativePath: string): Promise<Buffer>;
+    fingerprint(relativePath: string): Promise<FileFingerprint>;
+    exists(relativePath: string): Promise<boolean>;
+    /** Job-scoped temp directory: never an artifact, always removed (§47). */
+    createWorkDir(jobId: string): Promise<string>;
+    removeWorkDir(dir: string): Promise<void>;
+    /** Bundle directories, newest first, with their modification time. */
+    list(): Promise<{
+        artifactId: string;
+        dir: string;
+        modifiedAt: Date;
+    }[]>;
+    /** Retention sweep (§41): drop bundles older than `maxAgeDays`. */
+    cleanup(options: {
+        readonly maxAgeDays: number;
+        readonly now?: Date;
+    }): Promise<{
+        removed: string[];
+    }>;
+}
+//# sourceMappingURL=store.d.ts.map

package/lib/types/documents/capabilities.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Capability discovery (§43) and backend health (§42).
+ *
+ * Health separates required from optional backends on purpose: a deployment
+ * without Docling cannot extract PDFs, but it still creates documents, so the
+ * subsystem reports `degraded` and names what is missing instead of declaring
+ * itself down. An optional backend that was never enabled reports `disabled`,
+ * which is not a fault.
+ */
+import type { ResolvedQaDocumentsConfig } from "./config.js";
+import { type ProviderSeams, type ProviderSet } from "./providers/registry.js";
+import type { DocumentCapabilities, DocumentHealth } from "./types.js";
+import { type TemplateRegistry } from "./templates/registry.js";
+export interface HealthOptions {
+    readonly config: ResolvedQaDocumentsConfig;
+    readonly providers: ProviderSet;
+    /** Probe the two process-based backends; `false` answers from configuration. */
+    readonly probeProcessBackends?: boolean;
+}
+export declare function documentHealth(options: HealthOptions): Promise<DocumentHealth>;
+export declare function documentCapabilities(options: {
+    readonly config: ResolvedQaDocumentsConfig;
+    readonly providers: ProviderSet;
+    readonly templates: TemplateRegistry;
+}): DocumentCapabilities;
+/** Load the template registry of a workspace for capability reporting. */
+export declare function capabilitiesForRoot(options: {
+    readonly config: ResolvedQaDocumentsConfig;
+    readonly templateRoot: string | undefined;
+    readonly seams?: ProviderSeams;
+}): Promise<DocumentCapabilities>;
+//# sourceMappingURL=capabilities.d.ts.map

package/lib/types/documents/config.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Configuration of the document subsystem (§20).
+ *
+ * The subsystem is part of the `qa-surface` namespace, so this resolver
+ * follows the same shape as the other domains: it normalizes, validates and
+ * freezes, and the schema in `src/config.ts` takes every default from
+ * {@link DEFAULT_QA_DOCUMENTS_CONFIG} so an untouched deployment sends the
+ * resolver nothing at all.
+ *
+ * Environment overrides are applied in `applyDocumentsEnvOverrides`, on the
+ * way into the plugin, and only for the documented variables — a deployment
+ * that injects secrets into the process environment does not thereby get to
+ * reconfigure the pipeline.
+ */
+import { type QaDocumentsConfig, type ResolvedQaDocumentsConfig } from "./defaults.js";
+export { DEFAULT_QA_DOCUMENTS_CONFIG, type QaDocumentsCommandConfig, type QaDocumentsConfig, type QaDocumentsCreateConfig, type QaDocumentsEndpointConfig, type QaDocumentsExtractionConfig, type QaDocumentsLimitsConfig, type QaDocumentsRetentionConfig, type QaDocumentsStorageConfig, type QaDocumentsTemplatesConfig, type QaDocumentsWorkersConfig, type ResolvedQaDocumentsConfig, } from "./defaults.js";
+/** Materialize and validate the document configuration. */
+export declare function resolveDocumentsConfig(input?: QaDocumentsConfig): ResolvedQaDocumentsConfig;
+/**
+ * Apply the documented environment overrides (§20). Kept out of
+ * {@link resolveDocumentsConfig} so the resolver stays a pure function of its
+ * input — configuration tests never depend on the ambient environment.
+ */
+export declare function applyDocumentsEnvOverrides(config: QaDocumentsConfig, env: NodeJS.ProcessEnv): QaDocumentsConfig;
+/** Milliseconds a retention sweep interval would wait. */
+export declare function retentionIntervalMs(config: ResolvedQaDocumentsConfig): number;
+//# sourceMappingURL=config.d.ts.map