@yadsh/dsh-qa-surface 0.12.0 → 0.14.0

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

@@ -10,10 +10,25 @@ export interface CapabilityCatalogSnapshot {
     readonly skillIds: ReadonlySet<string>;
     /** Installed skills a person may invoke, including model-hidden ones. */
     readonly userSkillIds: ReadonlySet<string>;
+    /**
+     * The subset {@link userSkillIds} this account owns: what its own skills root
+     * contributes, never the deployment's shared root. The access model hands
+     * these to their owner without a role grant.
+     */
+    readonly ownUserSkillIds: ReadonlySet<string>;
     readonly skills: ReadonlyMap<string, SkillSummary>;
     /** Normalized `metadata.qa-surface` of every discovered skill. */
     readonly skillMetadata: ReadonlyMap<string, QaSkillDescriptor>;
 }
+/**
+ * The viewing scope of one preset read, plus the release of the revision lease
+ * the preset registry hands it out with. The caller owns the lease for exactly
+ * as long as the read it borrowed the scope for.
+ */
+export interface QaPresetScopeLease {
+    readonly key: ScopeKey;
+    release(): Promise<void>;
+}
 /** Read-only adapter over the current DSH registries. */
 export declare class QaCapabilityCatalog {
     private readonly ctx;
@@ -42,12 +57,13 @@ export declare class QaCapabilityCatalog {
      * Resolving the scope may compose the preset; a failure degrades to the
      * global view instead of failing the page.
      */
-    presetScope?: () => Promise<ScopeKey | undefined>);
+    presetScope?: () => Promise<QaPresetScopeLease | undefined>);
     snapshot(agent?: Agent): Promise<CapabilityCatalogSnapshot>;
+    private readCatalog;
     /**
-     * The scope an administrator's catalog is read with. A deployment that pins
-     * QA chats to an agent preset gets that preset's standing scope; without a
-     * pinned preset there is no scope to borrow, and the read stays global.
+     * The scope lease an administrator's catalog is read with. A deployment that
+     * pins QA chats to an agent preset gets that preset's standing scope; without
+     * a pinned preset there is no scope to borrow, and the read stays global.
      */
     private resolvePresetScope;
     /**

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

@@ -28,6 +28,12 @@ export interface CapabilityAvailability {
     readonly skills: ReadonlySet<string>;
     /** Installed skills a person may invoke; defaults to the model-facing set. */
     readonly userSkills?: ReadonlySet<string>;
+    /**
+     * User-invocable skills the account of this session owns. They join
+     * `userSkills` for their owner whatever the role lists, because a personal
+     * skill belongs to one account and cannot be named in a shared role at all.
+     */
+    readonly ownSkills?: ReadonlySet<string>;
 }
 export interface ResolveCapabilityPolicyInput {
     readonly config: QaCapabilityConfig;
@@ -40,6 +46,23 @@ export interface ResolveCapabilityPolicyInput {
     /** Revision recorded with the session snapshot; opaque to enforcement. */
     readonly revision?: string;
 }
+/**
+ * Names an administrator withdrew outright, which is every account at once,
+ * its owner included.
+ * @param config - the role configuration the withdrawal was recorded in.
+ */
+export declare function withdrawnSkillNames(config: QaCapabilityConfig): ReadonlySet<string>;
+/**
+ * The personal layer of one session's user-invoke list.
+ *
+ * Only an outright administrator withdrawal reaches a skill the account owns:
+ * the role overlay edits per-role audiences, and a personal skill is not a role
+ * grant, while `disabled` withdraws the name from the deployment for everyone,
+ * its owner included.
+ * @param config - the role configuration the policy is resolved against.
+ * @param ownSkills - the account's own user-invocable skills, if any.
+ */
+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;
 export interface ResolveSkillAccessInput {
     readonly config: QaCapabilityConfig;

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

@@ -1,12 +1,11 @@
 import type { Agent } from "@deepseek-ai/dsh-agent";
 import type { Context } from "@deepseek-ai/cordis";
-import type { ScopeKey } from "@deepseek-ai/dsh-scope";
 import type { PluginLogger } from "@yadsh/dsh-plugin-log";
 import type { QaAccounts } from "../accounts/store.js";
 import type { QaAgentToolGrants } from "../enforcement/tool-grants.js";
 import type { QaAccessAdminSnapshot, QaAccountUserPublic, QaCapabilityConfig, QaCapabilityDescriptor, QaCapabilitySelection, QaClaimResult, QaCurrentAccess, QaEffectiveCapabilityPolicy, QaSessionAccess, QaSkillActivationRecord, QaSkillAssignmentOverride, QaSubrole, QaUserAccess, ResolvedQaSurfaceConfig } from "../types.js";
 import type { QaSessionLogReader } from "../admin/session-log.js";
-import { QaCapabilityCatalog, type CapabilityCatalogSnapshot } from "./capability-catalog.js";
+import { QaCapabilityCatalog, type CapabilityCatalogSnapshot, type QaPresetScopeLease } from "./capability-catalog.js";
 import { QaRoleRepository } from "./role-repository.js";
 export interface QaResolvedSessionPolicy {
     readonly policy: QaEffectiveCapabilityPolicy;
@@ -51,7 +50,7 @@ export declare class QaAccessService {
          * preset's scope, so a global-only catalog left the operator unable to
          * see — or grant — what every QA chat actually mounts.
          */
-        readonly presetScope?: () => Promise<ScopeKey | undefined>;
+        readonly presetScope?: () => Promise<QaPresetScopeLease | undefined>;
         /**
          * Durable session listing, used to tell a chat from a delegated child
          * across Host runs. Without it the lineage answer degrades to the live

package/lib/types/account-remotes.d.ts

@@ -1,6 +1,6 @@
 import type { PluginLogger } from "@yadsh/dsh-plugin-log";
 import { QaAccounts } from "./accounts/store.js";
-import type { QaAccountProfileInput, QaAccountSession, QaAccountStartersInput, QaAccountUserPublic, QaIssuedServiceToken, QaOwnershipEntry, QaServiceTokenCreateInput, QaServiceTokenSummary, QaWhoamiResult, ResolvedQaSurfaceConfig } from "./types.js";
+import type { QaAccountNotificationsInput, QaAccountProfileInput, QaAccountSession, QaAccountStartersInput, QaAccountUserPublic, QaIssuedServiceToken, QaOwnershipEntry, QaServiceTokenCreateInput, QaServiceTokenSummary, QaWhoamiResult, ResolvedQaSurfaceConfig } from "./types.js";
 /**
  * Host-side bodies of the account remotes the `QaSurface` service exposes.
  * The `@Remote`-decorated signatures stay on the service class (typert code
@@ -57,6 +57,13 @@ export interface QaAccountRemotes {
     updateProfile(token: string, input: QaAccountProfileInput): QaAccountUserPublic;
     /** Replace the caller's own starter buttons; the token is the identity. */
     updateStarters(token: string, input: QaAccountStartersInput): QaAccountUserPublic;
+    /**
+     * Replace the caller's own notification channels; the token is the identity.
+     * The deployment's own switches are not this write's business: they gate the
+     * channels at read time, so an account can only ever narrow what a stand
+     * allows, never widen it.
+     */
+    updateNotifications(token: string, input: QaAccountNotificationsInput): QaAccountUserPublic;
     /**
      * The caller's own integration tokens, newest last. Never a secret: the
      * plaintext exists only in the answer that minted it.

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

@@ -55,10 +55,20 @@ export declare class QaAccountsDatabase {
     get secret(): string;
     /** True while the in-memory model a caller holds is still current. */
     get unchangedSinceLoad(): boolean;
-    /** Take the current data version as the baseline a caller's model reflects. */
-    markLoaded(): void;
-    /** Every account, ownership record and skill activation, in one read. */
+    /** Every account, ownership record and skill activation, as one snapshot. */
     loadAll(): AccountsFile;
+    /**
+     * The accounts model, read as the rows stand right now.
+     *
+     * Read through {@link loadAll}, never on its own: in autocommit every
+     * statement is a snapshot of its own, so these SELECTs are only one state
+     * when no other connection committed while they ran — which is exactly what
+     * the surrounding `PRAGMA data_version` check proves. The baseline used to be
+     * taken *after* the reads, which labeled a model of two states, and the token
+     * versions in it, as current: a token revoked by the `qa-accounts` CLI into
+     * this window kept working until some later write moved the version again.
+     */
+    private readModel;
     /** Append one account, preserving the order accounts are listed in. */
     insertUser(user: StoredUser): void;
     /** Replace one account's row in place. */

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

@@ -6,6 +6,8 @@
 export type QaAccountsErrorReason = "auth-required" | "admin-required" | "forbidden" | "invalid-credentials"
 /** The signed-in user typed a current password that does not match. */
  | "invalid-current-password" | "account-disabled" | "email-taken" | "invalid-email" | "invalid-display-name" | "invalid-profile" | "profile-disabled" | "invalid-starters" | "starters-disabled"
+/** The notifications payload named a channel that is not a yes or a no. */
+ | "invalid-notifications"
 /** The endpoint this credential is for is switched off on this deployment. */
  | "integration-disabled" | "invalid-role" | "weak-password" | "registration-disabled" | "rate-limited" | "session-owned-elsewhere"
 /** The conversation a deletion names is not one this deployment knows. */
@@ -13,7 +15,13 @@ export type QaAccountsErrorReason = "auth-required" | "admin-required" | "forbid
 /** The Harness still holds the conversation open, so its log would come back. */
  | "conversation-live"
 /** This deployment cannot remove stored conversations at all. */
- | "conversation-not-removable";
+ | "conversation-not-removable"
+/** The record an operator edited is no longer the one stored. */
+ | "memory-record-unknown"
+/** Expert memory is not reachable: no plugin composed it, or its store is down. */
+ | "memory-unavailable"
+/** The Host refused the memory edit itself, not who asked for it. */
+ | "invalid-memory";
 export declare class QaAccountsError extends Error {
     readonly reason: QaAccountsErrorReason;
     constructor(reason: QaAccountsErrorReason, message: string);

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

@@ -14,6 +14,16 @@ export interface StoredStarters {
     }[];
     hideDefaults?: boolean;
 }
+/**
+ * One account's notification channels as they rest in the accounts store. Every
+ * field is optional because the record is read, not parsed: an account created
+ * before the settings form existed has none of it, and a hand-edited row must
+ * not decide anything the reader never chose.
+ */
+export interface StoredNotifications {
+    inApp?: boolean;
+    desktop?: boolean;
+}
 export interface StoredUser {
     readonly id: string;
     readonly email: string;
@@ -37,6 +47,8 @@ export interface StoredUser {
     profile?: StoredProfile;
     /** Absent until the owner customizes the starter buttons. */
     starters?: StoredStarters;
+    /** Absent until the owner opens the notifications form for the first time. */
+    notifications?: StoredNotifications;
     /** Agent capability profiles assigned by an administrator. */
     qaAccess?: QaUserAccess;
 }

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

@@ -1,4 +1,4 @@
-import type { QaAccountIdentityField, QaAccountProfile, QaAccountProfileInput, QaAccountRole, QaAccountSession, QaAccountStartersInput, QaAccountUserPublic, QaAccessUser, QaAdminAccountRow, QaClaimResult, QaEffectiveCapabilityPolicy, QaOwnershipEntry, QaIssuedServiceToken, QaPasswordResetRequest, QaServiceTokenSummary, QaSkillActivationRecord, QaUserAccess, QaWhoamiResult } from "../types.js";
+import type { QaAccountIdentityField, QaAccountNotificationsInput, QaAccountProfile, QaAccountProfileInput, QaAccountRole, QaAccountSession, QaAccountStartersInput, QaAccountUserPublic, QaAccessUser, QaAdminAccountRow, QaClaimResult, QaEffectiveCapabilityPolicy, QaOwnershipEntry, QaIssuedServiceToken, QaPasswordResetRequest, QaServiceTokenSummary, QaSkillActivationRecord, QaUserAccess, QaWhoamiResult } from "../types.js";
 import { type StoredOwnership, type StoredUser } from "./file.js";
 import { type QaServiceTokenScope } from "./service-token.js";
 export { QaAccountsError } from "./errors.js";
@@ -105,6 +105,16 @@ export declare class QaAccounts {
      * mtime-and-size stamp of the JSON file used to provide.
      */
     private reloadIfChanged;
+    /**
+     * The authorization state as the database holds it right now.
+     *
+     * Every credential check reads through here, because what decides one — the
+     * token version and the disabled flag — is a row another process may have
+     * changed since this store last read. Refreshing inside the check rather than
+     * in whichever method the caller happened to invoke first is what keeps a
+     * revoked token from surviving in the in-memory model.
+     */
+    private authState;
     private pruneAuthAttempts;
     private assertAuthBudget;
     private userByEmail;
@@ -114,7 +124,14 @@ export declare class QaAccounts {
     /** Resolve a token to its user, or null for absent/invalid/expired ones. */
     verifyToken(token: string): string | null;
     private mintToken;
-    /** The account behind a token, or an auth-required refusal. */
+    /**
+     * The account behind a token, or an auth-required refusal.
+     *
+     * The check reads the current authorization state, so the refusal lands on the
+     * call that presents a revoked token rather than on whichever method reloaded
+     * first. The personal-skill remotes gate on this call alone, which is what
+     * made the difference a security one.
+     */
     requireUser(token: string): StoredUser;
     /** Public identity behind a token; used by server-side access services. */
     currentUser(token: string): QaAccountUserPublic;
@@ -449,6 +466,17 @@ export declare class QaAccounts {
      * write leaves the stored record untouched.
      */
     updateOwnStarters(token: string, input: QaAccountStartersInput): QaAccountUserPublic;
+    /**
+     * Replace the token account's notification channels. Same self-service shape
+     * as {@link updateOwnStarters}: the token is the only identity, the write is
+     * full-replace, and a rejected payload leaves the stored record alone.
+     *
+     * Deliberately not gated by a config key the way profiles and starters are —
+     * a stand that wanted this switched off already has `notifications.enabled`,
+     * and two switches for one decision is how a deployment ends up with an
+     * answer nobody can find.
+     */
+    updateOwnNotifications(token: string, input: QaAccountNotificationsInput): QaAccountUserPublic;
     /**
      * Validate one profile write and stamp it onto the account. Throws before
      * anything is mutated, so a rejected write leaves the stored profile, and

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

@@ -19,6 +19,21 @@ export interface QaManualQueueEntry {
     readonly userId: string;
     readonly createdAt: string;
 }
+/** The four record families the store keeps, one row each. */
+export type QualityRowKind = "feedback" | "review" | "queue" | "audit";
+/** How many rows of each family survive; the oldest fall off first. */
+export declare const QA_ROW_CAPS: Readonly<Record<QualityRowKind, number>>;
+/** Give up everything older in rank than the row at the cap, whose position the
+ * caller binds as `QA_ROW_CAPS[kind] - 1`. */
+export declare const OVERFLOW_CUT_SQL = "\n  DELETE FROM quality_rows\n   WHERE kind = ?\n     AND seq < (\n       SELECT seq FROM quality_rows\n        WHERE kind = ?\n        ORDER BY seq DESC\n        LIMIT 1 OFFSET ?\n     )";
+/** Read a whole family back in the order its records arrived. */
+export declare const FAMILY_REPLAY_SQL = "\n  SELECT json FROM quality_rows WHERE kind = ? ORDER BY seq";
+/** Write one record at the end of its family's order, taking that end from the
+ * family's `MAX(seq)` whether the record is new or being re-judged. */
+export declare const ROW_PLACEMENT_SQL = "\n  INSERT INTO quality_rows (kind, key, seq, json)\n  VALUES (?, ?, (SELECT COALESCE(MAX(seq), 0) + 1 FROM quality_rows WHERE kind = ?), ?)\n  ON CONFLICT(kind, key) DO UPDATE SET\n    seq = (SELECT COALESCE(MAX(seq), 0) + 1 FROM quality_rows WHERE kind = excluded.kind),\n    json = excluded.json";
+/** Read a whole family with each record's identity, the way the ownership sweep
+ * finds the rows of a conversation it is forgetting. */
+export declare const FAMILY_MEMBERSHIP_SQL = "\n  SELECT key, json FROM quality_rows WHERE kind = ?";
 export declare function defaultQualityFilePath(): string;
 /** The pre-SQLite quality file, imported once on first use. */
 export declare function defaultLegacyQualityFilePath(): string;
@@ -102,6 +117,24 @@ export declare class QaQualityStore {
     /** Append a record whose identity the store mints itself. */
     private appendRow;
     private deleteRow;
+    /**
+     * Drop the rows that overflow their family's cap.
+     *
+     * The rows to give up are the oldest by rank, not everything below
+     * `MAX(seq) - cap`. That range only equals the overflow while every sequence
+     * value is taken, and the store itself vacates values: an updated record
+     * moves to the end of the order and leaves its old value behind, and a
+     * dropped record leaves a hole. A range cut pays for each of those gaps with
+     * a real record, so a family at its cap loses one every time a record it
+     * already holds is re-rated — feedback disappears without anything new
+     * arriving to displace it.
+     *
+     * Reading that rank is not a seek: it walks cap entries of the family's own
+     * slice of the (kind, seq) index, so the cap bounds the cost of every write,
+     * while the delete reaches only the rows it removes and a write that does not
+     * overflow pays the read alone. Without the index the same read sorts the
+     * whole family into a temp B-tree.
+     */
     private applyCap;
     private rowsOf;
     private readDataVersion;

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

@@ -2,9 +2,10 @@ import type { PluginLogger } from "@yadsh/dsh-plugin-log";
 import type { QaAccounts } from "../accounts/store.js";
 import type { QaAccessService } from "../access/service.js";
 import type { QaRoleRepository } from "../access/role-repository.js";
-import type { QaAdminAuditEvent, QaAdminOverview, QaAdminPage, QaAdminSkillScope, QaAdminSkillsView, QaAdminUserDetail, QaAdminUserRow, QaAdminUserUpdate, QaAuditQuery, QaConversationDetail, QaConversationDeletion, QaConversationQuery, QaConversationReview, QaConversationReviewInput, QaConversationSummary, QaFeedbackQuery, QaFeedbackRow, QaMessageFeedback, QaMessageFeedbackInput, QaPasswordResetRequest, QaQualityMetrics, QaReviewQueueItem, QaReviewQueueRow, QaSkillDocument, QaSkillDraftInput, QaSkillRemoval, QaSkillToolDescriptor, QaSkillValidation, QaUserQuery } from "../types.js";
+import type { QaAdminAuditEvent, QaAdminOverview, QaAdminPage, QaAdminSkillScope, QaAdminSkillsView, QaAdminUserDetail, QaAdminUserRow, QaAdminUserUpdate, QaAuditQuery, QaConversationDetail, QaConversationDeletion, QaConversationQuery, QaConversationReview, QaConversationReviewInput, QaConversationSummary, QaExpertMemoryDraft, QaExpertMemoryPage, QaExpertMemoryRecord, QaExpertMemoryScope, QaFeedbackHarvestEntry, QaFeedbackHarvestResult, QaFeedbackQuery, QaFeedbackRow, QaMessageFeedback, QaMessageFeedbackInput, QaPasswordResetRequest, QaQualityMetrics, QaReviewQueueItem, QaReviewQueueRow, QaSkillDocument, QaSkillDraftInput, QaSkillRemoval, QaSkillToolDescriptor, QaSkillValidation, QaUserQuery } from "../types.js";
 import type { QaPersonalSkills } from "../personal-skills/index.js";
-import type { QaQualityStore } from "./quality-store.js";
+import type { QaDomainExpertsFace } from "../integration/expert-memory.js";
+import { type QaQualityStore } from "./quality-store.js";
 import type { QaAdminRedactor } from "./redaction.js";
 import type { QaSessionLogReader, QaStoredSessionEraser } from "./session-log.js";
 /**
@@ -43,6 +44,14 @@ export interface QaAdminServiceOptions {
      * never constructs storage before someone opens its skills page.
      */
     readonly skills: () => QaPersonalSkills;
+    /**
+     * The domain-experts service, if this deployment composed one. Resolved
+     * lazily for the same reason `skills` is, and for one more: a stand without
+     * experts must still open its console, so the memory page learns "there is
+     * nothing here to maintain" from this returning `undefined` rather than from a
+     * missing import at boot.
+     */
+    readonly domainExperts?: () => QaDomainExpertsFace | undefined;
     /** Drops the sources a conversation collected, when the deployment keeps any. */
     readonly dropSources?: (sessionId: string) => void;
     readonly logger: PluginLogger;
@@ -52,6 +61,8 @@ export interface QaAdminServiceOptions {
 export declare class QaAdminService {
     private readonly options;
     private readonly redactor;
+    /** The aggregate pass running now, shared by the callers waiting for it. */
+    private scanning;
     private readonly transcripts;
     constructor(options: QaAdminServiceOptions);
     private requireAccounts;
@@ -74,11 +85,46 @@ export declare class QaAdminService {
      * costs a listing per interval at most.
      */
     private index;
-    /** One conversation's projected log, cached for the TTL unless asked fresh. */
+    /**
+     * One conversation's projected log, held across calls.
+     *
+     * A log the Harness no longer holds is finished — nothing can append to it —
+     * so its projection stays valid until the cache evicts it or the conversation
+     * is deleted. Only a log this process is still writing is re-read once the TTL
+     * expires. A cache hit counts as a use: an aggregate pass walks the whole
+     * window, and evicting by read time would drop the conversations the pages ask
+     * for most often and then read them again.
+     *
+     * The one answer this can hold back is a conversation resumed and finished
+     * between two page loads: its counters lag until the log is read for another
+     * reason. The conversation itself is never affected — the detail view always
+     * reads the log — and what the aggregate pages show instead is the newest
+     * projection of every finished conversation, which is the cheaper lie.
+     */
     private transcript;
-    private facts;
-    overview(token: string): Promise<QaAdminOverview>;
-    metrics(token: string): Promise<QaQualityMetrics>;
+    /** Insert or re-touch one projection, keeping the cache inside its budget. */
+    private retain;
+    /**
+     * The aggregate rows of the newest scan window, read in one pass.
+     *
+     * The message counts and the tool failures come from the same projections, so
+     * one walk fills both. While a walk runs, a caller that wants the same window
+     * joins it rather than starting a second scan of the deployment's logs, and the
+     * walk stops once no caller waits for it: a scan nobody is reading is only ever
+     * a load on the store.
+     */
+    private scanOf;
+    /**
+     * Walk one scan window, filling the counts and the failure signals as it goes.
+     *
+     * `waiting` is the caller set of the pass this walk belongs to: the walk gives
+     * up between two reads once every caller has left, so a reviewer who abandons a
+     * page that has not answered does not keep the deployment reading logs for an
+     * answer nobody will see.
+     */
+    private walk;
+    overview(token: string, signal?: AbortSignal): Promise<QaAdminOverview>;
+    metrics(token: string, signal?: AbortSignal): Promise<QaQualityMetrics>;
     private metricsOf;
     /** One attention line per condition worth an administrator's time. */
     private alertsOf;
@@ -108,7 +154,7 @@ export declare class QaAdminService {
     private assertAdminSurvives;
     /** Validate an assignment against the enabled roles before storing it. */
     private exactAssignment;
-    conversations(token: string, query: QaConversationQuery, cursor: string | undefined, limit: number | undefined): Promise<QaAdminPage<QaConversationSummary>>;
+    conversations(token: string, query: QaConversationQuery, cursor: string | undefined, limit: number | undefined, signal?: AbortSignal): Promise<QaAdminPage<QaConversationSummary>>;
     private summaryOf;
     conversation(token: string, conversationId: string): Promise<QaConversationDetail>;
     /**
@@ -130,17 +176,31 @@ export declare class QaAdminService {
      */
     deleteConversation(token: string, conversationId: string): Promise<QaConversationDeletion>;
     private failuresOf;
-    private failureSignals;
     /**
      * Record the caller's verdict on one assistant message. The conversation must
      * be the caller's own: a rating is the user's own signal, and nobody rates
      * someone else's answer on their behalf.
      */
     rateMessage(token: string, conversationId: string, messageId: string, input: QaMessageFeedbackInput): QaMessageFeedback;
+    /**
+     * Replay the ratings a browser still holds from the window in which a thumbs
+     * never reached the Host.
+     *
+     * A harvest never overwrites. The browser's map stores no timestamp, so an
+     * entry may well be a rating the same user has since filed together with a
+     * reason and a comment; replacing that record with the bare thumbs would
+     * delete exactly what a reviewer reads. An entry the Host already answers for
+     * is counted as present and left alone.
+     *
+     * One unusable or foreign entry costs that entry alone: a browser keeps
+     * ratings of chats it no longer owns, and the rest of the replay must not be
+     * lost because of them.
+     */
+    harvestFeedback(token: string, entries: readonly QaFeedbackHarvestEntry[]): QaFeedbackHarvestResult;
     feedback(token: string, query: QaFeedbackQuery, cursor: string | undefined, limit: number | undefined): Promise<QaAdminPage<QaFeedbackRow>>;
     private feedbackRows;
     private queueRows;
-    reviewQueue(token: string, cursor: string | undefined, limit: number | undefined): Promise<QaAdminPage<QaReviewQueueRow>>;
+    reviewQueue(token: string, cursor: string | undefined, limit: number | undefined, signal?: AbortSignal): Promise<QaAdminPage<QaReviewQueueRow>>;
     /** Park a conversation for review without rating it. */
     queueConversation(token: string, conversationId: string, messageId: string | undefined): QaReviewQueueItem;
     /** Save a reviewer's verdict, and take the item out of the queue when done. */
@@ -179,6 +239,56 @@ export declare class QaAdminService {
     removeSkill(token: string, scope: QaAdminSkillScope, name: string, expectedRevision: string | null): Promise<QaSkillRemoval>;
     /** One skill as it exists now; a missing one is the service's refusal. */
     private existingSkill;
+    /**
+     * The domain-experts maintenance seam, or the refusal that says this stand
+     * runs no experts.
+     *
+     * Reach is host-plane on purpose: the sibling plugin's remotes carry no token
+     * and check no permission, because inside the Harness their caller is already
+     * a trusted component. This console answers a browser on a LAN port, so it
+     * calls the service directly and gates every call with its own `require`.
+     */
+    private expertMemory;
+    /**
+     * Run one memory call, translating the sibling plugin's refusal.
+     *
+     * The reason crosses the wire, never the message: a memory refusal names
+     * namespaces, and a storage failure names the database file behind them.
+     */
+    private memoryCall;
+    /**
+     * What an audit row keeps about one record.
+     *
+     * A remembered line runs to a few pages, and the trail holds a capped JSON
+     * snapshot; the identity of the record and the head of its text is what an
+     * operator reads back to decide whether the deletion was wrong.
+     */
+    private memoryImage;
+    /** The record one key holds now, if it still holds one. */
+    private rememberedRecord;
+    /** Every expert memory namespace on the stand, with its owner and size. */
+    memoryScopes(token: string): Promise<readonly QaExpertMemoryScope[]>;
+    /** One page of one namespace, newest first, with the filter's match count. */
+    memoryRecords(token: string, namespace: string, query: string, limit: number | null, offset: number): Promise<QaExpertMemoryPage>;
+    /**
+     * Rewrite one remembered line.
+     *
+     * The key is not editable: it is what the expert's own notes and the audit
+     * trail point at, and a console that renamed it would orphan both. The write
+     * refuses a record that vanished meanwhile rather than re-creating it — an
+     * operator editing a stale row should reload, not resurrect.
+     */
+    correctMemory(token: string, namespace: string, key: string, draft: QaExpertMemoryDraft): Promise<QaExpertMemoryRecord>;
+    /**
+     * Drop one or several remembered lines.
+     *
+     * A single deletion keeps the text it removed; a bulk one keeps only the
+     * count and the keys, because an audit trail that copies every page of memory
+     * it deletes becomes the thing an operator has to clean up.
+     */
+    forgetMemory(token: string, namespace: string, keys: readonly string[]): Promise<number>;
+    /** Empty one expert's private namespace. */
+    wipeMemory(token: string, namespace: string, expectedRecords: number | null): Promise<number>;
     /**
      * The audit trail as one table. Two writers keep records — the capability
      * service, whose repository predates the console, and the quality store —

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

@@ -1,4 +1,4 @@
-import type { QaAccountProfileInput, QaAccountStartersInput, QaAccountUserPublic, QaIssuedServiceToken, QaOwnershipEntry, QaServiceTokenCreateInput, QaServiceTokenSummary, ResolvedQaSurfaceConfig } from "../types.js";
+import type { QaAccountNotificationsInput, QaAccountProfileInput, QaAccountStartersInput, QaAccountUserPublic, QaIssuedServiceToken, QaOwnershipEntry, QaServiceTokenCreateInput, QaServiceTokenSummary, ResolvedQaSurfaceConfig } from "../types.js";
 import type { QaAccountsApi, QaIntegrationTokenResult, StorageLike } from "./types.js";
 /**
  * What the sign-in card says after a forgotten-password request. It names the
@@ -23,12 +23,19 @@ export type QaAccountsSnapshot = {
      * plus every mapped chat for an admin (the cross-user grouping view).
      */
     readonly ownedIds: readonly string[];
+    /**
+     * The account's own chats alone — {@link ownedIds} without the
+     * cross-user view. Reading another account's chat is not a claim on its
+     * activity, so a surface that reports a chat's state outward is bounded
+     * by this list rather than by the sidebar's.
+     */
+    readonly ownIds: readonly string[];
     /**
      * The full ownership map; admins only, empty for ordinary accounts and
      * whenever the admin listing was refused or unavailable.
      */
     readonly ownership: readonly QaOwnershipEntry[];
-    /** Bumped whenever ownedIds or ownership changes; re-projects lists. */
+    /** Bumped whenever ownedIds, ownIds or ownership changes; re-projects lists. */
     readonly ownedRevision: number;
 };
 /**
@@ -49,6 +56,17 @@ export interface QaAccountsControllerOptions {
      */
     readonly legacyChatIds?: () => readonly string[];
     readonly forgetChat?: (sessionId: string) => void;
+    /**
+     * Replay this browser's locally held ratings onto the account it just signed
+     * in as, for the chats that account owns. Runs once per account: the surface
+     * is usable while it is in flight, and a failure costs only the retry the
+     * next login performs.
+     */
+    readonly harvestRatings?: (context: {
+        readonly token: string;
+        readonly accountId: string;
+        readonly ownedIds: readonly string[];
+    }) => Promise<void>;
 }
 /**
  * Browser-side account lifecycle: token persistence, the checking → gate →
@@ -71,6 +89,12 @@ export declare class QaAccountsController {
     token(): string | null;
     /** Server-owned chat ids (empty until authed); falls back to nothing. */
     ownedIds(): readonly string[];
+    /**
+     * The chat ids this account owns outright (empty until authed): the set the
+     * admin's cross-user view may be wider than, and the scope a turn notice
+     * speaks within.
+     */
+    ownIds(): readonly string[];
     /** Boot probe: restore the stored token and ask the Host who it is. */
     start(): Promise<void>;
     login(email: string, password: string): Promise<void>;
@@ -112,6 +136,9 @@ export declare class QaAccountsController {
      * created or opened after login enters it here — the next login is not a
      * reasonable price for a chat the visitor is looking at. Ids already known,
      * and the ones an admin's cross-user view contributed, are left as they are.
+     *
+     * A chat this page claimed is owned outright, so both lists gain it: the
+     * sidebar's wider read is not what decides that.
      */
     private noteOwnedSession;
     /**
@@ -127,6 +154,13 @@ export declare class QaAccountsController {
      * carries the stored record, so the composer picks the new buttons up.
      */
     updateStarters(input: QaAccountStartersInput): Promise<string | null>;
+    /**
+     * Replace the signed-in user's own notification channels, mirroring
+     * {@link updateStarters}: refusal copy on rejection, null once the snapshot
+     * carries the stored record — which is also how the page learns the choice
+     * took effect, since it reads the same snapshot the notices plan with.
+     */
+    updateNotifications(input: QaAccountNotificationsInput): Promise<string | null>;
     /**
      * The signed-in user's integration tokens. Resolves to the list, or to the
      * copy the page renders when the Host refused the read; the tokens are not
@@ -145,7 +179,7 @@ export declare class QaAccountsController {
      */
     revokeServiceToken(tokenId: string): Promise<QaIntegrationTokenResult<null>>;
     private authenticate;
-    /** Own the account, migrate the legacy index, then project authed. */
+    /** Own the account, migrate the legacy index, replay held ratings, then auth. */
     private enterSession;
     /** Refresh the owned list after index changes; cheap enough to re-pull. */
     refreshOwned(): Promise<void>;

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

@@ -1,4 +1,4 @@
-import type { SettingsScope } from "@deepseek-ai/dsh-client-ui-settings/client";
+import type { ConfigForm } from "@deepseek-ai/dsh-client-ui-settings/client";
 import type { QaSurfaceConfig, ResolvedQaSurfaceConfig } from "../types.js";
 export interface QaConfigSnapshot {
     readonly status: "loading" | "ready" | "unavailable" | "error";
@@ -26,7 +26,7 @@ export declare class QaConfigController {
     private fallbackState;
     private fallbackConfig;
     private disposed;
-    constructor(scope: SettingsScope<QaSurfaceConfig>, fallback?: QaConfigFallback);
+    constructor(scope: ConfigForm<QaSurfaceConfig>, fallback?: QaConfigFallback);
     getSnapshot: () => QaConfigSnapshot;
     subscribe: (listener: () => void) => (() => void);
     dispose(): void;