@yadsh/dsh-qa-surface 0.8.0 → 0.9.0

package/lib/types/access/capability-catalog.d.ts

@@ -1,5 +1,6 @@
 import type { Agent } from "@deepseek-ai/dsh-agent";
 import type { Context } from "@deepseek-ai/cordis";
+import type { ScopeKey } from "@deepseek-ai/dsh-scope";
 import type { SkillSummary } from "@deepseek-ai/dsh-skill";
 import type { QaCapabilityDescriptor, QaSkillDescriptor } from "../types.js";
 export interface CapabilityCatalogSnapshot {
@@ -19,10 +20,36 @@ export declare class QaCapabilityCatalog {
     private readonly additionalToolNames;
     /** Role ids used to report unknown subrole ids in skill metadata. */
     private readonly knownSubroles;
+    /**
+     * The viewing scope an administrator's catalog is read with, for callers
+     * that have no agent of their own. Skills and tools an agent preset mounts
+     * (a kit's skill catalog, the preset's tool family) live in that preset's
+     * scope, so a global-only read reported an almost empty catalog: the
+     * administrator could neither see nor grant what every chat mounts.
+     * Resolving the scope may compose the preset; a failure degrades to the
+     * global view instead of failing the page.
+     */
+    private readonly presetScope;
     constructor(ctx: Context, additionalToolNames?: () => readonly string[], 
     /** Role ids used to report unknown subrole ids in skill metadata. */
-    knownSubroles?: () => readonly string[]);
+    knownSubroles?: () => readonly string[], 
+    /**
+     * The viewing scope an administrator's catalog is read with, for callers
+     * that have no agent of their own. Skills and tools an agent preset mounts
+     * (a kit's skill catalog, the preset's tool family) live in that preset's
+     * scope, so a global-only read reported an almost empty catalog: the
+     * administrator could neither see nor grant what every chat mounts.
+     * Resolving the scope may compose the preset; a failure degrades to the
+     * global view instead of failing the page.
+     */
+    presetScope?: () => Promise<ScopeKey | undefined>);
     snapshot(agent?: Agent): Promise<CapabilityCatalogSnapshot>;
+    /**
+     * The scope an administrator's catalog is read with. A deployment that pins
+     * QA chats to an agent preset gets that preset's standing scope; without a
+     * pinned preset there is no scope to borrow, and the read stays global.
+     */
+    private resolvePresetScope;
     /**
      * Read `metadata.qa-surface` of every discovered skill.
      *

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

@@ -1,5 +1,6 @@
 import type { Agent } from "@deepseek-ai/dsh-agent";
 import type { Context } from "@deepseek-ai/cordis";
+import type { ScopeKey } from "@deepseek-ai/dsh-scope";
 import type { PluginLogger } from "@yadsh/dsh-plugin-log";
 import type { QaAccounts } from "../accounts/store.js";
 import type { QaAgentToolGrants } from "../enforcement/tool-grants.js";
@@ -27,6 +28,8 @@ export declare class QaAccessService {
     readonly roles: QaRoleRepository;
     readonly catalog: QaCapabilityCatalog;
     private lastOwnershipSweepAt;
+    /** The sweep in flight, so a burst of readers runs one listing, not ten. */
+    private ownershipSweep;
     /**
      * Sessions the Host has listed as delegated children of another session.
      * The live registry answers for a child that is running right now; this
@@ -42,6 +45,13 @@ export declare class QaAccessService {
         readonly logger: PluginLogger;
         readonly repository?: QaRoleRepository;
         readonly dynamicToolNames?: () => readonly string[];
+        /**
+         * The viewing scope an administrator's catalog is read with. Skills and
+         * tools a deployment mounts through an agent preset live in that
+         * preset's scope, so a global-only catalog left the operator unable to
+         * see — or grant — what every QA chat actually mounts.
+         */
+        readonly presetScope?: () => Promise<ScopeKey | undefined>;
         /**
          * Durable session listing, used to tell a chat from a delegated child
          * across Host runs. Without it the lineage answer degrades to the live
@@ -49,6 +59,14 @@ export declare class QaAccessService {
          * materialized — the sweep then reclaims nothing rather than guessing.
          */
         readonly sessionLog?: QaSessionLogReader;
+        /**
+         * Called with the ids of chats the Harness no longer knows, once their
+         * ownership records are reclaimed. The record is the auth boundary, not
+         * the whole of what the deployment kept about a chat: ratings, reviews
+         * and queue entries are keyed by conversation, and they outlive their
+         * chat unless the caller drops them here.
+         */
+        readonly onVanishedSessions?: (sessionIds: readonly string[]) => void;
     });
     /**
      * Whether the Host can prove this session is a delegated child: a subagent's
@@ -68,11 +86,22 @@ export declare class QaAccessService {
      * Nothing else removes them: the browser's "delete chat" hides a chat in one
      * browser, and a record outlives its session forever, so a year of QA traffic
      * accumulates one row per chat ever created. The sweep is throttled, runs
-     * off the reservation path, and is skipped entirely when the Harness cannot
-     * say what exists — an unanswerable question is never a licence to delete an
-     * auth boundary.
+     * off the reservation path and off the review reads, and is skipped entirely
+     * when the Harness cannot say what exists — an unanswerable question is
+     * never a licence to delete an auth boundary.
+     *
+     * What exists is both halves of the Harness's own knowledge: the sessions
+     * this process has open and the ones its storage still holds. The live store
+     * alone would make a cold chat — one nobody has opened since the last
+     * restart — look deleted, and the sweep would reclaim records of chats that
+     * are merely quiet. A listing that cannot see stored sessions therefore
+     * reclaims nothing.
+     *
+     * @returns the sweep, for callers that want to await it (tests, and the
+     * review reads that must show the console what still exists).
      */
-    private maybePruneOwnership;
+    sweepVanishedOwnership(): Promise<void>;
+    private runOwnershipSweep;
     /**
      * Migrate a browser's local chat index into server-side ownership.
      *

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

@@ -3,7 +3,13 @@
  * 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" | "forbidden" | "invalid-credentials" | "account-disabled" | "email-taken" | "invalid-email" | "invalid-display-name" | "invalid-profile" | "profile-disabled" | "invalid-starters" | "starters-disabled" | "invalid-role" | "weak-password" | "registration-disabled" | "rate-limited" | "session-owned-elsewhere";
+export type QaAccountsErrorReason = "auth-required" | "admin-required" | "forbidden" | "invalid-credentials" | "account-disabled" | "email-taken" | "invalid-email" | "invalid-display-name" | "invalid-profile" | "profile-disabled" | "invalid-starters" | "starters-disabled" | "invalid-role" | "weak-password" | "registration-disabled" | "rate-limited" | "session-owned-elsewhere"
+/** The conversation a deletion names is not one this deployment knows. */
+ | "conversation-unknown"
+/** The Harness still holds the conversation open, so its log would come back. */
+ | "conversation-live"
+/** This deployment cannot remove stored conversations at all. */
+ | "conversation-not-removable";
 export declare class QaAccountsError extends Error {
     readonly reason: QaAccountsErrorReason;
     constructor(reason: QaAccountsErrorReason, message: string);

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

@@ -138,6 +138,18 @@ export declare class QaAccounts {
      * @returns the session ids whose records were dropped.
      */
     pruneDelegatedOwnership(sessionIds: ReadonlySet<string>): readonly string[];
+    /**
+     * Drop the ownership records of the named sessions, whatever their lineage.
+     *
+     * This is the record half of a deletion: the caller has already established
+     * that these sessions are gone (or is removing them as part of the same
+     * act), so the auth boundary goes with them. Nothing here decides anything —
+     * the sweeps above own the judgments, and both end in this.
+     *
+     * @param sessionIds - the ids whose records are dropped.
+     * @returns the session ids whose records were actually there.
+     */
+    forgetSessions(sessionIds: ReadonlySet<string>): readonly string[];
     /**
      * Drop ownership records for chats the Harness no longer knows.
      *

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

@@ -67,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;

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/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