@yadsh/dsh-qa-surface 0.7.4 → 0.9.0

package/lib/types/admin/quality-store.d.ts

@@ -20,6 +20,8 @@ export interface QaManualQueueEntry {
     readonly createdAt: string;
 }
 export declare function defaultQualityFilePath(): string;
+/** The pre-SQLite quality file, imported once on first use. */
+export declare function defaultLegacyQualityFilePath(): string;
 /**
  * Atomic, externally reloadable store for the quality layer. Writes are
  * synchronous and persisted with a temp file plus rename, matching the accounts
@@ -33,9 +35,11 @@ export declare function defaultQualityFilePath(): string;
  */
 export declare class QaQualityStore {
     readonly filePath: string;
+    private readonly storage;
     private file;
-    private fileStamp;
+    private observedDataVersion;
     constructor(filePath?: string);
+    close(): void;
     /**
      * Record or replace one user's rating of one message. Re-rating the same
      * message overwrites in place rather than appending: a reviewer reads the
@@ -63,6 +67,24 @@ export declare class QaQualityStore {
     /** Drop a manual queue entry once a reviewer has answered it. */
     dequeueReview(conversationId: string, messageId?: string): boolean;
     manualQueue(): readonly QaManualQueueEntry[];
+    /**
+     * Drop every quality record of the named conversations.
+     *
+     * A record is keyed by the conversation it judges, and nothing else removes
+     * it: a chat deleted from the Harness would otherwise leave its ratings,
+     * reviews and queue entries behind, still counted by the metrics and still
+     * pointing at a conversation the console cannot open. The ownership sweep is
+     * the one place that learns a chat is gone, and it calls this with the ids
+     * it reclaimed.
+     *
+     * The audit trail is not touched: it records what administrators did, not
+     * what a conversation held, and a housekeeping drop is not an administrative
+     * act to answer for.
+     *
+     * @param conversationIds - the conversations to forget.
+     * @returns how many rows were removed.
+     */
+    dropConversations(conversationIds: readonly string[]): number;
     /** Append one administrative action to the audit trail. */
     appendAudit(input: {
         readonly actorId: string;
@@ -75,8 +97,22 @@ export declare class QaQualityStore {
     auditEvents(): readonly QaAdminAuditEvent[];
     /** Serialize one before/after value, refusing what no reader could use. */
     private snapshot;
+    /** Write one record, moving it to the end of its family's order. */
+    private upsertRow;
+    /** Append a record whose identity the store mints itself. */
+    private appendRow;
+    private deleteRow;
+    private applyCap;
+    private rowsOf;
+    private readDataVersion;
     private reload;
     private load;
-    private persist;
+    /**
+     * Import a pre-SQLite `qa-quality.json` exactly once, then rename it aside.
+     * A row the database already holds wins, so a leftover file cannot overwrite
+     * a verdict a person has since given.
+     */
+    private importLegacyFile;
+    private assertImportArrived;
 }
 //# sourceMappingURL=quality-store.d.ts.map

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

@@ -2,10 +2,10 @@ import type { PluginLogger } from "@yadsh/dsh-plugin-log";
 import type { QaAccounts } from "../accounts/store.js";
 import type { QaAccessService } from "../access/service.js";
 import type { QaRoleRepository } from "../access/role-repository.js";
-import type { QaAdminAuditEvent, QaAdminOverview, QaAdminPage, QaAdminUserDetail, QaAdminUserRow, QaAdminUserUpdate, QaAuditQuery, QaConversationDetail, QaConversationQuery, QaConversationReview, QaConversationReviewInput, QaConversationSummary, QaFeedbackQuery, QaFeedbackRow, QaMessageFeedback, QaMessageFeedbackInput, QaQualityMetrics, QaReviewQueueItem, QaReviewQueueRow, QaUserQuery } from "../types.js";
+import type { QaAdminAuditEvent, QaAdminOverview, QaAdminPage, QaAdminUserDetail, QaAdminUserRow, QaAdminUserUpdate, QaAuditQuery, QaConversationDetail, QaConversationDeletion, QaConversationQuery, QaConversationReview, QaConversationReviewInput, QaConversationSummary, QaFeedbackQuery, QaFeedbackRow, QaMessageFeedback, QaMessageFeedbackInput, QaQualityMetrics, QaReviewQueueItem, QaReviewQueueRow, QaUserQuery } from "../types.js";
 import type { QaQualityStore } from "./quality-store.js";
 import type { QaAdminRedactor } from "./redaction.js";
-import type { QaSessionLogReader } from "./session-log.js";
+import type { QaSessionLogReader, QaStoredSessionEraser } from "./session-log.js";
 /**
  * The administrative console's server side.
  *
@@ -31,6 +31,14 @@ export interface QaAdminServiceOptions {
     readonly roles: () => QaRoleRepository;
     readonly access: () => QaAccessService;
     readonly sessionLog: QaSessionLogReader;
+    /**
+     * Removal of stored session logs, the one thing the Harness does not offer.
+     * Without it the console refuses to delete a conversation rather than
+     * pretending it did.
+     */
+    readonly sessionFiles?: QaStoredSessionEraser;
+    /** Drops the sources a conversation collected, when the deployment keeps any. */
+    readonly dropSources?: (sessionId: string) => void;
     readonly logger: PluginLogger;
     readonly redactor?: QaAdminRedactor;
     readonly clock?: QaServiceClock;
@@ -52,6 +60,12 @@ export declare class QaAdminService {
      * enriched with the stored header when the deployment can list one. A chat
      * that exists but has no readable log still appears — the reviewer must see
      * that it happened.
+     *
+     * Reading the index first asks the access sweep to reclaim what the Harness
+     * no longer knows: a chat deleted outside the deployment would otherwise sit
+     * in this list, in the counters and in the metrics until some later chat
+     * creation happened to trigger housekeeping. The sweep is throttled, so this
+     * costs a listing per interval at most.
      */
     private index;
     /** One conversation's projected log, cached for the TTL unless asked fresh. */
@@ -76,6 +90,24 @@ export declare class QaAdminService {
     conversations(token: string, query: QaConversationQuery, cursor: string | undefined, limit: number | undefined): Promise<QaAdminPage<QaConversationSummary>>;
     private summaryOf;
     conversation(token: string, conversationId: string): Promise<QaConversationDetail>;
+    /**
+     * Delete one conversation from the deployment.
+     *
+     * The Harness has no deletion seam: persistence offers create, open, flush,
+     * stat and list, and a chat stops existing only when its stored log is gone.
+     * This is where the console's delete button gets its teeth — the stored logs
+     * of the conversation and of every session delegated from it are removed,
+     * and then everything the QA layer kept about it: the ownership record that
+     * is its authorization boundary, its ratings, reviews and queue entries, and
+     * the sources it collected. The act is audited, because it destroys what a
+     * person wrote, and that is not the same as hiding a row.
+     *
+     * Every refusal comes before anything is removed, so a chat is never
+     * half-deleted: a conversation the Harness still holds open would have its
+     * log written back by the next flush, and one the deployment stores somewhere
+     * directories do not express cannot be removed at all.
+     */
+    deleteConversation(token: string, conversationId: string): Promise<QaConversationDeletion>;
     private failuresOf;
     private failureSignals;
     /**

package/lib/types/admin/session-log.d.ts

@@ -35,9 +35,54 @@ export type QaSessionReadResult = {
     readonly ok: false;
     readonly reason: QaTranscriptUnavailableReason;
 };
+/**
+ * One listing of the deployment's sessions together with what the answer
+ * covers. The distinction is load-bearing: on a deployment that serves no
+ * durable query engine the listing is only what this process has open, and a
+ * chat nobody opened since the last restart is absent from it without being
+ * gone.
+ */
+export interface QaSessionListing {
+    readonly headers: readonly QaStoredSessionHeader[];
+    /**
+     * True when the listing answers for every stored session, not only the live
+     * ones. A consumer that must never read "absent" as "deleted" — the
+     * ownership sweep — reclaims nothing against an incomplete listing.
+     */
+    readonly complete: boolean;
+}
 export interface QaSessionLogReader {
-    list(): Promise<readonly QaStoredSessionHeader[]>;
+    list(): Promise<QaSessionListing>;
     read(sessionId: string): Promise<QaSessionReadResult>;
+    /**
+     * Whether the Harness holds this session in memory right now. Such a session
+     * is still being written: storage removal cannot take it away, because the
+     * next flush would put its log back.
+     */
+    live(sessionId: string): boolean;
+}
+/** What one storage-removal call did, id by id. */
+export interface QaSessionEraseOutcome {
+    /** Ids whose stored directories were removed. */
+    readonly removed: readonly string[];
+    /**
+     * Ids with no stored directory to remove: the session is already gone, or
+     * this deployment keeps it somewhere directories cannot express.
+     */
+    readonly absent: readonly string[];
+}
+/**
+ * Removal of stored sessions.
+ *
+ * The Harness has no deletion seam: `sessionPersistence` offers
+ * create/open/flush/stat/list, and the in-memory store drops a session only
+ * when the fiber that owns it disposes. A deployment that wants a conversation
+ * to stop existing therefore has to remove the artifacts storage keeps, which
+ * for the directory-backed backend means the session directories under the
+ * home. Implementations report what they could not do instead of guessing.
+ */
+export interface QaStoredSessionEraser {
+    erase(sessionIds: readonly string[]): Promise<QaSessionEraseOutcome>;
 }
 /**
  * Build the reader for one plugin instance. The services are looked up per
@@ -49,5 +94,24 @@ export declare function createSessionLogReader(ctx: Context): QaSessionLogReader
 export declare function staticSessionLogReader(input: {
     readonly sessions?: readonly QaStoredSessionHeader[];
     readonly events?: Readonly<Record<string, readonly StoredSessionEvent[]>>;
+    /**
+     * Whether the listed sessions are the fixture's whole world. True by
+     * default — a fixture that names its sessions means them to be all of them;
+     * pass false to stand for a live-only view of a larger deployment.
+     */
+    readonly complete?: boolean;
+    /** Ids the fixture's Harness still holds open. */
+    readonly held?: readonly string[];
 }): QaSessionLogReader;
+/**
+ * The stored sessions of a directory-backed deployment: one directory per
+ * session under `<home>/sessions/<project>/<sessionId>`, named by the id the
+ * header carries. The home follows the same convention as the deployment's
+ * other stores (`DSH_HOME`, then the working directory).
+ *
+ * Removal is by directory name and never by guessing a project key: the id is
+ * what the caller knows, and the directory either exists under one of the
+ * projects or does not exist at all.
+ */
+export declare function createSessionEraser(home?: string): QaStoredSessionEraser;
 //# sourceMappingURL=session-log.d.ts.map

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

@@ -1,6 +1,6 @@
 import type { ConnectionGenerationState } from "@deepseek-ai/dsh-client-connection/client";
 import type { QaAttachmentDraft, QaSessionState, ResolvedQaSurfaceConfig } from "../types.js";
-import type { QaApprovalApi, QaConversation, QaCreateSession, QaFileUpload, QaSecureSession, QaSessions, QaSessionsApi, QaQuestionApi, QaSourceApi, StorageLike } from "./types.js";
+import type { QaApprovalApi, QaConversation, QaCreateSession, QaFileUpload, QaSecureSession, QaSessions, QaSessionsApi, QaQuestionApi, QaSlashApi, QaSourceApi, StorageLike } from "./types.js";
 import type { QaApprovalDecision, QaQuestionAnswerItem } from "../types.js";
 export interface QaAccountsFacade {
     /** The account bearer token, or null while anonymous. */
@@ -38,6 +38,12 @@ export interface QaSessionControllerOptions {
      * does not answer questions: the surface then only renders what it can.
      */
     readonly questionApi?: QaQuestionApi;
+    /**
+     * The slash half of the Host namespace. Absent on a page whose Host build
+     * predates it: the palette then never appears and ordinary prompts keep
+     * working, which is exactly the pre-feature behaviour.
+     */
+    readonly slashApi?: QaSlashApi;
     readonly storage?: StorageLike;
     /**
      * Browser file-upload service, resolved lazily: the page may not serve the
@@ -74,6 +80,8 @@ export declare class QaSessionController {
     private readonly sourceApi;
     private readonly chats;
     private readonly accounts;
+    /** Slash half of the Host namespace; absent on an older Host build. */
+    private readonly slashApi;
     /** Resolved per send: a page without the upload plugin has no receipts. */
     private readonly fileUpload;
     /** Per-chat attachment URL cache; blob URLs die with the chat binding. */
@@ -114,6 +122,25 @@ export declare class QaSessionController {
     private readonly hostQuestions;
     /** Set while a running turn is polled for parked requests. */
     private pendingTimer;
+    /**
+     * Slash catalog of the bound chat. Keyed by session: it depends on the
+     * chat's cwd, its agent composition and its role, so it is dropped with the
+     * binding instead of being carried across chats.
+     */
+    private slashSessionId;
+    private slashEntries;
+    private slashDenied;
+    private slashSurface;
+    private slashState;
+    private slashError;
+    private slashLoadedAt;
+    private slashLoading;
+    /** Last published view; its identity is the render signal. */
+    private slashViewCache;
+    /** Bumped to re-open a palette the user dismissed; see `QaSlashView`. */
+    private slashReopen;
+    /** Chat, connection and admission state of the last one-shot probe. */
+    private pendingProbeKey;
     constructor(options: QaSessionControllerOptions);
     getSnapshot: () => QaSessionState;
     subscribe: (listener: () => void) => (() => void);
@@ -124,7 +151,48 @@ export declare class QaSessionController {
      * favor of a fresh Host-owned session.
      */
     selectSubrole(subroleId: string, adminPreview?: boolean): Promise<void>;
-    send(text: string, attachments?: readonly QaAttachmentDraft[]): Promise<boolean>;
+    /**
+     * The attested live session a submission may ride, or `undefined` when the
+     * caller must abort. Materializing a draft chat, attesting policy and
+     * recovering from a stale proof live here, so the prompt path and the
+     * command path cannot drift apart on what "ready to send" means.
+     */
+    private liveTarget;
+    /**
+     * Route one composer draft. Ordinary text and a skill invocation both ride
+     * the native prompt path — a skill is a gesture inside the prompt, not a
+     * call this surface makes — while a human command goes to the Host's command
+     * runtime and never becomes a model message.
+     */
+    send(text: string, attachments?: readonly QaAttachmentDraft[], pick?: string | null): Promise<boolean>;
+    /**
+     * Run one admitted human command. The Host answers it and writes the
+     * lifecycle into the session log; this method only decides what the composer
+     * does next, which is why nothing here creates a pending user row.
+     *
+     * A refusal keeps the draft and the attachments: the user asked for
+     * something the deployment does not allow, and retyping the line is a worse
+     * answer than leaving it in place to be edited.
+     */
+    private sendCommand;
+    /**
+     * Refresh the catalog of the bound chat. Called when a chat binds, and again
+     * when the palette opens on a catalog that has had time to go stale: the
+     * skill registry has no browser-facing change event, so a skill installed
+     * while the page is open is only discovered by asking again.
+     */
+    refreshSlashCatalog(force?: boolean): Promise<void>;
+    /**
+     * Install one catalog answer. `null` means the deployment runs with the
+     * slash interface off; `undefined` means the answer never arrived. The
+     * difference matters: an unreachable catalog must not turn ordinary prompts
+     * into refusals.
+     */
+    private applySlashCatalog;
+    /** Whether the catalog of the bound chat was read successfully. */
+    private slashCatalogReady;
+    /** The slash view of the current state; assembled where the state is. */
+    private slashView;
     /** Publish a browser-only copy before any network or Host admission awaits. */
     private beginSubmission;
     /**
@@ -239,8 +307,22 @@ export declare class QaSessionController {
      * inside an open turn, and it is Host state: polling is how the page learns
      * about it, and how it reappears after a reload. One timer serves both seams,
      * and each is polled only where the deployment answers it.
+     *
+     * A request that is already on screen keeps the timer alive past the end of
+     * its turn: the Host settles what the turn can no longer answer — an aborted
+     * tool call, an agent that went idle — and this keeps reading until that
+     * settlement reaches the page, so the form goes away instead of sitting
+     * there answerable but dead.
      */
     private syncPendingPolling;
+    /**
+     * Read what the Host parks once per chat and connection, whether or not a
+     * turn is running. A reload binds the chat before any turn reports itself
+     * over the fresh stream, and a turn that is already waiting on a question
+     * would otherwise sit behind an empty composer until the operator happened
+     * to send something.
+     */
+    private probePending;
     private stopPendingPolling;
     private hostToken;
 }

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

@@ -3,9 +3,10 @@ import type { InjectFace, PropsRenderSlots, PropsRuntime } from "@deepseek-ai/ds
 import type { QaConfigController } from "./QaConfigController.js";
 import type { QaRouteController } from "./QaRouteController.js";
 import type { QaAccountsController } from "./QaAccountsController.js";
-import type { QaApprovalApi, QaAccessApi, QaAdminApi, QaConversation, QaCreateSession, QaFileUpload, QaSecureSession, QaSessions, QaSessionsApi, QaQuestionApi, QaSkillApi, QaSourceApi } from "./types.js";
+import type { QaApprovalApi, QaAccessApi, QaAdminApi, QaConversation, QaCreateSession, QaFileUpload, QaSecureSession, QaSessions, QaSessionsApi, QaQuestionApi, QaSkillApi, QaSlashApi, QaSourceApi } from "./types.js";
 import type { QaSurfacePanelRegistry } from "./panels/registry.js";
 import type { QaUserSettingsSections } from "./settings-extensions/index.js";
+import type { QaAuditController } from "./audit/controller.js";
 export interface QaSurfaceFace {
     readonly route: QaRouteController;
     readonly config: QaConfigController;
@@ -34,6 +35,12 @@ export interface QaSurfaceFace {
     readonly approvalApi?: QaApprovalApi;
     /** Question half of the plugin's namespace, when the Host answers it. */
     readonly questionApi?: QaQuestionApi;
+    /**
+     * Slash half of the plugin's namespace. Absent on a Host build that predates
+     * it: the composer then never opens a palette and ordinary prompts are
+     * untouched.
+     */
+    readonly slashApi?: QaSlashApi;
     /**
      * Browser file-upload service, when the page serves the upload plugin.
      * Resolved per send so a page that loads it later still gets file support.
@@ -45,6 +52,12 @@ export interface QaSurfaceFace {
     readonly panels: QaSurfacePanelRegistry;
     /** First-class settings pages registered by additive QA plugins. */
     readonly settingsSections: QaUserSettingsSections;
+    /**
+     * Whether the session-audit provider is installed. Its snapshot carries the
+     * audit API, or `null` — the badge and the dialog exist only while it is
+     * present.
+     */
+    readonly audit: QaAuditController;
 }
 export type QaSurfaceProps = PropsRuntime<"shell.overlay"> & PropsRenderSlots<"qa.surface.panel"> & InjectFace<QaSurfaceFace>;
 export declare function QaSurface(props: QaSurfaceProps): import("react/jsx-runtime").JSX.Element | null;

package/lib/types/client/admin/{format.d.ts → copy.d.ts}

@@ -40,4 +40,4 @@ export declare function formatRelative(iso: string, now?: number): string;
 /** Milliseconds as a short duration; tool timings are second-scale. */
 export declare function formatDuration(ms: number | undefined): string;
 export declare function formatCount(value: number): string;
-//# sourceMappingURL=format.d.ts.map
+//# sourceMappingURL=copy.d.ts.map

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

@@ -16,6 +16,10 @@ export declare function AdminConversation(props: {
     readonly conversationId: string;
     readonly messageId?: string;
     readonly canReview: boolean;
+    /** Removing the conversation itself belongs to the administrator alone. */
+    readonly canDelete: boolean;
     readonly onBack: () => void;
+    /** Called once the conversation is gone, so the console leaves the page. */
+    readonly onDeleted?: () => void;
 }): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=Conversations.d.ts.map

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

@@ -0,0 +1,21 @@
+/**
+ * The audit dialog: the same content as the session page, in this surface's
+ * own shell (SPEC §51).
+ *
+ * The status bar is compact and the tab strip is shared, because the audit is
+ * the same audit — a reader who has seen it in the ordinary DSH session should
+ * recognise every number here.
+ */
+import { type ReactNode } from "react";
+import type { QaAuditApi, QaAuditSummary } from "./types.js";
+export interface QaAuditDialogProps {
+    readonly open: boolean;
+    readonly sessionId: string | null;
+    readonly title: string;
+    readonly api: QaAuditApi | null;
+    /** The summary the badge was built from, for the reload key. */
+    readonly summary: QaAuditSummary | undefined;
+    readonly onClose: () => void;
+}
+export declare function QaAuditDialog(props: QaAuditDialogProps): ReactNode;
+//# sourceMappingURL=QaAuditDialog.d.ts.map

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

@@ -0,0 +1,18 @@
+/**
+ * The row badge: "this chat was audited", and what the audit found.
+ *
+ * Two visually distinct things, on purpose (SPEC §52). The check mark and the
+ * label say *an audit exists*; the verdict and the counts say *what it found*.
+ * A green tick next to "poor" has to read as "audited, and it went badly",
+ * which is why the tick is never the thing that carries the quality.
+ */
+import type { ReactNode } from "react";
+import type { QaAuditMark } from "./types.js";
+export interface QaAuditRowBadgeProps {
+    readonly mark: QaAuditMark;
+    /** Whether the row also carries a delete control, which takes the right slot. */
+    readonly withDelete: boolean;
+    readonly onOpen: () => void;
+}
+export declare function QaAuditRowBadge(props: QaAuditRowBadgeProps): ReactNode;
+//# sourceMappingURL=QaAuditRowBadge.d.ts.map

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

@@ -0,0 +1,27 @@
+/**
+ * Whether the audit provider is present, as a client-side service.
+ *
+ * The audit plugin may or may not be installed, and its Remote namespace
+ * arrives asynchronously. A React tree cannot watch a Cordis injection by
+ * itself, so the attach/detach pair below is exposed as an external store and
+ * the surface reads it with `useSyncExternalStore` — the same shape the rest
+ * of this client uses for host-driven state.
+ */
+import type { QaAuditApi } from "./types.js";
+/** The snapshot the surface renders from; replaced, never mutated. */
+export interface QaAuditSnapshot {
+    readonly api: QaAuditApi | null;
+}
+export declare class QaAuditController {
+    private snapshot;
+    private readonly listeners;
+    /** The provider's namespace resolved: audits become visible. */
+    attach(api: QaAuditApi): void;
+    /** The provider went away: the badge and the dialog disappear with it. */
+    detach(): void;
+    getSnapshot: () => QaAuditSnapshot;
+    subscribe: (listener: () => void) => (() => void);
+    dispose(): void;
+    private emit;
+}
+//# sourceMappingURL=controller.d.ts.map

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

@@ -0,0 +1,72 @@
+/**
+ * The QA Surface's view of the session-audit Remote namespace.
+ *
+ * Declared here, structurally, rather than imported from `@yadsh/dsh-session-audit`:
+ * a plugin may not depend on another plugin, and it does not need to. The
+ * namespace is a wire contract, and the surface simply asks whether it is
+ * there — when the audit plugin is not installed, `ctx.inject` never fires and
+ * the badge and the dialog are simply absent (SPEC §48).
+ */
+/** The cheap per-session summary the badge reads. */
+export interface QaAuditSummary {
+    readonly available: boolean;
+    readonly auditId: string;
+    readonly sessionId: string;
+    readonly verdict: string;
+    readonly outcomeStatus: string;
+    readonly evidenceLevel: string;
+    readonly model: string;
+    readonly agentPreset: string;
+    readonly toolCalls: number;
+    readonly toolErrors: number;
+    readonly critical: number;
+    readonly major: number;
+    readonly minor: number;
+    readonly observation: number;
+    readonly other: number;
+    readonly schemaVersion: number;
+    readonly modifiedAt: string;
+}
+/** The full audit, as two documents and their summary. */
+export interface QaSessionAudit {
+    readonly available: boolean;
+    readonly summary: QaAuditSummary;
+    readonly analysisJson: string;
+    readonly report: string;
+}
+/** A failed Remote result, narrowed to what the surface reports. */
+interface RemoteFailure {
+    readonly ok: false;
+    readonly error: {
+        readonly code: string;
+    };
+}
+type RemoteResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | RemoteFailure;
+/** The `sessionAudit` namespace as the browser sees it. */
+export interface QaAuditRemote {
+    summary(sessionId: string): Promise<RemoteResult<QaAuditSummary>>;
+    audit(sessionId: string): Promise<RemoteResult<QaSessionAudit>>;
+}
+/** The narrow surface the surface's components are handed. */
+export interface QaAuditApi {
+    summary(sessionId: string): Promise<QaAuditSummary>;
+    audit(sessionId: string): Promise<QaSessionAudit>;
+}
+/** Build the facade over a mounted Remote namespace. */
+export declare function createQaAuditApi(remote: QaAuditRemote): QaAuditApi;
+/** The numbers the row badge shows, or `null` when there is no audit. */
+export interface QaAuditMark {
+    readonly verdict: string;
+    readonly critical: number;
+    readonly major: number;
+    readonly minor: number;
+    readonly observation: number;
+    readonly other: number;
+}
+/** Reduce a summary to the mark a row shows. */
+export declare function auditMark(summary: QaAuditSummary | undefined): QaAuditMark | null;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/lib/types/client/audit/use-chat-audits.d.ts

@@ -0,0 +1,20 @@
+import type { QaAuditApi, QaSessionAudit, QaAuditSummary } from "./types.js";
+/** How often the chat list re-asks which chats have an audit. */
+export declare const AUDIT_POLL_MS = 30000;
+/**
+ * Poll the audit summary for every chat id.
+ *
+ * @param api - the Remote facade, or `null` when the audit plugin is absent.
+ * @param sessionIds - the chats currently listed.
+ */
+export declare function useChatAudits(api: QaAuditApi | null, sessionIds: readonly string[]): ReadonlyMap<string, QaAuditSummary>;
+/** The dialog's own load: one audit's documents, fetched when it opens. */
+export interface QaAuditLoad {
+    readonly loading: boolean;
+    readonly audit: QaSessionAudit | null;
+    readonly error: string | null;
+}
+export declare function useSessionAuditDocument(api: QaAuditApi | null, sessionId: string | null, open: boolean, 
+/** Reload key; the summary's `modifiedAt` changes exactly when bytes do. */
+modifiedAt: string | null): QaAuditLoad;
+//# sourceMappingURL=use-chat-audits.d.ts.map

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

@@ -1,13 +1,12 @@
 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;
-}
+import type { QaSourceRefs } from "./source-refs.js";
+export type { MarkdownSourceContext } from "../markdown/source-chip.js";
 /**
- * Deliberately small, HTML-free Markdown renderer for assistant-visible text.
+ * Assistant-visible Markdown. The grammar lives in `../markdown/`: blocks are
+ * parsed once per text value, inline content is resolved per block, and a link
+ * or inline-code token that names a source the owning message knows about
+ * renders as a source chip instead of plain text.
+ *
  * Memoized on the text value: stream updates re-render only the message whose
  * text actually changed, so committed history is never re-parsed.
  */

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

@@ -1,4 +1,4 @@
-import type { QaAttachmentDraft } from "../../types.js";
+import type { QaAttachmentDraft, QaSlashView, ResolvedQaSlashCommands } from "../../types.js";
 import { type QaAttachmentLimits } from "../attachments.js";
 import type { QaQuickQuestion } from "../types.js";
 export interface QaComposerProps {
@@ -13,8 +13,18 @@ export interface QaComposerProps {
     readonly attachments: readonly QaAttachmentDraft[];
     /** Deployment policy: accepted kinds, ceilings and the paste threshold. */
     readonly limits: QaAttachmentLimits;
+    /** Slash catalog of this chat; inert while the master switch is off. */
+    readonly slash: QaSlashView;
+    readonly slashPolicy: ResolvedQaSlashCommands["palette"];
     readonly onAttachmentsChange: (attachments: readonly QaAttachmentDraft[]) => void;
-    readonly onSend: (text: string, attachments: readonly QaAttachmentDraft[]) => Promise<boolean>;
+    /**
+     * `pick` names the entry the user chose in the palette, while the draft
+     * still reads as its invocation. It is what disambiguates a skill and a
+     * command that share a name; `null` means the draft alone decides.
+     */
+    readonly onSend: (text: string, attachments: readonly QaAttachmentDraft[], pick: string | null) => Promise<boolean>;
+    /** Called when the palette opens, so the caller can revalidate the catalog. */
+    readonly onSlashOpen: () => void;
     readonly onStop: () => Promise<void>;
 }
 /**

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

@@ -3,6 +3,13 @@ export interface QaQuestionsProps {
     readonly questions: readonly QaPendingQuestion[];
     readonly onAnswer: (requestId: string, answers: readonly QaQuestionAnswerItem[]) => Promise<void>;
     readonly onCancel: (requestId: string) => Promise<void>;
+    /**
+     * Stop the turn the questions belong to. The form takes the composer's
+     * place, so the run's own stop action moves here: an operator who does not
+     * want to answer must still be able to end the turn instead.
+     */
+    readonly onStop?: () => Promise<void>;
+    readonly canStop?: boolean;
 }
 /**
  * The questions a running turn waits on. Answers are the operator's own: the

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

@@ -1,4 +1,5 @@
 import type { SessionSummary } from "@deepseek-ai/dsh-api-session-controller/client";
+import { type QaAuditSummary } from "../audit/types.js";
 /** One renderable row of the chat-history sidebar. */
 export interface QaChatRow {
     readonly id: string;
@@ -14,7 +15,9 @@ export interface QaChatRow {
  * Project this browser's indexed chat ids onto the host session list, most
  * recently updated first. Opening a chat is not an update: only the host's
  * `updatedAt` (fresh messages) orders the list. Ids the host no longer lists
- * are skipped (the controller prunes them on switch).
+ * are skipped (the controller prunes them on switch), and so is a delegated
+ * child: a subagent's session is not a chat, even when an ownership record
+ * from an older release still names it.
  */
 export declare function buildChatRows(chatIds: readonly string[], byId: Readonly<Record<string, SessionSummary>>, activeId: string | null, ownerNameOf?: (sessionId: string) => string | undefined, now?: number): readonly QaChatRow[];
 /** One per-owner section of the admin sidebar grouping. */
@@ -51,6 +54,13 @@ export interface QaSidebarProps {
     readonly onNewChat: () => void;
     /** Removes a chat from this browser's index; omit to hide the control. */
     readonly onDelete?: (sessionId: string) => void;
+    /**
+     * Audit summaries by chat id, for the row badge. Empty when the audit plugin
+     * is not installed — the badge is then absent rather than empty.
+     */
+    readonly audits?: ReadonlyMap<string, QaAuditSummary>;
+    /** Opens the audit dialog for a chat; omit when audits are unavailable. */
+    readonly onAudit?: (sessionId: string) => void;
     /** The signed-in account; omit when accounts are disabled. */
     readonly account?: {
         readonly email: string;