@yadsh/dsh-qa-surface 0.12.0 → 0.14.0

package/lib/types/index.d.ts

@@ -1,12 +1,14 @@
 import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import type { Context } from "@deepseek-ai/cordis";
+import type { QaSurfaceConfigRefs } from "./config.js";
+import type { QaAccountNotificationsInput } from "./types.js";
 import type { QaTurnSources } from "./provenance/types.js";
-import type { QaAccountProfileInput, QaAccountSession, QaAccountStartersInput, QaAccountUserPublic, QaApprovalDecision, QaClaimResult, QaDocumentPreview, QaIssuedServiceToken, QaLockdownProof, QaOwnershipEntry, QaPasswordResetRequest, QaPendingApproval, QaPendingQuestion, QaQuestionAnswerItem, QaServiceTokenCreateInput, QaServiceTokenSummary, QaSurfaceConfig, ResolvedQaSurfaceConfig, QaAdminSkillScope, QaAdminSkillsView, QaSkillDocument, QaSkillDraftInput, QaSkillRemoval, QaSkillSummary, QaSkillToolDescriptor, QaSkillValidation, QaSourceFilePreview, QaWhoamiResult, QaWorkspaceFile, QaWorkspaceListing, 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";
+import type { QaAccountProfileInput, QaAccountSession, QaAccountStartersInput, QaAccountUserPublic, QaApprovalDecision, QaClaimResult, QaDocumentPreview, QaIssuedServiceToken, QaLockdownProof, QaOwnershipEntry, QaPasswordResetRequest, QaPendingApproval, QaPendingQuestion, QaQuestionAnswerItem, QaQueueStatus, QaServiceTokenCreateInput, QaServiceTokenSummary, ResolvedQaSurfaceConfig, QaAdminSkillScope, QaAdminSkillsView, QaExpertMemoryDraft, QaExpertMemoryPage, QaExpertMemoryRecord, QaExpertMemoryScope, QaSkillDocument, QaSkillDraftInput, QaSkillRemoval, QaSkillSummary, QaSkillToolDescriptor, QaSkillValidation, QaSourceFilePreview, QaWhoamiResult, QaWorkspaceFile, QaWorkspaceListing, QaPrincipal, QaAccessAdminSnapshot, QaAdminAuditEvent, QaAdminOverview, QaAdminPage, QaAdminUserDetail, QaAdminUserRow, QaAdminUserUpdate, QaAuditQuery, QaCapabilitySelection, QaConversationDetail, QaConversationDeletion, QaConversationQuery, QaConversationReview, QaConversationReviewInput, QaConversationSummary, QaCurrentAccess, QaFeedbackHarvestEntry, QaFeedbackHarvestResult, 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";
 export { QA_SURFACE_SETTINGS_NAMESPACE };
-export declare const Config: import("@deepseek-ai/schemastery").default<QaSurfaceConfig>;
+export declare const Config: import("@deepseek-ai/schemastery").default<QaSurfaceConfigRefs>;
 declare module "@deepseek-ai/cordis" {
     interface Context {
         qaSurface: QaSurface;
@@ -15,8 +17,8 @@ declare module "@deepseek-ai/cordis" {
 /** Host companion: validates config, owns the admission boundary and the route. */
 export declare class QaSurface extends TypertRemoteService {
     static inject: string[];
-    static Config: import("@deepseek-ai/schemastery").default<QaSurfaceConfig>;
-    private source;
+    static Config: import("@deepseek-ai/schemastery").default<QaSurfaceConfigRefs>;
+    private readonly source;
     private readonly logger;
     private readonly admission;
     private readonly approvals;
@@ -64,7 +66,7 @@ export declare class QaSurface extends TypertRemoteService {
      * opens the admin console never grows one.
      */
     private qualityStore;
-    constructor(ctx: Context, entry?: QaSurfaceConfig);
+    constructor(ctx: Context, entry?: Partial<QaSurfaceConfigRefs>);
     /** The quality store, opening its file the first time anyone needs it. */
     private quality;
     /**
@@ -75,6 +77,9 @@ export declare class QaSurface extends TypertRemoteService {
      * 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.
+     *
+     * The registry answers with a lease on one preset revision, so the scope is
+     * handed to the caller that reads with it and released when that read ends.
      */
     private qaPresetScope;
     /**
@@ -157,6 +162,13 @@ export declare class QaSurface extends TypertRemoteService {
      * deployment's limits are enforced in the store before anything is written.
      */
     accountsUpdateStarters(token: string, input: QaAccountStartersInput): QaAccountUserPublic;
+    /**
+     * Replace the caller's own notification channels. The account the token
+     * authenticates is the only one editable, and the answer is the whole public
+     * record, so the settings form re-reads what the stand now holds rather than
+     * what it meant to send.
+     */
+    accountsUpdateNotifications(token: string, input: QaAccountNotificationsInput): QaAccountUserPublic;
     /**
      * The caller's own integration tokens. The list is the account's own: the
      * token names it, and a secret is never part of a summary, so reading this
@@ -188,6 +200,20 @@ export declare class QaSurface extends TypertRemoteService {
      * boundary stays in {@link secureSession}.
      */
     describe(): ResolvedQaSurfaceConfig;
+    /**
+     * Report how much of the deployment's request ceiling the stand is using, so
+     * a browser holds its question back instead of opening another turn on a
+     * model that is busy answering the ones it allows.
+     *
+     * The count is the Host's, not the browser's: a visitor cannot see another
+     * account's chats, and the HTTP API's questions are invisible to every chat
+     * view. Read-only, and a ceiling rather than a lock — a prompt rides the
+     * native session RPC this plugin does not own, so the boundary is the
+     * browser's own courtesy, and two questions sent in the same instant can
+     * still overshoot by one. What the ceiling buys is that steady state, not a
+     * strict bound.
+     */
+    queueStatus(): QaQueueStatus;
     /**
      * Create a QA session from Host-owned inputs. With account workspaces on,
      * cwd is `<configured workspace>/.qa-users/<account UUID>` and the child is
@@ -232,15 +258,44 @@ export declare class QaSurface extends TypertRemoteService {
     adminSkillTools(token: string, scope: QaAdminSkillScope): Promise<{
         readonly tools: readonly QaSkillToolDescriptor[];
     }>;
-    /** Counters, attention lines and the newest quality signals. */
-    adminOverview(token: string): Promise<QaAdminOverview>;
+    /**
+     * Which experts hold memory, and how much.
+     *
+     * Reads the domain-experts service on the host plane rather than its remotes:
+     * those answer a trusted in-Harness caller and check no token, while this
+     * console answers a browser, so the permission check lives here.
+     */
+    adminMemoryScopes(token: string): Promise<readonly QaExpertMemoryScope[]>;
+    /** One page of one namespace, newest first, with the filter's match count. */
+    adminMemoryRecords(token: string, namespace: string, query: string, limit: number | null, offset: number): Promise<QaExpertMemoryPage>;
+    /** Rewrite one remembered line; the audit trail keeps both images. */
+    adminMemoryCorrect(token: string, namespace: string, key: string, draft: QaExpertMemoryDraft): Promise<QaExpertMemoryRecord>;
+    /** Drop one or several remembered lines of one namespace. */
+    adminMemoryForget(token: string, namespace: string, keys: readonly string[]): Promise<number>;
+    /**
+     * Empty one namespace, confirming the count the operator was shown.
+     *
+     * The check is the console's, not the store's: what the operator clicked was
+     * a number on a screen, and memory an expert wrote in the meantime is not
+     * memory they agreed to erase.
+     */
+    adminMemoryWipe(token: string, namespace: string, expectedRecords: number | null): Promise<number>;
+    /**
+     * Counters, attention lines and the newest quality signals.
+     *
+     * The Host hands the last parameter its cancellation: this call reads the
+     * newest conversation logs of the deployment, which on a real store is minutes
+     * of work, and a reviewer who leaves the page while it runs must not leave it
+     * running — every other administrative call waits behind it.
+     */
+    adminOverview(token: string, signal: AbortSignal): Promise<QaAdminOverview>;
     adminUsers(token: string, query: QaUserQuery, cursor: string | null, limit: number | null): Promise<QaAdminPage<QaAdminUserRow>>;
     adminUser(token: string, userId: string): Promise<QaAdminUserDetail>;
     /** Authorization role, status and subrole assignment of one account. */
     adminUpdateUser(token: string, userId: string, update: QaAdminUserUpdate): Promise<QaAdminUserDetail>;
     adminPasswordResetRequests(token: string): Promise<readonly QaPasswordResetRequest[]>;
     adminResetPassword(token: string, userId: string, password: string): Promise<QaAdminUserDetail>;
-    adminConversations(token: string, query: QaConversationQuery, cursor: string | null, limit: number | null): Promise<QaAdminPage<QaConversationSummary>>;
+    adminConversations(token: string, query: QaConversationQuery, cursor: string | null, limit: number | null, signal: AbortSignal): Promise<QaAdminPage<QaConversationSummary>>;
     /** One conversation with its messages, tool calls and review state. */
     adminConversation(token: string, conversationId: string): Promise<QaConversationDetail>;
     /**
@@ -255,11 +310,16 @@ export declare class QaSurface extends TypertRemoteService {
      * ratable conversation, exactly as the self-service profile write does.
      */
     adminRateMessage(token: string, conversationId: string, messageId: string, input: QaMessageFeedbackInput): QaMessageFeedback;
-    adminReviewQueue(token: string, cursor: string | null, limit: number | null): Promise<QaAdminPage<QaReviewQueueRow>>;
+    /**
+     * Replay the ratings a browser still holds from before a thumbs reached the
+     * Host. Insert-only: what the deployment already records is never rewritten.
+     */
+    adminHarvestFeedback(token: string, entries: readonly QaFeedbackHarvestEntry[]): QaFeedbackHarvestResult;
+    adminReviewQueue(token: string, cursor: string | null, limit: number | null, signal: AbortSignal): Promise<QaAdminPage<QaReviewQueueRow>>;
     /** Park a conversation for review without rating it. */
     adminQueueConversation(token: string, conversationId: string, messageId: string | null): QaReviewQueueItem;
     adminSaveReview(token: string, input: QaConversationReviewInput): QaConversationReview;
-    adminMetrics(token: string): Promise<QaQualityMetrics>;
+    adminMetrics(token: string, signal: AbortSignal): Promise<QaQualityMetrics>;
     adminAudit(token: string, query: QaAuditQuery, cursor: string | null, limit: number | null): Promise<QaAdminPage<QaAdminAuditEvent>>;
     /** Pin and attest the effective policy. The browser supplies identity only. */
     secureSession(token: string, sessionId: string): Promise<QaLockdownProof>;

package/lib/types/integration/answer.d.ts

@@ -20,6 +20,15 @@ export interface QaTurnAnswer {
     /** Durable seq of the message the answer came from, when there was one. */
     readonly seq: number | null;
 }
+/** One request's answer, additionally attributed to the turn it came from. */
+export interface QaRequestAnswer extends QaTurnAnswer {
+    /**
+     * The harness turn number the answer was read out of, or null when the log
+     * named no turn for the request's own row. The provenance bundle of a turn is
+     * the evidence of its answer, so the caller cites the same number.
+     */
+    readonly turn: number | null;
+}
 /** The empty answer: what a turn that committed nothing readable looks like. */
 export declare const QA_EMPTY_ANSWER: QaTurnAnswer;
 /**
@@ -35,6 +44,24 @@ export declare const QA_EMPTY_ANSWER: QaTurnAnswer;
  * @returns the publishable answer and whether the turn was interrupted.
  */
 export declare function answerAfter(events: readonly StoredSessionEvent[], afterSeq: number): QaTurnAnswer;
+/**
+ * Project the answer of the turn one request's own prompt opened.
+ *
+ * The harness stamps the prompt's rpc id onto the durable user row it claims,
+ * so the row is found by id rather than guessed from the newest human message:
+ * two questions in flight on one chat open two turns, and a selection by
+ * "latest" answers each caller with the other's turn. The turn that answers a
+ * request is the one its row was claimed into — `turn/start` opens a turn and
+ * the claimed rows follow it — so the answer is read out of that turn's
+ * assistant messages only, and its number travels with it for the citation.
+ *
+ * @param events - durable events, in any order.
+ * @param requestId - the rpc id the prompt was submitted with.
+ * @returns the answer of this request's turn, or `undefined` when the log
+ * holds no row for the request (an unflushed prompt, or a harness that does not
+ * echo the id), which leaves the choice of cursor to the caller.
+ */
+export declare function answerForRequest(events: readonly StoredSessionEvent[], requestId: string): QaRequestAnswer | undefined;
 /**
  * Cut an answer down to the size the caller publishes.
  *

package/lib/types/integration/expert-memory.d.ts

@@ -0,0 +1,49 @@
+import type { QaExpertMemoryRecord, QaExpertMemoryScope } from "../types.js";
+/**
+ * The slice of `@yadsh/dsh-domain-experts` the QA console uses.
+ *
+ * Declared structurally instead of imported, for the same reason the audit
+ * remote is: the QA surface has to load on a stand where the experts plugin is
+ * not composed at all, and a package dependency would turn "not installed" into
+ * "does not boot".
+ *
+ * What is reached is the plugin's `memoryAdmin` seam — not its `@Remote`
+ * methods. A domain-experts remote takes no token and checks no permission,
+ * because inside the Harness its caller is already a trusted component; the QA
+ * console answers a browser on a LAN port, so it carries the identity itself
+ * and goes through the host-plane seam instead.
+ */
+export interface QaExpertMemoryAdmin {
+    scopes(): Promise<readonly QaExpertMemoryScope[]>;
+    search(namespace: string, query: string, limit: number, offset: number): Promise<{
+        readonly records: readonly QaExpertMemoryRecord[];
+        readonly total: number;
+    }>;
+    correct(input: QaExpertMemoryRecordInput): Promise<QaExpertMemoryRecord>;
+    remove(namespace: string, key: string): Promise<boolean>;
+    removeMany(namespace: string, keys: readonly string[]): Promise<number>;
+    wipe(namespace: string): Promise<number>;
+}
+/** What a correction says one record should hold. The key is the address. */
+export interface QaExpertMemoryRecordInput {
+    readonly namespace: string;
+    readonly key: string;
+    readonly text: string;
+    readonly tags?: readonly string[];
+}
+/** The part of the domain-experts service the console addresses. */
+export interface QaDomainExpertsFace {
+    readonly memoryAdmin: QaExpertMemoryAdmin;
+}
+/**
+ * Why a memory call failed, in the coarse vocabulary the console's copy table
+ * speaks.
+ *
+ * The refusal is read off the plugin's stable `code` field rather than its
+ * message: a message is written for a log and gets reworded, and matching one
+ * here would mean a rename in another package silently turns a refusal into an
+ * unhandled fault. `cause` is checked too, because the storage seam wraps what
+ * the backend threw.
+ */
+export declare function expertMemoryReasonOf(error: unknown): "forbidden" | "memory-record-unknown" | "memory-unavailable" | "invalid-memory" | undefined;
+//# sourceMappingURL=expert-memory.d.ts.map

package/lib/types/notifications.d.ts

@@ -0,0 +1,32 @@
+import type { QaAccountNotifications, QaAccountNotificationsInput } from "./types.js";
+/**
+ * What an account that never opened the notifications form gets.
+ *
+ * The in-page line is the shipped default of the feature itself, so an
+ * untouched account keeps behaving as it did before the form existed. The
+ * desktop channel stays off until asked for: raising an operating-system notice
+ * is the one choice that leaves the page, and a stand where the browser was
+ * never asked must not make it on the account's behalf.
+ */
+export declare function emptyNotifications(): QaAccountNotifications;
+/**
+ * Read one stored (or wire-delivered) notifications record into its public
+ * shape. Unknown or hand-edited input degrades to the readable subset rather
+ * than throwing, mirroring the starters read path: a malformed record must
+ * never cost the account its session.
+ */
+export declare function normalizeNotifications(value: unknown): QaAccountNotifications;
+export type QaNotificationsWriteResult = {
+    readonly ok: true;
+    readonly value: QaAccountNotificationsInput;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+/**
+ * Validate one full-replace notifications write. Both channels are required: a
+ * payload that names only one would silently reset the other, and the form
+ * always sends the pair it was rendered with.
+ */
+export declare function validateNotificationsWrite(input: unknown): QaNotificationsWriteResult;
+//# sourceMappingURL=notifications.d.ts.map

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

@@ -3,7 +3,7 @@
  * `(reason: <code>)` marker the account remotes established: the browser maps
  * them to audience-safe copy, while the precise cause stays in the Host log.
  */
-export type QaPersonalSkillErrorReason = "skills-disabled" | "workspace-unavailable" | "skill-not-found" | "skill-exists" | "skill-conflict" | "skill-name-invalid" | "skill-invalid" | "storage-unavailable";
+export type QaPersonalSkillErrorReason = "skills-disabled" | "workspace-unavailable" | "skill-not-found" | "skill-exists" | "skill-conflict" | "skill-truncated" | "skill-name-invalid" | "skill-invalid" | "storage-unavailable";
 export declare class QaPersonalSkillError extends Error {
     readonly reason: QaPersonalSkillErrorReason;
     constructor(reason: QaPersonalSkillErrorReason, message: string);

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

@@ -55,6 +55,12 @@ export interface QaStoredSkill {
     readonly contents: QaSkillFileContents | undefined;
     readonly diagnostics: readonly QaSkillDiagnostic[];
     readonly resourceCount: number;
+    /**
+     * True when `raw` is only the head of the file: an oversized `SKILL.md` is
+     * read up to the ceiling, and what follows it was never loaded. A write must
+     * not overwrite such a document without saying so out loud.
+     */
+    readonly truncated: boolean;
 }
 export interface QaPersonalSkillsOptions {
     readonly getConfig: () => ResolvedQaSurfaceConfig;

package/lib/types/prompt-notes.d.ts

@@ -1,13 +1,26 @@
 import type { Context } from "@deepseek-ai/cordis";
+import type { ContextSnapshotSection } from "@deepseek-ai/dsh-llm";
 import type { PluginLogger } from "@yadsh/dsh-plugin-log";
 import type { QaAccounts } from "./accounts/store.js";
 import type { QaAccountIdentityField, QaAccountProfile, ResolvedQaSurfaceConfig } from "./types.js";
 /**
- * Plugin marker on every injected message. The chat projection turns a
- * plugin-sourced user message into injected context rather than a chat
- * bubble, and the QA transcript keeps exactly those hidden.
+ * This plugin's own producer source kind. The `@deepseek-ai/dsh-llm` source map
+ * is merge-extensible and ships no catch-all `plugin` kind, so a producer names
+ * itself here. The chat projection turns a `qa-notes`-sourced user message into
+ * injected context rather than a chat bubble, and the QA transcript keeps
+ * exactly those hidden.
  */
-export declare const QA_NOTES_PLUGIN = "qa-surface";
+export interface QaNotesMessageSource {
+    readonly kind: "qa-notes";
+    /** Every note is superseded by the next one this plugin injects. */
+    readonly form: "snapshot";
+    readonly sections: readonly ContextSnapshotSection[];
+}
+declare module "@deepseek-ai/dsh-llm" {
+    interface MessageSourceMap {
+        "qa-notes": QaNotesMessageSource;
+    }
+}
 /** Note name carrying who the assistant is talking to. */
 export declare const QA_IDENTITY_NOTE = "dsh-qa-surface:user-identity";
 /** Note name carrying the deployment's rule about source provenance. */

package/lib/types/qa-tools/docs-tools.d.ts

@@ -161,8 +161,8 @@ export interface QaDocsSearchRequest {
 /**
  * Search the documentation tree of one chat workspace.
  *
- * Matching is a case-insensitive substring test, line by line: a hit is a
- * line, not a file, so the caller can cite it. The result is bounded twice —
+ * Matching uses one case-insensitive, grep-style regular expression, line by
+ * line: a hit is a line, not a file, so the caller can cite it. The result is bounded twice —
  * by `limit` hits and by the byte budget of the rendered report — and reports
  * which bound cut it short instead of silently dropping matches.
  * @throws QaDocsError when the tree is missing, the scope path is wrong, or the query is empty.

package/lib/types/request-queue.d.ts

@@ -0,0 +1,32 @@
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import type { QaQueueStatus } from "./types.js";
+/**
+ * Chat turns the stand is answering right now.
+ *
+ * `running` is the harness's own definition of an active request: an agent
+ * enters it when waking input starts the driver and leaves it when the driver
+ * retires, which is what `agent/status` reports. Reading the live agents rather
+ * than counting the plugin's own sends is what keeps the places honest — a
+ * browser that closes mid-answer, an answer started through the HTTP API and a
+ * turn resumed by another surface all occupy a place, and none of them has to
+ * report it here. Only top-level agents count: a delegated expert's requests
+ * belong to the chat turn that delegated them, so charging both would bill one
+ * conversation twice.
+ *
+ * The count is of the model's load, not of this plugin's traffic: a turn the
+ * native assistant runs occupies a place exactly like a QA question does,
+ * because the ceiling exists for the card that is busy either way.
+ */
+export declare function qaActiveRequests(agents: readonly {
+    readonly status: Agent["status"];
+}[]): number;
+/**
+ * Judge the live count against the deployment's ceiling. A ceiling of 0 sets no
+ * limit, so the stand is never full and nobody waits.
+ *
+ * There is deliberately no "ahead of you" number: `active` includes this
+ * visitor's own turns, and a stand that cannot say which place belongs to whom
+ * should not pretend to know who is waiting behind whom.
+ */
+export declare function qaQueueStatus(limit: number, active: number): QaQueueStatus;
+//# sourceMappingURL=request-queue.d.ts.map

package/lib/types/shared/settings.d.ts

@@ -5,6 +5,23 @@
  * browser build must not pull the Host config surface (schemastery) into the
  * page just to learn the namespace name.
  */
-/** Settings namespace the QA surface owns and its card binds to. */
-export declare const QA_SURFACE_SETTINGS_NAMESPACE = "qa-surface";
+/**
+ * Settings namespace the QA surface owns and its card binds to.
+ *
+ * The namespace is the profile entry id the bundle declares in
+ * `cordis.patch.yml`, not a name this plugin picks: the Host derives the
+ * configuration form of every entry from its volatile `Config` fields and serves
+ * it under that id.
+ */
+export declare const QA_SURFACE_SETTINGS_NAMESPACE = "dsh-qa-surface";
+/**
+ * The key of the seat this card takes on the Host's Plugins page.
+ *
+ * `plugins.row.config` is keyed `<package name>#<row id>`, so the two names the
+ * page joins are this bundle's `package.json.name` and the profile entry id
+ * above. Neither is a name this plugin picks: a key that drifts from that pair
+ * leaves the row without its configure control and the card off the page, with
+ * nothing said about it.
+ */
+export declare const QA_SURFACE_ROW_CONFIG_KEY = "@yadsh/dsh-qa-surface#dsh-qa-surface";
 //# sourceMappingURL=settings.d.ts.map

package/lib/types/turn-failure-log.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { PluginLogger } from "@yadsh/dsh-plugin-log";
+/**
+ * Write a failed turn where the operator of the stand reads it.
+ *
+ * The chat row of a failed turn carries the failure code and nothing else: the
+ * provider's own message is deliberately kept out of the browser, and the
+ * session journal that holds it is a zstd archive nobody reads over an
+ * operator's shoulder. So a stand whose provider adapters never registered —
+ * every turn ending `NO_ADAPTER` — shows its tester «Помощнику не удалось
+ * завершить ответ.» and stays undiagnosable until someone decodes frames by
+ * hand. This listener puts the facts an operator needs — the chat, the session
+ * that died inside it, the turn, the code, and the provider the Host was asked
+ * to route to — into the plugin's own daily log, which is mirrored to the
+ * container's stdout from `warn` up.
+ */
+export declare function registerTurnFailureLog(ctx: Context, logger: PluginLogger, resolveChat: (sessionId: string) => string | undefined): () => void;
+//# sourceMappingURL=turn-failure-log.d.ts.map