@yadsh/dsh-qa-surface 0.2.0 → 0.3.0

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

@@ -0,0 +1,27 @@
+import type { SettingsOnboardingOwnerProps } from "@deepseek-ai/dsh-client-ui-settings/client";
+import type { StorageLike } from "../types.js";
+/** Bump when the notice changes materially and must be acknowledged again. */
+export declare const QA_WELCOME_NOTICE_VERSION = "2026-09-12.1";
+export declare const QA_WELCOME_NOTICE_COPY: Readonly<{
+    title: "Перед началом тестирования";
+    paragraphs: readonly string[];
+    continueLabel: "Понятно, продолжить";
+}>;
+export interface QaWelcomeNoticeFace {
+    readonly storage: StorageLike;
+    readonly storageKey: string;
+}
+export interface QaWelcomeNoticeProps extends QaWelcomeNoticeFace {
+    readonly complete?: () => void;
+}
+export interface QaWelcomeNoticeStepProps extends SettingsOnboardingOwnerProps, QaWelcomeNoticeFace {
+}
+/** Route-scoped replacement for DSH's stock `welcome-notice` onboarding step. */
+export declare function QaWelcomeNotice(props: QaWelcomeNoticeProps): import("react").ReactPortal | null;
+/**
+ * Invisible shadow for DSH's stock welcome step. The host coordinator removes
+ * onboarding content as soon as a chat stops being blank, so the visible QA
+ * notice is owned by the route overlay above instead of this lifecycle.
+ */
+export declare function QaWelcomeNoticeStep(props: QaWelcomeNoticeStepProps): null;
+//# sourceMappingURL=QaWelcomeNotice.d.ts.map

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

@@ -0,0 +1,36 @@
+import { type RefObject } from "react";
+/** DSH's dragged content-width floor; a lower operator cap still wins. */
+export declare const QA_CONTENT_MIN_WIDTH = 640;
+/**
+ * Space kept outside the content: 88px per side leaves room for the handle,
+ * its inset, and a safe zone that remains draggable in both directions.
+ */
+export declare const QA_CONTENT_EDGE_BUDGET = 176;
+export declare function readQaContentWidth(storage: Pick<Storage, "getItem">, key: string): number | null;
+export declare function writeQaContentWidth(storage: Pick<Storage, "setItem">, key: string, width: number): void;
+/** Resolve the centered content width for the currently available column. */
+export declare function resolveQaContentWidth(columnWidth: number, preference: number | null, maxContentWidth: number): number;
+interface QaWidthHandleProps {
+    readonly side: "left" | "right";
+    readonly onStart: () => number;
+    readonly onDrag: (width: number) => void;
+    readonly onCommit: (width: number) => void;
+    readonly onEnd: () => void;
+}
+/** Pointer-captured, rAF-throttled symmetric content-width handle. */
+export declare function QaWidthHandle(props: QaWidthHandleProps): import("react/jsx-runtime").JSX.Element;
+interface UseQaContentWidthOptions {
+    readonly active: boolean;
+    readonly root: RefObject<HTMLDivElement | null>;
+    readonly storage: Pick<Storage, "getItem" | "setItem">;
+    readonly storageKey: string;
+    readonly maxContentWidth: number;
+}
+export declare function useQaContentWidth({ active, root, storage, storageKey, maxContentWidth, }: UseQaContentWidthOptions): {
+    readonly onStart: () => number;
+    readonly onDrag: (requestedWidth: number) => void;
+    readonly onCommit: (requestedWidth: number) => void;
+    readonly onEnd: () => void;
+};
+export {};
+//# sourceMappingURL=QaWidthHandle.d.ts.map

package/lib/types/client/components/source-refs.d.ts

@@ -0,0 +1,16 @@
+import type { QaSource } from "../../types.js";
+/**
+ * Match layer between assistant text and the canonical turn sources: markdown
+ * links resolve by normalized URL, inline-code tokens by file path. A token
+ * that matches nothing keeps its plain rendering — the surface never guesses.
+ */
+export interface QaSourceRefs {
+    /** Identity of the source set; memo comparators compare this. */
+    readonly signature: string;
+    resolveUrl(url: string): QaSource | undefined;
+    resolvePath(token: string): QaSource | undefined;
+}
+/** Display name for a file-backed source: the file name alone, case kept. */
+export declare function sourceFileName(source: QaSource): string;
+export declare function buildSourceRefs(sources: readonly QaSource[]): QaSourceRefs;
+//# sourceMappingURL=source-refs.d.ts.map

package/lib/types/client/create-session.d.ts

@@ -0,0 +1,16 @@
+import type { ResolvedQaSurfaceConfig } from "../types.js";
+import type { QaSessions, QaSessionsApi } from "./types.js";
+/**
+ * Create one Host session and pin the configured preset and model onto the
+ * still-blank session. The creation wire takes no preset, so
+ * agentPresets/select recomposes the agent and durably logs
+ * `agent-preset/selected`, which the client projection replays. The session
+ * is addressed only here — no prompt can run before the caller attests the
+ * composed preset.
+ */
+export declare function createQaSession(args: {
+    readonly sessions: QaSessions;
+    readonly api: QaSessionsApi;
+    readonly config: ResolvedQaSurfaceConfig;
+}): Promise<string>;
+//# sourceMappingURL=create-session.d.ts.map

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

@@ -9,6 +9,7 @@ export declare const inject: string[];
 /** Register the route-aware, full-frame QA entry in the additive overlay slot. */
 export declare function apply(ctx: Context): Promise<() => Promise<void>>;
 export { QaConfigController } from "./QaConfigController.js";
+export { QaAccountsController } from "./QaAccountsController.js";
 export { QaRouteController, matchesQaRoute } from "./QaRouteController.js";
 export { QaSessionController } from "./QaSessionController.js";
 export { projectTranscript } from "./QaTranscriptAdapter.js";

package/lib/types/client/project-session-state.d.ts

@@ -0,0 +1,30 @@
+import type { SessionFace } from "@deepseek-ai/dsh-api-session-controller/client";
+import type { ConversationSnapshot } from "@deepseek-ai/dsh-client-ui-conversation/client";
+import type { QaSessionState, QaSubagentView, QaTurnSources, ResolvedQaSurfaceConfig } from "../types.js";
+/** Everything the bound-chat projection reads; the computation is pure. */
+export interface QaBoundProjectionInput {
+    readonly connected: boolean;
+    readonly sessionId: string;
+    readonly sessionSnapshot: ReturnType<SessionFace["getSnapshot"]>;
+    readonly conversationSnapshot: ConversationSnapshot | undefined;
+    /** Turn bundles with the Host provenance already merged in (Host wins). */
+    readonly sourceBundles: readonly QaTurnSources[];
+    readonly operationError: string | null;
+    readonly policyReady: boolean;
+    readonly admissionPending: boolean;
+    readonly chatsRevision: number;
+    readonly viewingSubagent: QaSubagentView | null;
+    readonly config: ResolvedQaSurfaceConfig;
+    /**
+     * The chat owner's display name for author labels; present only when an
+     * admin reads a foreign chat (chat-level, not per-message).
+     */
+    readonly author?: string;
+}
+/**
+ * Project one bound chat into the observable surface state: phase, transcript
+ * with per-turn sources, footer sources, and the composer's capabilities.
+ * Side effects (host-bundle refresh, notifications) live in the controller.
+ */
+export declare function projectBoundSessionState(input: QaBoundProjectionInput): QaSessionState;
+//# sourceMappingURL=project-session-state.d.ts.map

package/lib/types/client/session-admission.d.ts

@@ -0,0 +1,23 @@
+import type { QaSecureSession } from "./types.js";
+import type { ResolvedQaSurfaceConfig } from "../types.js";
+export type QaAttestationOutcome = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    /** The identity is absent or expired; the caller returns to the gate. */
+    readonly authRequired: boolean;
+    readonly reason: string | null;
+};
+/**
+ * One send-time policy attestation against the Host admission gate. The
+ * QA-facing message stays generic by design; the coarse reason plus an
+ * operator hint go to the console once per refusal.
+ */
+export declare function attestQaPolicy(args: {
+    readonly secureSession: QaSecureSession;
+    readonly token: string;
+    readonly sessionId: string;
+    readonly lockdown: ResolvedQaSurfaceConfig["lockdown"];
+    readonly report: boolean;
+}): Promise<QaAttestationOutcome>;
+//# sourceMappingURL=session-admission.d.ts.map

package/lib/types/client/session-assets.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Per-chat cache of resolved attachment URLs. Attachment reads are
+ * session-scoped (the loader reads the bound session's durable store), and
+ * attachment ids are only unique within a chat, so both the cache and the
+ * blob lifetime are keyed by chat, not by the page.
+ */
+export declare class SessionAssetRepository {
+    private readonly bySession;
+    /** Resolve one attachment of one chat, deduplicating concurrent reads. */
+    resolve(sessionId: string, attachmentId: string, load: (attachmentId: string) => Promise<string>): Promise<string>;
+    /**
+     * Revoke the chat's blob URLs and drop its cache. Data URLs need no
+     * revocation; a failed resolution never produced a URL at all.
+     */
+    release(sessionId: string): void;
+    dispose(): void;
+}
+/** Revoke one blob URL; data URLs (and other runtimes) need nothing. */
+export declare function revokeObjectUrlIfBlob(url: string): void;
+//# sourceMappingURL=session-assets.d.ts.map

package/lib/types/client/session-sources.d.ts

@@ -0,0 +1,28 @@
+import type { QaTurnSources } from "../types.js";
+import type { QaSourceApi } from "./types.js";
+/**
+ * Host-side provenance of the bound chat. The client projects turn sources
+ * from durable conversation events; the Host bundle (which also carries
+ * subagent-inherited evidence) is fetched on the side and merged by turn,
+ * Host data winning over the projection.
+ */
+export declare class QaHostSourceBridge {
+    private readonly sourceApi;
+    private readonly token;
+    private bundles;
+    private signature;
+    private refreshing;
+    /** Bumped on reset so a stale in-flight fetch never lands. */
+    private generation;
+    constructor(sourceApi: QaSourceApi, token: () => string);
+    /** Leave the chat: drop its bundles; merging degrades to the projection. */
+    reset(): void;
+    merge(projected: readonly QaTurnSources[]): readonly QaTurnSources[];
+    /**
+     * Fetch the Host bundles of one chat; a changed payload republishes through
+     * the callback. Repeated calls coalesce while one is in flight, and a
+     * response that outlives the chat is dropped.
+     */
+    refresh(sessionId: string, onChanged: () => void): Promise<void>;
+}
+//# sourceMappingURL=session-sources.d.ts.map

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

@@ -0,0 +1,6 @@
+/** Fold the host settlement wording into a title plus the closing message. */
+export declare function parseSettlement(text: string): {
+    title: string;
+    body: string;
+} | undefined;
+//# sourceMappingURL=settlement.d.ts.map

package/lib/types/client/tool-presentation.d.ts

@@ -0,0 +1,6 @@
+import type { ToolResultNode } from "@deepseek-ai/dsh-client-ui-conversation/client";
+import type { QaWorkItem } from "../types.js";
+export declare function flattenToolOutput(node: ToolResultNode): string | null;
+export declare function toolStatus(node: ToolResultNode): "ok" | "error" | "stopped";
+export declare function workTool(callId: string, name: string, argsRaw: string, status: "running" | "ok" | "error" | "stopped", startedAt: number | undefined, endedAt: number | undefined, output: string | null): QaWorkItem;
+//# sourceMappingURL=tool-presentation.d.ts.map

package/lib/types/client/turn-sources.d.ts

@@ -0,0 +1,14 @@
+import type { ConversationSnapshot } from "@deepseek-ai/dsh-client-ui-conversation/client";
+import type { LegacyConversationSlice } from "@deepseek-ai/dsh-client-ui-chat/client";
+import type { QaSource, QaTurnSources } from "../types.js";
+/** The transcript-bearing Chat slice of one Conversation snapshot (absent before the view activates). */
+export declare function chatLegacyOf(snapshot: ConversationSnapshot | undefined): LegacyConversationSlice;
+/**
+ * Rebuild canonical turn bundles from durable tool-result metadata. Since the
+ * metadata is persisted by DSH, this projection is identical on live updates
+ * and replay and requires no assistant-authored bibliography.
+ */
+export declare function projectTurnSources(snapshot: ConversationSnapshot | undefined, sessionId?: string, workspaceRoot?: string): readonly QaTurnSources[];
+/** Visible evidence sources for the latest turn, shared by the drawer/footer. */
+export declare function projectSources(snapshot: ConversationSnapshot | undefined, sessionId?: string, workspaceRoot?: string): readonly QaSource[];
+//# sourceMappingURL=turn-sources.d.ts.map

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

@@ -1,23 +1,86 @@
-import type { IApiClient } from "@deepseek-ai/dsh-client-connection/client";
-import type { ISessions, SessionRuntime } from "@deepseek-ai/dsh-client-runtime/client";
-import type { QaLockdownProof, QaSessionState } from "../types.js";
-import type { SessionFace } from "@deepseek-ai/dsh-client-runtime/client";
+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 { QaAccountSession, QaClaimResult, QaLockdownProof, QaOwnershipEntry, QaSessionState, 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. */
-export type QaSessions = ISessions & Pick<SessionRuntime, "create">;
+export type QaSessions = ISessions;
 /** Narrow client API slice used to pin the preset and model of a fresh chat. */
-export type QaSessionsApi = Pick<IApiClient["sessions"], "selectModel"> & {
-    readonly selectAgentPreset: IApiClient["agentPresets"]["select"];
+export type QaSessionsApi = {
+    selectModel: ClientRemote["session"]["selectModel"];
+    selectAgentPreset: ClientRemote["agentPresets"]["select"];
 };
-/** Attestation channel to the Host admission boundary (`qaSurface/secureSession`). */
-export type QaSecureSession = (sessionId: string) => Promise<{
+/**
+ * Conversation assembly the QA transcript is projected from: the per-Session
+ * binding carries the assembled Chat view (nodes, partials, tool calls).
+ */
+export type QaConversation = Pick<UiConversation, "binding">;
+/**
+ * Attestation channel to the Host admission boundary
+ * (`qaSurface/secureSession`). The account token rides as the first argument
+ * when accounts are enabled; an empty string is the anonymous caller.
+ */
+export type QaSecureSession = (token: string, sessionId: string) => Promise<{
     readonly ok: true;
     readonly value: QaLockdownProof;
 } | {
     readonly ok: false;
     readonly error: unknown;
 }>;
+export interface QaSourceApi {
+    sources(token: string, sessionId: string): Promise<{
+        readonly ok: true;
+        readonly value: readonly QaTurnSources[];
+    } | {
+        readonly ok: false;
+        readonly error: unknown;
+    }>;
+    readSourceFile(token: string, sessionId: string, sourcePath: string): Promise<{
+        readonly ok: true;
+        readonly value: QaSourceFilePreview;
+    } | {
+        readonly ok: false;
+        readonly error: unknown;
+    }>;
+}
+/** A source API with the account token already bound at the call site. */
+export type QaBoundSourceApi = {
+    sources(sessionId: string): Promise<{
+        readonly ok: true;
+        readonly value: readonly QaTurnSources[];
+    } | {
+        readonly ok: false;
+        readonly error: unknown;
+    }>;
+    readSourceFile(sessionId: string, sourcePath: string): Promise<{
+        readonly ok: true;
+        readonly value: QaSourceFilePreview;
+    } | {
+        readonly ok: false;
+        readonly error: unknown;
+    }>;
+};
+/** Account remotes exposed by the plugin's own typert namespace. */
+export interface QaAccountsApi {
+    accountsWhoami(token: string): Promise<RemoteResult<QaWhoamiResult>>;
+    accountsLogin(email: string, password: string): Promise<RemoteResult<QaAccountSession>>;
+    accountsRegister(email: string, password: string): Promise<RemoteResult<QaAccountSession>>;
+    accountsClaimSessions(token: string, sessionIds: readonly string[]): Promise<RemoteResult<QaClaimResult>>;
+    accountsOwnedSessions(token: string): Promise<RemoteResult<{
+        readonly ids: readonly string[];
+    }>>;
+    accountsListOwnership(token: string): Promise<RemoteResult<{
+        readonly entries: readonly QaOwnershipEntry[];
+    }>>;
+}
+type RemoteResult<Value> = {
+    readonly ok: true;
+    readonly value: Value;
+} | {
+    readonly ok: false;
+    readonly error: unknown;
+};
 /** Minimal persistence contract; backed by `window.localStorage` in the app. */
 export interface StorageLike {
     getItem(key: string): string | null;
@@ -26,4 +89,5 @@ 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/use-session-ui-state.d.ts

@@ -0,0 +1,35 @@
+import { type Dispatch, type SetStateAction } from "react";
+import type { QaImageDraft, QaSource, QaTurnSources } from "../types.js";
+/** Snapshot completeness captured when a drawer was opened from a message. */
+export interface QaDrawerCompleteness {
+    readonly complete: boolean;
+    readonly incompleteOrigins?: QaTurnSources["incompleteOrigins"];
+}
+export interface QaSessionUiState {
+    /** Per group: how many answers back from the newest is shown (0 = newest). */
+    readonly variantOffsets: Record<string, number>;
+    readonly setVariantOffsets: Dispatch<SetStateAction<Record<string, number>>>;
+    /** The turn the transcript's reading line currently owns. */
+    readonly activeTurn: number | null;
+    readonly setActiveTurn: Dispatch<SetStateAction<number | null>>;
+    readonly agentsOpen: boolean;
+    readonly setAgentsOpen: Dispatch<SetStateAction<boolean>>;
+    readonly sourcesOpen: boolean;
+    readonly setSourcesOpen: Dispatch<SetStateAction<boolean>>;
+    readonly drawerSources: readonly QaSource[] | null;
+    readonly setDrawerSources: Dispatch<SetStateAction<readonly QaSource[] | null>>;
+    readonly drawerCompleteness: QaDrawerCompleteness | null;
+    readonly setDrawerCompleteness: Dispatch<SetStateAction<QaDrawerCompleteness | null>>;
+    readonly drawerDetail: QaSource | null;
+    readonly setDrawerDetail: Dispatch<SetStateAction<QaSource | null>>;
+    readonly pendingImages: readonly QaImageDraft[];
+    readonly setPendingImages: (next: readonly QaImageDraft[]) => void;
+}
+/**
+ * Per-chat UI state: composer attachments, variant offsets, the rail mark and
+ * the drawers. Everything here describes the chat it was made in, so a
+ * session change clears it instead of leaking a draft, an image or a drawer
+ * from one conversation into the next.
+ */
+export declare function useSessionUiState(sessionId: string | null): QaSessionUiState;
+//# sourceMappingURL=use-session-ui-state.d.ts.map

package/lib/types/client/use-transcript-view.d.ts

@@ -0,0 +1,20 @@
+import type { QaMessage } from "../types.js";
+import { type QaTurnRailItem } from "./components/QaTurnRail.js";
+import { type QaVariantGroup } from "./components/VariantSwitcher.js";
+export interface QaTranscriptView {
+    readonly visibleMessages: readonly QaMessage[];
+    /** Answer groups by the user message id that opens them. */
+    readonly groupByPromptId: ReadonlyMap<string, QaVariantGroup>;
+    /** Per group: the turn the current variant offset selects. */
+    readonly selectedTurn: ReadonlyMap<string, number>;
+    readonly railItems: readonly QaTurnRailItem[];
+}
+/**
+ * Memoized transcript view model. The controller republishes state with a
+ * fresh messages array on every stream frame, but re-renders that keep the
+ * transcript unchanged (drawers, the active turn mark, variant offsets) must
+ * not re-run the projections — and per-row group lookups go through a map
+ * instead of a linear find inside the render loop.
+ */
+export declare function useTranscriptView(messages: readonly QaMessage[], variantOffsets: Record<string, number>): QaTranscriptView;
+//# sourceMappingURL=use-transcript-view.d.ts.map

package/lib/types/entry-redirect.d.ts

@@ -0,0 +1,20 @@
+import type { ResolvedQaSurfaceConfig } from "./types.js";
+/**
+ * The operator/LAN split is decided client-side on `location.hostname` on
+ * purpose: behind the qa-deploy proxy every request appears loopback to the
+ * Host, and the deployment convention is "operator uses localhost, QA users
+ * use the LAN address". `?ui=admin` persists the operator escape hatch under
+ * the deployment's storage key; `?ui=qa` clears it again.
+ */
+export declare function entryRedirectScript(config: ResolvedQaSurfaceConfig): string;
+export interface EntryRedirectRow {
+    readonly kind: "script";
+    readonly placement: "head";
+    readonly text: string;
+}
+/**
+ * The structured index-injection row for one config snapshot, or undefined
+ * when the plugin is disabled or the redirect flag is off.
+ */
+export declare function entryRedirectRow(config: ResolvedQaSurfaceConfig): EntryRedirectRow | undefined;
+//# sourceMappingURL=entry-redirect.d.ts.map

package/lib/types/host-route.d.ts

@@ -1,9 +1,22 @@
+import type { IncomingMessage } from "node:http";
 import type { WebServer } from "@deepseek-ai/dsh-host-webserver";
 import type { ResolvedQaSurfaceConfig } from "./types.js";
+import type { LaunchTokenSource } from "./launch-token.js";
+export interface QaNavigationRouteOptions {
+    /**
+     * Resolves the process launch token; when supplied and the browser carries
+     * no host-auth cookie, the route defers the marker hand-off in favor of the
+     * one-time `/?token=` exchange (relative location: the browser mints the
+     * cookie on the origin it actually used).
+     */
+    readonly launchToken?: LaunchTokenSource;
+}
+/** Presence-only check: an invalid cookie still fails the root gate later. */
+export declare function hasHostAuthCookie(request: IncomingMessage): boolean;
 /**
  * DSH 0.1.1 static hosting returns 404 for missing paths. Redirect a browser
  * navigation through its canonical index entry; the client restores the
  * requested pathname before activating the QA overlay.
  */
-export declare function registerQaNavigationRoute(webServer: Pick<WebServer, "register">, config: ResolvedQaSurfaceConfig): () => void;
+export declare function registerQaNavigationRoute(webServer: Pick<WebServer, "register">, config: ResolvedQaSurfaceConfig, options?: QaNavigationRouteOptions): () => void;
 //# sourceMappingURL=host-route.d.ts.map

package/lib/types/index.d.ts

@@ -1,9 +1,10 @@
 import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import type { Context } from "@deepseek-ai/cordis";
-import type { QaLockdownProof, QaSurfaceConfig, ResolvedQaSurfaceConfig } from "./types.js";
+import type { QaTurnSources } from "./provenance/types.js";
+import type { QaAccountSession, QaClaimResult, QaLockdownProof, QaOwnershipEntry, QaSurfaceConfig, ResolvedQaSurfaceConfig, QaSourceFilePreview, QaWhoamiResult } from "./types.js";
 export declare const name = "qa-surface";
 export declare const inject: string[];
-export declare const QA_SURFACE_SETTINGS_NAMESPACE: import("@deepseek-ai/dsh-settings").SettingsNamespace;
+export declare const QA_SURFACE_SETTINGS_NAMESPACE = "qa-surface";
 export declare const Config: import("@deepseek-ai/schemastery").default<QaSurfaceConfig>;
 declare module "@deepseek-ai/cordis" {
     interface Context {
@@ -17,11 +18,47 @@ export declare class QaSurface extends TypertRemoteService {
     private source;
     private readonly logger;
     private readonly admission;
+    private readonly provenance;
+    private accounts;
+    private accountsOptions;
+    private readonly launchToken;
     private webServer;
     private disposeRoute;
     private routeKey;
     constructor(ctx: Context, entry?: QaSurfaceConfig);
     getConfig(): ResolvedQaSurfaceConfig;
+    /**
+     * The accounts store behind the runtime toggle. Rebuilt only when the
+     * account-affecting options change; the file is shared across rebuilds.
+     */
+    private accountsFor;
+    /** The accounts store, or the disabled refusal the browser maps to copy. */
+    private requireAccounts;
+    /** Account failures ride the shared `(reason: <code>)` wire marker. */
+    private accountsRemote;
+    /**
+     * Self-service signup; the first account ever created becomes admin. The
+     * display name derives from the email: the generated client enforces exact
+     * wire arity, so an optional name parameter would still be required.
+     */
+    accountsRegister(email: string, password: string): QaAccountSession;
+    accountsLogin(email: string, password: string): QaAccountSession;
+    /** Identity probe; safe to call with an empty or expired token. */
+    accountsWhoami(token: string): QaWhoamiResult;
+    /** Migrate a browser's local chat index into server-side ownership. */
+    accountsClaimSessions(token: string, sessionIds: readonly string[]): QaClaimResult;
+    /** The token user's owned session ids; the sidebar list authority. */
+    accountsOwnedSessions(token: string): {
+        readonly ids: readonly string[];
+    };
+    /**
+     * Every chat-ownership entry with owner display names; the cross-user view
+     * admin browsers group the sidebar by. Ordinary accounts are refused with
+     * the dedicated reason, anonymous ones with auth-required.
+     */
+    accountsListOwnership(token: string): {
+        readonly entries: readonly QaOwnershipEntry[];
+    };
     /**
      * Serve the effective QA configuration to the browser. The DSH gateway pins
      * settings RPCs to loopback, so a browser served over the LAN always sees
@@ -31,15 +68,22 @@ export declare class QaSurface extends TypertRemoteService {
      */
     describe(): ResolvedQaSurfaceConfig;
     /** Pin and attest the effective policy. The browser supplies identity only. */
-    secureSession(sessionId: string): QaLockdownProof;
+    secureSession(token: string, sessionId: string): QaLockdownProof;
+    /** Return canonical Host snapshots; replay is rebuilt from qa/sources events. */
+    sources(token: string, sessionId: string): readonly QaTurnSources[];
+    /** Narrow read-only preview capability for files already present as sources. */
+    readSourceFile(token: string, sessionId: string, sourcePath: string): Promise<QaSourceFilePreview>;
     private refreshRoute;
 }
 export { ConfigSchema, DEFAULT_QA_SURFACE_CONFIG, normalizeRoutePath, resolveConfig, } from "./config.js";
 export { QaAttestationError } from "./attestation.js";
 export type { QaAttestationReason } from "./attestation.js";
+export { QaAccounts, QaAccountsError } from "./accounts/store.js";
+export { entryRedirectRow, entryRedirectScript } from "./entry-redirect.js";
 export { registerQaNavigationRoute } from "./host-route.js";
 export { qaToolDenial, qaToolPolicyPlan } from "./lockdown-policy.js";
 export { QaPolicyAdmission } from "./secure-session.js";
+export * from "./provenance/index.js";
 export type * from "./types.js";
 export default QaSurface;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/launch-token.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Plugin-side launch-token bridge (the pattern proven by dsh-auth-gate): the
+ * 0.1.x host exposes `connection.authenticatedUrl(baseUrl)` whose `?token=`
+ * parameter carries the per-process launch token. The `/qa` route handler
+ * uses it to send cookie-less browsers through the one-time host-cookie
+ * exchange themselves, so the transparent entry works without the qa-deploy
+ * proxy. The host/scheme of the resolved URL are dropped — the redirect is
+ * relative, so the browser stays on the origin it actually used.
+ */
+export type LaunchTokenSource = () => string | undefined;
+interface AuthenticatedUrlFace {
+    authenticatedUrl?(baseUrl: string): string;
+}
+/**
+ * Resolve the launch token once per process (it is stable for the process
+ * lifetime); a missing connection service or an unusable answer warns once
+ * and permanently disables the bridge instead of retrying per request.
+ */
+export declare function makeLaunchTokenSource(getConnection: () => AuthenticatedUrlFace | undefined, warn: (message: string) => void): LaunchTokenSource;
+export {};
+//# sourceMappingURL=launch-token.d.ts.map

package/lib/types/provenance/collector.d.ts

@@ -0,0 +1,26 @@
+import type { QaSourceReference, QaTurnSources, SourceExtractorContext } from "./types.js";
+import type { SourceExtractorRegistry } from "./extractors.js";
+export interface QaSourceCollectorOptions {
+    readonly sessionId: string;
+    readonly turn: number;
+    readonly registry: SourceExtractorRegistry;
+    readonly displayScoreThreshold?: number;
+    readonly mergeFileRanges?: boolean;
+}
+/** Mutable turn-local accumulator; snapshots are immutable plain data. */
+export declare class QaSourceCollector {
+    private readonly options;
+    private readonly collected;
+    private readonly incompleteOrigins;
+    private readonly threshold;
+    constructor(options: QaSourceCollectorOptions);
+    observe(context: SourceExtractorContext): void;
+    add(sources: readonly QaSourceReference[]): void;
+    markIncomplete(origin: {
+        readonly subagentRunId?: string;
+        readonly provider?: string;
+        readonly reason: string;
+    }): void;
+    snapshot(): QaTurnSources;
+}
+//# sourceMappingURL=collector.d.ts.map

package/lib/types/provenance/connectors.d.ts

@@ -0,0 +1,11 @@
+import { canonicalizeUrl } from "./normalize.js";
+import type { SourceExtractor } from "./types.js";
+type UrlOptions = Parameters<typeof canonicalizeUrl>[1];
+export declare function createJiraExtractor(urlOptions?: UrlOptions): SourceExtractor;
+export declare function createConfluenceExtractor(urlOptions?: UrlOptions): SourceExtractor;
+export declare function createKnowledgeExtractor(urlOptions?: UrlOptions): SourceExtractor;
+export declare const jiraExtractor: SourceExtractor;
+export declare const confluenceExtractor: SourceExtractor;
+export declare const knowledgeExtractor: SourceExtractor;
+export {};
+//# sourceMappingURL=connectors.d.ts.map

package/lib/types/provenance/dedupe.d.ts

@@ -0,0 +1,6 @@
+import type { QaSourceReference } from "./types.js";
+/** Merge by canonical id and rank by score, preserving first-use order on ties. */
+export declare function dedupeAndRankSources(sources: readonly QaSourceReference[], options?: {
+    readonly mergeFileRanges?: boolean;
+}): readonly QaSourceReference[];
+//# sourceMappingURL=dedupe.d.ts.map

package/lib/types/provenance/extractors.d.ts

@@ -0,0 +1,14 @@
+import { canonicalizeUrl } from "./normalize.js";
+import type { QaSourceReference, SourceExtractor, SourceExtractorContext } from "./types.js";
+export declare const readFileExtractor: SourceExtractor;
+export declare function createWebSearchExtractor(maxPromotedPerSearch?: number, urlOptions?: Parameters<typeof canonicalizeUrl>[1]): SourceExtractor;
+export declare function createWebFetchExtractor(urlOptions?: Parameters<typeof canonicalizeUrl>[1]): SourceExtractor;
+export declare const webFetchExtractor: SourceExtractor;
+export declare const fileSearchExtractor: SourceExtractor;
+export declare class SourceExtractorRegistry {
+    private readonly extractors;
+    register(extractor: SourceExtractor): () => void;
+    extract(context: SourceExtractorContext): readonly QaSourceReference[];
+}
+export declare function createDefaultSourceExtractorRegistry(maxPromotedPerSearch?: number, urlOptions?: Parameters<typeof canonicalizeUrl>[1]): SourceExtractorRegistry;
+//# sourceMappingURL=extractors.d.ts.map

package/lib/types/provenance/file-preview.d.ts

@@ -0,0 +1,10 @@
+import type { QaSourceFilePreview } from "../types.js";
+export interface QaSourceFilePreviewOptions {
+    readonly root: string;
+    readonly sourcePath: string;
+    readonly maxBytes: number;
+    readonly maxMarkdownRenderBytes: number;
+}
+/** Read one canonical in-root file without following a symlink outside root. */
+export declare function readSourceFilePreview({ root, sourcePath, maxBytes, maxMarkdownRenderBytes, }: QaSourceFilePreviewOptions): Promise<QaSourceFilePreview>;
+//# sourceMappingURL=file-preview.d.ts.map