@yadsh/dsh-qa-surface 0.9.0 → 0.11.0

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

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

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

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

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

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

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

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

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

@@ -17,6 +17,8 @@ export declare function useAdminResource<T>(load: () => Promise<RemoteResult<T>>
     readonly error: string | undefined;
     readonly loading: boolean;
     reload: () => Promise<void>;
+    /** Adopt a value this page already holds, without re-asking the Host. */
+    apply: (value: T) => void;
 };
 /** A status chip; the modifier class carries the semantic colour. */
 export declare function Badge(props: {

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

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

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

@@ -1,5 +1,5 @@
 /**
- * Browser-side binary-to-base64. Chunked so `String.fromCharCode` never
+ * Browser-side base64. Encoding is chunked so `String.fromCharCode` never
  * crosses the engine's argument limit on large attachments.
  */
 /**
@@ -7,4 +7,16 @@
  * @returns the canonical base64 text (no `data:` prefix, no padding tricks).
  */
 export declare function bytesToBase64(bytes: Uint8Array): string;
+/**
+ * Decode base64 the Host sent for a file the panel could not read as text.
+ *
+ * A malformed body is tolerated rather than thrown on: the caller is about to
+ * hand the bytes to a download or an image tag, and a partial file is a better
+ * outcome than losing the panel to an exception. `atob` still rejects input
+ * that is not base64 at all; the caller keeps that refusal.
+ *
+ * @param value - base64 text, with or without a data-URL prefix.
+ * @returns the decoded bytes.
+ */
+export declare function base64ToBytes(value: string): Uint8Array;
 //# sourceMappingURL=base64.d.ts.map

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

@@ -5,7 +5,8 @@ export interface QaSubagentRow {
     readonly title: string;
     readonly running: boolean;
     readonly completed: boolean;
-    readonly meta: string;
+    /** Muted facts rendered after the title, one span per part. */
+    readonly meta: readonly string[];
 }
 /**
  * Direct subagent children of the open chat, running first. Reads the host

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

@@ -1,15 +1,27 @@
 import type { QaChatFileGroup } from "../chat-files.js";
+import type { QaBoundSourceApi } from "../types.js";
 export interface QaFilesPanelProps {
     readonly groups: readonly QaChatFileGroup[];
     /** Resolve an image attachment to an object URL; images render inert without it. */
     readonly resolveImage?: (attachmentId: string) => Promise<string>;
     /** Scroll the transcript to the group's user message. */
     readonly onJumpToMessage: (messageId: string) => void;
+    /**
+     * The chat whose workspace the panel browses. Both this and `api` are absent
+     * in hosts that only render the attachment roster, where the workspace
+     * section is left out rather than shown as a refusal.
+     */
+    readonly sessionId?: string;
+    readonly api?: QaBoundSourceApi;
 }
 /**
- * The chat's attachment roster: one section per sending message, newest
- * first. Rows mirror the transcript's handles — the browser never reads a
- * file back, and the images are the same object URLs the message showed.
+ * The chat's attachment roster plus, when the Host is reachable, the chat's
+ * own workspace: one section per sending message, newest first, and above it
+ * the file browser the conversation worked in.
+ *
+ * Rows mirror the transcript's handles — the browser never reads an attachment
+ * back, and the images are the same object URLs the message showed — while the
+ * workspace section reads through the Host's fenced listing and file reads.
  */
-export declare function QaFilesPanel({ groups, resolveImage, onJumpToMessage, }: QaFilesPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function QaFilesPanel({ groups, resolveImage, onJumpToMessage, sessionId, api, }: QaFilesPanelProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=QaFilesPanel.d.ts.map

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

@@ -17,10 +17,9 @@ export interface QaHeaderProps {
     readonly logoUrl: string | null;
     /** The derived conversation title; null hides the heading. */
     readonly title: string | null;
-    /** A subagent view replaces the mode caption with its return control. */
+    /** A subagent view shows its return control in the title row. */
     readonly viewingSubagent: boolean;
     readonly onCloseSubagent: () => void;
-    readonly agentPreset: string | null;
     readonly roleSelector?: ReactNode;
     readonly administration?: {
         readonly onOpen: () => void;
@@ -36,6 +35,13 @@ export interface QaHeaderProps {
     readonly sourcesOpen: boolean;
     readonly onOpenSources: () => void;
     readonly fileCount: number;
+    /**
+     * Whether the files tab has anything to open: attachments, or the chat's own
+     * workspace when the deployment lets the panel read files. The count stays
+     * the attachment number, so an empty chat with a readable workspace shows no
+     * badge but still opens.
+     */
+    readonly filesEnabled: boolean;
     readonly filesOpen: boolean;
     readonly onOpenFiles: () => void;
     /**
@@ -53,5 +59,5 @@ export interface QaHeaderProps {
     readonly resetDisabled: boolean;
     readonly onReset: () => void;
 }
-export declare function QaHeader({ logoUrl, title, viewingSubagent, onCloseSubagent, agentPreset, roleSelector, administration, agentCount, agentsOpen, onToggleAgents, sourcesVisible, sourcesCount, sourcesComplete, sourcesOpen, onOpenSources, fileCount, filesOpen, onOpenFiles, settings, panelLauncher, showReset, resetDisabled, onReset, }: QaHeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare function QaHeader({ logoUrl, title, viewingSubagent, onCloseSubagent, roleSelector, administration, agentCount, agentsOpen, onToggleAgents, sourcesVisible, sourcesCount, sourcesComplete, sourcesOpen, onOpenSources, fileCount, filesEnabled, filesOpen, onOpenFiles, settings, panelLauncher, showReset, resetDisabled, onReset, }: QaHeaderProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=QaHeader.d.ts.map

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

@@ -11,11 +11,12 @@ export interface QaModalProps {
     readonly footer?: ReactNode;
     readonly wide?: boolean;
     /**
-     * Panel size: `wide` fits prose that must not wrap mid-sentence, and
+     * Panel size: `wide` fits prose that must not wrap mid-sentence,
      * `settings` the sectioned user-settings dialog, which needs both a
-     * comfortable height and a two-column body.
+     * comfortable height and a two-column body, and `document` a file
+     * preview the reader expanded out of the rail.
      */
-    readonly size?: "default" | "wide" | "settings";
+    readonly size?: "default" | "wide" | "settings" | "document";
 }
 /**
  * The shared QA dialog shell: backdrop, panel, head with the close control,

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

@@ -19,8 +19,12 @@ export declare const QA_HANDLE_FREE_BAND = 40;
  * at every width; the stylesheet caps it once more by the live side gutter.
  */
 export declare const QA_BLEED_MAX_WIDTH: number;
-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;
+/**
+ * A stored positive width, or null when the browser has none (first visit,
+ * denied storage, corrupt value). Shared by every draggable width.
+ */
+export declare function readQaStoredWidth(storage: Pick<Storage, "getItem">, key: string): number | null;
+export declare function writeQaStoredWidth(storage: Pick<Storage, "setItem">, key: string, width: number): void;
 /**
  * Resolve the centered content width for the currently available column. The
  * operator sets only the floor; the column is the ceiling, so the content may
@@ -52,5 +56,47 @@ export declare function useQaContentWidth({ active, root, storage, storageKey, m
     readonly onEnd: () => void;
 };
 export type UseQaContentWidthResult = ReturnType<typeof useQaContentWidth>;
+/** Drag clamp for the chat-list sidebar, borrowed from the DSH frame. */
+export declare const QA_SIDEBAR_MIN_WIDTH = 264;
+export declare const QA_SIDEBAR_MAX_WIDTH = 420;
+/** The width the sidebar keeps until its first drag: today's fixed width. */
+export declare const QA_SIDEBAR_DEFAULT_WIDTH = 264;
+/** Integer pixels, no snapping and no step, like the DSH frame clamp. */
+export declare function clampQaSidebarWidth(px: number): number;
+/** Resolve the sidebar width for this browser: the stored drag or the default. */
+export declare function resolveQaSidebarWidth(stored: number | null): number;
+interface QaSidebarHandleProps {
+    readonly onStart: () => number;
+    readonly onDrag: (width: number) => void;
+    readonly onCommit: (width: number) => void;
+    readonly onEnd: () => void;
+}
+/**
+ * The invisible strip on the sidebar's border, like the DSH frame's handle: an
+ * 8px hit target straddling the edge, found by the cursor alone. One-sided —
+ * the pointer delta is the width delta — and pointer-captured, so the drag
+ * keeps tracking outside the strip and never selects text.
+ */
+export declare function QaSidebarHandle(props: QaSidebarHandleProps): import("react/jsx-runtime").JSX.Element;
+interface UseQaSidebarWidthOptions {
+    /** Whether the expanded sidebar is mounted (the collapsed rail has none). */
+    readonly active: boolean;
+    readonly root: RefObject<HTMLElement | null>;
+    readonly storage: Pick<Storage, "getItem" | "setItem">;
+    readonly storageKey: string;
+}
+/**
+ * Sidebar counterpart of `useQaContentWidth`: the width never enters React
+ * state — the drag writes the custom property straight onto the nav element,
+ * so the memoized sidebar does not re-render per frame — and only the
+ * committed value reaches storage, which the next mount restores.
+ */
+export declare function useQaSidebarWidth({ active, root, storage, storageKey, }: UseQaSidebarWidthOptions): {
+    readonly onStart: () => number;
+    readonly onDrag: (width: number) => void;
+    readonly onCommit: (width: number) => void;
+    readonly onEnd: () => void;
+};
+export type UseQaSidebarWidthResult = ReturnType<typeof useQaSidebarWidth>;
 export {};
 //# sourceMappingURL=QaWidthHandle.d.ts.map

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

@@ -0,0 +1,15 @@
+import type { QaBoundSourceApi } from "../types.js";
+export interface QaWorkspaceBrowserProps {
+    readonly sessionId: string;
+    readonly api: QaBoundSourceApi;
+}
+/**
+ * The chat's own workspace, browsable from the files rail.
+ *
+ * One directory at a time: the Host lists a directory, the panel descends into
+ * its children and never travels by path, so a link in a listing cannot walk
+ * the visitor out of the chat's tree. Opening a file reads exactly that file —
+ * text inline, anything else as a downloadable handle.
+ */
+export declare function QaWorkspaceBrowser({ sessionId, api, }: QaWorkspaceBrowserProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=QaWorkspaceBrowser.d.ts.map

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

@@ -6,7 +6,7 @@ declare module "@deepseek-ai/cordis" {
     }
 }
 export declare const inject: string[];
-/** Register the route-aware, full-frame QA entry in the additive overlay slot. */
+/** Register the route-aware, full-frame QA entry: root owner in the kiosk, additive overlay slot otherwise. */
 export declare function apply(ctx: Context): Promise<() => Promise<void>>;
 export { QaConfigController } from "./QaConfigController.js";
 export { QaAccountsController } from "./QaAccountsController.js";

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

@@ -0,0 +1,34 @@
+/**
+ * The QA kiosk presentation mode, as the client half of the plugin sees it.
+ *
+ * The harness publishes the deployment's UI mode into every served document
+ * ahead of the first application script (the index prelude injected for
+ * `DSH_UI_MODE=qa`): `window.DSH_UI_MODE` and, alongside it, the QA base path
+ * the server-side route policy serves the application under. The mode — not
+ * `location.pathname` — is what the client branches on: the route policy owns
+ * which paths carry a document at all, and a client that keyed off the
+ * pathname would re-introduce exactly the paths the policy closed.
+ *
+ * A document without the globals (a host without the kiosk patches, a plugin
+ * bundle served into an overlay deployment) reads as the overlay
+ * presentation: the `shell.overlay` registration this plugin has always
+ * used. That keeps one plugin build compatible with both compositions.
+ */
+/**
+ * Whether one URL pathname lives on a surface: the surface path itself or any
+ * child of it. A plain prefix check would also match `/qadmin` or `/qa-test`.
+ */
+export declare function matchesSurface(pathname: string, surface: string): boolean;
+/**
+ * Whether this browser was served by a QA kiosk deployment.
+ * @param target - the global object; overridable for tests.
+ */
+export declare function qaKioskMode(target?: Readonly<Record<string, unknown>>): boolean;
+/**
+ * The QA surface's base path of a kiosk deployment, normalized: single
+ * leading slash, no trailing slash. A malformed value falls back to the
+ * default rather than disabling the mode.
+ * @param target - the global object; overridable for tests.
+ */
+export declare function qaKioskBasePath(target?: Readonly<Record<string, unknown>>): string;
+//# sourceMappingURL=kiosk.d.ts.map

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

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

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

@@ -9,6 +9,13 @@
  * blocks, setext inside lists, link reference definitions spanning lines) stay
  * out. Raw HTML never becomes a block: a tag line is a paragraph whose inline
  * pass leaves the tag as literal text.
+ *
+ * Math follows the Host transcript's settled grammar: display TeX is a
+ * `$$`-delimited block (a fence on its own lines or one line
+ * `$$…$$`) or a ```math fence, and nothing else — the `\(…\)` and `\[…\]`
+ * delimiters stay literal text, exactly as the Host renders them. Footnote
+ * definitions (`[^id]: …`) are collected the way GitHub's dialect does, with
+ * lazy and indented continuation lines.
  */
 /** `#`-through-`######` heading levels. */
 export type HeadingDepth = 1 | 2 | 3 | 4 | 5 | 6;
@@ -46,6 +53,9 @@ export type MarkdownBlock = {
     readonly align: readonly TableAlign[];
     readonly head: readonly string[];
     readonly rows: readonly (readonly string[])[];
+} | {
+    readonly kind: "math";
+    readonly text: string;
 } | {
     readonly kind: "rule";
 };
@@ -54,6 +64,8 @@ export interface ParsedMarkdown {
     readonly blocks: readonly MarkdownBlock[];
     /** Link/image definitions by upper-cased identifier. */
     readonly definitions: ReadonlyMap<string, string>;
+    /** Footnote bodies by upper-cased identifier; first definition wins. */
+    readonly footnotes: ReadonlyMap<string, readonly MarkdownBlock[]>;
 }
 /** Split one table row into trimmed cells, honoring escaped pipes. */
 export declare function splitTableRow(line: string): string[];
@@ -67,8 +79,9 @@ export declare function parseMarkdown(text: string): ParsedMarkdown;
  * Parse the blocks of one container (document, quote, or list item).
  * @param lines - Container lines, already de-indented by the caller.
  * @param definitions - Document-wide definition accumulator.
+ * @param footnotes - Document-wide footnote accumulator.
  * @param depth - Container nesting depth.
  * @returns The container's blocks.
  */
-export declare function parseBlocks(lines: readonly string[], definitions: Map<string, string>, depth: number): MarkdownBlock[];
+export declare function parseBlocks(lines: readonly string[], definitions: Map<string, string>, footnotes: Map<string, readonly MarkdownBlock[]>, depth: number): MarkdownBlock[];
 //# sourceMappingURL=blocks.d.ts.map

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

@@ -1,10 +1,13 @@
 /**
  * GFM inline grammar for the chat renderer: code spans, emphasis, links,
- * images, autolinks, and the two line-break flavors. Emphasis follows the
- * CommonMark intent (a closer must match its opener's delimiter run, `_` never
- * opens inside a word) rather than the full delimiter-stack algorithm — the
- * shapes this grammar cannot express are the pathological ones, and they
- * degrade to literal text instead of mangling the sentence.
+ * images, autolinks, TeX math, footnotes, and the two line-break flavors.
+ * Emphasis follows the CommonMark intent (a closer must match its opener's
+ * delimiter run, `_` never opens inside a word) rather than the full
+ * delimiter-stack algorithm — the shapes this grammar cannot express are the
+ * pathological ones, and they degrade to literal text instead of mangling the
+ * sentence. Math follows the Host transcript: `$…$` and `$$…$$` spans, with
+ * maximal-munch dollar runs and whitespace padding stripped only when both
+ * ends carry it.
  */
 /** One inline node; `children` nodes nest. */
 export type MarkdownInline = {
@@ -28,13 +31,26 @@ export type MarkdownInline = {
     readonly kind: "image";
     readonly src: string;
     readonly alt: string;
+} | {
+    readonly kind: "inlineMath";
+    readonly value: string;
+} | {
+    readonly kind: "footnoteRef";
+    readonly id: string;
 };
+/** The reference targets one inline pass resolves against. */
+export interface InlineTargets {
+    /** Link/image definitions by upper-cased identifier. */
+    readonly definitions: ReadonlyMap<string, string>;
+    /** Footnote identifiers that have a definition, by upper-cased label. */
+    readonly footnotes: ReadonlyMap<string, unknown>;
+}
 /**
  * Parse the inline content of one leaf block.
  * @param text - Raw inline Markdown, newlines included.
- * @param definitions - Link/image definitions collected by the block pass.
+ * @param targets - The definitions and footnotes this pass resolves against.
  * @param depth - Inline nesting depth.
  * @returns The inline nodes in document order.
  */
-export declare function parseInline(text: string, definitions: ReadonlyMap<string, string>, depth?: number): MarkdownInline[];
+export declare function parseInline(text: string, targets: ReadonlyMap<string, string> | InlineTargets, depth?: number): MarkdownInline[];
 //# sourceMappingURL=inline.d.ts.map

package/lib/types/client/markdown/katex-css.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `katex/dist/katex.min.css` with every font inlined as a woff2 data URI.
+ * Generated by `scripts/generate-katex-css.mjs` from the pinned `katex`
+ * devDependency — do not edit by hand; regenerate after a `katex` upgrade.
+ *
+ * The QA overlay is a self-contained client bundle, so the math styles and
+ * their fonts travel inside it: nothing here may reference an external file,
+ * and a data URI cannot collide with the Host's own KaTeX font declarations.
+ */
+export declare const KATEX_CSS: string;
+//# sourceMappingURL=katex-css.d.ts.map

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

@@ -0,0 +1,23 @@
+/**
+ * TeX-to-React via KaTeX, mirroring the Host transcript's math pipeline: the
+ * same two-arm error chain (strict render, `strict: 'ignore'` retry, error
+ * span) so a formula renders identically here and in DSH's own message. KaTeX
+ * emits an HTML string; the browser's HTML parser turns it into a tree this
+ * module maps onto React elements — the output is a static span/MathML/SVG
+ * vocabulary with no raw author HTML, the same trust the fenced-code
+ * highlighter's tree gets.
+ *
+ * React has no MathML support, so the `.katex-mathml` subtree's elements land
+ * in the HTML namespace; the visual arm is the `.katex-html` span tree and
+ * the MathML arm serves assistive technology, which reads it by tag name.
+ */
+import type { ReactNode } from "react";
+/**
+ * Render TeX source to React elements through KaTeX.
+ * @param value - The TeX source (a math node's raw content).
+ * @param displayMode - Display (block) versus inline rendering.
+ * @returns KaTeX's element tree, or the error span when the source does not
+ * parse even under `strict: 'ignore'`.
+ */
+export declare function renderTexToReact(value: string, displayMode: boolean): ReactNode;
+//# sourceMappingURL=math.d.ts.map