@yadsh/dsh-qa-surface 0.10.0 → 0.11.1

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

@@ -1,12 +1,20 @@
-import type { QaAccountProfileInput, QaAccountStartersInput, QaAccountUserPublic, QaOwnershipEntry, ResolvedQaSurfaceConfig } from "../types.js";
-import type { QaAccountsApi, StorageLike } from "./types.js";
+import type { QaAccountProfileInput, QaAccountStartersInput, QaAccountUserPublic, QaIssuedServiceToken, QaOwnershipEntry, QaServiceTokenCreateInput, QaServiceTokenSummary, ResolvedQaSurfaceConfig } from "../types.js";
+import type { QaAccountsApi, QaIntegrationTokenResult, StorageLike } from "./types.js";
+/**
+ * What the sign-in card says after a forgotten-password request. It names the
+ * request, never the account: a real address and an unknown one get the same
+ * sentence, which is the whole point of the endpoint.
+ */
+export declare const QA_RESET_FILED_NOTICE = "\u0417\u0430\u044F\u0432\u043A\u0430 \u043E\u0442\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0430 \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440\u0443. \u0415\u0441\u043B\u0438 \u0442\u0430\u043A\u043E\u0439 \u0430\u043A\u043A\u0430\u0443\u043D\u0442 \u0435\u0441\u0442\u044C, \u043F\u0430\u0440\u043E\u043B\u044C \u0441\u0431\u0440\u043E\u0441\u044F\u0442 \u2014 \u0437\u0430\u0442\u0435\u043C \u0432\u043E\u0439\u0434\u0438\u0442\u0435 \u0441 \u043D\u043E\u0432\u044B\u043C \u043F\u0430\u0440\u043E\u043B\u0435\u043C.";
 export type QaAccountsSnapshot = {
     readonly stage: "checking";
 } | {
     readonly stage: "gate";
-    readonly mode: "login" | "register";
+    readonly mode: "login" | "register" | "reset";
     readonly busy: boolean;
     readonly error: string | null;
+    /** Neutral confirmation of a filed reset request; null otherwise. */
+    readonly notice?: string | null;
 } | {
     readonly stage: "authed";
     readonly user: QaAccountUserPublic;
@@ -67,11 +75,45 @@ export declare class QaAccountsController {
     start(): Promise<void>;
     login(email: string, password: string): Promise<void>;
     register(email: string, password: string): Promise<void>;
-    setMode(mode: "login" | "register"): void;
+    setMode(mode: "login" | "register" | "reset"): void;
+    /**
+     * File a forgotten-password request for the operator queue. The card says
+     * the same thing whether or not the address exists — the Host refuses to
+     * tell, and so does this controller.
+     */
+    requestPasswordReset(email: string): Promise<void>;
+    /**
+     * Change the signed-in user's own password. The Host answers with a fresh
+     * token, because the write bumps the account's token version — this browser
+     * keeps its session only by storing that token. Resolves to audience-safe
+     * refusal copy, or to null once the snapshot carries the new account.
+     */
+    changePassword(currentPassword: string, nextPassword: string): Promise<string | null>;
     /** Drop the token and return to the gate (logout or expired identity). */
     signOut(): void;
-    /** Claim one freshly created chat so the ownership map stays current. */
+    /**
+     * Claim one freshly created chat so the ownership map stays current, and
+     * remember it in the owned list the sidebar shows.
+     *
+     * The claim runs on every bind — a chat created now and one reopened later
+     * both take this path. A chat the Host reports as taken by another account
+     * stays out of the list: the page then holds a binding whose ownership
+     * belongs to someone else, and showing it is exactly what the list must not
+     * do. A claim that never reached the Host still records the id, because the
+     * page opened this chat through the attendance boundary, which claims an
+     * unowned chat for whoever asks first and refuses another account's — so the
+     * binding is this account's either way, and hiding a chat the visitor is
+     * looking at would be the greater lie.
+     */
     claimNewSession(sessionId: string): Promise<void>;
+    /**
+     * Add one chat this page holds to the owned list. The list is what the
+     * sidebar shows and what every cross-chat projection is scoped by, so a chat
+     * created or opened after login enters it here — the next login is not a
+     * reasonable price for a chat the visitor is looking at. Ids already known,
+     * and the ones an admin's cross-user view contributed, are left as they are.
+     */
+    private noteOwnedSession;
     /**
      * Replace the signed-in user's own profile. Resolves to audience-safe
      * refusal copy when the Host rejected the write, and to null once the
@@ -85,6 +127,23 @@ export declare class QaAccountsController {
      * carries the stored record, so the composer picks the new buttons up.
      */
     updateStarters(input: QaAccountStartersInput): Promise<string | null>;
+    /**
+     * The signed-in user's integration tokens. Resolves to the list, or to the
+     * copy the page renders when the Host refused the read; the tokens are not
+     * part of the account snapshot, because they are not part of the account.
+     */
+    serviceTokens(): Promise<QaIntegrationTokenResult<readonly QaServiceTokenSummary[]>>;
+    /**
+     * Mint one integration token for the signed-in user. The plaintext is in the
+     * answer and nowhere else — the caller has to hand it over now, because
+     * nothing can show it again.
+     */
+    createServiceToken(input: QaServiceTokenCreateInput): Promise<QaIntegrationTokenResult<QaIssuedServiceToken>>;
+    /**
+     * Revoke one of the signed-in user's integration tokens. The Host is the
+     * authority on whose token it is; a refusal is shown as it arrives.
+     */
+    revokeServiceToken(tokenId: string): Promise<QaIntegrationTokenResult<null>>;
     private authenticate;
     /** Own the account, migrate the legacy index, then project authed. */
     private enterSession;

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

@@ -233,8 +233,18 @@ export declare class QaSessionController {
     viewSubagent(id: string, title: string): Promise<void>;
     /** Leave the subagent transcript and re-open the chat it was launched from. */
     closeSubagent(): Promise<void>;
-    /** This browser's chat ids: the owned list when accounts are on, else the
-     * local index. Both intersect the host session list at projection time. */
+    /**
+     * This browser's chat ids: the account's owned chats while accounts are on,
+     * else the browser-local index. Either way they intersect the host session
+     * list at projection time.
+     *
+     * The local index is what this browser accumulated, not an identity: with
+     * accounts on it is the set the page *claims* at login, never one it lists.
+     * Unioning it in would show a chat another account started — its title, its
+     * timestamp, its live activity — on a shared browser, and a chat this page
+     * has yet to claim is added to the owned list by the claim itself, so the
+     * index has nothing left to supply.
+     */
     chatIds(): readonly string[];
     /** The bound session id, or null while no chat is bound. */
     activeSessionId(): string | null;
@@ -281,8 +291,20 @@ export declare class QaSessionController {
      * delegation's description verbatim; a child the host listed without a
      * catalog falls back to its own list title. Tolerates a host bundle older
      * than either field: an absent snapshot piece just contributes no names.
+     *
+     * Only the chats this page lists contribute: the host list is the whole
+     * deployment's, so an unfiltered read would hand another account's
+     * delegation into this browser — and a notice signed with a name that is
+     * not the chat's own is exactly the leak the chat list itself is scoped
+     * against.
      */
     private subagentNames;
+    /**
+     * The chats this page may show and name: the account's owned list while
+     * accounts are on, and `undefined` — every chat on the Host — for a
+     * deployment without accounts, where the list is the browser's own.
+     */
+    private visibleChatIds;
     private fail;
     /**
      * Attest the currently bound session. `ok` carries the session id the proof

package/lib/types/client/admin/pages/SkillFiles.d.ts

@@ -0,0 +1,17 @@
+import type { QaAdminApi } from "../../types.js";
+export interface AdminSkillFilesProps {
+    readonly api: QaAdminApi;
+    readonly token: string;
+}
+/**
+ * Skill files: the deployment's shared skills, and the personal skills of one
+ * named account.
+ *
+ * The page is a scope picker around the very component a person edits their
+ * own skills with — there is no second editor, because a second editor is a
+ * second set of rules for what a `SKILL.md` may contain. What the console adds
+ * is the choice of store, the naming of its owner, and the fact that its writes
+ * are recorded as an administrator's.
+ */
+export declare function AdminSkillFiles(props: AdminSkillFilesProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SkillFiles.d.ts.map

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

@@ -17,6 +17,8 @@ export type QaAdminRoute = {
     readonly page: "subroles";
 } | {
     readonly page: "skills";
+} | {
+    readonly page: "skill-files";
 } | {
     readonly page: "common";
 } | {

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

@@ -24,14 +24,31 @@ export interface QaAttachmentLimits {
  */
 export declare function attachmentLimits(config: ResolvedQaSurfaceConfig): QaAttachmentLimits;
 /**
- * The file picker's `accept` value: the raster formats plus either the
- * configured text extensions or the browser's whole `text/*` family.
+ * The file picker's `accept` value: the raster formats plus either every
+ * configured extension and the browser's whole `text/*` family, or nothing
+ * when file attachments are off.
  * @param limits - attachment policy in effect.
  * @returns the accept attribute value.
  */
 export declare function attachmentAccept(limits: QaAttachmentLimits): string;
-/** Whether a dropped payload may be attached as a text file at all. */
-export declare function acceptsTextFile(name: string, mediaType: string, limits: QaAttachmentLimits): boolean;
+/**
+ * Whether a dropped payload may be attached as a file at all. An extension the
+ * operator listed is enough on its own: the list is what the deployment can
+ * work with, and a stand whose pipeline reads Word documents lists `docx`
+ * rather than hoping the browser calls it text.
+ */
+export declare function acceptsFileAttachment(name: string, mediaType: string, limits: QaAttachmentLimits): boolean;
+/**
+ * Why one non-image file is refused, in the visitor's terms, or null when it is
+ * accepted. The copy used to name a fixed list ("md, txt, log и другие") that
+ * had nothing to do with the deployment's own setting, which is how a stand
+ * able to read Word documents ended up looking like a text-only one.
+ * @param name - display file name.
+ * @param mediaType - MIME type the browser reported.
+ * @param limits - attachment policy in effect.
+ * @returns the refusal message, or null.
+ */
+export declare function fileAttachmentRefusal(name: string, mediaType: string, limits: QaAttachmentLimits): string | null;
 /**
  * Turn one dropped or picked file into a composer draft, or into the message
  * the visitor sees when the file is not accepted.

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

@@ -12,4 +12,46 @@ import type { SessionSummary } from "@deepseek-ai/dsh-api-session-controller/cli
  * disagree about what a chat is.
  */
 export declare function isDelegatedSession(summary: Pick<SessionSummary, "origin" | "parentId"> | undefined): boolean;
+/** The session-list slice the lineage walk reads. */
+export type SessionLineage = Readonly<Record<string, Pick<SessionSummary, "parentId"> | undefined>>;
+/**
+ * The chat a session belongs to: itself when nothing delegated it, otherwise
+ * the root of its parent chain.
+ *
+ * A nested child names its own delegated parent in `parentId`, so one hop is
+ * not the chat. The walk stops at the first entry the host list does not know,
+ * which keeps a partially hydrated list from inventing a chat that is not
+ * there; a repeated id (a hostile or broken list) resolves to the id it
+ * repeated on instead of hanging.
+ */
+export declare function chatRootOf(byId: SessionLineage, sessionId: string): string;
+/** One delegated session a notice may be signed with, and its raw label. */
+export interface SubagentNameCandidate {
+    readonly id: string;
+    /** The Host's own wording for the delegation; empty when it listed none. */
+    readonly label: string;
+}
+/** One durable delegation catalog entry, as the Host lists it. */
+export interface SubagentCatalogEntry {
+    readonly kind?: string;
+    readonly id?: string;
+    readonly label?: string;
+}
+/** Direct delegation catalogs keyed by their parent chat. */
+export type SubagentCatalogs = Readonly<Record<string, {
+    readonly entries?: readonly SubagentCatalogEntry[];
+} | undefined>>;
+/**
+ * Delegated sessions whose names a page may sign its notices with: the
+ * children of the chats it lists, catalog labels first and list titles after.
+ *
+ * `chats` is the visible chat set — the account's own chats while accounts are
+ * on, and `undefined` for a deployment without accounts, where every chat on
+ * the Host is the browser's own. Ownership is checked against the chat, never
+ * against the child: a delegated session has no owner of its own, so a child
+ * is visible exactly when the chat it belongs to is. Another account's chat
+ * therefore contributes no id and no label — a foreign chat can neither sign
+ * a notice nor be named by one.
+ */
+export declare function visibleSubagentCandidates(byId: Readonly<Record<string, SessionSummary>>, catalogs: SubagentCatalogs, chats: ReadonlySet<string> | undefined): readonly SubagentNameCandidate[];
 //# sourceMappingURL=lineage.d.ts.map

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

@@ -1,8 +1,10 @@
 /**
  * Model notes: the ambient plugin messages the injector writes into a QA chat
- * (who the user is, the source-provenance rules, delegation naming). Each note
- * has a switch and an optional wording override; an empty template keeps the
- * built-in text, so the fields double as a wording editor and a mute switch.
+ * (who the user is, the source-provenance rules, delegation naming, which
+ * reader an attached document belongs to, where an answer should come from).
+ * Each note has a switch and an optional wording override; an empty template
+ * keeps the built-in text, so the fields double as a wording editor and a mute
+ * switch.
  */
 import { type ConfigProps } from "./common.js";
 /** The ambient notes the Host writes into QA chats as hidden user messages. */

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, QaAccountStartersInput, QaAccountStarter, QaAccountUserPublic, QaAccessAdminSnapshot, QaApprovalDecision, QaClaimResult, QaLockdownProof, QaOwnershipEntry, QaPendingApproval, QaPendingQuestion, QaQuestionAnswerItem, QaSessionState, QaSkillDocument, QaSkillDraftInput, QaSkillRemoval, QaSkillSummary, QaSkillToolDescriptor, QaSkillValidation, QaSourceFilePreview, QaTurnSources, QaWhoamiResult, QaDocumentPreview, QaWorkspaceFile, QaWorkspaceListing, QaCapabilitySelection, QaCurrentAccess, QaSessionAccess, QaSkillActivationRecord, QaSkillAssignmentOverride, QaSubrole, QaUserAccess, QaAdminAuditEvent, QaAdminOverview, QaAdminPage, QaAdminUserDetail, QaAdminUserRow, QaAdminUserUpdate, QaAuditQuery, QaConversationDetail, QaConversationDeletion, QaConversationQuery, QaConversationReview, QaConversationReviewInput, QaConversationSummary, QaFeedbackQuery, QaFeedbackRow, QaMessageFeedback, QaMessageFeedbackInput, QaQualityMetrics, QaReviewQueueItem, QaReviewQueueRow, QaSlashCatalog, QaSlashExecution, QaSlashSubmitAttachment, QaUserQuery } from "../types.js";
+import type { QaAccountProfileInput, QaAccountSession, QaAccountStartersInput, QaAccountStarter, QaAccountUserPublic, QaAccessAdminSnapshot, QaApprovalDecision, QaClaimResult, QaLockdownProof, QaOwnershipEntry, QaPasswordResetRequest, QaPendingApproval, QaPendingQuestion, QaQuestionAnswerItem, QaIssuedServiceToken, QaServiceTokenCreateInput, QaServiceTokenSummary, QaSessionState, QaSkillDocument, QaSkillDraftInput, QaSkillRemoval, QaSkillSummary, QaSkillToolDescriptor, QaSkillValidation, QaSourceFilePreview, QaTurnSources, QaWhoamiResult, QaDocumentPreview, QaWorkspaceFile, QaWorkspaceListing, QaCapabilitySelection, QaCurrentAccess, QaSessionAccess, QaSkillActivationRecord, QaSkillAssignmentOverride, QaSubrole, QaUserAccess, QaAdminAuditEvent, QaAdminOverview, QaAdminPage, QaAdminSkillScope, QaAdminSkillsView, QaAdminUserDetail, QaAdminUserRow, QaAdminUserUpdate, QaAuditQuery, QaConversationDetail, QaConversationDeletion, QaConversationQuery, QaConversationReview, QaConversationReviewInput, QaConversationSummary, QaFeedbackQuery, QaFeedbackRow, QaMessageFeedback, QaMessageFeedbackInput, QaQualityMetrics, QaReviewQueueItem, QaReviewQueueRow, QaSlashCatalog, QaSlashExecution, QaSlashSubmitAttachment, QaUserQuery } 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. */
@@ -56,6 +56,16 @@ export interface QaAdminApi {
     users(token: string, query: QaUserQuery, cursor: string | null, limit: number | null): Promise<RemoteResult<QaAdminPage<QaAdminUserRow>>>;
     user(token: string, userId: string): Promise<RemoteResult<QaAdminUserDetail>>;
     updateUser(token: string, userId: string, update: QaAdminUserUpdate): Promise<RemoteResult<QaAdminUserDetail>>;
+    /**
+     * Accounts that asked for a password reset from the sign-in screen, newest
+     * first. Reading takes `users.read`; answering one takes `users.manage`.
+     */
+    passwordResetRequests(token: string): Promise<RemoteResult<readonly QaPasswordResetRequest[]>>;
+    /**
+     * Answer one request: set that account's new password and drop its row. The
+     * account's live sessions end with the token-version bump.
+     */
+    resetPassword(token: string, userId: string, password: string): Promise<RemoteResult<QaAdminUserDetail>>;
     conversations(token: string, query: QaConversationQuery, cursor: string | null, limit: number | null): Promise<RemoteResult<QaAdminPage<QaConversationSummary>>>;
     conversation(token: string, conversationId: string): Promise<RemoteResult<QaConversationDetail>>;
     /**
@@ -71,6 +81,18 @@ export interface QaAdminApi {
     saveReview(token: string, input: QaConversationReviewInput): Promise<RemoteResult<QaConversationReview>>;
     metrics(token: string): Promise<RemoteResult<QaQualityMetrics>>;
     audit(token: string, query: QaAuditQuery, cursor: string | null, limit: number | null): Promise<RemoteResult<QaAdminPage<QaAdminAuditEvent>>>;
+    /**
+     * Skill files an administrator may edit: the deployment's shared store, or
+     * one named account's own. These are the same files the owner edits from
+     * their settings dialog, opened here with the authorization to leave a mark
+     * the owner sees.
+     */
+    skills(token: string, scope: QaAdminSkillScope): Promise<RemoteResult<QaAdminSkillsView>>;
+    skill(token: string, scope: QaAdminSkillScope, name: string): Promise<RemoteResult<QaSkillDocument>>;
+    saveSkill(token: string, scope: QaAdminSkillScope, name: string | null, input: QaSkillDraftInput): Promise<RemoteResult<QaSkillDocument>>;
+    deleteSkill(token: string, scope: QaAdminSkillScope, name: string, expectedRevision: string | null): Promise<RemoteResult<QaSkillRemoval>>;
+    validateSkill(token: string, scope: QaAdminSkillScope, name: string | null, input: QaSkillDraftInput): Promise<RemoteResult<QaSkillValidation>>;
+    skillTools(token: string, scope: QaAdminSkillScope): Promise<RemoteResult<readonly QaSkillToolDescriptor[]>>;
 }
 /**
  * Browser file-upload service (`ctx.fileUpload`), described structurally on
@@ -263,6 +285,31 @@ export interface QaBoundSkillApi {
     tools(): Promise<RemoteResult<readonly QaSkillToolDescriptor[]>>;
     validate(name: string | null, input: QaSkillDraftInput): Promise<RemoteResult<QaSkillValidation>>;
 }
+/**
+ * Outcome of one integration-token operation as the settings page sees it:
+ * the value, or the audience-safe copy for the refusal. The page renders the
+ * copy and never has to know a reason code.
+ */
+export type QaIntegrationTokenResult<Value> = {
+    readonly ok: true;
+    readonly value: Value;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+/** The integration-token section with the account token bound at the call site. */
+export interface QaIntegrationTokenApi {
+    /**
+     * Whether this deployment can mint at all. A token is a credential for the
+     * HTTP API, so when that API is off the page explains the state instead of
+     * offering a button that only ever refuses — while listing and revoking stay
+     * available, because a credential has to remain revocable.
+     */
+    readonly canCreate: boolean;
+    list(): Promise<QaIntegrationTokenResult<readonly QaServiceTokenSummary[]>>;
+    create(input: QaServiceTokenCreateInput): Promise<QaIntegrationTokenResult<QaIssuedServiceToken>>;
+    revoke(tokenId: string): Promise<QaIntegrationTokenResult<null>>;
+}
 /** Account remotes exposed by the plugin's own typert namespace. */
 export interface QaAccountsApi {
     accountsWhoami(token: string): Promise<RemoteResult<QaWhoamiResult>>;
@@ -279,6 +326,29 @@ export interface QaAccountsApi {
     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>>;
+    /**
+     * Replace the caller's own password. The answer carries a fresh token: the
+     * write bumps the account's token version, so without it the browser that
+     * made the change would sign itself out.
+     */
+    accountsChangePassword(token: string, currentPassword: string, nextPassword: string): Promise<RemoteResult<QaAccountSession>>;
+    /**
+     * File a forgotten-password request for the operator queue. The answer is
+     * the same for every address, so it reveals nothing about the account.
+     */
+    accountsRequestPasswordReset(email: string): Promise<RemoteResult<{
+        readonly accepted: true;
+    }>>;
+    /** The caller's own integration tokens; never a secret. */
+    accountsListServiceTokens(token: string): Promise<RemoteResult<{
+        readonly tokens: readonly QaServiceTokenSummary[];
+    }>>;
+    /** Mint one integration token for the caller; the plaintext comes back once. */
+    accountsCreateServiceToken(token: string, input: QaServiceTokenCreateInput): Promise<RemoteResult<QaIssuedServiceToken>>;
+    /** Revoke one of the caller's own integration tokens. */
+    accountsRevokeServiceToken(token: string, tokenId: string): Promise<RemoteResult<{
+        readonly revoked: boolean;
+    }>>;
 }
 /** One button above an empty composer: what it reads and what it sends. */
 export type QaQuickQuestion = QaAccountStarter;

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

@@ -0,0 +1,21 @@
+import type { QaIntegrationTokenApi } from "../types.js";
+/**
+ * The integration tokens of the signed-in account: mint, read the secret once,
+ * and revoke.
+ *
+ * An integration token is the credential a non-browser application presents to
+ * the QA HTTP API, and it is deliberately a second, separate credential from
+ * the browser session: it survives a password change, it carries its own
+ * scopes and expiry, and it is revoked here rather than by signing anybody out.
+ * The page therefore says what the token is *for* before it offers to mint one
+ * — handing a long-lived key to a service is not a preference toggle.
+ *
+ * The plaintext exists in exactly one place: the answer that minted it. It is
+ * shown once, with the warning that this is the only time, and the list that
+ * follows carries no secret in any state — a list that could repeat a
+ * credential would be a list that leaks it.
+ */
+export declare function QaIntegrationTokensPage(props: {
+    readonly api: QaIntegrationTokenApi;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=IntegrationTokensPage.d.ts.map

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

@@ -0,0 +1,19 @@
+export interface QaPasswordSettingsPageProps {
+    /**
+     * Replace the signed-in user's password; resolves to refusal copy, or to
+     * null once the Host accepted it. The controller keeps this browser signed
+     * in with the token that answer carries.
+     */
+    readonly onChange: (currentPassword: string, nextPassword: string) => Promise<string | null>;
+}
+/**
+ * The password section of the settings dialog: current, new, repeat. The
+ * repeat field is client-side only — it exists to catch a typo in the field
+ * that, unlike a name, cannot be read back later.
+ *
+ * The consequence is stated rather than discovered: changing a password ends
+ * every *other* session of this account, which is exactly the point after a
+ * leak and exactly what looks like a bug when nobody said so.
+ */
+export declare function QaPasswordSettingsPage(props: QaPasswordSettingsPageProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=PasswordSettingsPage.d.ts.map

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

@@ -1,8 +1,8 @@
 import type { QaAccountIdentityField, QaAccountProfile, QaAccountProfileInput, QaAccountStarters, QaAccountStartersInput } from "../../types.js";
-import type { QaBoundSkillApi } from "../types.js";
+import type { QaBoundSkillApi, QaIntegrationTokenApi } 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 type QaSettingsSectionId = "profile" | "password" | "starters" | "tokens" | "general" | "skills" | (string & {});
 export interface QaUserSettingsDialogProps {
     readonly open: boolean;
     /** Section to show when the dialog opens. */
@@ -18,11 +18,20 @@ export interface QaUserSettingsDialogProps {
         readonly instructionsMaxLength: number;
         readonly onSave: (input: QaAccountProfileInput) => Promise<string | null>;
     };
+    /**
+     * Self-service password change. Absent only where the surface runs without
+     * accounts at all, in which case this dialog is not shown either.
+     */
+    readonly password?: {
+        readonly onChange: (currentPassword: string, nextPassword: string) => 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>;
     };
+    /** Integration tokens; absent when accounts are off altogether. */
+    readonly integrationTokens?: QaIntegrationTokenApi;
     /** Personal skills; absent when the deployment cannot host them. */
     readonly skills?: QaBoundSkillApi;
     /** Additive pages contributed by separately shipped QA plugins. */

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

@@ -1,4 +1,4 @@
-import type { QaSkillDiagnostic } from "../../types.js";
+import type { QaSkillAdminEdit, 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.
@@ -11,6 +11,15 @@ export declare function diagnosticMessage(diagnostic: QaSkillDiagnostic): string
  * fault, an unknown code — reads as the generic failure.
  */
 export declare function skillFailureCopy(error: unknown): string;
+/**
+ * The badge line for a skill an administrator last wrote.
+ *
+ * It names the role, not the person: the row already carries a date, and who
+ * administers a deployment is not a fact a personal settings page should
+ * depend on. The mark itself comes from the Host, which only reports one while
+ * the stored bytes are still the administrator's.
+ */
+export declare function adminEditMessage(edit: QaSkillAdminEdit): string;
 /** Whether a failure is the optimistic-concurrency refusal. */
 export declare function isSkillConflict(error: unknown): boolean;
 export declare const SKILLS_EMPTY_COPY: {

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

@@ -0,0 +1,47 @@
+import type { QaIntegrationConfig, ResolvedQaSurfaceConfig } from "../types.js";
+type ResolvedIntegration = ResolvedQaSurfaceConfig["integration"];
+/** Operator-tunable bounds; the values the settings card shows as hard limits. */
+export declare const QA_INTEGRATION_TTL_DAYS_MIN = 1;
+export declare const QA_INTEGRATION_TTL_DAYS_MAX = 3650;
+export declare const QA_INTEGRATION_TIMEOUT_MS_MIN = 5000;
+export declare const QA_INTEGRATION_TIMEOUT_MS_MAX = 600000;
+export declare const QA_INTEGRATION_CONCURRENCY_MIN = 1;
+export declare const QA_INTEGRATION_CONCURRENCY_MAX = 16;
+export declare const QA_INTEGRATION_RATE_MIN = 1;
+export declare const QA_INTEGRATION_RATE_MAX = 600;
+export declare const QA_INTEGRATION_BODY_BYTES_MIN = 1048576;
+export declare const QA_INTEGRATION_BODY_BYTES_MAX = 67108864;
+export declare const QA_INTEGRATION_ATTACHMENT_BYTES_MIN = 1024;
+export declare const QA_INTEGRATION_ANSWER_CHARS_MIN = 256;
+export declare const QA_INTEGRATION_ANSWER_CHARS_MAX = 65536;
+/**
+ * Normalize the integration API's base path.
+ *
+ * It is a route namespace rather than a page: it may live under `/qa` (the
+ * default does), because the web server tries its exact table before the QA
+ * navigation's prefix, so `/qa/api/ask` never falls into the page route. What
+ * it may not do is claim the operator root, the first-party `/api` namespace
+ * or the plugin asset namespace.
+ * @param value - the configured path.
+ * @returns the path without a trailing slash.
+ */
+export declare function normalizeIntegrationBasePath(value: string): string;
+/**
+ * The integration API's slice of the resolved configuration.
+ *
+ * The endpoint is off unless a deployment asks for it: it is a network
+ * surface reachable by anything that holds a token, and a QA stand that never
+ * integrates anything must not grow one by accident.
+ *
+ * It also needs accounts. Integration tokens are issued to an account and
+ * verified against it, so a deployment with `accounts.enabled: false` has
+ * nothing to authenticate a caller with; switching the API on there is a
+ * configuration mistake, and it is refused rather than served open.
+ *
+ * @param input - raw integration config.
+ * @param accounts - the resolved accounts domain, for the cross-check.
+ * @returns the frozen resolved slice.
+ */
+export declare function resolveIntegration(input: QaIntegrationConfig | undefined, accounts: ResolvedQaSurfaceConfig["accounts"]): ResolvedIntegration;
+export {};
+//# sourceMappingURL=integration.d.ts.map

package/lib/types/config.d.ts

@@ -1,5 +1,15 @@
 import z from "@deepseek-ai/schemastery";
 import type { QaSurfaceConfig } from "./types.js";
+/**
+ * Version this build reports to the integration API's health endpoint.
+ *
+ * Read from the package manifest rather than written as a constant, so a
+ * release bump cannot drift away from it. Resolved on first use so importing
+ * the module never touches the filesystem, and this module is the right home
+ * for it: it is bundled one level under the package root, which is the depth
+ * `../package.json` resolves at.
+ */
+export declare function qaSurfaceVersion(): string;
 export declare const ConfigSchema: z<QaSurfaceConfig>;
 export { DEFAULT_QA_SURFACE_CONFIG, normalizeRoutePath, resolveConfig, } from "./resolve-config.js";
 //# sourceMappingURL=config.d.ts.map