@yadsh/dsh-qa-surface 0.1.1 → 0.3.0

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

@@ -0,0 +1,121 @@
+import type { QaAccountRole, QaAccountSession, QaAccountUserPublic, QaClaimResult, QaOwnershipEntry, QaWhoamiResult } from "../types.js";
+/**
+ * Coarse, wire-safe account failure codes. They ride the `(reason: <code>)`
+ * marker pattern the attestation path established; the browser maps them to
+ * audience-safe copy and the precise cause stays in the Host logs.
+ */
+export type QaAccountsErrorReason = "auth-required" | "admin-required" | "invalid-credentials" | "account-disabled" | "email-taken" | "invalid-email" | "invalid-display-name" | "invalid-role" | "weak-password" | "registration-disabled" | "rate-limited" | "session-owned-elsewhere";
+export declare class QaAccountsError extends Error {
+    readonly reason: QaAccountsErrorReason;
+    constructor(reason: QaAccountsErrorReason, message: string);
+}
+interface StoredUser {
+    readonly id: string;
+    readonly email: string;
+    readonly displayName: string;
+    readonly role: QaAccountRole;
+    /** scrypt material: hex salt + hex hash. */
+    readonly passwordHash: {
+        readonly salt: string;
+        readonly hash: string;
+    };
+    readonly createdAt: string;
+    lastLoginAt: string | null;
+    /** Disabled accounts are refused at login and lose their live tokens. */
+    disabled?: boolean;
+    /**
+     * Bumped to invalidate every token ever issued to the account: the value
+     * rides the token payload and must match at verification time.
+     */
+    tokenVersion?: number;
+}
+export interface QaAccountsOptions {
+    readonly sessionTtlDays: number;
+    readonly allowRegistration: boolean;
+    /** Login/registration attempts accepted per rolling minute, store-wide. */
+    readonly maxAuthAttemptsPerMinute?: number;
+}
+/** The accounts file lives next to the DSH home the launcher exports. */
+export declare function defaultAccountsFilePath(): string;
+/**
+ * Host authority for QA accounts: the file-backed user list, the session
+ * ownership map and the HMAC account tokens. All mutations are synchronous
+ * and persisted atomically (temp file + rename); LAN scale keeps this trivial.
+ */
+export declare class QaAccounts {
+    readonly filePath: string;
+    private file;
+    private readonly authAttempts;
+    private readonly maxAuthAttemptsPerMinute;
+    private readonly sessionTtlDays;
+    private readonly allowRegistration;
+    /** mtime+size of the file as of the last load; the external-change probe. */
+    private lastLoadStamp;
+    constructor(filePath: string | undefined, options: QaAccountsOptions);
+    /**
+     * The qa-accounts CLI runs in its own process against the same file. Re-read
+     * it whenever it changed on disk, before every read or read-modify-write:
+     * without this a running Host would keep honoring tokens the CLI revoked
+     * and its next save would resurrect the CLI's change from a stale snapshot.
+     * One file, one writer at a time remains the deployment's discipline; LAN
+     * scale keeps the stat per operation trivial.
+     */
+    private reloadIfChanged;
+    private load;
+    private persist;
+    private save;
+    private pruneAuthAttempts;
+    private assertAuthBudget;
+    private userByEmail;
+    register(email: string, password: string, displayName?: string): QaAccountSession;
+    login(email: string, password: string): QaAccountSession;
+    whoami(token: string): QaWhoamiResult;
+    /** Resolve a token to its user, or null for absent/invalid/expired ones. */
+    verifyToken(token: string): string | null;
+    private mintToken;
+    /** The account behind a token, or an auth-required refusal. */
+    requireUser(token: string): StoredUser;
+    /**
+     * Ownership gate for one session: claim unowned sessions for the requesting
+     * user (first come, first served — the pre-accounts migration path), refuse
+     * foreign sessions unless the caller administers the deployment.
+     */
+    ensureSessionAccess(token: string, sessionId: string): QaAccountUserPublic;
+    /** Bulk-claim a browser's local chat index; foreign ids come back as conflicts. */
+    claimSessions(token: string, sessionIds: readonly string[]): QaClaimResult;
+    /** Session ids owned by the token's user, most recently claimed first. */
+    ownedSessionIds(token: string): readonly string[];
+    /**
+     * Every ownership entry with the owner's display name resolved at read
+     * time, oldest claim first. Admin-only: this is the cross-user view the
+     * admin sidebar groups chats by; ordinary accounts get a dedicated refusal.
+     */
+    listOwnership(token: string): readonly QaOwnershipEntry[];
+    /** Every account, file order; for `qa-accounts list`. */
+    listUsers(): readonly {
+        readonly email: string;
+        readonly displayName: string;
+        readonly role: QaAccountRole;
+        readonly disabled: boolean;
+        readonly createdAt: string;
+        readonly lastLoginAt: string | null;
+    }[];
+    /** Create an account outside the self-registration gate. */
+    addUser(email: string, password: string, options?: {
+        displayName?: string;
+        role?: QaAccountRole;
+    }): QaAccountUserPublic;
+    private editUser;
+    /** Grant or revoke the admin role. */
+    setUserRole(email: string, role: QaAccountRole): QaAccountUserPublic;
+    /**
+     * Disable an account: future logins are refused and every live token is
+     * invalidated (the token version bumps). `enable` does not resurrect old
+     * tokens — the account signs in again.
+     */
+    setUserDisabled(email: string, disabled: boolean): QaAccountUserPublic;
+    /** Invalidate every token of the account (password-leak response). */
+    revokeTokens(email: string): QaAccountUserPublic;
+}
+export {};
+//# sourceMappingURL=store.d.ts.map

package/lib/types/attestation.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Stable, coarse reason codes for QA policy attestation rejections.
+ *
+ * The RPC carrier folds a thrown Host error into `{ code, message, details }`
+ * and always empties `details`, so the wire message is the only channel back
+ * to the browser. The message therefore carries a `(reason: <code>)` marker:
+ * coarse enough to reveal nothing about the deployment policy to the QA
+ * audience, precise enough for an operator reading the browser console to
+ * know which class of mismatch to look for in the Host logs.
+ */
+export type QaAttestationReason = "agent-unavailable" | "workspace-unavailable" | "composition-mismatch" | "permission-preset" | "adoption-refused" | "unknown-tools" | "auth-required" | "session-owned-elsewhere" | "attestation-failed";
+/** Host rejection whose wire message carries the coarse reason marker. */
+export declare class QaAttestationError extends Error {
+    readonly reason: QaAttestationReason;
+    constructor(reason: QaAttestationReason, message: string);
+}
+//# sourceMappingURL=attestation.d.ts.map

package/lib/types/cli.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+export interface CliIo {
+    out(line: string): void;
+    err(line: string): void;
+}
+/** Execute one management command; returns the process exit code. */
+export declare function run(argv: readonly string[], io: CliIo, readPassword?: () => string): number;
+export declare function main(argv: readonly string[], io?: CliIo, readPassword?: () => string): number;
+//# sourceMappingURL=cli.d.ts.map

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

@@ -0,0 +1,95 @@
+import type { QaAccountUserPublic, QaOwnershipEntry, ResolvedQaSurfaceConfig } from "../types.js";
+import type { QaAccountsApi, StorageLike } from "./types.js";
+export type QaAccountsSnapshot = {
+    readonly stage: "checking";
+} | {
+    readonly stage: "gate";
+    readonly mode: "login" | "register";
+    readonly busy: boolean;
+    readonly error: string | null;
+} | {
+    readonly stage: "authed";
+    readonly user: QaAccountUserPublic;
+    /**
+     * Server-known chat ids; the sidebar list authority. Own chats always,
+     * plus every mapped chat for an admin (the cross-user grouping view).
+     */
+    readonly ownedIds: readonly string[];
+    /**
+     * The full ownership map; admins only, empty for ordinary accounts and
+     * whenever the admin listing was refused or unavailable.
+     */
+    readonly ownership: readonly QaOwnershipEntry[];
+    /** Bumped whenever ownedIds or ownership changes; re-projects lists. */
+    readonly ownedRevision: number;
+};
+/**
+ * Audience-safe copy for the coarse account refusal codes; anything unknown
+ * falls back to the generic line.
+ */
+export declare function accountsErrorMessage(code: string | null): string;
+/** Extract the coarse account reason code from a Host wire failure. */
+export declare function accountsReasonOf(failure: unknown): string | null;
+export interface QaAccountsControllerOptions {
+    readonly remote: QaAccountsApi;
+    readonly storage: StorageLike | undefined;
+    /** Config snapshot getter; the token key follows the deployment identity. */
+    readonly config: () => ResolvedQaSurfaceConfig;
+    /**
+     * The legacy per-browser chat index at login time, for the one-shot
+     * ownership migration; conflicts are dropped through {@link forgetChat}.
+     */
+    readonly legacyChatIds?: () => readonly string[];
+    readonly forgetChat?: (sessionId: string) => void;
+}
+/**
+ * Browser-side account lifecycle: token persistence, the checking → gate →
+ * authed state machine, and the ownership bookkeeping the sidebar list is
+ * built from. Anonymous/failed identity never blocks a deployment with
+ * accounts disabled — the caller simply does not mount this controller.
+ */
+export declare class QaAccountsController {
+    private readonly options;
+    private readonly listeners;
+    private snapshot;
+    private tokenValue;
+    private disposed;
+    constructor(options: QaAccountsControllerOptions);
+    getSnapshot: () => QaAccountsSnapshot;
+    subscribe: (listener: () => void) => (() => void);
+    dispose(): void;
+    /** The bearer token threaded into gated remotes; null while anonymous. */
+    /** The bearer token threaded into gated remotes; null while anonymous. */
+    token(): string | null;
+    /** Server-owned chat ids (empty until authed); falls back to nothing. */
+    ownedIds(): readonly string[];
+    /** Boot probe: restore the stored token and ask the Host who it is. */
+    start(): Promise<void>;
+    login(email: string, password: string): Promise<void>;
+    register(email: string, password: string): Promise<void>;
+    setMode(mode: "login" | "register"): void;
+    /** 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. */
+    claimNewSession(sessionId: string): Promise<void>;
+    private authenticate;
+    /** Own the account, migrate the legacy index, then project authed. */
+    private enterSession;
+    /** Refresh the owned list after index changes; cheap enough to re-pull. */
+    refreshOwned(): Promise<void>;
+    /** The admin cross-user ownership view; failures degrade to an empty map. */
+    private fetchOwnership;
+    /** Session id → owner display name; empty unless an admin is signed in. */
+    ownerNames(): ReadonlyMap<string, string>;
+    /**
+     * The chat owner's display name for author labels: admins see it on
+     * foreign chats only; the owner themself and ordinary accounts see none.
+     */
+    messageAuthorOf(sessionId: string): string | undefined;
+    private readStoredToken;
+    private saveStoredToken;
+    private clearStoredToken;
+    private tokenKey;
+    private publish;
+}
+//# sourceMappingURL=QaAccountsController.d.ts.map

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

@@ -1,21 +1,53 @@
-import type { SettingsScope } from "@deepseek-ai/dsh-client-runtime/client";
+import type { SettingsScope } from "@deepseek-ai/dsh-client-ui-settings/client";
 import type { QaSurfaceConfig, ResolvedQaSurfaceConfig } from "../types.js";
 export interface QaConfigSnapshot {
     readonly status: "loading" | "ready" | "unavailable" | "error";
     readonly config: ResolvedQaSurfaceConfig;
     readonly error: string | null;
 }
-/** Browser projection of the Host-owned qa-surface settings namespace. */
+/** Reads the effective Host configuration when the settings namespace cannot. */
+export type QaConfigFallback = () => Promise<ResolvedQaSurfaceConfig>;
+/**
+ * Browser projection of the Host-owned qa-surface settings namespace.
+ *
+ * The DSH gateway pins settings RPCs to loopback, so a browser served over the
+ * LAN always sees the namespace as `unavailable`. When the caller supplies the
+ * `qaSurface/describe` Remote as a fallback, that channel answers instead: the
+ * projection waits in `loading` until it settles, then reports the Host-owned
+ * configuration as `ready`. A rejected fallback returns the projection to
+ * `unavailable`, exactly as when no fallback exists.
+ */
 export declare class QaConfigController {
     private readonly scope;
     private readonly listeners;
     private snapshot;
     private readonly unsubscribe;
-    constructor(scope: SettingsScope<QaSurfaceConfig>);
+    private readonly fallback;
+    private fallbackState;
+    private fallbackConfig;
+    private disposed;
+    constructor(scope: SettingsScope<QaSurfaceConfig>, fallback?: QaConfigFallback);
     getSnapshot: () => QaConfigSnapshot;
     subscribe: (listener: () => void) => (() => void);
     dispose(): void;
     private project;
     private refresh;
+    /**
+     * Re-read the Host configuration after a Host reconnect. Without this, an
+     * open page keeps the configuration it fetched at load time: after the Host
+     * restarts with a changed deployment config, the next attestation compares
+     * its proof against the stale client copy and refuses. While re-reading,
+     * the previous answer stays projected — no loading flicker; the snapshot
+     * updates only when the answer actually changed.
+     */
+    refreshFallback(): void;
+    /**
+     * The fallback trigger rides every refresh: the scope flips to
+     * `unavailable` whenever the browser is served over the LAN, which a
+     * constructor-time check can miss. The state guard makes repeats a no-op,
+     * so one fetch runs per controller lifetime; the recursive refresh lets the
+     * pending state surface before the first notification pass.
+     */
+    private requestFallbackIfNeeded;
 }
 //# sourceMappingURL=QaConfigController.d.ts.map

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

@@ -1,59 +1,185 @@
-import type { HostDescriptionSource, IApiClient } from "@deepseek-ai/dsh-client-connection/client";
-import type { ISessions, SessionListState } from "@deepseek-ai/dsh-client-runtime/client";
-import type { QaSessionState, ResolvedQaSurfaceConfig } from "../types.js";
-type QaSessionsApi = Pick<IApiClient["sessions"], "create" | "selectModel">;
-export interface StorageLike {
-    getItem(key: string): string | null;
-    setItem(key: string, value: string): void;
-    removeItem(key: string): void;
+import type { ConnectionGenerationState } from "@deepseek-ai/dsh-client-connection/client";
+import type { QaImageDraft, QaSessionState, ResolvedQaSurfaceConfig } from "../types.js";
+import type { QaConversation, QaSecureSession, QaSessions, QaSessionsApi, QaSourceApi, StorageLike } from "./types.js";
+export interface QaAccountsFacade {
+    /** The account bearer token, or null while anonymous. */
+    readonly token: () => string | null;
+    /** Server-owned chat ids; the list authority while accounts are on. */
+    readonly ownedIds: () => readonly string[];
+    /**
+     * The chat owner's display name for author labels; admins see it on
+     * foreign chats only, everyone else gets undefined.
+     */
+    readonly messageAuthorOf: (sessionId: string) => string | undefined;
+    /** Called after a new chat binds, so ownership stays current. */
+    readonly onSessionCreated: (sessionId: string) => void;
+    /** Called when the Host refuses with auth-required (expired/rotated). */
+    readonly onAuthRequired: () => void;
 }
 export interface QaSessionControllerOptions {
-    readonly sessions: ISessions;
+    readonly sessions: QaSessions;
     readonly api: QaSessionsApi;
-    readonly connection: HostDescriptionSource;
+    /** Conversation assembly feeding the transcript projection. */
+    readonly conversation: QaConversation;
+    readonly connection: ConnectionGenerationState;
     readonly config: ResolvedQaSurfaceConfig;
+    readonly secureSession: QaSecureSession;
+    readonly sourceApi?: QaSourceApi;
     readonly storage?: StorageLike;
+    /** Present while the deployment gates QA users with accounts. */
+    readonly accounts?: QaAccountsFacade;
     readonly timeoutMs?: number;
+    /**
+     * Minimum spacing between projections of a running turn's stream frames.
+     * The host runtime already batches deltas to one notification per
+     * animation frame; this ceiling keeps the render path flat on long
+     * transcripts and weak hardware. Zero disables the spacing.
+     */
+    readonly streamIntervalMs?: number;
 }
-/** The only module that couples QA behavior to DSH Session/client APIs. */
+/**
+ * The only module that couples QA behavior to DSH Session/client APIs. It owns
+ * the chat lifecycle state machine; the observable wait, browser-local chat
+ * bookkeeping and policy-attestation details live in their own modules.
+ */
 export declare class QaSessionController {
     private readonly listeners;
     private readonly sessions;
     private readonly api;
+    private readonly conversation;
     private readonly connection;
     private readonly config;
-    private readonly storage;
+    private readonly secureSessionRemote;
+    private readonly sourceApi;
+    private readonly chats;
+    private readonly accounts;
+    /** Per-chat attachment URL cache; blob URLs die with the chat binding. */
+    private readonly assets;
     private readonly timeoutMs;
+    private readonly streamIntervalMs;
     private state;
     private session;
+    private conversationBinding;
     private unsubscribeSession;
+    private unsubscribeChat;
     private readonly unsubscribeConnection;
     private ensuring;
+    private materializing;
     private operationError;
     private admissionPending;
+    private policyReady;
+    private drafting;
+    private streamFlushTimer;
+    /** The chat session to return to when a subagent view closes. */
+    private chatSessionId;
+    private viewingSubagent;
     private connectedOnce;
     private disposed;
     private generation;
+    private chatsRevision;
+    /** Host-side provenance of the bound chat, merged into the projection. */
+    private readonly hostSources;
     constructor(options: QaSessionControllerOptions);
     getSnapshot: () => QaSessionState;
     subscribe: (listener: () => void) => (() => void);
     ensureSession(): Promise<void>;
-    send(text: string): Promise<boolean>;
+    send(text: string, images?: readonly QaImageDraft[]): Promise<boolean>;
+    /**
+     * Ask for a fresh variant of the previous answer. The session has no
+     * truncation seam, so this sends the hidden regeneration instruction as an
+     * ordinary prompt: the model produces a follow-up turn, the projection
+     * hides the marker message, and the consecutive turns read as variants of
+     * the original question (switched in the surface).
+     */
+    regenerate(): Promise<boolean>;
     stop(): Promise<void>;
-    reset(): Promise<void>;
+    /**
+     * Enter the "new chat" draft: show an empty composer without creating any
+     * session. Nothing appears in the chat list and no Host session is spent
+     * until the first prompt is actually sent, which materializes the session
+     * lazily ({@link materializeDraft}). Fixed-policy deployments cannot draft.
+     */
+    startDraft(): Promise<void>;
+    /**
+     * Turn the current draft into a real attested session. Runs inside the
+     * send flow; concurrent sends share one materialization. A refusal here is
+     * reported at once — a fresh session's first attestation is the
+     * deployment's only chance to learn the reason.
+     */
+    private materializeDraft;
+    /**
+     * Open one of this browser's indexed chats. The id must be present in the
+     * host session list and pass policy attestation; an unknown id is forgotten
+     * from the index. Fixed-policy deployments cannot switch.
+     */
+    switchTo(sessionId: string): Promise<void>;
+    /**
+     * Watch a subagent's transcript live. The binding is read-only by
+     * construction: no attestation runs (attestation admits sending, and the
+     * composer stays disabled here), the chat index is untouched, and
+     * {@link closeSubagent} returns to the chat the panel was opened from.
+     */
+    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. */
+    chatIds(): readonly string[];
+    /** The bound session id, or null while no chat is bound. */
+    activeSessionId(): string | null;
+    /**
+     * Resolve one durable image attachment of the bound session into a
+     * browser-usable URL. Resolutions are cached per chat in the asset
+     * repository (attachment ids repeat across chats) and revoked when the chat
+     * is unbound; failures surface as broken views and retry on demand.
+     */
+    readImage(attachmentId: string): Promise<string>;
+    private readAttachmentUrl;
+    /**
+     * Remove one chat from this browser's index. Deleting the chat that is
+     * currently open also forgets the persisted id and starts a fresh attested
+     * session (when the deployment allows session resets); the Host-side
+     * session itself is not touched — no host deletion seam exists.
+     */
+    deleteChat(id: string): Promise<void>;
+    /** Drop one chat id from this browser's index. */
+    forgetChat(sessionId: string): void;
     dispose(): void;
     private ensureSessionNow;
-    private createSession;
+    /**
+     * Recovery ladder after a refused send-time attestation. The prompt was
+     * never admitted, so nothing here can duplicate it. Step 1 re-opens the
+     * session: a Host that idled the agent out dismantles its tool view, and
+     * re-opening re-materializes it. Step 2 — when that refused session is
+     * still blank (it never received the prompt, so there is nothing to lose) —
+     * starts a fresh attested session instead. A session with history is left
+     * alone: recreating it would silently drop the conversation. Returns the
+     * attested session id, or null when nothing was attested.
+     */
+    private recoverForSend;
     private bind;
     private unbind;
     private waitForConnection;
+    /**
+     * Project one session notification. A running turn's frames arrive at
+     * animation-frame cadence, so re-projections are spaced at least
+     * {@link streamIntervalMs} apart: the first frame of a window projects at
+     * once and further frames are absorbed (the memoized render path replays
+     * nothing, so absorbing a frame only defers it). Everything outside a
+     * running turn - phase flips, errors, turn completion - projects
+     * immediately.
+     */
+    private publishSessionUpdate;
+    private clearStreamFlush;
     private publish;
     private fail;
-    private storageKey;
-    private readPersisted;
-    private persist;
-    private clearPersisted;
+    /**
+     * Attest the currently bound session. `ok` carries the session id the proof
+     * was issued for; `stale` means the binding changed while the request was
+     * in flight, so nothing was written — the newer binding manages its own
+     * attestation; `refused` is a genuine admission refusal of this binding.
+     */
+    private attestPolicy;
     private emit;
 }
-export type { SessionListState };
 //# sourceMappingURL=QaSessionController.d.ts.map

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

@@ -1,14 +1,20 @@
-import type { HostDescriptionSource, IApiClient } from "@deepseek-ai/dsh-client-connection/client";
-import type { ISessions } from "@deepseek-ai/dsh-client-runtime/client";
+import type { ConnectionGenerationState } from "@deepseek-ai/dsh-client-connection/client";
 import type { InjectFace, PropsRuntime } from "@deepseek-ai/dsh-client-ui-slots";
 import type { QaConfigController } from "./QaConfigController.js";
 import type { QaRouteController } from "./QaRouteController.js";
+import type { QaAccountsController } from "./QaAccountsController.js";
+import type { QaConversation, QaSecureSession, QaSessions, QaSessionsApi, QaSourceApi } from "./types.js";
 export interface QaSurfaceFace {
     readonly route: QaRouteController;
     readonly config: QaConfigController;
-    readonly sessions: ISessions;
-    readonly api: Pick<IApiClient["sessions"], "create" | "selectModel">;
-    readonly connection: HostDescriptionSource;
+    readonly sessions: QaSessions;
+    readonly conversation: QaConversation;
+    readonly api: QaSessionsApi;
+    readonly connection: ConnectionGenerationState;
+    readonly secureSession: QaSecureSession;
+    readonly sourceApi: QaSourceApi;
+    /** Present when the deployment mounts the QA account gate. */
+    readonly accounts?: QaAccountsController;
 }
 type QaSurfaceProps = PropsRuntime<"shell.overlay"> & InjectFace<QaSurfaceFace>;
 export declare function QaSurface(props: QaSurfaceProps): import("react/jsx-runtime").JSX.Element | null;

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

@@ -1,7 +1,17 @@
-import type { ConversationSnapshot } from "@deepseek-ai/dsh-client-runtime/client";
+import type { ConversationSnapshot } from "@deepseek-ai/dsh-client-ui-conversation/client";
 import type { QaMessage } from "../types.js";
-/** Project only end-user-safe text from the public DSH conversation snapshot. */
-export declare function projectTranscript(snapshot: ConversationSnapshot, options?: {
+/**
+ * The hidden regeneration prompt. Regenerate sends this as an ordinary
+ * prompt — the session has no truncation seam, so a "variant" is a real
+ * follow-up turn — and the projection drops it from the visible transcript,
+ * leaving the consecutive answer turns to read as variants of one question.
+ */
+export declare const QA_REGENERATE_MARKER = "\u041F\u0435\u0440\u0435\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u0443\u0439 \u0441\u0432\u043E\u0439 \u043F\u0440\u0435\u0434\u044B\u0434\u0443\u0449\u0438\u0439 \u043E\u0442\u0432\u0435\u0442 \u2014 \u0434\u0430\u0439 \u043D\u043E\u0432\u044B\u0439 \u0432\u0430\u0440\u0438\u0430\u043D\u0442, \u043D\u0435 \u043F\u043E\u0432\u0442\u043E\u0440\u044F\u044F \u043F\u0440\u0435\u0434\u044B\u0434\u0443\u0449\u0438\u0439.";
+/** Project end-user messages plus optional operator-approved work detail. */
+export declare function projectTranscript(snapshot: ConversationSnapshot | undefined, options?: {
+    /** Live turn lifecycle from the bound Session (drives running-row status). */
+    readonly running?: boolean;
     readonly showToolActivity?: boolean;
+    readonly showReasoning?: boolean;
 }): readonly QaMessage[];
 //# sourceMappingURL=QaTranscriptAdapter.d.ts.map

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

@@ -0,0 +1,25 @@
+import type { QaLockdownProof, ResolvedQaSurfaceConfig } from "../types.js";
+/**
+ * Browser-side reading of Host policy attestation: one error type the session
+ * lifecycle branches on, plus pure diagnostics for the console. The specific
+ * mismatch facts stay in the Host logs; a refusal only reveals the coarse
+ * reason class and an operator hint.
+ */
+export declare class QaPolicyAttestationError extends Error {
+    constructor();
+}
+/**
+ * Extract the coarse attestation reason code from a Host wire failure, if the
+ * failure carries the marker.
+ */
+export declare function attestationReasonOf(failure: {
+    readonly message?: string;
+} | undefined | null): string | null;
+export declare function attestationHint(reason: string | null): string;
+/**
+ * Whether a Host proof answers the deployment lockdown config this browser
+ * holds. Every field must match; the allow-list is compared as exact JSON so
+ * order differences refuse too, mirroring the Host's pinned list.
+ */
+export declare function proofMatchesConfig(proof: QaLockdownProof, lockdown: ResolvedQaSurfaceConfig["lockdown"], sessionId: string): boolean;
+//# sourceMappingURL=attestation.d.ts.map

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

@@ -0,0 +1,28 @@
+import type { StorageLike } from "./types.js";
+/**
+ * Browser-local chat bookkeeping: a most-recently-used index of chat ids for
+ * the sidebar plus the id of the chat this browser reopens on load. Both live
+ * under the deployment's storage key and route path, and every access
+ * tolerates a denied or broken store — persistence must never prevent a real
+ * DSH session.
+ */
+export declare class QaChatIndex {
+    private readonly storage;
+    private readonly sessionKey;
+    private readonly chatKey;
+    constructor(storage: StorageLike | undefined, prefix: string);
+    /** This browser's indexed chat ids, most recently used first. */
+    chatIds(): readonly string[];
+    /**
+     * Add one chat to the index without reordering anything. Display order is
+     * the host's `updatedAt`, so merely opening a chat must not move it — the
+     * index is membership only.
+     */
+    addChat(sessionId: string): void;
+    forgetChat(sessionId: string): void;
+    /** The persisted chat id this browser reopens on load, or null. */
+    activeId(): string | null;
+    saveActive(sessionId: string): void;
+    clearActive(): void;
+}
+//# sourceMappingURL=chat-index.d.ts.map

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

@@ -1,5 +1,19 @@
-/** Deliberately small, HTML-free Markdown renderer for assistant-visible text. */
-export declare function Markdown({ text }: {
+import type { QaSource } from "../../types.js";
+import { type QaSourceRefs } from "./source-refs.js";
+/** Inline source awareness handed down from the owning assistant message. */
+export interface MarkdownSourceContext {
+    readonly refs?: QaSourceRefs;
+    /** Open a path-backed source in the sources drawer's detail view. */
+    readonly onSourceOpen?: (source: QaSource) => void;
+}
+/**
+ * Deliberately small, HTML-free Markdown renderer for assistant-visible text.
+ * Memoized on the text value: stream updates re-render only the message whose
+ * text actually changed, so committed history is never re-parsed.
+ */
+export declare const Markdown: import("react").MemoExoticComponent<({ text, sourceRefs, onSourceOpen, }: {
     readonly text: string;
-}): import("react/jsx-runtime").JSX.Element;
+    readonly sourceRefs?: QaSourceRefs;
+    readonly onSourceOpen?: (source: QaSource) => void;
+}) => import("react/jsx-runtime").JSX.Element>;
 //# sourceMappingURL=Markdown.d.ts.map