@yadsh/dsh-qa-surface 0.15.1 → 0.15.3

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

@@ -64,6 +64,19 @@ export declare function withdrawnSkillNames(config: QaCapabilityConfig): Readonl
  */
 export declare function personalUserSkillNames(config: QaCapabilityConfig, ownSkills: ReadonlySet<string> | undefined): readonly string[];
 export declare function resolveCapabilityPolicy({ config, subroleId, systemTools, systemSkills, available: installed, skillMetadata, revision, }: ResolveCapabilityPolicyInput): QaEffectiveCapabilityPolicy;
+/**
+ * The skills a person may invoke under one policy — the whole of the
+ * user-facing allow-list, and the one place it is read.
+ *
+ * An empty `userSkills` means the role keeps no separate user list, not that it
+ * grants nothing, so the model-facing set stands in for it. A typed gesture is
+ * admitted or refused by this list and the palette is narrowed by it, so both
+ * have to derive it here: a name the palette offers but the line refuses, or
+ * one the palette hides while the line would accept, is one rule read two ways.
+ *
+ * @param policy - the effective capability policy of one session.
+ */
+export declare function userInvocableSkillNames(policy: QaEffectiveCapabilityPolicy): readonly string[];
 export interface ResolveSkillAccessInput {
     readonly config: QaCapabilityConfig;
     /** Every discovered skill with its normalized metadata. */

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

@@ -158,6 +158,32 @@ export declare class QaAccessService {
     policyForSessionOwner(owner: {
         readonly id: string;
     } | undefined, sessionId: string, agent: Agent): Promise<QaResolvedSessionPolicy | undefined>;
+    /**
+     * The policy one session record answers with: the snapshot it froze, or the
+     * role as it is configured now when the chat has never frozen one.
+     *
+     * Every read of a session's capabilities goes through here, so a chat that is
+     * running and a chat nobody has woken cannot disagree about what its role
+     * grants.
+     */
+    private policyForRecord;
+    /**
+     * The policy of a chat this process holds no live agent for.
+     *
+     * A cold chat has an owner and a role, and the reads that name its
+     * capabilities must narrow it by the rule above — the same one a live chat is
+     * narrowed by — rather than answer "no role opinion" because the agent that
+     * carries the capability snapshot happens to be asleep. What a cold chat has
+     * no answer for is that snapshot: the catalog the deployment mounts for every
+     * chat stands in for the agent's own, which is why the project layer of this
+     * chat's workspace is missing from it, and why nothing is frozen onto the
+     * session record here — a palette read must not decide what a later turn may
+     * do.
+     *
+     * @returns the resolved policy; the ownership check is the refusal, so a
+     *   foreign browser never reaches it.
+     */
+    policyForColdSession(token: string, sessionId: string): Promise<QaEffectiveCapabilityPolicy>;
     /** The browser's entry point: the token resolves the owning account. */
     policyForSession(token: string, sessionId: string, agent: Agent): Promise<QaResolvedSessionPolicy | undefined>;
     /** Activation history of one session, for review and quality analysis. */

package/lib/types/attestation.d.ts

@@ -8,7 +8,7 @@
  * audience, precise enough for an operator reading the browser console to
  * know which class of mismatch to look for in the Host logs.
  */
-export type QaAttestationReason = "agent-unavailable" | "workspace-unavailable" | "composition-mismatch" | "permission-preset" | "adoption-refused" | "unknown-tools" | "auth-required" | "session-owned-elsewhere" | "attestation-failed";
+export type QaAttestationReason = "agent-unavailable" | "workspace-unavailable" | "composition-mismatch" | "permission-preset" | "adoption-refused" | "subagent-session" | "unknown-tools" | "auth-required" | "session-owned-elsewhere" | "attestation-failed";
 /** Host rejection whose wire message carries the coarse reason marker. */
 export declare class QaAttestationError extends Error {
     readonly reason: QaAttestationReason;

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

@@ -38,6 +38,8 @@ export type QaAccountsSnapshot = {
     /** Bumped whenever ownedIds, ownIds or ownership changes; re-projects lists. */
     readonly ownedRevision: number;
 };
+/** The Host's password floor, mirrored so a refusal and its copy name the same number. */
+export declare const QA_MIN_PASSWORD_LENGTH = 8;
 /**
  * Audience-safe copy for the coarse account refusal codes; anything unknown
  * falls back to the generic line.

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

@@ -307,6 +307,19 @@ export declare class QaSessionController {
      * so this call gives up rather than taking the chat back from under them.
      */
     startDraft(policyChange?: boolean): Promise<void>;
+    /**
+     * Put a draft on the screen: no session, so no row in the chat history and no
+     * record on the Host until the first prompt is sent into it
+     * ({@link materializeDraft}). Taking the screen moves the generation the way
+     * every other path that retires a binding does, so an adoption still looking
+     * for its session measures itself against the new one rather than taking the
+     * draft back.
+     *
+     * A draft that is already on screen — including one whose first send fell
+     * short of a claimed session — keeps its chat identity: a new one rebuilds the
+     * composer over the question the visitor is still looking at.
+     */
+    private enterDraft;
     /**
      * Turn the current draft into a real attested session. Runs inside the
      * send flow; concurrent sends share one materialization. A refusal here is

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

@@ -20,5 +20,11 @@ export declare function projectTranscript(snapshot: ConversationSnapshot | undef
     readonly subagentNames?: Readonly<Record<string, string>>;
     /** Sign settlement titles with deterministic codenames. */
     readonly subagentCodenames?: boolean;
+    /**
+     * The chat's own workspace directory. An answer that quotes a file inside it
+     * is made to name the file instead of locating it, because the directory is
+     * the account's own and the transcript is not where that layout belongs.
+     */
+    readonly workspaceRoot?: string;
 }): readonly QaMessage[];
 //# sourceMappingURL=QaTranscriptAdapter.d.ts.map

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

@@ -10,9 +10,13 @@ export declare class QaPolicyAttestationError extends Error {
     constructor(reason?: string | null);
 }
 /**
- * Refusals that classify an existing chat as belonging to an older deployment
- * composition. Keeping only its transcript is safe: policyReady stays false,
- * so no prompt, cancel, approval or question reaches the Host.
+ * Refusals that classify what the browser has on screen rather than faulting
+ * the deployment: an existing chat of an older composition, one adopted from
+ * outside the QA policy, or an identity that is another conversation's
+ * delegated child.
+ *
+ * Keeping only its transcript is safe: policyReady stays false, so no prompt,
+ * cancel, approval or question reaches the Host.
  */
 export declare function canOpenAsCompatibilityReadOnly(reason: string | null): boolean;
 /**

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

@@ -0,0 +1,10 @@
+import type { QaArtifactView } from "../types.js";
+/**
+ * The files one tool result reports, in the order it reported them.
+ *
+ * `output` is the rendered text of the result, the same string the work group
+ * shows. A tool that produced nothing — a read, an inspection, a refusal — is
+ * not in the table and contributes no artifact.
+ */
+export declare function artifactsOfToolResult(toolName: string, output: string | null): readonly QaArtifactView[];
+//# sourceMappingURL=chat-artifacts.d.ts.map

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

@@ -2,27 +2,32 @@
  * Attachment roster of one chat, projected for the rail's files tab: a pure
  * scan of the durable transcript, newest message first. The browser never
  * re-reads file bytes (the attachment route serves images), so a row keeps
- * the same handle the transcript shows.
+ * the same handle the transcript shows. A document the agent produced is on
+ * the same roster: it is an attachment of the conversation, sent by the answer
+ * rather than by the question.
  */
-import type { QaImageView, QaMessage, QaFileView } from "../types.js";
-/** Everything one user message carried, in prompt order. */
+import type { QaArtifactView, QaImageView, QaMessage, QaFileView } from "../types.js";
+/** Everything one message carried, in prompt order. */
 export interface QaChatFileGroup {
-    /** The user message id; doubles as the transcript turn anchor. */
+    /** The message id; doubles as the transcript turn anchor. */
     readonly messageId: string;
     /** Wall-clock send time, when the transcript recorded one. */
     readonly timestamp?: number;
     readonly files: readonly QaFileView[];
     readonly images: readonly QaImageView[];
+    /** Files this message's turn produced; empty on a message that made none. */
+    readonly artifacts?: readonly QaArtifactView[];
 }
 /** Whether the group carries at least one attachment of either kind. */
 export declare function groupHasAttachments(group: QaChatFileGroup): boolean;
 /** Total attachment count across groups; the header badge's value. */
 export declare function countChatAttachments(groups: readonly QaChatFileGroup[]): number;
 /**
- * Group the attachments of a chat by their sending message. Only user
- * messages can carry attachments; messages without any are dropped. The
- * groups come out newest message first, matching a roster that grows at the
- * bottom of the transcript.
+ * Group the attachments of a chat by their message. A user message carries what
+ * was sent; an assistant message carries what its turn produced, so a document
+ * the stand made is listed beside the answer that made it instead of only on
+ * disk. Messages with neither are dropped. The groups come out newest first,
+ * matching a roster that grows at the bottom of the transcript.
  * @param messages - the chat's projected transcript.
  * @returns attachment groups, newest message first.
  */

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

@@ -0,0 +1,37 @@
+/**
+ * The sentence a copy affordance falls back to. Three surfaces show it, so it
+ * is written once.
+ */
+export declare const COPY_MANUAL_HINT = "\u0421\u043A\u043E\u043F\u0438\u0440\u0443\u0439\u0442\u0435 \u0432\u0440\u0443\u0447\u043D\u0443\u044E";
+/** The reason behind that sentence, for the tooltip that carries it. */
+export declare const COPY_MANUAL_REASON = "\u0411\u0440\u0430\u0443\u0437\u0435\u0440 \u043D\u0435 \u043E\u0442\u0434\u0430\u0451\u0442 \u0431\u0443\u0444\u0435\u0440 \u043E\u0431\u043C\u0435\u043D\u0430 \u2014 \u0432\u044B\u0434\u0435\u043B\u0438\u0442\u0435 \u0442\u0435\u043A\u0441\u0442 \u0438 \u0441\u043A\u043E\u043F\u0438\u0440\u0443\u0439\u0442\u0435 \u0435\u0433\u043E \u0441\u0430\u043C\u0438";
+/**
+ * Whether this browser can be asked to move text at all.
+ *
+ * The stand is served over plain HTTP on a LAN address, and there
+ * `window.isSecureContext` is false, so the browser never exposes
+ * `navigator.clipboard`. The older copy command still works in an insecure
+ * context, which is why the absence of the API alone does not mean copying is
+ * impossible — and why asking for it anyway only ends in silence.
+ */
+export declare function canCopyToClipboard(): boolean;
+/**
+ * Write `text` to the clipboard, resolving false when nothing took it — the
+ * caller then says so instead of leaving the click unanswered.
+ */
+export declare function copyTextToClipboard(text: string): Promise<boolean>;
+export interface CopyAction {
+    /** The flash that says the text left. */
+    readonly copied: boolean;
+    /** Nothing can copy here: the affordance is a hint, not a button. */
+    readonly impossible: boolean;
+    /** A copy was attempted and refused: the hint joins a still-live button. */
+    readonly refused: boolean;
+    readonly copy: () => void;
+}
+/**
+ * The copy state one affordance needs: the confirmation window, the refusal
+ * that replaces it with the manual hint, and whether either was ever possible.
+ */
+export declare function useCopyAction(text: string): CopyAction;
+//# sourceMappingURL=clipboard.d.ts.map

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

@@ -1,4 +1,4 @@
-import type { QaAccountsController, QaAccountsSnapshot } from "../QaAccountsController.js";
+import { type QaAccountsController, type QaAccountsSnapshot } from "../QaAccountsController.js";
 export interface QaAuthGateProps {
     readonly accounts: QaAccountsController;
     readonly snapshot: QaAccountsSnapshot;
@@ -9,7 +9,9 @@ export interface QaAuthGateProps {
 /**
  * The full-frame login/registration card shown instead of the chat while the
  * deployment has accounts enabled and the browser holds no valid identity.
- * Errors are the Host's coarse codes rendered as audience-safe copy.
+ * Both halves of the error line are the surface's own copy: the card refuses
+ * mistyped input itself, and renders the Host's coarse codes in audience-safe
+ * words.
  */
 export declare function QaAuthGate(props: QaAuthGateProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=QaAuthGate.d.ts.map

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

@@ -4,11 +4,20 @@ export interface QaFileAttachmentProps {
     /** Pending draft vs already-sent attachment: pending offers removal. */
     readonly tone: "draft" | "sent";
     readonly onRemove?: () => void;
+    /**
+     * Open the file: shown as a control on a card the reader can act on, and left
+     * out of a chip that only records what was sent. A produced document is
+     * worthless as a name in a paragraph — this is what makes it reachable.
+     */
+    readonly onOpen?: () => void;
+    /** Save the file. Omitted where the surface cannot read its bytes. */
+    readonly onDownload?: () => void;
 }
 /**
- * One attached file: the extension badge, the name and the size. The browser
- * never re-reads these bytes (the Host attachment route serves images), so
- * both the composer card and the sent row show the same handle.
+ * One attached file: the extension badge, the name and the size. A sent
+ * attachment shows the handle the model resolved and the browser never
+ * re-reads its bytes; a file the turn produced is the same chip with the two
+ * controls that make it usable — open it, or take it away.
  */
-export declare function QaFileAttachment({ name, bytes, tone, onRemove, }: QaFileAttachmentProps): import("react/jsx-runtime").JSX.Element;
+export declare function QaFileAttachment({ name, bytes, tone, onRemove, onOpen, onDownload, }: QaFileAttachmentProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=QaFileAttachment.d.ts.map

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

@@ -1,11 +1,24 @@
+import type { QaArtifactView } from "../../types.js";
 import type { QaChatFileGroup } from "../chat-files.js";
 import type { QaBoundSourceApi } from "../types.js";
 export interface QaFilesPanelProps {
     readonly groups: readonly QaChatFileGroup[];
     /** Resolve an image attachment to an object URL; images render inert without it. */
     readonly resolveImage?: (attachmentId: string) => Promise<string>;
-    /** Scroll the transcript to the group's user message. */
+    /** Scroll the transcript to the group's message. */
     readonly onJumpToMessage: (messageId: string) => void;
+    /** Open a produced file in the workspace viewer below. */
+    readonly onArtifactOpen?: (artifact: QaArtifactView) => void;
+    /** Save a produced file. */
+    readonly onArtifactDownload?: (artifact: QaArtifactView) => void;
+    /**
+     * A file to open on arrival, with the request's stamp. The stamp is what makes
+     * a second click on the same card a fresh arrival rather than a no-op.
+     */
+    readonly openArtifact?: {
+        readonly path: string;
+        readonly stamp: number;
+    };
     /**
      * The chat whose workspace the panel browses. Both this and `api` are absent
      * in hosts that only render the attachment roster, where the workspace
@@ -23,5 +36,5 @@ export interface QaFilesPanelProps {
  * back, and the images are the same object URLs the message showed — while the
  * workspace section reads through the Host's fenced listing and file reads.
  */
-export declare function QaFilesPanel({ groups, resolveImage, onJumpToMessage, sessionId, api, }: QaFilesPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function QaFilesPanel({ groups, resolveImage, onJumpToMessage, onArtifactOpen, onArtifactDownload, openArtifact, sessionId, api, }: QaFilesPanelProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=QaFilesPanel.d.ts.map

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

@@ -1,4 +1,4 @@
-import type { QaMessage as QaMessageModel, QaSource, QaTurnSources } from "../../types.js";
+import type { QaArtifactView, QaMessage as QaMessageModel, QaSource, QaTurnSources } from "../../types.js";
 import type { QaFeedbackReason } from "../../types.js";
 export interface QaMessageProps {
     readonly message: QaMessageModel;
@@ -17,6 +17,14 @@ export interface QaMessageProps {
     readonly onOpenSources?: (sources: readonly QaSource[], complete: boolean, incompleteOrigins: QaTurnSources["incompleteOrigins"]) => void;
     /** Open one path-backed source's detail (an inline footnote click). */
     readonly onSourceDetail?: (source: QaSource) => void;
+    /**
+     * Open a file this answer's turn produced, in the surface's own file viewer.
+     * Omitted where the surface has no workspace reads: the card then names the
+     * file without promising an action it cannot perform.
+     */
+    readonly onArtifactOpen?: (artifact: QaArtifactView) => void;
+    /** Save a produced file. Omitted on the same terms as {@link onArtifactOpen}. */
+    readonly onArtifactDownload?: (artifact: QaArtifactView) => void;
     /** Operator-configured running phrases; omitted reads the built-in list. */
     readonly thinkingPhrases?: readonly string[];
     /**
@@ -39,5 +47,5 @@ export interface QaMessageProps {
  * comparison is by value, which keeps fresh copies cheap to recognize.
  */
 export declare function sameMessage(a: QaMessageModel, b: QaMessageModel): boolean;
-export declare const QaMessage: import("react").MemoExoticComponent<({ message, renderMarkdown, showTimestamp, stateKey, onRegenerate, resolveImage, onOpenSources, onSourceDetail, thinkingPhrases, onRateFeedback, }: QaMessageProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const QaMessage: import("react").MemoExoticComponent<({ message, renderMarkdown, showTimestamp, stateKey, onRegenerate, resolveImage, onOpenSources, onSourceDetail, onArtifactOpen, onArtifactDownload, thinkingPhrases, onRateFeedback, }: QaMessageProps) => import("react/jsx-runtime").JSX.Element>;
 //# sourceMappingURL=QaMessage.d.ts.map

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

@@ -2,6 +2,12 @@ import type { QaBoundSourceApi } from "../types.js";
 export interface QaWorkspaceBrowserProps {
     readonly sessionId: string;
     readonly api: QaBoundSourceApi;
+    /**
+     * A file to open on arrival, named inside this workspace. The card under an
+     * answer points here rather than carrying its own viewer, so a document the
+     * turn produced previews through the same fenced read a browsed file uses.
+     */
+    readonly initialFile?: string;
 }
 /**
  * The chat's own workspace, browsable from the files rail.
@@ -11,5 +17,5 @@ export interface QaWorkspaceBrowserProps {
  * the visitor out of the chat's tree. Opening a file reads exactly that file —
  * text inline, anything else as a downloadable handle.
  */
-export declare function QaWorkspaceBrowser({ sessionId, api, }: QaWorkspaceBrowserProps): import("react/jsx-runtime").JSX.Element;
+export declare function QaWorkspaceBrowser({ sessionId, api, initialFile, }: QaWorkspaceBrowserProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=QaWorkspaceBrowser.d.ts.map

package/lib/types/client/components/copy-hint.d.ts

@@ -0,0 +1,8 @@
+/**
+ * What a copy affordance shows where copying cannot happen: a sentence naming
+ * the dead end, in place of a button that would only look like it worked.
+ */
+export declare function CopyHint({ testId }: {
+    readonly testId: string;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=copy-hint.d.ts.map

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

@@ -25,6 +25,11 @@ export interface QaBoundProjectionInput {
     readonly conversationSnapshot: ConversationSnapshot | undefined;
     /** Turn bundles with the Host provenance already merged in (Host wins). */
     readonly sourceBundles: readonly QaTurnSources[];
+    /**
+     * The chat's own workspace directory, as the Host records it for this session.
+     * The transcript masks it out of an answer that quotes a file it made.
+     */
+    readonly workspaceRoot?: string;
     /**
      * Tool calls and questions the Host parked for the operator. They are
      * host-side state, not part of the session snapshot, so the controller polls

package/lib/types/client/workspace-download.d.ts

@@ -0,0 +1,16 @@
+import type { QaWorkspaceFile } from "../types.js";
+/**
+ * Handing one file of the chat's workspace to the person the turn produced it
+ * for.
+ *
+ * A produced document has no attachment-store handle, so the download is the
+ * same read the files panel does: the Host returns the bytes under the chat's
+ * own fence and the browser's download machinery takes it from there. Shared by
+ * the panel's own viewer and the card under an answer, so the two can never
+ * disagree on what "download this file" means.
+ */
+/** Last segment of a workspace path, spelled with either separator. */
+export declare function fileNameOf(path: string): string;
+/** Save one workspace file under its own name. */
+export declare function downloadWorkspaceFile(file: QaWorkspaceFile): void;
+//# sourceMappingURL=workspace-download.d.ts.map

package/lib/types/client/workspace-paths.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The answer a person reads names a file; it does not say where the deployment
+ * keeps the account that owns it.
+ *
+ * A model quoting a path it was handed prints it verbatim, and a QA deployment
+ * gives every account its own directory under one parent, so a path printed
+ * with an account identifier is a sentence about the server's layout — and
+ * stand dialogs below the signature line can be read by other accounts of the
+ * same server. The document tools report workspace-relative names, which is
+ * the fix at the source; this is the repair for what still arrives, because a
+ * model can rebuild a path from the working directory it is told, and because
+ * an answer written before this change is durable history that replays.
+ */
+/**
+ * Rewrite an answer so a file is named, not located.
+ *
+ * The chat's own workspace directory is removed, leaving the spelling the
+ * producing tool reports and the workspace reads take. The per-account
+ * partition is removed the same way even when the root is unknown or the answer
+ * quotes a different chat's file, because the identifier inside it is the part
+ * that must not be printed. A path that is neither of those is left alone: a
+ * reader told about `/etc/hosts` is not being shown this deployment's layout.
+ */
+export declare function toWorkspaceRelativeText(text: string, workspaceRoot: string | undefined): string;
+//# sourceMappingURL=workspace-paths.d.ts.map

package/lib/types/index.d.ts

@@ -107,10 +107,12 @@ export declare class QaSurface extends TypertRemoteService {
      * 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.
+     * The grant is {@link userInvocableSkillNames} — the one list the typed
+     * gesture is admitted or refused by — for every chat that has a role, woken
+     * or not: the palette a visitor sees before the chat runs is narrowed by that
+     * same rule, so it can neither offer a name the line would refuse nor hide
+     * one it would accept. `undefined` is answered only where the deployment has
+     * no roles to consult at all.
      */
     private slashSessionGrant;
     /**

package/lib/types/secure-session.d.ts

@@ -137,6 +137,10 @@ export declare class QaPolicyAdmission {
      * composition a stock prompt would produce — so a session composed outside
      * the QA preset still lands on the mismatch refusals below ("composition
      * mismatch"), and the adoption and permission checks stay the gate.
+     *
+     * Not every answer describes this deployment: the Host also names an identity
+     * subagent routing owns, which is a fact about another conversation's child
+     * rather than a failure of this chat. The two are refused apart below.
      */
     private liveAgent;
     /**

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

@@ -39,6 +39,11 @@ export interface BuildSlashCatalogOptions {
      * 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".
+     *
+     * This is the only grant a read may answer with, whatever the chat looks
+     * like: a chat that is running and a chat nobody has woken are narrowed by
+     * the same allow-list and the same role, because the palette that names a
+     * skill this chat may not invoke teaches the visitor a gesture that fails.
      */
     readonly grantedSkills?: readonly string[] | undefined;
     readonly commandSurface: QaSlashCommandSurface;

package/lib/types/types.d.ts

@@ -1480,6 +1480,13 @@ export type QaMessage = QaUserMessage | {
     readonly seq?: number;
     /** Host turn this answer belongs to; groups regenerations into variants. */
     readonly turn?: number;
+    /**
+     * Files this turn produced, in the order the tools reported them. The
+     * answer is the place a produced document is handed over: without these
+     * cards the file exists only as a path in a paragraph, and a reader who
+     * does not know the files tab concludes nothing was made.
+     */
+    readonly artifacts?: readonly QaArtifactView[];
     /** Canonical evidence snapshot shared with this answer's source drawer. */
     readonly sources?: readonly QaSource[];
     readonly sourcesComplete?: boolean;
@@ -1589,6 +1596,25 @@ export interface QaFileView {
     readonly name: string;
     readonly bytes: number;
 }
+/**
+ * A file the agent produced during the turn an answer belongs to.
+ *
+ * An artifact has no attachment-store handle: it lives in the chat's own
+ * workspace, so the card addresses it by the workspace-relative name the
+ * producing tool reported — the spelling the Host's workspace reads take, and
+ * the only spelling that cannot publish the directory the deployment keeps
+ * this account's workspace in.
+ */
+export interface QaArtifactView {
+    /** Workspace-relative path; the identifier every workspace read takes. */
+    readonly path: string;
+    /** Last path segment, which is what the card is signed with. */
+    readonly name: string;
+    /** Format the producing tool reported: `docx`, `pdf` or `md`. */
+    readonly format: string;
+    /** Bytes as the tool reported them; 0 when it reported no size. */
+    readonly bytes: number;
+}
 /** A subagent transcript opened read-only from the agents panel. */
 export interface QaSubagentView {
     readonly id: string;

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "QA Surface",
+    "description": "A focused end-user QA surface backed by native DeepSeek Harness sessions"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yadsh/dsh-qa-surface",
-  "version": "0.15.1",
+  "version": "0.15.3",
   "description": "A focused end-user QA surface backed by native DeepSeek Harness sessions",
   "repository": {
     "type": "git",
@@ -48,6 +48,7 @@
       "types": "./lib/types/types.d.ts",
       "default": "./lib/types.js"
     },
+    "./locale/en.json": "./locale/en.json",
     "./package.json": "./package.json"
   },
   "dsh": {
@@ -78,6 +79,7 @@
     "lib/**/*.d.ts",
     "scripts/repair-session-events.mjs",
     "scripts/attach-workspace-sessions.mjs",
+    "locale/*.json",
     "cordis.patch.yml",
     "compatibility.json",
     "capability-policy.json",
@@ -133,10 +135,10 @@
   "dependencies": {
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "@yadsh/dsh-audit-core": "^0.1.1",
     "@yadsh/dsh-audit-ui": "^0.1.2",
-    "@yadsh/dsh-documents": "^0.6.1",
+    "@yadsh/dsh-documents": "^0.6.2",
     "@yadsh/dsh-plugin-kit": "^0.5.0",
+    "@yadsh/dsh-audit-core": "^0.1.1",
     "@yadsh/dsh-plugin-log": "^0.4.1"
   },
   "devDependencies": {