@yadsh/dsh-qa-surface 0.17.0 → 0.18.0

package/lib/types/forms/gate.d.ts

@@ -0,0 +1,33 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { ToolExecution } from "@deepseek-ai/dsh-tools";
+import type { QaFormService } from "./service.js";
+import type { QaFormRecord, QaFormSubmission } from "./types.js";
+type Outcome = QaFormSubmission | {
+    status: "paused";
+    form_id: string;
+    reason: string;
+};
+/** A parked tool call is transient. Never reconstruct one from a saved draft. */
+export declare class QaFormGate {
+    readonly service: () => QaFormService;
+    private readonly rootOf;
+    private readonly busy;
+    private readonly allowed;
+    private readonly filesAvailable;
+    private readonly waiters;
+    private readonly disposers;
+    private closed;
+    private readonly clients;
+    constructor(service: () => QaFormService, rootOf: (id: string) => string | undefined, busy: (id: string) => boolean, allowed: (exec: ToolExecution) => boolean, filesAvailable?: () => boolean);
+    install(ctx: Context): void;
+    waiting(id: string): boolean;
+    touch(session: string): void;
+    hasSession(session: string): boolean;
+    request(raw: unknown, exec: ToolExecution): Promise<Outcome>;
+    notify(record: QaFormRecord, pause?: boolean): void;
+    cancel(session: string): void;
+    cancelAll(): void;
+    dispose(): void;
+}
+export {};
+//# sourceMappingURL=gate.d.ts.map

package/lib/types/forms/schema.d.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import type { QaFormPolicy, QaFormSchema } from "./types.js";
+export declare const DEFAULT_FORM_POLICY: Readonly<QaFormPolicy>;
+export declare const formSchemaParser: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    submit_label: z.ZodOptional<z.ZodString>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            answer: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                required: z.ZodBoolean;
+                placeholder: z.ZodOptional<z.ZodString>;
+                min_length: z.ZodOptional<z.ZodNumber>;
+                max_length: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"textarea">;
+                required: z.ZodBoolean;
+                placeholder: z.ZodOptional<z.ZodString>;
+                min_length: z.ZodOptional<z.ZodNumber>;
+                max_length: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"single_select">;
+                required: z.ZodBoolean;
+                options: z.ZodArray<z.ZodObject<{
+                    value: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    recommended: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
+                allow_other: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"multi_select">;
+                required: z.ZodBoolean;
+                options: z.ZodArray<z.ZodObject<{
+                    value: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    recommended: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
+                allow_other: z.ZodOptional<z.ZodBoolean>;
+                min_selected: z.ZodOptional<z.ZodNumber>;
+                max_selected: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>], "type">>;
+            files: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                requirement: z.ZodLiteral<"none">;
+            }, z.core.$strict>, z.ZodObject<{
+                max_count: z.ZodNumber;
+                accept: z.ZodArray<z.ZodString>;
+                max_file_size_bytes: z.ZodNumber;
+                requirement: z.ZodLiteral<"required">;
+                min_count: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                max_count: z.ZodNumber;
+                accept: z.ZodArray<z.ZodString>;
+                max_file_size_bytes: z.ZodNumber;
+                requirement: z.ZodLiteral<"optional">;
+            }, z.core.$strict>], "requirement">;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Shared by server and browser. No Node APIs or browser-supplied readiness. */
+export declare function parseFormSchema(input: unknown, policy: Readonly<QaFormPolicy>): QaFormSchema;
+export declare function resolveFormPolicy(input?: Partial<QaFormPolicy>): QaFormPolicy;
+//# sourceMappingURL=schema.d.ts.map

package/lib/types/forms/service.d.ts

@@ -0,0 +1,15 @@
+import type { QaFormPolicy, QaFormRecord, QaFormStoreApi, QaFormView } from "./types.js";
+export declare class QaFormService {
+    readonly store: QaFormStoreApi;
+    readonly policy: () => Readonly<QaFormPolicy>;
+    private readonly ownerOf;
+    constructor(store: QaFormStoreApi, policy: () => Readonly<QaFormPolicy>, ownerOf?: (session: string) => string);
+    enabled(): void;
+    create(session: string, key: string, input: unknown): QaFormRecord;
+    view(record: QaFormRecord, waiting?: boolean): QaFormView;
+    get(session: string, id: string): QaFormRecord;
+    step(session: string, id: string, stepId: string, revision: number): void;
+    command(session: string, raw: unknown): QaFormRecord;
+    private beginUpload;
+}
+//# sourceMappingURL=service.d.ts.map

package/lib/types/forms/store.d.ts

@@ -0,0 +1,25 @@
+import { SqliteDatabase } from "@yadsh/dsh-plugin-kit/sqlite";
+import type { QaFormRecord, QaFormStoreApi } from "./types.js";
+export { fingerprint } from "./fingerprint.js";
+/** Full synchronous commits: snapshot, revision and mutation receipt share one transaction. */
+export declare class QaFormStore implements QaFormStoreApi {
+    readonly storage: SqliteDatabase;
+    constructor(file: string);
+    list(session: string): QaFormRecord[];
+    get(session: string, id: string): QaFormRecord;
+    put(record: QaFormRecord): void;
+    create(session: string, key: string, schema: QaFormRecord["schema"], creator?: string): QaFormRecord;
+    editableOrSubmitted(record: QaFormRecord): void;
+    private mutationReceipt;
+    replayedMutation(formId: string, mutationId: string, input: unknown): QaFormRecord | null;
+    mutate(session: string, id: string, revision: number, mutationId: string, input: unknown, work: (r: QaFormRecord) => void): QaFormRecord;
+    /** Async work happens before this short final transaction; no revision captured at upload start. */
+    update(session: string, id: string, work: (r: QaFormRecord) => void): QaFormRecord;
+    resource(formId: string, id: string): Uint8Array;
+    saveResource(formId: string, id: string, data: Uint8Array): void;
+    storedBytes(session: string): number;
+    identityReservedBytes(creator: string): number;
+    cancelSession(session: string): void;
+    close(): void;
+}
+//# sourceMappingURL=store.d.ts.map

package/lib/types/forms/types.d.ts

@@ -0,0 +1,215 @@
+/** Browser-safe wire contract; storage and tool waiting have independent lifetimes. */
+export interface QaFormPolicy {
+    enabled: boolean;
+    maxSteps: number;
+    maxItemsPerForm: number;
+    maxOptionsPerItem: number;
+    maxSchemaBytes: number;
+    maxTextLength: number;
+    maxTotalAnswerBytes: number;
+    maxFilesPerItem: number;
+    maxFileSizeBytes: number;
+    maxTotalFileBytesPerForm: number;
+    maxConcurrentUploadsPerSession: number;
+    uploadIntentTtlSeconds: number;
+    allowedExtensions: readonly string[];
+}
+export interface QaFormOption {
+    value: string;
+    label: string;
+    description?: string | undefined;
+    recommended?: boolean | undefined;
+}
+export type QaFormAnswerSpec = {
+    type: "text" | "textarea";
+    required: boolean;
+    placeholder?: string | undefined;
+    min_length?: number | undefined;
+    max_length?: number | undefined;
+} | {
+    type: "single_select" | "multi_select";
+    required: boolean;
+    options: QaFormOption[];
+    allow_other?: boolean | undefined;
+    min_selected?: number | undefined;
+    max_selected?: number | undefined;
+};
+export type QaFormFilesSpec = {
+    requirement: "none";
+} | {
+    requirement: "required";
+    min_count: number;
+    max_count: number;
+    accept: string[];
+    max_file_size_bytes: number;
+} | {
+    requirement: "optional";
+    max_count: number;
+    accept: string[];
+    max_file_size_bytes: number;
+};
+export interface QaFormItem {
+    id: string;
+    title: string;
+    description?: string | undefined;
+    answer?: QaFormAnswerSpec | undefined;
+    files: QaFormFilesSpec;
+}
+export interface QaFormStep {
+    id: string;
+    title: string;
+    description?: string | undefined;
+    items: QaFormItem[];
+}
+export interface QaFormSchema {
+    schema_version: 1;
+    title: string;
+    description?: string | undefined;
+    submit_label?: string | undefined;
+    steps: QaFormStep[];
+}
+export type QaFormAnswer = {
+    type: "text" | "textarea";
+    text: string;
+} | {
+    type: "single_select" | "multi_select";
+    selected: string[];
+    other_text?: string | undefined;
+};
+export interface QaFormAttachment {
+    attachment_id: string;
+    version: number;
+    name: string;
+    size_bytes: number;
+    media_type: string;
+    sha256: string;
+    resource_id: string;
+}
+export interface QaFormUpload {
+    id: string;
+    item_id: string;
+    name: string;
+    size_bytes: number;
+    state: "pending" | "uploading" | "failed" | "ready" | "cancelled";
+    expires_at: number;
+    target?: {
+        attachment_id: string;
+        version: number;
+    } | undefined;
+    result?: QaFormAttachment;
+    error?: string;
+}
+export interface QaFormFieldError {
+    step_id: string;
+    item_id: string;
+    component: "answer" | "files";
+    code: string;
+    message: string;
+}
+export interface QaFormSubmission {
+    status: "submitted";
+    form_id: string;
+    submission_id: string;
+    schema_version: 1;
+    schema_hash: string;
+    form_revision: number;
+    submitted_at: string;
+    items: {
+        step_id: string;
+        item_id: string;
+        answer: QaFormAnswer | null;
+        files: QaFormAttachment[];
+    }[];
+    empty_optional_item_ids: string[];
+}
+export interface QaFormRecord {
+    storage_version: 1;
+    id: string;
+    session_id: string;
+    creator_id: string;
+    request_key: string;
+    schema: QaFormSchema;
+    schema_hash: string;
+    status: "draft" | "submitted" | "cancelled" | "expired";
+    revision: number;
+    created_at: string;
+    answers: Record<string, QaFormAnswer | null>;
+    attachments: Record<string, QaFormAttachment[]>;
+    uploads: QaFormUpload[];
+    step: number;
+    submission?: QaFormSubmission;
+}
+export type QaFormView = QaFormRecord & {
+    waiting: boolean;
+    field_errors: QaFormFieldError[];
+};
+export interface QaFormMutation {
+    form_id: string;
+    expected_revision: number;
+    mutation_id: string;
+}
+export type QaFormCommand = (QaFormMutation & {
+    action: "save";
+    answers: Record<string, QaFormAnswer | null>;
+    step: number;
+}) | (QaFormMutation & {
+    action: "submit" | "pause";
+}) | (QaFormMutation & {
+    action: "begin_upload";
+    item_id: string;
+    name: string;
+    size_bytes: number;
+    target?: {
+        attachment_id: string;
+        version: number;
+    } | undefined;
+}) | (QaFormMutation & {
+    action: "cancel_upload";
+    upload_id: string;
+}) | (QaFormMutation & {
+    action: "remove";
+    item_id: string;
+    attachment_id: string;
+    version: number;
+});
+export type QaFormResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        form_revision?: number;
+        field_errors?: QaFormFieldError[];
+    };
+};
+/**
+ * The store surface the service programs against.
+ *
+ * The service must never reach into a concrete storage backend: the shipped
+ * store is sqlite (durable), and the client component tests mount an in-memory
+ * implementation, which a browser test environment could never load through
+ * the sqlite bridge.
+ */
+export interface QaFormStoreApi {
+    list(session: string): QaFormRecord[];
+    create(session: string, key: string, schema: QaFormRecord["schema"], creator?: string): QaFormRecord;
+    get(session: string, id: string): QaFormRecord;
+    editableOrSubmitted(record: QaFormRecord): void;
+    mutate(session: string, id: string, revision: number, mutationId: string, input: unknown, work: (r: QaFormRecord) => void): QaFormRecord;
+    update(session: string, id: string, work: (r: QaFormRecord) => void): QaFormRecord;
+    resource(formId: string, id: string): Uint8Array;
+    saveResource(formId: string, id: string, data: Uint8Array): void;
+    storedBytes(session: string): number;
+    identityReservedBytes(creator: string): number;
+    cancelSession(session: string): void;
+    /**
+     * Submit retries are idempotent: when this mutation identity was already
+     * applied, return its recorded result and refuse a reused identity that
+     * carries different data. `null` means the identity is unused.
+     */
+    replayedMutation(formId: string, mutationId: string, input: unknown): QaFormRecord | null;
+    close(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/forms/validation.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import type { QaFormAnswer, QaFormAnswerSpec, QaFormFieldError, QaFormPolicy, QaFormRecord } from "./types.js";
+export declare const formAnswerParser: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodEnum<{
+        text: "text";
+        textarea: "textarea";
+    }>;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodEnum<{
+        multi_select: "multi_select";
+        single_select: "single_select";
+    }>;
+    selected: z.ZodArray<z.ZodString>;
+    other_text: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>]>;
+/** Requiredness is checked at navigation/submit; invalid supplied values fail even if optional. */
+export declare function normalizeFormAnswer(spec: QaFormAnswerSpec | undefined, raw: unknown, policy: Readonly<QaFormPolicy>, requireComplete?: boolean): QaFormAnswer | null;
+export declare function validateForm(record: QaFormRecord, policy: Readonly<QaFormPolicy>, stepId?: string): QaFormFieldError[];
+//# sourceMappingURL=validation.d.ts.map

package/lib/types/index.d.ts

@@ -3,6 +3,7 @@ import type { SessionPageRequest, SessionFollowRequest, SessionPromptRequest, Se
 import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import type { Context } from "@deepseek-ai/cordis";
 import type { QaSurfaceConfigRefs } from "./config.js";
+import type { QaFormCommand, QaFormResult, QaFormView } from "./forms/types.js";
 import type { QaAccountNotificationsInput } from "./types.js";
 import type { QaTurnSources } from "./provenance/types.js";
 import type { QaAccountProfileInput, QaAccountSession, QaAccountStartersInput, QaAccountUserPublic, QaApprovalDecision, QaClaimResult, QaDocumentPreview, QaSpreadsheetPreviewSelection, QaDocumentWorkflowStatus, QaIssuedServiceToken, QaLockdownProof, QaOwnershipEntry, QaPasswordResetRequest, QaPendingApproval, QaPendingQuestion, QaQuestionAnswerItem, QaQueueStatus, QaServiceTokenCreateInput, QaServiceTokenSummary, ResolvedQaSurfaceConfig, QaAdminSkillScope, QaAdminSkillsView, QaExpertMemoryDraft, QaExpertMemoryPage, QaExpertMemoryRecord, QaExpertMemoryScope, QaSkillDocument, QaSkillDraftInput, QaSkillRemoval, QaSkillSummary, QaSkillToolDescriptor, QaSkillValidation, QaSourceFilePreview, QaWhoamiResult, QaWorkspaceFile, QaWorkspaceFileChunk, QaWorkspaceListing, QaPrincipal, QaAccessAdminSnapshot, QaAdminAuditEvent, QaAdminOverview, QaAdminPage, QaAdminUserDetail, QaAdminUserRow, QaAdminUserUpdate, QaAuditQuery, QaCapabilitySelection, QaConversationDetail, QaConversationDeletion, QaConversationQuery, QaConversationReview, QaConversationReviewInput, QaConversationSummary, QaCurrentAccess, QaFeedbackHarvestEntry, QaFeedbackHarvestResult, QaFeedbackQuery, QaFeedbackRow, QaMessageFeedback, QaMessageFeedbackInput, QaModelCatalogEntry, QaModelPair, QaQualityMetrics, QaReviewQueueItem, QaReviewQueueRow, QaSessionAccess, QaSlashCatalog, QaSlashExecution, QaSlashSubmitAttachment, QaSkillActivationRecord, QaSkillAssignmentOverride, QaSubrole, QaUserAccess, QaUserQuery } from "./types.js";
@@ -26,6 +27,10 @@ export declare class QaSurface extends TypertRemoteService {
     private readonly approvals;
     private readonly fileDeleteGate;
     private readonly userQuestions;
+    private formService?;
+    private readonly formGate;
+    private readonly formAttachments;
+    private forms;
     private readonly provenance;
     private readonly notes;
     /** Assigned after the admission gate; that gate only reads it per execution. */
@@ -54,6 +59,9 @@ export declare class QaSurface extends TypertRemoteService {
     private readonly integrationPrincipals;
     private webServer;
     private disposeRoute;
+    private readonly oidc;
+    private disposeOidcRoute;
+    private oidcRouteKey;
     private routeKey;
     /**
      * The HTTP API an external application asks questions through. Constructed
@@ -142,6 +150,9 @@ export declare class QaSurface extends TypertRemoteService {
      */
     accountsRegister(email: string, password: string): QaAccountSession;
     accountsLogin(email: string, password: string): QaAccountSession;
+    accountsOidcStart(): Promise<import("./types.js").QaOidcStart>;
+    accountsOidcComplete(handoff: string, completionKey: string): QaAccountSession;
+    accountsOidcLogout(token: string): Promise<string | null>;
     /** Identity probe; safe to call with an empty or expired token. */
     accountsChangePassword(token: string, currentPassword: string, nextPassword: string): QaAccountSession;
     /**
@@ -391,6 +402,22 @@ export declare class QaSurface extends TypertRemoteService {
      * deployment with unsupported questions answers with an empty list.
      */
     pendingQuestions(token: string, sessionId: string): Promise<readonly QaPendingQuestion[]>;
+    /** Forms stay owner-scoped; UUIDs and a browser-supplied session never grant access. */
+    private admitForm;
+    listForms(token: string, sessionId: string): Promise<QaFormResult<QaFormView[]>>;
+    getForm(token: string, sessionId: string, formId: string): Promise<QaFormResult<QaFormView>>;
+    mutateForm(token: string, sessionId: string, command: QaFormCommand): Promise<QaFormResult<QaFormView>>;
+    validateFormStep(token: string, sessionId: string, formId: string, stepId: string, revision: number): Promise<QaFormResult<null>>;
+    formCapabilities(): Promise<{
+        enabled: boolean;
+        schemaVersion: number;
+        upload: boolean;
+    }>;
+    readFormAttachment(token: string, sessionId: string, formId: string, resourceId: string): Promise<QaFormResult<{
+        name: string;
+        media_type: string;
+        data: string;
+    }>>;
     /**
      * Apply the operator's answers to one parked question request. Every question
      * of the request must be present in `answers`; one the browser omits reads as
@@ -511,6 +538,7 @@ export declare class QaSurface extends TypertRemoteService {
      * immediately rather than at the next restart.
      */
     private refreshIntegrationRoutes;
+    private refreshOidcRoute;
     private refreshRoute;
     /**
      * A deployment that set `lockdown.allowSlashCommands: true` before this

package/lib/types/oidc/http.d.ts

@@ -0,0 +1,5 @@
+import type { WebServer } from "@deepseek-ai/dsh-host-webserver";
+import type { ResolvedQaSurfaceConfig } from "../types.js";
+import type { QaOidcService } from "./service.js";
+export declare function registerQaOidcRoute(webServer: Pick<WebServer, "register">, config: ResolvedQaSurfaceConfig, service: QaOidcService): () => void;
+//# sourceMappingURL=http.d.ts.map

package/lib/types/oidc/service.d.ts

@@ -0,0 +1,30 @@
+import * as oidc from "openid-client";
+import type { QaAccounts } from "../accounts/store.js";
+import type { QaAccountSession, QaOidcStart, ResolvedQaSurfaceConfig } from "../types.js";
+/** A coarse refusal never carries provider responses, codes or tokens. */
+export declare function oidcRefusal(): Error;
+/** Authorization Code + PKCE with a browser-bound, single-use QA handoff. */
+export declare class QaOidcService {
+    private readonly options;
+    private generation;
+    private key;
+    private discovery;
+    private readonly transactions;
+    private readonly handoffs;
+    private attempts;
+    constructor(options: {
+        config: () => ResolvedQaSurfaceConfig;
+        accounts: () => QaAccounts | undefined;
+        discover?: typeof oidc.discovery;
+    });
+    private sync;
+    clear(): void;
+    private prune;
+    private client;
+    start(): Promise<QaOidcStart>;
+    /** Callback is reconstructed from configured origin, never Host/Forwarded headers. */
+    callback(requestUrl: string): Promise<string>;
+    complete(handoff: string, completionKey: string): QaAccountSession;
+    logout(token: string): Promise<string | null>;
+}
+//# sourceMappingURL=service.d.ts.map

package/lib/types/oidc.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=oidc.js.map

package/lib/types/oidc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oidc.js","sourceRoot":"","sources":["../../src/types/oidc.ts"],"names":[],"mappings":""}

package/lib/types/qa-tools/activation-manager.d.ts

@@ -19,7 +19,12 @@ export interface QaToolActivationManagerOptions {
 export declare class QaToolActivationManager implements QaToolActivation {
     private readonly options;
     private readonly states;
+    private readonly activeAgents;
+    private catalog;
     constructor(options: QaToolActivationManagerOptions);
+    /** Reconcile feature switches only for scopes which already earned activation. */
+    replaceCatalog(catalog: readonly QaToolDescriptor[]): void;
+    disposeAll(): void;
     /**
      * Register the whole catalog on one agent, all or nothing.
      *

package/lib/types/qa-tools/catalog.d.ts

@@ -1,5 +1,6 @@
 import type { Agent } from "@deepseek-ai/dsh-agent";
 import type { QaToolDescriptor } from "./types.js";
+import type { QaFormGate } from "../forms/gate.js";
 /**
  * Deterministic catalog identity. The durable activation marker is derived from
  * the session log rather than stored, so this version is not compared against a
@@ -8,9 +9,11 @@ import type { QaToolDescriptor } from "./types.js";
  *
  * Bump it whenever the catalog's tool set or their schemas change.
  */
-export declare const QA_TOOL_CATALOG_VERSION = "3";
+export declare const QA_TOOL_CATALOG_VERSION = "4";
 /** What the catalog's definitions read, beyond the execution record. */
 export interface QaToolsSelfcheckDeps {
+    readonly forms?: QaFormGate;
+    readonly formProjection?: (submission: import("../forms/types.js").QaFormSubmission) => Promise<unknown>;
     readonly catalogVersion: string;
     readonly activationMode: string;
     /** Names the catalog contributes, in catalog order. */

package/lib/types/qa-tools/index.d.ts

@@ -3,6 +3,9 @@ import type { Context } from "@deepseek-ai/cordis";
 import type { PluginLogger } from "@yadsh/dsh-plugin-log";
 import type { QaToolActivation } from "./types.js";
 export interface QaToolsOptions {
+    readonly forms?: import("../forms/gate.js").QaFormGate;
+    readonly formsEnabled?: () => boolean;
+    readonly formProjection?: (submission: import("../forms/types.js").QaFormSubmission) => Promise<unknown>;
     readonly logger: PluginLogger;
     readonly dynamicActivation: boolean;
     readonly activationSkill: string;
@@ -31,12 +34,13 @@ export declare class QaTools implements QaToolActivation {
     private readonly manager;
     private readonly detector;
     private readonly lifecycle;
-    private readonly catalogTools;
+    private catalogTools;
     constructor(ctx: Context, options: QaToolsOptions);
     /** Names currently registered on one agent; the admission guard reads this per call. */
     activeToolNames(agent: Agent): readonly string[];
     /** Shipped scope-local names, including entries not activated on an agent yet. */
     catalogToolNames(): readonly string[];
+    refreshForms(): void;
     dispose(): void;
     /**
      * The preset gate. An empty `activationPresets` leaves it open, which is only

package/lib/types/qa-tools/request-user-form.d.ts

@@ -0,0 +1,5 @@
+import type { ToolDefinition } from "@deepseek-ai/dsh-tools";
+import type { QaFormGate } from "../forms/gate.js";
+/** Build only; the QA activation manager owns registration and role admission. */
+export declare function createRequestUserFormTool(gate: QaFormGate, project?: (submission: import("../forms/types.js").QaFormSubmission) => Promise<unknown>): ToolDefinition;
+//# sourceMappingURL=request-user-form.d.ts.map

package/lib/types/secure-session.d.ts

@@ -71,6 +71,7 @@ export declare class QaPolicyAdmission {
      * one set answers for the whole chat.
      */
     private readonly attested;
+    private readonly questionWarnings;
     private readonly workspaceAccess;
     /**
      * Removers of the document input roots granted per session, so a grant lives

package/lib/types/types/accounts.d.ts

@@ -1,6 +1,8 @@
 import type { QaAccountRole } from "./policy.js";
 /** The account fields projected to browsers; never includes credentials. */
 export interface QaAccountUserPublic {
+    /** Corporate passwords are managed outside QA. Absent on legacy/local accounts. */
+    readonly authMethod?: "oidc";
     readonly id: string;
     readonly email: string;
     readonly displayName: string;

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

@@ -196,6 +196,12 @@ export interface QaQualityTrendPoint {
     readonly negative: number;
 }
 export interface QaQualityMetrics {
+    /** Counts derived from journals are incomplete until every journal was read. */
+    readonly coverage?: {
+        readonly complete: boolean;
+        readonly readConversations: number;
+        readonly totalConversations: number;
+    };
     readonly conversations: number;
     readonly activeUsers: number;
     readonly assistantMessages: number;

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

@@ -94,6 +94,7 @@ export interface QaNotesConfig {
     };
 }
 export interface QaSurfaceConfig {
+    readonly forms?: Partial<import("../forms/types.js").QaFormPolicy>;
     readonly enabled?: boolean;
     readonly route?: {
         readonly path?: string;
@@ -237,6 +238,8 @@ export interface QaSurfaceConfig {
         readonly frameAncestors?: string | null;
     };
     readonly accounts?: {
+        readonly localLogin?: boolean;
+        readonly oidc?: import("./oidc.js").QaOidcConfig;
         /** Opt-in; the QA gate stays off until the deployment turns this on. */
         readonly enabled?: boolean;
         readonly allowRegistration?: boolean;
@@ -372,6 +375,7 @@ export interface QaAttachmentsConfig {
     readonly extensions?: readonly string[];
 }
 export interface ResolvedQaSurfaceConfig {
+    readonly forms: Readonly<import("../forms/types.js").QaFormPolicy>;
     readonly enabled: boolean;
     readonly route: {
         readonly path: string;
@@ -441,6 +445,8 @@ export interface ResolvedQaSurfaceConfig {
         readonly frameAncestors: string | null;
     };
     readonly accounts: {
+        readonly localLogin: boolean;
+        readonly oidc: import("./oidc.js").ResolvedQaOidcConfig;
         readonly enabled: boolean;
         readonly allowRegistration: boolean;
         readonly sessionTtlDays: number;