@yadsh/dsh-qa-surface 0.8.0 → 0.9.0

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/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;
@@ -53,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;

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

@@ -1,6 +1,6 @@
 import type { SessionFace } from "@deepseek-ai/dsh-api-session-controller/client";
 import type { ConversationSnapshot } from "@deepseek-ai/dsh-client-ui-conversation/client";
-import type { QaPendingApproval, QaPendingQuestion, QaSessionState, QaSubagentView, QaTurnSources, ResolvedQaSurfaceConfig } from "../types.js";
+import type { QaPendingApproval, QaPendingQuestion, QaSessionState, QaSlashView, QaSubagentView, QaTurnSources, ResolvedQaSurfaceConfig } from "../types.js";
 /** Everything the bound-chat projection reads; the computation is pure. */
 export interface QaBoundProjectionInput {
     readonly connected: boolean;
@@ -23,6 +23,8 @@ export interface QaBoundProjectionInput {
     readonly admissionPending: boolean;
     readonly chatsRevision: number;
     readonly viewingSubagent: QaSubagentView | null;
+    /** Slash catalog state of this chat; the controller owns its lifetime. */
+    readonly slash: QaSlashView;
     readonly config: ResolvedQaSurfaceConfig;
     /**
      * The chat's subagent display names keyed by session id, read from the

package/lib/types/client/prompt-content.d.ts

@@ -1,5 +1,5 @@
 import type { SessionFace } from "@deepseek-ai/dsh-api-session-controller/client";
-import type { QaAttachmentDraft, QaFileDraft } from "../types.js";
+import type { QaAttachmentDraft, QaFileDraft, QaSlashSubmitAttachment } from "../types.js";
 import type { QaFileUpload, QaPromptContent } from "./types.js";
 /**
  * Stage every pending file on the Host and collect the receipts the prompt
@@ -26,5 +26,13 @@ export declare function stageQaFiles(service: QaFileUpload | undefined, session:
  * staging failed elsewhere) degrades to an empty receipt rather than
  * dropping the attachment.
  */
+/**
+ * The same two shapes for a human command, which admits attachments through
+ * the shared store rather than through the prompt: an image rides encoded, a
+ * file rides the receipt its staging minted. An attachment whose staging
+ * failed is dropped instead of being sent as an empty receipt — the command
+ * would otherwise read a handle that resolves to nothing.
+ */
+export declare function buildQaSlashAttachments(attachments: readonly QaAttachmentDraft[], receipts: ReadonlyMap<string, string>): readonly QaSlashSubmitAttachment[];
 export declare function buildQaPromptContent(prompt: string, attachments: readonly QaAttachmentDraft[], receipts: ReadonlyMap<string, string>): QaPromptContent;
 //# sourceMappingURL=prompt-content.d.ts.map

package/lib/types/client/settings/sections/slash.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Slash interface: the master switch, the two admission policies and the
+ * palette itself.
+ *
+ * The allow lists stay name-based, which is what the deployment config stores
+ * — an operator writes `generate-tkp`, never an id. They are plain lists
+ * rather than checkboxes over a discovered catalog because the two halves are
+ * discovered differently and only one of them can be enumerated here at all:
+ * skills are a registry lookup, while a command is only resolvable against a
+ * live chat's agent, so this card could not honestly offer a fixed list of
+ * command names to tick.
+ */
+import { type ConfigProps } from "./common.js";
+/** Master switch, per-kind admission policy and palette presentation. */
+export declare function SlashSection(props: ConfigProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=slash.d.ts.map

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

@@ -19,6 +19,7 @@ export { EmbeddingSection } from "./sections/embedding.js";
 export { InterfaceSection } from "./sections/interface.js";
 export { LockdownSection } from "./sections/lockdown.js";
 export { SessionSection } from "./sections/session.js";
+export { SlashSection } from "./sections/slash.js";
 export { SourcesSection } from "./sections/sources.js";
 export { StatusSection } from "./sections/status.js";
 export type { StatusProps } from "./sections/status.js";

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

@@ -0,0 +1,24 @@
+import type { QaSlashCatalogEntry, QaSlashCommandSurface, QaSlashView } from "../../types.js";
+export interface QaSlashPaletteProps {
+    readonly rows: readonly QaSlashCatalogEntry[];
+    readonly activeId: string | null;
+    readonly state: QaSlashView["state"];
+    readonly error: string | null;
+    readonly commandSurface: QaSlashCommandSurface;
+    readonly showDescriptions: boolean;
+    readonly showKindBadge: boolean;
+    readonly idPrefix: string;
+    readonly onHover: (index: number) => void;
+    readonly onPick: (entry: QaSlashCatalogEntry) => void;
+}
+/**
+ * The palette itself: a listbox over rows the composer has already filtered
+ * and ranked. It owns no state — an empty list means "nothing matches", and
+ * the surface line says why when the catalog could not be read at all.
+ *
+ * Options are picked on `click` and never take focus (`onMouseDown` prevents
+ * the default) so the caret stays in the textarea: the keyboard keeps working
+ * straight after a click, and Escape still closes what the mouse opened.
+ */
+export declare const QaSlashPalette: import("react").MemoExoticComponent<(props: QaSlashPaletteProps) => import("react/jsx-runtime").JSX.Element>;
+//# sourceMappingURL=SlashPalette.d.ts.map

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

@@ -0,0 +1,30 @@
+import type { QaSlashCatalogEntry, QaSlashExecution } from "../../types.js";
+import type { QaSlashRoute } from "./slash-router.js";
+/**
+ * The user-facing copy of every slash decision. One module because these
+ * strings are the whole interface between a refusal and the person reading it:
+ * a refusal that does not say what to do next is indistinguishable from a bug.
+ */
+/** The refusal that predates the feature; unchanged, so nothing regresses. */
+export declare const SLASH_DISABLED_COPY = "\u041A\u043E\u043C\u0430\u043D\u0434\u044B \u0441\u043E \u0441\u043B\u0435\u0448\u0435\u043C \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B \u0432 \u0440\u0435\u0436\u0438\u043C\u0435 \u043F\u043E\u043C\u043E\u0449\u043D\u0438\u043A\u0430.";
+export declare function slashRefusalCopy(route: Extract<QaSlashRoute, {
+    kind: "unknown" | "ambiguous" | "unavailable";
+}>): string;
+/**
+ * A gesture inside an ordinary prompt that this deployment withholds. Stated
+ * as a fact about the deployment, not as a fault of the message, because the
+ * message itself is fine — it is one word of it that will not take effect.
+ */
+export declare function slashWithheldCopy(names: readonly string[]): string;
+export declare function slashExecuteFailureCopy(entry: QaSlashCatalogEntry): string;
+/** Copy for a refusal the Host decided, keyed by its reason. */
+export declare function slashHostRefusalCopy(refusal: Extract<QaSlashExecution, {
+    kind: "refused";
+}>): string;
+/**
+ * Attachments the chosen command refuses. Checked before dispatch so the
+ * composer keeps the draft and the files; the Host checks it again and stays
+ * the authority.
+ */
+export declare function slashAttachmentsCopy(entry: QaSlashCatalogEntry): string;
+//# sourceMappingURL=copy.d.ts.map

package/lib/types/client/slash/slash-router.d.ts

@@ -0,0 +1,67 @@
+import type { QaSlashCatalogEntry } from "../../types.js";
+/**
+ * Where one composer draft should go.
+ *
+ * The composer used to have a single path — `sendPrompt` — with a guard that
+ * turned every `/`-leading line away. That guard is now the `disabled` case
+ * below, and everything else is decided here, in one place, from the draft and
+ * the catalog alone. Keeping it pure is what makes the ambiguous, unknown and
+ * withheld cases testable without a browser or a Host.
+ */
+export type QaSlashRoute = 
+/**
+ * Ordinary text: the model gets it, exactly as before this feature. It may
+ * still name a skill this deployment withholds — the turn runs, and the
+ * surface says so rather than letting the user believe it took effect.
+ */
+{
+    readonly kind: "prompt";
+    readonly withheld?: readonly string[];
+}
+/** A user-invocable skill: the native prompt path carries the gesture. */
+ | {
+    readonly kind: "skill";
+    readonly entry: QaSlashCatalogEntry;
+}
+/** A human command: the Host's command runtime answers it, the model never sees it. */
+ | {
+    readonly kind: "command";
+    readonly entry: QaSlashCatalogEntry;
+}
+/** Nothing by that name is offered here. */
+ | {
+    readonly kind: "unknown";
+    readonly name: string;
+}
+/** A skill and a command share the name; only the user may choose. */
+ | {
+    readonly kind: "ambiguous";
+    readonly name: string;
+    readonly entries: readonly QaSlashCatalogEntry[];
+}
+/** The catalog could not be read, so no `/name` can be classified. */
+ | {
+    readonly kind: "unavailable";
+    readonly name: string;
+}
+/** The deployment runs with the slash interface off. */
+ | {
+    readonly kind: "disabled";
+};
+export interface ResolveSlashRouteInput {
+    readonly text: string;
+    readonly enabled: boolean;
+    readonly catalogReady: boolean;
+    readonly entries: readonly QaSlashCatalogEntry[];
+    /** User-invocable skills this deployment withholds from this chat. */
+    readonly deniedSkills: readonly string[];
+    /**
+     * The entry the user picked in the palette, while the draft still reads as
+     * its invocation. A picked identity outranks name resolution: when a skill
+     * and a command share a name, the user already answered the only question
+     * the router would otherwise have to guess at.
+     */
+    readonly picked?: string | null;
+}
+export declare function resolveSlashRoute(input: ResolveSlashRouteInput): QaSlashRoute;
+//# sourceMappingURL=slash-router.d.ts.map

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

@@ -0,0 +1,47 @@
+import type { QaSlashCatalogEntry, QaSlashView } from "../../types.js";
+export interface QaSlashNavigation {
+    /** True while the palette is on screen. */
+    readonly open: boolean;
+    readonly query: string;
+    /** The rows the palette renders, best match first. */
+    readonly rows: readonly QaSlashCatalogEntry[];
+    /** Index into `rows`; -1 when there is nothing to select. */
+    readonly active: number;
+    readonly activeId: string | null;
+    /** Move the selection by one row, wrapping at both ends. */
+    readonly move: (delta: number) => void;
+    /** Point the selection at one row, as a tap does. */
+    readonly hover: (index: number) => void;
+    /** Insert the active row's invocation into the draft. */
+    readonly pickActive: () => void;
+    /** Insert one row, as a click or a tap does. */
+    readonly pick: (entry: QaSlashCatalogEntry) => void;
+    /** Dismiss the palette for this draft. */
+    readonly dismiss: () => void;
+    /** The identity the user picked, while the draft still reads as its call. */
+    readonly picked: QaSlashCatalogEntry | undefined;
+}
+export interface UseSlashNavigationOptions {
+    readonly draft: string;
+    readonly slash: QaSlashView;
+    readonly maxVisible: number;
+    readonly fuzzySearch: boolean;
+    /** Set the draft to `text` and put the caret at its end. */
+    readonly setDraft: (text: string) => void;
+    /** Monotonic token; a change re-opens a palette the user had dismissed. */
+    readonly reopen: number;
+}
+/**
+ * Palette state for one composer draft.
+ *
+ * The palette is a pure function of the draft: it is open while the draft is
+ * `/` plus a name still being typed, and closes the moment the user types a
+ * space and starts writing arguments. Nothing has to be kept in sync — which
+ * is also why switching chats (the composer is keyed by chat and remounts)
+ * cannot leave a palette behind.
+ *
+ * Selection is one index over the filtered rows; the arrow keys, the mouse and
+ * the touch screen all move the same number.
+ */
+export declare function useSlashNavigation(options: UseSlashNavigationOptions): QaSlashNavigation;
+//# sourceMappingURL=useSlashNavigation.d.ts.map

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

@@ -1,4 +1,13 @@
 /** Every `--dsh-qa-*` custom property the root rule declares. */
 export declare const QA_BRAND_TOKEN_NAMES: readonly string[];
 export declare const QA_SURFACE_STYLES: string;
+/**
+ * Everything the QA overlay paints, as one sheet for one `<style>` tag.
+ *
+ * The shared audit components keep their own stylesheet in
+ * `@yadsh/dsh-audit-ui`; it is folded in here so the overlay is self-contained
+ * — the audit dialog must look right whether or not the audit plugin's own
+ * client bundle happens to have injected the same rules into the document.
+ */
+export declare const QA_OVERLAY_STYLES: string;
 //# sourceMappingURL=styles.d.ts.map

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

@@ -1,7 +1,7 @@
 import type { ClientRemote } from "@deepseek-ai/dsh-api-gateway/client";
 import type { ISessions, SessionFace } from "@deepseek-ai/dsh-api-session-controller/client";
 import type { UiConversation } from "@deepseek-ai/dsh-client-ui-conversation/client";
-import type { QaAccountProfileInput, QaAccountSession, QaAccountStartersInput, QaAccountStarter, QaAccountUserPublic, QaAccessAdminSnapshot, QaApprovalDecision, QaClaimResult, QaLockdownProof, QaOwnershipEntry, QaPendingApproval, QaPendingQuestion, QaQuestionAnswerItem, QaSessionState, QaSkillDocument, QaSkillDraftInput, QaSkillRemoval, QaSkillSummary, QaSkillToolDescriptor, QaSkillValidation, QaSourceFilePreview, QaTurnSources, QaWhoamiResult, QaCapabilitySelection, QaCurrentAccess, QaSessionAccess, QaSkillActivationRecord, QaSkillAssignmentOverride, QaSubrole, QaUserAccess, 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 { QaAccountProfileInput, QaAccountSession, QaAccountStartersInput, QaAccountStarter, QaAccountUserPublic, QaAccessAdminSnapshot, QaApprovalDecision, QaClaimResult, QaLockdownProof, QaOwnershipEntry, QaPendingApproval, QaPendingQuestion, QaQuestionAnswerItem, QaSessionState, QaSkillDocument, QaSkillDraftInput, QaSkillRemoval, QaSkillSummary, QaSkillToolDescriptor, QaSkillValidation, QaSourceFilePreview, QaTurnSources, QaWhoamiResult, QaCapabilitySelection, QaCurrentAccess, QaSessionAccess, QaSkillActivationRecord, QaSkillAssignmentOverride, QaSubrole, QaUserAccess, QaAdminAuditEvent, QaAdminOverview, QaAdminPage, QaAdminUserDetail, QaAdminUserRow, QaAdminUserUpdate, QaAuditQuery, QaConversationDetail, QaConversationDeletion, QaConversationQuery, QaConversationReview, QaConversationReviewInput, QaConversationSummary, QaFeedbackQuery, QaFeedbackRow, QaMessageFeedback, QaMessageFeedbackInput, QaQualityMetrics, QaReviewQueueItem, QaReviewQueueRow, QaSlashCatalog, QaSlashExecution, QaSlashSubmitAttachment, QaUserQuery } from "../types.js";
 /** Wire content one prompt carries: text plus base64 image uploads. */
 export type QaPromptContent = Parameters<SessionFace["prompt"]>[0];
 /** DSH session runtime surface the QA controller is allowed to touch. */
@@ -58,6 +58,11 @@ export interface QaAdminApi {
     updateUser(token: string, userId: string, update: QaAdminUserUpdate): Promise<RemoteResult<QaAdminUserDetail>>;
     conversations(token: string, query: QaConversationQuery, cursor: string | null, limit: number | null): Promise<RemoteResult<QaAdminPage<QaConversationSummary>>>;
     conversation(token: string, conversationId: string): Promise<RemoteResult<QaConversationDetail>>;
+    /**
+     * Remove the conversation from the deployment, stored logs included. Only an
+     * administrator may call it; the sidebar's own delete is unrelated.
+     */
+    deleteConversation(token: string, conversationId: string): Promise<RemoteResult<QaConversationDeletion>>;
     feedback(token: string, query: QaFeedbackQuery, cursor: string | null, limit: number | null): Promise<RemoteResult<QaAdminPage<QaFeedbackRow>>>;
     /** The signed-in user's own verdict on one of their assistant messages. */
     rateMessage(token: string, conversationId: string, messageId: string, input: QaMessageFeedbackInput): Promise<RemoteResult<QaMessageFeedback>>;
@@ -107,6 +112,16 @@ export interface QaSourceApi {
         readonly error: unknown;
     }>;
 }
+/**
+ * The slash half of the Host namespace. The catalog comes back already cut
+ * down by the deployment policy and the chat's role; `execute` takes the raw
+ * line, because admission re-derives the name from it rather than trusting
+ * anything the browser says about which entry it means.
+ */
+export interface QaSlashApi {
+    catalog(token: string, sessionId: string): Promise<RemoteResult<QaSlashCatalog>>;
+    execute(token: string, sessionId: string, line: string, attachments: readonly QaSlashSubmitAttachment[]): Promise<RemoteResult<QaSlashExecution>>;
+}
 /** A source API with the account token already bound at the call site. */
 export type QaBoundSourceApi = {
     sources(sessionId: string): Promise<{

package/lib/types/config-resolvers/slash-commands.d.ts

@@ -0,0 +1,20 @@
+import type { QaSurfaceConfig, ResolvedQaSlashCommands } from "../types.js";
+/** Palette ceilings; a palette longer than the viewport is unusable on mobile. */
+export declare const QA_SLASH_MAX_VISIBLE_MIN = 1;
+export declare const QA_SLASH_MAX_VISIBLE_MAX = 100;
+/**
+ * Resolve the slash interface policy.
+ *
+ * The master switch lives in lockdown, so it arrives as a neighbor rather than
+ * being re-read here — one owner per decision. Two consequences are deliberate:
+ *
+ * - An upgrade from a deployment that had already set
+ *   `lockdown.allowSlashCommands: true` but knows nothing about this section
+ *   keeps working: skills fall back to `all` (every user-invocable skill the
+ *   session already exposed) and commands stay denied. The flag is reported as
+ *   `legacyDefaults` so the Host can say so once, out loud.
+ * - A deployment that declares the section and leaves the switch off changes
+ *   nothing at all: the resolved policy is inert until the switch is on.
+ */
+export declare function resolveSlashCommands(input: QaSurfaceConfig, allowSlashCommands: boolean): ResolvedQaSlashCommands;
+//# sourceMappingURL=slash-commands.d.ts.map

package/lib/types/index.d.ts

@@ -1,7 +1,7 @@
 import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import type { Context } from "@deepseek-ai/cordis";
 import type { QaTurnSources } from "./provenance/types.js";
-import type { QaAccountProfileInput, QaAccountSession, QaAccountStartersInput, QaAccountUserPublic, QaApprovalDecision, QaClaimResult, QaLockdownProof, QaOwnershipEntry, QaPendingApproval, QaPendingQuestion, QaQuestionAnswerItem, QaSurfaceConfig, ResolvedQaSurfaceConfig, QaSkillDocument, QaSkillDraftInput, QaSkillRemoval, QaSkillSummary, QaSkillToolDescriptor, QaSkillValidation, QaSourceFilePreview, QaWhoamiResult, QaPrincipal, QaAccessAdminSnapshot, QaAdminAuditEvent, QaAdminOverview, QaAdminPage, QaAdminUserDetail, QaAdminUserRow, QaAdminUserUpdate, QaAuditQuery, QaCapabilitySelection, QaConversationDetail, QaConversationQuery, QaConversationReview, QaConversationReviewInput, QaConversationSummary, QaCurrentAccess, QaFeedbackQuery, QaFeedbackRow, QaMessageFeedback, QaMessageFeedbackInput, QaQualityMetrics, QaReviewQueueItem, QaReviewQueueRow, QaSessionAccess, QaSkillActivationRecord, QaSkillAssignmentOverride, QaSubrole, QaUserAccess, QaUserQuery } from "./types.js";
+import type { QaAccountProfileInput, QaAccountSession, QaAccountStartersInput, QaAccountUserPublic, QaApprovalDecision, QaClaimResult, QaLockdownProof, QaOwnershipEntry, QaPendingApproval, QaPendingQuestion, QaQuestionAnswerItem, QaSurfaceConfig, ResolvedQaSurfaceConfig, QaSkillDocument, QaSkillDraftInput, QaSkillRemoval, QaSkillSummary, QaSkillToolDescriptor, QaSkillValidation, QaSourceFilePreview, QaWhoamiResult, QaPrincipal, QaAccessAdminSnapshot, QaAdminAuditEvent, QaAdminOverview, QaAdminPage, QaAdminUserDetail, QaAdminUserRow, QaAdminUserUpdate, QaAuditQuery, QaCapabilitySelection, QaConversationDetail, QaConversationDeletion, QaConversationQuery, QaConversationReview, QaConversationReviewInput, QaConversationSummary, QaCurrentAccess, QaFeedbackQuery, QaFeedbackRow, QaMessageFeedback, QaMessageFeedbackInput, QaQualityMetrics, QaReviewQueueItem, QaReviewQueueRow, QaSessionAccess, QaSlashCatalog, QaSlashExecution, QaSlashSubmitAttachment, QaSkillActivationRecord, QaSkillAssignmentOverride, QaSubrole, QaUserAccess, QaUserQuery } from "./types.js";
 export declare const name = "qa-surface";
 export declare const inject: string[];
 import { QA_SURFACE_SETTINGS_NAMESPACE } from "./shared/settings.js";
@@ -38,6 +38,12 @@ export declare class QaSurface extends TypertRemoteService {
     private readonly personalSkills;
     /** Personal-skill remote bodies; the wire signatures stay on this class. */
     private readonly skillRemotes;
+    /**
+     * Slash-catalog and command-admission bodies. Admission, not execution:
+     * the native skill and command runtimes stay the only things that know what
+     * a `/name` means.
+     */
+    private readonly slashRemotes;
     private readonly launchToken;
     /** Root session principals attested for their owner, never for admin viewing. */
     private readonly integrationPrincipals;
@@ -52,6 +58,25 @@ export declare class QaSurface extends TypertRemoteService {
     constructor(ctx: Context, entry?: QaSurfaceConfig);
     /** The quality store, opening its file the first time anyone needs it. */
     private quality;
+    /**
+     * The standing scope of the preset QA chats run under, so an administrator's
+     * capability catalog is read the way a chat reads it. Everything a preset
+     * mounts — its skill catalog, its tool family — is registered in that scope,
+     * and a global-only read showed the operator an almost empty page. Resolving
+     * the preset composes it but starts no agent, no session and no turn;
+     * without a pinned preset there is nothing to borrow, and the read stays
+     * global.
+     */
+    private qaPresetScope;
+    /**
+     * Drop what the quality layer kept about chats that no longer exist in the
+     * Harness. The ownership sweep calls this with the ids it reclaimed: the
+     * record it removes is one thing the deployment held about a chat, and
+     * ratings, reviews and queue entries are the rest. Failure is logged and
+     * swallowed — housekeeping runs inside a review read, and a store that
+     * cannot be opened must not fail the page that triggered it.
+     */
+    private dropVanishedChats;
     /** Resolve browser authentication to the caller only; never accepts an id. */
     principalForToken(token: string): QaPrincipal | undefined;
     /** Resolve only a directly QA-owned root session; delegated children fail closed. */
@@ -59,6 +84,21 @@ export declare class QaSurface extends TypertRemoteService {
     /** Admit tools that independently enforce the same QA principal boundary. */
     registerPrincipalScopedTools(names: readonly string[]): () => void;
     getConfig(): ResolvedQaSurfaceConfig;
+    /**
+     * Ownership plus the role's user-skill grant for one slash read.
+     *
+     * Ownership comes first and for the same reason the rest of the plugin does
+     * it: a catalog names the skills a chat can reach, and a foreign browser has
+     * no business enumerating that. With accounts off there is no identity to
+     * check and the deployment's lockdown is the boundary, exactly as it is for
+     * every other remote.
+     *
+     * The grant mirrors `installQaSkillPolicy` to the letter — an empty
+     * `userSkills` list means the role keeps no separate user list, not that it
+     * grants nothing — so the palette can never offer a skill the typed gesture
+     * would refuse, nor hide one it would accept.
+     */
+    private slashSessionGrant;
     /**
      * Self-service signup; the first account ever created becomes admin. The
      * display name derives from the email: the generated client enforces exact
@@ -139,6 +179,12 @@ export declare class QaSurface extends TypertRemoteService {
     adminConversations(token: string, query: QaConversationQuery, cursor: string | null, limit: number | null): Promise<QaAdminPage<QaConversationSummary>>;
     /** One conversation with its messages, tool calls and review state. */
     adminConversation(token: string, conversationId: string): Promise<QaConversationDetail>;
+    /**
+     * Remove one conversation from the deployment. Admin-only, audited, and the
+     * only path that deletes what a person wrote — the sidebar's own delete
+     * stays what it always was, a per-browser row.
+     */
+    adminDeleteConversation(token: string, conversationId: string): Promise<QaConversationDeletion>;
     adminFeedback(token: string, query: QaFeedbackQuery, cursor: string | null, limit: number | null): Promise<QaAdminPage<QaFeedbackRow>>;
     /**
      * Rate one of the caller's own assistant messages. The token names the only
@@ -216,7 +262,38 @@ export declare class QaSurface extends TypertRemoteService {
     skillsTools(token: string): {
         readonly tools: readonly QaSkillToolDescriptor[];
     };
+    /**
+     * The slash entries this browser may offer for one chat: the session's
+     * user-invocable skills and its agent's effective commands, already cut down
+     * by the deployment policy and by the chat's role. The browser filters and
+     * ranks this list; it never widens it.
+     *
+     * Enabled is reported rather than assumed, so a page that loaded before the
+     * operator flipped the master switch learns the truth instead of showing an
+     * empty palette forever.
+     */
+    slashCatalog(token: string, sessionId: string): Promise<QaSlashCatalog>;
+    /**
+     * Run one human command line. The line is the whole request — the browser
+     * sends no name, no kind and no descriptor, so there is nothing for it to
+     * forge; admission re-derives the name and re-checks the policy against the
+     * deployment's own config.
+     *
+     * A command never becomes a model message: the native runtime answers it and
+     * writes `command/run`/`command/done` into the session log, which is where
+     * the transcript row is read from.
+     */
+    slashExecute(token: string, sessionId: string, line: string, attachments: readonly QaSlashSubmitAttachment[]): Promise<QaSlashExecution>;
     private refreshRoute;
+    /**
+     * A deployment that set `lockdown.allowSlashCommands: true` before this
+     * section existed keeps the behaviour it asked for — skills at `all`,
+     * commands denied — and is told so once per configuration change, because
+     * "skills appeared after the upgrade" is otherwise indistinguishable from a
+     * defect. Commands are never part of that fallback: an upgrade must not hand
+     * the user a control-plane command nobody named.
+     */
+    private warnLegacySlashDefaults;
     /**
      * The document pipeline moved out of this plugin into `@yadsh/dsh-documents`.
      * A deployment whose profile still carries the old `documents` section would

package/lib/types/personal-skills/service.d.ts

@@ -92,6 +92,11 @@ export declare class QaPersonalSkills {
      * The skills one session cwd exposes to DSH. A file the parser rejects, or
      * one whose name disagrees with its directory, is reported in the editor and
      * never handed to the model as a half-valid skill.
+     *
+     * This is the model-facing discovery path, so it degrades to empty instead
+     * of throwing: a provider that throws marks the whole catalog snapshot
+     * incomplete, and the harness then withholds the available-skills section
+     * from every session — not just this account's skills.
      */
     discover(cwd: string): readonly QaStoredSkill[];
     /** Re-read one skill of a session cwd, re-checking the same boundary. */

package/lib/types/provenance/host-store.d.ts

@@ -44,6 +44,19 @@ export declare class QaProvenanceHost {
      * restart. Growth of the file is bounded by the snapshot store's caps.
      */
     private forget;
+    private forgetById;
+    /**
+     * Drop everything kept about one chat, in memory and in storage alike.
+     *
+     * Unlike {@link forget}, which runs on every teardown of a chat that still
+     * exists and deliberately keeps its stored turns, this is for a chat that is
+     * gone: nothing will reopen it, so the durable shard goes with it. The
+     * administrative deletion calls this in the same act that removes the
+     * session's logs.
+     *
+     * @param sessionId - the chat whose collected sources are dropped.
+     */
+    dropSession(sessionId: string): void;
     private forgetAll;
     bundles(sessionId: string): readonly QaTurnSources[];
     sourceAllowed(sessionId: string, path: string): boolean;

package/lib/types/questions.d.ts

@@ -33,6 +33,12 @@ export interface QaQuestionAnswer {
 }
 /** What the model reads when the deployment does not answer questions. */
 export declare const QA_QUESTIONS_UNSUPPORTED = "questions are not answered in this assistant view; ask the user in plain text instead";
+/**
+ * The harness tool that produces these requests. A deployment that parks
+ * questions still has to let the attested session call it: this plugin never
+ * adds the name to a tool policy on its own.
+ */
+export declare const QA_ASK_QUESTION_TOOL = "ask_user_question";
 /**
  * User questions in the QA view.
  *
@@ -84,5 +90,7 @@ export declare class QaQuestionGate {
     private park;
     /** Fail the questions one session's agent owns; a disposed agent cannot ask. */
     private settleOwner;
+    /** Fail the questions one agent parked; an idle agent cannot receive them. */
+    private settleAgent;
 }
 //# sourceMappingURL=questions.d.ts.map

package/lib/types/slash/catalog.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The unified presentation model behind the palette.
+ *
+ * Two native catalogs arrive here — the session's user-invocable skills and
+ * the session agent's effective commands — and leave as one list of entries
+ * whose identity is `skill:<name>` / `command:<name>`. The prefix is the whole
+ * point: both registries may publish a `plan`, and a palette that keyed rows
+ * by bare name would let one of them silently replace the other.
+ *
+ * Pure on purpose. Nothing here reads a session, a service or a file: the host
+ * remote gathers the native inputs, this module decides what the palette sees,
+ * and the tests drive it with plain arrays.
+ */
+import type { QaSlashCatalogEntry, QaSlashCommandSurface } from "../types.js";
+import { type QaSlashPolicy } from "./policy.js";
+export declare const QA_SLASH_SKILL_PREFIX = "skill:";
+export declare const QA_SLASH_COMMAND_PREFIX = "command:";
+/** One user-invocable skill, as the skills registry published it. */
+export interface QaSlashNativeSkill {
+    readonly name: string;
+    readonly description: string;
+    readonly whenToUse?: string;
+    /** Whether the model is also offered this skill. */
+    readonly modelInvocable?: boolean;
+}
+/** One effective command descriptor, as the command registry published it. */
+export interface QaSlashNativeCommand {
+    readonly name: string;
+    readonly description: string;
+    readonly inputHint?: string;
+    readonly acceptsAttachments?: boolean;
+}
+export interface BuildSlashCatalogOptions {
+    readonly skills: readonly QaSlashNativeSkill[];
+    readonly commands: readonly QaSlashNativeCommand[];
+    readonly skillPolicy: QaSlashPolicy;
+    readonly commandPolicy: QaSlashPolicy;
+    /**
+     * The session role's own user-skill grant, when the access system is on.
+     * `undefined` means the role system has no opinion, which is its state on a
+     * deployment that never enabled roles — not "grant nothing".
+     */
+    readonly grantedSkills?: readonly string[] | undefined;
+    readonly commandSurface: QaSlashCommandSurface;
+    /** Native entries arrive alphabetically; this makes the order explicit. */
+    readonly localeCompare?: (left: string, right: string) => number;
+}
+/** The routing identity of one native name; never the bare name. */
+export declare function slashEntryId(kind: QaSlashCatalogEntry["kind"], name: string): string;
+/**
+ * Build the palette the browser is allowed to show. Skills lead, commands
+ * follow: the two kinds stay contiguous so the palette can group them without
+ * re-sorting, and a name collision keeps both rows.
+ */
+export declare function buildSlashCatalog(options: BuildSlashCatalogOptions): readonly QaSlashCatalogEntry[];
+//# sourceMappingURL=catalog.d.ts.map